/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_ |