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 
25 namespace llvm {
26 
27 class MemoryBuffer;
28 
29 } // namespace llvm
30 
31 namespace clang {
32 
33 /// Enumerate the kinds of standard library that
34 enum 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.
46 enum 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().
64 class PreprocessorOptions {
65 public:
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 
215 public:
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