clang 19.0.0git
PreprocessorOptions.h
Go to the documentation of this file.
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
14#include "clang/Basic/LLVM.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/ADT/StringSet.h"
18#include <functional>
19#include <map>
20#include <memory>
21#include <optional>
22#include <set>
23#include <string>
24#include <utility>
25#include <vector>
26
27namespace llvm {
28
29class MemoryBuffer;
30
31} // namespace llvm
32
33namespace clang {
34
35/// Enumerate the kinds of standard library that
38
39 /// libc++
41
42 /// libstdc++
44};
45
46/// Whether to disable the normal validation performed on precompiled
47/// headers and module files when they are loaded.
49 /// Perform validation, don't disable it.
50 None = 0,
51
52 /// Disable validation for a precompiled header and the modules it depends on.
53 PCH = 0x1,
54
55 /// Disable validation for module files.
56 Module = 0x2,
57
58 /// Disable validation for all kinds.
59 All = PCH | Module,
60
61 LLVM_MARK_AS_BITMASK_ENUM(Module)
62};
63
64/// PreprocessorOptions - This class is used for passing the various options
65/// used in preprocessor initialization to InitializePreprocessor().
67public:
68 std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
69 std::vector<std::string> Includes;
70 std::vector<std::string> MacroIncludes;
71
72 /// Perform extra checks when loading PCM files for mutable file systems.
74
75 /// Initialize the preprocessor with the compiler and target specific
76 /// predefines.
77 bool UsePredefines = true;
78
79 /// Indicates whether to predefine target OS macros.
81
82 /// Whether we should maintain a detailed record of all macro
83 /// definitions and expansions.
84 bool DetailedRecord = false;
85
86 /// When true, we are creating or using a PCH where a #pragma hdrstop is
87 /// expected to indicate the beginning or end of the PCH.
88 bool PCHWithHdrStop = false;
89
90 /// When true, we are creating a PCH or creating the PCH object while
91 /// expecting a #pragma hdrstop to separate the two. Allow for a
92 /// missing #pragma hdrstop, which generates a PCH for the whole file,
93 /// and creates an empty PCH object.
95
96 /// If non-empty, the filename used in an #include directive in the primary
97 /// source file (or command-line preinclude) that is used to implement
98 /// MSVC-style precompiled headers. When creating a PCH, after the #include
99 /// of this header, the PCH generation stops. When using a PCH, tokens are
100 /// skipped until after an #include of this header is seen.
101 std::string PCHThroughHeader;
102
103 /// The implicit PCH included at the start of the translation unit, or empty.
105
106 /// Headers that will be converted to chained PCHs in memory.
107 std::vector<std::string> ChainedIncludes;
108
109 /// Whether to disable most of the normal validation performed on
110 /// precompiled headers and module files.
113
114 /// When true, a PCH with compiler errors will not be rejected.
116
117 /// When true, a PCH with modules cache path different to the current
118 /// compilation will not be rejected.
120
121 /// Dump declarations that are deserialized from PCH, for testing.
123
124 /// This is a set of names for decls that we do not want to be
125 /// deserialized, and we emit an error if they are; for testing purposes.
126 std::set<std::string> DeserializedPCHDeclsToErrorOn;
127
128 /// If non-zero, the implicit PCH include is actually a precompiled
129 /// preamble that covers this number of bytes in the main source file.
130 ///
131 /// The boolean indicates whether the preamble ends at the start of a new
132 /// line.
133 std::pair<unsigned, bool> PrecompiledPreambleBytes;
134
135 /// True indicates that a preamble is being generated.
136 ///
137 /// When the lexer is done, one of the things that need to be preserved is the
138 /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
139 /// processing the rest of the file. Similarly, we track an unterminated
140 /// #pragma assume_nonnull.
141 bool GeneratePreamble = false;
142
143 /// Whether to write comment locations into the PCH when building it.
144 /// Reading the comments from the PCH can be a performance hit even if the
145 /// clients don't use them.
147
148 /// When enabled, preprocessor is in a mode for parsing a single file only.
149 ///
150 /// Disables #includes of other files and if there are unresolved identifiers
151 /// in preprocessor directive conditions it causes all blocks to be parsed so
152 /// that the client can get the maximum amount of information from the parser.
154
155 /// When enabled, the preprocessor will construct editor placeholder tokens.
157
158 /// True if the SourceManager should report the original file name for
159 /// contents of files that were remapped to other files. Defaults to true.
161
162 /// The set of file remappings, which take existing files on
163 /// the system (the first part of each pair) and gives them the
164 /// contents of other files on the system (the second part of each
165 /// pair).
166 std::vector<std::pair<std::string, std::string>> RemappedFiles;
167
168 /// The set of file-to-buffer remappings, which take existing files
169 /// on the system (the first part of each pair) and gives them the contents
170 /// of the specified memory buffer (the second part of each pair).
171 std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
172
173 /// Whether the compiler instance should retain (i.e., not free)
174 /// the buffers associated with remapped files.
175 ///
176 /// This flag defaults to false; it can be set true only through direct
177 /// manipulation of the compiler invocation object, in cases where the
178 /// compiler invocation and its buffers will be reused.
180
181 /// When enabled, excluded conditional blocks retain in the main file.
183
184 /// The Objective-C++ ARC standard library that we should support,
185 /// by providing appropriate definitions to retrofit the standard library
186 /// with support for lifetime-qualified pointers.
188
189 /// Records the set of modules
191 llvm::StringSet<> Failed;
192
193 public:
194 bool hasAlreadyFailed(StringRef module) {
195 return Failed.count(module) > 0;
196 }
197
198 void addFailed(StringRef module) {
199 Failed.insert(module);
200 }
201 };
202
203 /// The set of modules that failed to build.
204 ///
205 /// This pointer will be shared among all of the compiler instances created
206 /// to (re)build modules, so that once a module fails to build anywhere,
207 /// other instances will see that the module has failed and won't try to
208 /// build it again.
209 std::shared_ptr<FailedModulesSet> FailedModules;
210
211 /// Function for getting the dependency preprocessor directives of a file.
212 ///
213 /// These are directives derived from a special form of lexing where the
214 /// source input is scanned for the preprocessor directives that might have an
215 /// effect on the dependencies for a compilation unit.
216 ///
217 /// Enables a client to cache the directives for a file and provide them
218 /// across multiple compiler invocations.
219 /// FIXME: Allow returning an error.
220 std::function<std::optional<ArrayRef<dependency_directives_scan::Directive>>(
223
224 /// Set up preprocessor for RunAnalysis action.
226
227 /// Prevents intended crashes when using #pragma clang __debug. For testing.
229
230 /// If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
231 std::optional<uint64_t> SourceDateEpoch;
232
233public:
235
236 void addMacroDef(StringRef Name) {
237 Macros.emplace_back(std::string(Name), false);
238 }
239 void addMacroUndef(StringRef Name) {
240 Macros.emplace_back(std::string(Name), true);
241 }
242
243 void addRemappedFile(StringRef From, StringRef To) {
244 RemappedFiles.emplace_back(std::string(From), std::string(To));
245 }
246
247 void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
248 RemappedFileBuffers.emplace_back(std::string(From), To);
249 }
250
252 RemappedFiles.clear();
253 RemappedFileBuffers.clear();
254 }
255
256 /// Reset any options that are not considered when building a
257 /// module.
259 Includes.clear();
260 MacroIncludes.clear();
261 ChainedIncludes.clear();
263 ImplicitPCHInclude.clear();
264 SingleFileParseMode = false;
267 PrecompiledPreambleBytes.first = 0;
268 PrecompiledPreambleBytes.second = false;
270 }
271};
272
273} // namespace clang
274
275#endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
Provides LLVM's BitmaskEnum facility to enumeration types declared in namespace clang.
This is the interface for scanning header and source files to get the minimum necessary preprocessor ...
Defines interfaces for clang::FileEntry and clang::FileEntryRef.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Definition: FileEntry.h:57
Describes a module or submodule.
Definition: Module.h:105
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
bool PCHWithHdrStopCreate
When true, we are creating a PCH or creating the PCH object while expecting a #pragma hdrstop to sepa...
bool DisablePragmaDebugCrash
Prevents intended crashes when using #pragma clang __debug. For testing.
std::vector< std::string > MacroIncludes
std::vector< std::string > Includes
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
bool WriteCommentListToPCH
Whether to write comment locations into the PCH when building it.
bool RemappedFilesKeepOriginalName
True if the SourceManager should report the original file name for contents of files that were remapp...
bool LexEditorPlaceholders
When enabled, the preprocessor will construct editor placeholder tokens.
void resetNonModularOptions()
Reset any options that are not considered when building a module.
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
bool ModulesCheckRelocated
Perform extra checks when loading PCM files for mutable file systems.
void addMacroUndef(StringRef Name)
std::string PCHThroughHeader
If non-empty, the filename used in an #include directive in the primary source file (or command-line ...
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
bool SingleFileParseMode
When enabled, preprocessor is in a mode for parsing a single file only.
void addMacroDef(StringRef Name)
bool DefineTargetOSMacros
Indicates whether to predefine target OS macros.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
void addRemappedFile(StringRef From, llvm::MemoryBuffer *To)
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
bool RetainExcludedConditionalBlocks
When enabled, excluded conditional blocks retain in the main file.
bool PCHWithHdrStop
When true, we are creating or using a PCH where a #pragma hdrstop is expected to indicate the beginni...
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
DisableValidationForModuleKind DisablePCHOrModuleValidation
Whether to disable most of the normal validation performed on precompiled headers and module files.
bool AllowPCHWithDifferentModulesCachePath
When true, a PCH with modules cache path different to the current compilation will not be rejected.
bool DumpDeserializedPCHDecls
Dump declarations that are deserialized from PCH, for testing.
std::optional< uint64_t > SourceDateEpoch
If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
void addRemappedFile(StringRef From, StringRef To)
bool SetUpStaticAnalyzer
Set up preprocessor for RunAnalysis action.
std::vector< std::pair< std::string, bool > > Macros
std::function< std::optional< ArrayRef< dependency_directives_scan::Directive > >(FileEntryRef)> DependencyDirectivesForFile
Function for getting the dependency preprocessor directives of a file.
bool GeneratePreamble
True indicates that a preamble is being generated.
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
std::shared_ptr< FailedModulesSet > FailedModules
The set of modules that failed to build.
std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers
The set of file-to-buffer remappings, which take existing files on the system (the first part of each...
The JSON file list parser is used to communicate input to InstallAPI.
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
@ ARCXX_libcxx
libc++
@ ARCXX_libstdcxx
libstdc++
DisableValidationForModuleKind
Whether to disable the normal validation performed on precompiled headers and module files when they ...
@ None
Perform validation, don't disable it.
@ PCH
Disable validation for a precompiled header and the modules it depends on.
@ None
The alignment was not explicit in code.
YAML serialization mapping.
Definition: Dominators.h:30
#define false
Definition: stdbool.h:22