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: hasAlreadyFailed(StringRef module)181 bool hasAlreadyFailed(StringRef module) { 182 return Failed.count(module) > 0; 183 } 184 addFailed(StringRef module)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: PreprocessorOptions()216 PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {} 217 addMacroDef(StringRef Name)218 void addMacroDef(StringRef Name) { 219 Macros.emplace_back(std::string(Name), false); 220 } addMacroUndef(StringRef Name)221 void addMacroUndef(StringRef Name) { 222 Macros.emplace_back(std::string(Name), true); 223 } 224 addRemappedFile(StringRef From,StringRef To)225 void addRemappedFile(StringRef From, StringRef To) { 226 RemappedFiles.emplace_back(std::string(From), std::string(To)); 227 } 228 addRemappedFile(StringRef From,llvm::MemoryBuffer * To)229 void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) { 230 RemappedFileBuffers.emplace_back(std::string(From), To); 231 } 232 clearRemappedFiles()233 void clearRemappedFiles() { 234 RemappedFiles.clear(); 235 RemappedFileBuffers.clear(); 236 } 237 238 /// Reset any options that are not considered when building a 239 /// module. resetNonModularOptions()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