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

source code of clang/include/clang/Lex/HeaderSearchOptions.h