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