Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Lex/PreprocessorOptions.h
Line
Count
Source
1
//===- PreprocessorOptions.h ------------------------------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
10
#define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
11
12
#include "clang/Basic/BitmaskEnum.h"
13
#include "clang/Basic/FileEntry.h"
14
#include "clang/Basic/LLVM.h"
15
#include "clang/Lex/DependencyDirectivesScanner.h"
16
#include "llvm/ADT/StringRef.h"
17
#include "llvm/ADT/StringSet.h"
18
#include <functional>
19
#include <map>
20
#include <memory>
21
#include <set>
22
#include <string>
23
#include <utility>
24
#include <vector>
25
26
namespace llvm {
27
28
class MemoryBuffer;
29
30
} // namespace llvm
31
32
namespace clang {
33
34
/// Enumerate the kinds of standard library that
35
enum ObjCXXARCStandardLibraryKind {
36
  ARCXX_nolib,
37
38
  /// libc++
39
  ARCXX_libcxx,
40
41
  /// libstdc++
42
  ARCXX_libstdcxx
43
};
44
45
/// Whether to disable the normal validation performed on precompiled
46
/// headers and module files when they are loaded.
47
enum class DisableValidationForModuleKind {
48
  /// Perform validation, don't disable it.
49
  None = 0,
50
51
  /// Disable validation for a precompiled header and the modules it depends on.
52
  PCH = 0x1,
53
54
  /// Disable validation for module files.
55
  Module = 0x2,
56
57
  /// Disable validation for all kinds.
58
  All = PCH | Module,
59
60
  LLVM_MARK_AS_BITMASK_ENUM(Module)
61
};
62
63
/// PreprocessorOptions - This class is used for passing the various options
64
/// used in preprocessor initialization to InitializePreprocessor().
65
class PreprocessorOptions {
66
public:
67
  std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
68
  std::vector<std::string> Includes;
69
  std::vector<std::string> MacroIncludes;
70
71
  /// Initialize the preprocessor with the compiler and target specific
72
  /// predefines.
73
  bool UsePredefines = true;
74
75
  /// Whether we should maintain a detailed record of all macro
76
  /// definitions and expansions.
77
  bool DetailedRecord = false;
78
79
  /// When true, we are creating or using a PCH where a #pragma hdrstop is
80
  /// expected to indicate the beginning or end of the PCH.
81
  bool PCHWithHdrStop = false;
82
83
  /// When true, we are creating a PCH or creating the PCH object while
84
  /// expecting a #pragma hdrstop to separate the two.  Allow for a
85
  /// missing #pragma hdrstop, which generates a PCH for the whole file,
86
  /// and creates an empty PCH object.
87
  bool PCHWithHdrStopCreate = false;
88
89
  /// If non-empty, the filename used in an #include directive in the primary
90
  /// source file (or command-line preinclude) that is used to implement
91
  /// MSVC-style precompiled headers. When creating a PCH, after the #include
92
  /// of this header, the PCH generation stops. When using a PCH, tokens are
93
  /// skipped until after an #include of this header is seen.
94
  std::string PCHThroughHeader;
95
96
  /// The implicit PCH included at the start of the translation unit, or empty.
97
  std::string ImplicitPCHInclude;
98
99
  /// Headers that will be converted to chained PCHs in memory.
100
  std::vector<std::string> ChainedIncludes;
101
102
  /// Whether to disable most of the normal validation performed on
103
  /// precompiled headers and module files.
104
  DisableValidationForModuleKind DisablePCHOrModuleValidation =
105
      DisableValidationForModuleKind::None;
106
107
  /// When true, a PCH with compiler errors will not be rejected.
108
  bool AllowPCHWithCompilerErrors = false;
109
110
  /// When true, a PCH with modules cache path different to the current
111
  /// compilation will not be rejected.
112
  bool AllowPCHWithDifferentModulesCachePath = false;
113
114
  /// Dump declarations that are deserialized from PCH, for testing.
115
  bool DumpDeserializedPCHDecls = false;
116
117
  /// This is a set of names for decls that we do not want to be
118
  /// deserialized, and we emit an error if they are; for testing purposes.
119
  std::set<std::string> DeserializedPCHDeclsToErrorOn;
120
121
  /// If non-zero, the implicit PCH include is actually a precompiled
122
  /// preamble that covers this number of bytes in the main source file.
123
  ///
124
  /// The boolean indicates whether the preamble ends at the start of a new
125
  /// line.
126
  std::pair<unsigned, bool> PrecompiledPreambleBytes;
127
128
  /// True indicates that a preamble is being generated.
129
  ///
130
  /// When the lexer is done, one of the things that need to be preserved is the
131
  /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
132
  /// processing the rest of the file. Similarly, we track an unterminated
133
  /// #pragma assume_nonnull.
134
  bool GeneratePreamble = false;
135
136
  /// Whether to write comment locations into the PCH when building it.
137
  /// Reading the comments from the PCH can be a performance hit even if the
138
  /// clients don't use them.
139
  bool WriteCommentListToPCH = true;
140
141
  /// When enabled, preprocessor is in a mode for parsing a single file only.
142
  ///
143
  /// Disables #includes of other files and if there are unresolved identifiers
144
  /// in preprocessor directive conditions it causes all blocks to be parsed so
145
  /// that the client can get the maximum amount of information from the parser.
146
  bool SingleFileParseMode = false;
147
148
  /// When enabled, the preprocessor will construct editor placeholder tokens.
149
  bool LexEditorPlaceholders = true;
150
151
  /// True if the SourceManager should report the original file name for
152
  /// contents of files that were remapped to other files. Defaults to true.
153
  bool RemappedFilesKeepOriginalName = true;
154
155
  /// The set of file remappings, which take existing files on
156
  /// the system (the first part of each pair) and gives them the
157
  /// contents of other files on the system (the second part of each
158
  /// pair).
159
  std::vector<std::pair<std::string, std::string>> RemappedFiles;
160
161
  /// The set of file-to-buffer remappings, which take existing files
162
  /// on the system (the first part of each pair) and gives them the contents
163
  /// of the specified memory buffer (the second part of each pair).
164
  std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
165
166
  /// Whether the compiler instance should retain (i.e., not free)
167
  /// the buffers associated with remapped files.
168
  ///
169
  /// This flag defaults to false; it can be set true only through direct
170
  /// manipulation of the compiler invocation object, in cases where the
171
  /// compiler invocation and its buffers will be reused.
172
  bool RetainRemappedFileBuffers = false;
173
174
  /// When enabled, excluded conditional blocks retain in the main file.
175
  bool RetainExcludedConditionalBlocks = false;
176
177
  /// The Objective-C++ ARC standard library that we should support,
178
  /// by providing appropriate definitions to retrofit the standard library
179
  /// with support for lifetime-qualified pointers.
180
  ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
181
182
  /// Records the set of modules
183
  class FailedModulesSet {
184
    llvm::StringSet<> Failed;
185
186
  public:
187
878
    bool hasAlreadyFailed(StringRef module) {
188
878
      return Failed.count(module) > 0;
189
878
    }
190
191
43
    void addFailed(StringRef module) {
192
43
      Failed.insert(module);
193
43
    }
194
  };
195
196
  /// The set of modules that failed to build.
197
  ///
198
  /// This pointer will be shared among all of the compiler instances created
199
  /// to (re)build modules, so that once a module fails to build anywhere,
200
  /// other instances will see that the module has failed and won't try to
201
  /// build it again.
202
  std::shared_ptr<FailedModulesSet> FailedModules;
203
204
  /// Function for getting the dependency preprocessor directives of a file.
205
  ///
206
  /// These are directives derived from a special form of lexing where the
207
  /// source input is scanned for the preprocessor directives that might have an
208
  /// effect on the dependencies for a compilation unit.
209
  ///
210
  /// Enables a client to cache the directives for a file and provide them
211
  /// across multiple compiler invocations.
212
  /// FIXME: Allow returning an error.
213
  std::function<Optional<ArrayRef<dependency_directives_scan::Directive>>(
214
      FileEntryRef)>
215
      DependencyDirectivesForFile;
216
217
  /// Set up preprocessor for RunAnalysis action.
218
  bool SetUpStaticAnalyzer = false;
219
220
  /// Prevents intended crashes when using #pragma clang __debug. For testing.
221
  bool DisablePragmaDebugCrash = false;
222
223
public:
224
202k
  PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
225
226
680k
  void addMacroDef(StringRef Name) {
227
680k
    Macros.emplace_back(std::string(Name), false);
228
680k
  }
229
90
  void addMacroUndef(StringRef Name) {
230
90
    Macros.emplace_back(std::string(Name), true);
231
90
  }
232
233
19
  void addRemappedFile(StringRef From, StringRef To) {
234
19
    RemappedFiles.emplace_back(std::string(From), std::string(To));
235
19
  }
236
237
4.14k
  void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
238
4.14k
    RemappedFileBuffers.emplace_back(std::string(From), To);
239
4.14k
  }
240
241
1.54k
  void clearRemappedFiles() {
242
1.54k
    RemappedFiles.clear();
243
1.54k
    RemappedFileBuffers.clear();
244
1.54k
  }
245
246
  /// Reset any options that are not considered when building a
247
  /// module.
248
1.87k
  void resetNonModularOptions() {
249
1.87k
    Includes.clear();
250
1.87k
    MacroIncludes.clear();
251
1.87k
    ChainedIncludes.clear();
252
1.87k
    DumpDeserializedPCHDecls = false;
253
1.87k
    ImplicitPCHInclude.clear();
254
1.87k
    SingleFileParseMode = false;
255
1.87k
    LexEditorPlaceholders = true;
256
1.87k
    RetainRemappedFileBuffers = true;
257
1.87k
    PrecompiledPreambleBytes.first = 0;
258
1.87k
    PrecompiledPreambleBytes.second = false;
259
1.87k
    RetainExcludedConditionalBlocks = false;
260
1.87k
  }
261
};
262
263
} // namespace clang
264
265
#endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_