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   /// When true, a PCH with modules cache path different to the current
110   /// compilation will not be rejected.
111   bool AllowPCHWithDifferentModulesCachePath = false;
112 
113   /// Dump declarations that are deserialized from PCH, for testing.
114   bool DumpDeserializedPCHDecls = false;
115 
116   /// This is a set of names for decls that we do not want to be
117   /// deserialized, and we emit an error if they are; for testing purposes.
118   std::set<std::string> DeserializedPCHDeclsToErrorOn;
119 
120   /// If non-zero, the implicit PCH include is actually a precompiled
121   /// preamble that covers this number of bytes in the main source file.
122   ///
123   /// The boolean indicates whether the preamble ends at the start of a new
124   /// line.
125   std::pair<unsigned, bool> PrecompiledPreambleBytes;
126 
127   /// True indicates that a preamble is being generated.
128   ///
129   /// When the lexer is done, one of the things that need to be preserved is the
130   /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
131   /// processing the rest of the file.
132   bool GeneratePreamble = false;
133 
134   /// Whether to write comment locations into the PCH when building it.
135   /// Reading the comments from the PCH can be a performance hit even if the
136   /// clients don't use them.
137   bool WriteCommentListToPCH = true;
138 
139   /// When enabled, preprocessor is in a mode for parsing a single file only.
140   ///
141   /// Disables #includes of other files and if there are unresolved identifiers
142   /// in preprocessor directive conditions it causes all blocks to be parsed so
143   /// that the client can get the maximum amount of information from the parser.
144   bool SingleFileParseMode = false;
145 
146   /// When enabled, the preprocessor will construct editor placeholder tokens.
147   bool LexEditorPlaceholders = true;
148 
149   /// True if the SourceManager should report the original file name for
150   /// contents of files that were remapped to other files. Defaults to true.
151   bool RemappedFilesKeepOriginalName = true;
152 
153   /// The set of file remappings, which take existing files on
154   /// the system (the first part of each pair) and gives them the
155   /// contents of other files on the system (the second part of each
156   /// pair).
157   std::vector<std::pair<std::string, std::string>> RemappedFiles;
158 
159   /// The set of file-to-buffer remappings, which take existing files
160   /// on the system (the first part of each pair) and gives them the contents
161   /// of the specified memory buffer (the second part of each pair).
162   std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
163 
164   /// Whether the compiler instance should retain (i.e., not free)
165   /// the buffers associated with remapped files.
166   ///
167   /// This flag defaults to false; it can be set true only through direct
168   /// manipulation of the compiler invocation object, in cases where the
169   /// compiler invocation and its buffers will be reused.
170   bool RetainRemappedFileBuffers = false;
171 
172   /// When enabled, excluded conditional blocks retain in the main file.
173   bool RetainExcludedConditionalBlocks = false;
174 
175   /// The Objective-C++ ARC standard library that we should support,
176   /// by providing appropriate definitions to retrofit the standard library
177   /// with support for lifetime-qualified pointers.
178   ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
179 
180   /// Records the set of modules
181   class FailedModulesSet {
182     llvm::StringSet<> Failed;
183 
184   public:
185     bool hasAlreadyFailed(StringRef module) {
186       return Failed.count(module) > 0;
187     }
188 
189     void addFailed(StringRef module) {
190       Failed.insert(module);
191     }
192   };
193 
194   /// The set of modules that failed to build.
195   ///
196   /// This pointer will be shared among all of the compiler instances created
197   /// to (re)build modules, so that once a module fails to build anywhere,
198   /// other instances will see that the module has failed and won't try to
199   /// build it again.
200   std::shared_ptr<FailedModulesSet> FailedModules;
201 
202   /// Contains the currently active skipped range mappings for skipping excluded
203   /// conditional directives.
204   ///
205   /// The pointer is passed to the Preprocessor when it's constructed. The
206   /// pointer is unowned, the client is responsible for its lifetime.
207   ExcludedPreprocessorDirectiveSkipMapping
208       *ExcludedConditionalDirectiveSkipMappings = nullptr;
209 
210   /// Set up preprocessor for RunAnalysis action.
211   bool SetUpStaticAnalyzer = false;
212 
213   /// Prevents intended crashes when using #pragma clang __debug. For testing.
214   bool DisablePragmaDebugCrash = false;
215 
216 public:
217   PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
218 
219   void addMacroDef(StringRef Name) {
220     Macros.emplace_back(std::string(Name), false);
221   }
222   void addMacroUndef(StringRef Name) {
223     Macros.emplace_back(std::string(Name), true);
224   }
225 
226   void addRemappedFile(StringRef From, StringRef To) {
227     RemappedFiles.emplace_back(std::string(From), std::string(To));
228   }
229 
230   void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
231     RemappedFileBuffers.emplace_back(std::string(From), To);
232   }
233 
234   void clearRemappedFiles() {
235     RemappedFiles.clear();
236     RemappedFileBuffers.clear();
237   }
238 
239   /// Reset any options that are not considered when building a
240   /// module.
241   void resetNonModularOptions() {
242     Includes.clear();
243     MacroIncludes.clear();
244     ChainedIncludes.clear();
245     DumpDeserializedPCHDecls = false;
246     ImplicitPCHInclude.clear();
247     SingleFileParseMode = false;
248     LexEditorPlaceholders = true;
249     RetainRemappedFileBuffers = true;
250     PrecompiledPreambleBytes.first = 0;
251     PrecompiledPreambleBytes.second = false;
252     RetainExcludedConditionalBlocks = false;
253   }
254 };
255 
256 } // namespace clang
257 
258 #endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
259