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