1 //===- HeaderSearchOptions.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_HEADERSEARCHOPTIONS_H 10 #define LLVM_CLANG_LEX_HEADERSEARCHOPTIONS_H 11 12 #include "clang/Basic/LLVM.h" 13 #include "llvm/ADT/CachedHashString.h" 14 #include "llvm/ADT/SetVector.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/Support/HashBuilder.h" 17 #include <cstdint> 18 #include <map> 19 #include <string> 20 #include <vector> 21 22 namespace clang { 23 24 namespace frontend { 25 26 /// IncludeDirGroup - Identifies the group an include Entry belongs to, 27 /// representing its relative positive in the search list. 28 /// \#include directives whose paths are enclosed by string quotes ("") 29 /// start searching at the Quoted group (specified by '-iquote'), 30 /// then search the Angled group, then the System group, etc. 31 enum IncludeDirGroup { 32 /// '\#include ""' paths, added by 'gcc -iquote'. 33 Quoted = 0, 34 35 /// Paths for '\#include <>' added by '-I'. 36 Angled, 37 38 /// Like Angled, but marks header maps used when building frameworks. 39 IndexHeaderMap, 40 41 /// Like Angled, but marks system directories. 42 System, 43 44 /// Like System, but headers are implicitly wrapped in extern "C". 45 ExternCSystem, 46 47 /// Like System, but only used for C. 48 CSystem, 49 50 /// Like System, but only used for C++. 51 CXXSystem, 52 53 /// Like System, but only used for ObjC. 54 ObjCSystem, 55 56 /// Like System, but only used for ObjC++. 57 ObjCXXSystem, 58 59 /// Like System, but searched after the system directories. 60 After 61 }; 62 63 } // namespace frontend 64 65 /// HeaderSearchOptions - Helper class for storing options related to the 66 /// initialization of the HeaderSearch object. 67 class HeaderSearchOptions { 68 public: 69 struct Entry { 70 std::string Path; 71 frontend::IncludeDirGroup Group; 72 LLVM_PREFERRED_TYPE(bool) 73 unsigned IsFramework : 1; 74 75 /// IgnoreSysRoot - This is false if an absolute path should be treated 76 /// relative to the sysroot, or true if it should always be the absolute 77 /// path. 78 LLVM_PREFERRED_TYPE(bool) 79 unsigned IgnoreSysRoot : 1; 80 81 Entry(StringRef path, frontend::IncludeDirGroup group, bool isFramework, 82 bool ignoreSysRoot) 83 : Path(path), Group(group), IsFramework(isFramework), 84 IgnoreSysRoot(ignoreSysRoot) {} 85 }; 86 87 struct SystemHeaderPrefix { 88 /// A prefix to be matched against paths in \#include directives. 89 std::string Prefix; 90 91 /// True if paths beginning with this prefix should be treated as system 92 /// headers. 93 bool IsSystemHeader; 94 95 SystemHeaderPrefix(StringRef Prefix, bool IsSystemHeader) 96 : Prefix(Prefix), IsSystemHeader(IsSystemHeader) {} 97 }; 98 99 /// If non-empty, the directory to use as a "virtual system root" for include 100 /// paths. 101 std::string Sysroot; 102 103 /// User specified include entries. 104 std::vector<Entry> UserEntries; 105 106 /// User-specified system header prefixes. 107 std::vector<SystemHeaderPrefix> SystemHeaderPrefixes; 108 109 /// The directory which holds the compiler resource files (builtin includes, 110 /// etc.). 111 std::string ResourceDir; 112 113 /// The directory used for the module cache. 114 std::string ModuleCachePath; 115 116 /// The directory used for a user build. 117 std::string ModuleUserBuildPath; 118 119 /// The mapping of module names to prebuilt module files. 120 std::map<std::string, std::string, std::less<>> PrebuiltModuleFiles; 121 122 /// The directories used to load prebuilt module files. 123 std::vector<std::string> PrebuiltModulePaths; 124 125 /// The module/pch container format. 126 std::string ModuleFormat; 127 128 /// Whether we should disable the use of the hash string within the 129 /// module cache. 130 /// 131 /// Note: Only used for testing! 132 LLVM_PREFERRED_TYPE(bool) 133 unsigned DisableModuleHash : 1; 134 135 /// Implicit module maps. This option is enabld by default when 136 /// modules is enabled. 137 LLVM_PREFERRED_TYPE(bool) 138 unsigned ImplicitModuleMaps : 1; 139 140 /// Set the 'home directory' of a module map file to the current 141 /// working directory (or the home directory of the module map file that 142 /// contained the 'extern module' directive importing this module map file 143 /// if any) rather than the directory containing the module map file. 144 // 145 /// The home directory is where we look for files named in the module map 146 /// file. 147 LLVM_PREFERRED_TYPE(bool) 148 unsigned ModuleMapFileHomeIsCwd : 1; 149 150 /// Set the base path of a built module file to be the current working 151 /// directory. This is useful for sharing module files across machines 152 /// that build with different paths without having to rewrite all 153 /// modulemap files to have working directory relative paths. 154 LLVM_PREFERRED_TYPE(bool) 155 unsigned ModuleFileHomeIsCwd : 1; 156 157 /// Also search for prebuilt implicit modules in the prebuilt module cache 158 /// path. 159 LLVM_PREFERRED_TYPE(bool) 160 unsigned EnablePrebuiltImplicitModules : 1; 161 162 /// The interval (in seconds) between pruning operations. 163 /// 164 /// This operation is expensive, because it requires Clang to walk through 165 /// the directory structure of the module cache, stat()'ing and removing 166 /// files. 167 /// 168 /// The default value is large, e.g., the operation runs once a week. 169 unsigned ModuleCachePruneInterval = 7 * 24 * 60 * 60; 170 171 /// The time (in seconds) after which an unused module file will be 172 /// considered unused and will, therefore, be pruned. 173 /// 174 /// When the module cache is pruned, any module file that has not been 175 /// accessed in this many seconds will be removed. The default value is 176 /// large, e.g., a month, to avoid forcing infrequently-used modules to be 177 /// regenerated often. 178 unsigned ModuleCachePruneAfter = 31 * 24 * 60 * 60; 179 180 /// The time in seconds when the build session started. 181 /// 182 /// This time is used by other optimizations in header search and module 183 /// loading. 184 uint64_t BuildSessionTimestamp = 0; 185 186 /// The set of macro names that should be ignored for the purposes 187 /// of computing the module hash. 188 llvm::SmallSetVector<llvm::CachedHashString, 16> ModulesIgnoreMacros; 189 190 /// The set of user-provided virtual filesystem overlay files. 191 std::vector<std::string> VFSOverlayFiles; 192 193 /// Include the compiler builtin includes. 194 LLVM_PREFERRED_TYPE(bool) 195 unsigned UseBuiltinIncludes : 1; 196 197 /// Include the system standard include search directories. 198 LLVM_PREFERRED_TYPE(bool) 199 unsigned UseStandardSystemIncludes : 1; 200 201 /// Include the system standard C++ library include search directories. 202 LLVM_PREFERRED_TYPE(bool) 203 unsigned UseStandardCXXIncludes : 1; 204 205 /// Use libc++ instead of the default libstdc++. 206 LLVM_PREFERRED_TYPE(bool) 207 unsigned UseLibcxx : 1; 208 209 /// Whether header search information should be output as for -v. 210 LLVM_PREFERRED_TYPE(bool) 211 unsigned Verbose : 1; 212 213 /// If true, skip verifying input files used by modules if the 214 /// module was already verified during this build session (see 215 /// \c BuildSessionTimestamp). 216 LLVM_PREFERRED_TYPE(bool) 217 unsigned ModulesValidateOncePerBuildSession : 1; 218 219 /// Whether to validate system input files when a module is loaded. 220 LLVM_PREFERRED_TYPE(bool) 221 unsigned ModulesValidateSystemHeaders : 1; 222 223 // Whether the content of input files should be hashed and used to 224 // validate consistency. 225 LLVM_PREFERRED_TYPE(bool) 226 unsigned ValidateASTInputFilesContent : 1; 227 228 // Whether the input files from C++20 Modules should be checked. 229 LLVM_PREFERRED_TYPE(bool) 230 unsigned ForceCheckCXX20ModulesInputFiles : 1; 231 232 /// Whether the module includes debug information (-gmodules). 233 LLVM_PREFERRED_TYPE(bool) 234 unsigned UseDebugInfo : 1; 235 236 LLVM_PREFERRED_TYPE(bool) 237 unsigned ModulesValidateDiagnosticOptions : 1; 238 239 /// Whether to entirely skip writing diagnostic options. 240 /// Primarily used to speed up deserialization during dependency scanning. 241 LLVM_PREFERRED_TYPE(bool) 242 unsigned ModulesSkipDiagnosticOptions : 1; 243 244 /// Whether to entirely skip writing header search paths. 245 /// Primarily used to speed up deserialization during dependency scanning. 246 LLVM_PREFERRED_TYPE(bool) 247 unsigned ModulesSkipHeaderSearchPaths : 1; 248 249 /// Whether to entirely skip writing pragma diagnostic mappings. 250 /// Primarily used to speed up deserialization during dependency scanning. 251 LLVM_PREFERRED_TYPE(bool) 252 unsigned ModulesSkipPragmaDiagnosticMappings : 1; 253 254 /// Whether to prune non-affecting module map files from PCM files. 255 LLVM_PREFERRED_TYPE(bool) 256 unsigned ModulesPruneNonAffectingModuleMaps : 1; 257 258 LLVM_PREFERRED_TYPE(bool) 259 unsigned ModulesHashContent : 1; 260 261 /// Whether we should include all things that could impact the module in the 262 /// hash. 263 /// 264 /// This includes things like the full header search path, and enabled 265 /// diagnostics. 266 LLVM_PREFERRED_TYPE(bool) 267 unsigned ModulesStrictContextHash : 1; 268 269 /// Whether to include ivfsoverlay usage information in written AST files. 270 LLVM_PREFERRED_TYPE(bool) 271 unsigned ModulesIncludeVFSUsage : 1; 272 273 HeaderSearchOptions(StringRef _Sysroot = "/") 274 : Sysroot(_Sysroot), ModuleFormat("raw"), DisableModuleHash(false), 275 ImplicitModuleMaps(false), ModuleMapFileHomeIsCwd(false), 276 ModuleFileHomeIsCwd(false), EnablePrebuiltImplicitModules(false), 277 UseBuiltinIncludes(true), UseStandardSystemIncludes(true), 278 UseStandardCXXIncludes(true), UseLibcxx(false), Verbose(false), 279 ModulesValidateOncePerBuildSession(false), 280 ModulesValidateSystemHeaders(false), 281 ValidateASTInputFilesContent(false), 282 ForceCheckCXX20ModulesInputFiles(false), UseDebugInfo(false), 283 ModulesValidateDiagnosticOptions(true), 284 ModulesSkipDiagnosticOptions(false), 285 ModulesSkipHeaderSearchPaths(false), 286 ModulesSkipPragmaDiagnosticMappings(false), 287 ModulesPruneNonAffectingModuleMaps(true), ModulesHashContent(false), 288 ModulesStrictContextHash(false), ModulesIncludeVFSUsage(false) {} 289 290 /// AddPath - Add the \p Path path to the specified \p Group list. 291 void AddPath(StringRef Path, frontend::IncludeDirGroup Group, 292 bool IsFramework, bool IgnoreSysRoot) { 293 UserEntries.emplace_back(Path, Group, IsFramework, IgnoreSysRoot); 294 } 295 296 /// AddSystemHeaderPrefix - Override whether \#include directives naming a 297 /// path starting with \p Prefix should be considered as naming a system 298 /// header. 299 void AddSystemHeaderPrefix(StringRef Prefix, bool IsSystemHeader) { 300 SystemHeaderPrefixes.emplace_back(Prefix, IsSystemHeader); 301 } 302 303 void AddVFSOverlayFile(StringRef Name) { 304 VFSOverlayFiles.push_back(std::string(Name)); 305 } 306 307 void AddPrebuiltModulePath(StringRef Name) { 308 PrebuiltModulePaths.push_back(std::string(Name)); 309 } 310 }; 311 312 template <typename HasherT, llvm::endianness Endianness> 313 inline void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder, 314 const HeaderSearchOptions::Entry &E) { 315 HBuilder.add(E.Path, E.Group, E.IsFramework, E.IgnoreSysRoot); 316 } 317 318 template <typename HasherT, llvm::endianness Endianness> 319 inline void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder, 320 const HeaderSearchOptions::SystemHeaderPrefix &SHP) { 321 HBuilder.add(SHP.Prefix, SHP.IsSystemHeader); 322 } 323 324 } // namespace clang 325 326 #endif // LLVM_CLANG_LEX_HEADERSEARCHOPTIONS_H 327