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