1 | //===--- InitHeaderSearch.cpp - Initialize header search paths ------------===// |
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 | // This file implements the InitHeaderSearch class. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "clang/Basic/FileManager.h" |
14 | #include "clang/Basic/LangOptions.h" |
15 | #include "clang/Config/config.h" // C_INCLUDE_DIRS |
16 | #include "clang/Lex/HeaderMap.h" |
17 | #include "clang/Lex/HeaderSearch.h" |
18 | #include "clang/Lex/HeaderSearchOptions.h" |
19 | #include "llvm/ADT/SmallPtrSet.h" |
20 | #include "llvm/ADT/StringExtras.h" |
21 | #include "llvm/ADT/Twine.h" |
22 | #include "llvm/Support/ErrorHandling.h" |
23 | #include "llvm/Support/Path.h" |
24 | #include "llvm/Support/raw_ostream.h" |
25 | #include "llvm/TargetParser/Triple.h" |
26 | #include <optional> |
27 | |
28 | using namespace clang; |
29 | using namespace clang::frontend; |
30 | |
31 | namespace { |
32 | /// Holds information about a single DirectoryLookup object. |
33 | struct DirectoryLookupInfo { |
34 | IncludeDirGroup Group; |
35 | DirectoryLookup Lookup; |
36 | std::optional<unsigned> UserEntryIdx; |
37 | |
38 | DirectoryLookupInfo(IncludeDirGroup Group, DirectoryLookup Lookup, |
39 | std::optional<unsigned> UserEntryIdx) |
40 | : Group(Group), Lookup(Lookup), UserEntryIdx(UserEntryIdx) {} |
41 | }; |
42 | |
43 | /// This class makes it easier to set the search paths of a HeaderSearch object. |
44 | /// InitHeaderSearch stores several search path lists internally, which can be |
45 | /// sent to a HeaderSearch object in one swoop. |
46 | class { |
47 | std::vector<DirectoryLookupInfo> ; |
48 | std::vector<std::pair<std::string, bool> > ; |
49 | HeaderSearch &; |
50 | bool ; |
51 | std::string ; |
52 | bool ; |
53 | |
54 | public: |
55 | (HeaderSearch &HS, bool verbose, StringRef sysroot) |
56 | : Headers(HS), Verbose(verbose), IncludeSysroot(std::string(sysroot)), |
57 | HasSysroot(!(sysroot.empty() || sysroot == "/" )) {} |
58 | |
59 | /// Add the specified path to the specified group list, prefixing the sysroot |
60 | /// if used. |
61 | /// Returns true if the path exists, false if it was ignored. |
62 | bool AddPath(const Twine &Path, IncludeDirGroup Group, bool isFramework, |
63 | std::optional<unsigned> UserEntryIdx = std::nullopt); |
64 | |
65 | /// Add the specified path to the specified group list, without performing any |
66 | /// sysroot remapping. |
67 | /// Returns true if the path exists, false if it was ignored. |
68 | bool AddUnmappedPath(const Twine &Path, IncludeDirGroup Group, |
69 | bool isFramework, |
70 | std::optional<unsigned> UserEntryIdx = std::nullopt); |
71 | |
72 | /// Add the specified prefix to the system header prefix list. |
73 | void (StringRef Prefix, bool ) { |
74 | SystemHeaderPrefixes.emplace_back(args: std::string(Prefix), args&: IsSystemHeader); |
75 | } |
76 | |
77 | /// Add paths that should always be searched. |
78 | void AddDefaultCIncludePaths(const llvm::Triple &triple, |
79 | const HeaderSearchOptions &HSOpts); |
80 | |
81 | /// Returns true iff AddDefaultIncludePaths should do anything. If this |
82 | /// returns false, include paths should instead be handled in the driver. |
83 | bool ShouldAddDefaultIncludePaths(const llvm::Triple &triple); |
84 | |
85 | /// Adds the default system include paths so that e.g. stdio.h is found. |
86 | void AddDefaultIncludePaths(const LangOptions &Lang, |
87 | const llvm::Triple &triple, |
88 | const HeaderSearchOptions &HSOpts); |
89 | |
90 | /// Merges all search path lists into one list and send it to HeaderSearch. |
91 | void Realize(const LangOptions &Lang); |
92 | }; |
93 | |
94 | } // end anonymous namespace. |
95 | |
96 | static bool CanPrefixSysroot(StringRef Path) { |
97 | #if defined(_WIN32) |
98 | return !Path.empty() && llvm::sys::path::is_separator(Path[0]); |
99 | #else |
100 | return llvm::sys::path::is_absolute(path: Path); |
101 | #endif |
102 | } |
103 | |
104 | bool InitHeaderSearch::(const Twine &Path, IncludeDirGroup Group, |
105 | bool isFramework, |
106 | std::optional<unsigned> UserEntryIdx) { |
107 | // Add the path with sysroot prepended, if desired and this is a system header |
108 | // group. |
109 | if (HasSysroot) { |
110 | SmallString<256> MappedPathStorage; |
111 | StringRef MappedPathStr = Path.toStringRef(Out&: MappedPathStorage); |
112 | if (CanPrefixSysroot(Path: MappedPathStr)) { |
113 | return AddUnmappedPath(Path: IncludeSysroot + Path, Group, isFramework, |
114 | UserEntryIdx); |
115 | } |
116 | } |
117 | |
118 | return AddUnmappedPath(Path, Group, isFramework, UserEntryIdx); |
119 | } |
120 | |
121 | bool InitHeaderSearch::(const Twine &Path, IncludeDirGroup Group, |
122 | bool isFramework, |
123 | std::optional<unsigned> UserEntryIdx) { |
124 | assert(!Path.isTriviallyEmpty() && "can't handle empty path here" ); |
125 | |
126 | FileManager &FM = Headers.getFileMgr(); |
127 | SmallString<256> MappedPathStorage; |
128 | StringRef MappedPathStr = Path.toStringRef(Out&: MappedPathStorage); |
129 | |
130 | // If use system headers while cross-compiling, emit the warning. |
131 | if (HasSysroot && (MappedPathStr.starts_with(Prefix: "/usr/include" ) || |
132 | MappedPathStr.starts_with(Prefix: "/usr/local/include" ))) { |
133 | Headers.getDiags().Report(diag::warn_poison_system_directories) |
134 | << MappedPathStr; |
135 | } |
136 | |
137 | // Compute the DirectoryLookup type. |
138 | SrcMgr::CharacteristicKind Type; |
139 | if (Group == Quoted || Group == Angled) { |
140 | Type = SrcMgr::C_User; |
141 | } else if (Group == ExternCSystem) { |
142 | Type = SrcMgr::C_ExternCSystem; |
143 | } else { |
144 | Type = SrcMgr::C_System; |
145 | } |
146 | |
147 | // If the directory exists, add it. |
148 | if (auto DE = FM.getOptionalDirectoryRef(DirName: MappedPathStr)) { |
149 | IncludePath.emplace_back(args&: Group, args: DirectoryLookup(*DE, Type, isFramework), |
150 | args&: UserEntryIdx); |
151 | return true; |
152 | } |
153 | |
154 | // Check to see if this is an apple-style headermap (which are not allowed to |
155 | // be frameworks). |
156 | if (!isFramework) { |
157 | if (auto FE = FM.getOptionalFileRef(Filename: MappedPathStr)) { |
158 | if (const HeaderMap *HM = Headers.CreateHeaderMap(FE: *FE)) { |
159 | // It is a headermap, add it to the search path. |
160 | IncludePath.emplace_back(args&: Group, args: DirectoryLookup(HM, Type), |
161 | args&: UserEntryIdx); |
162 | return true; |
163 | } |
164 | } |
165 | } |
166 | |
167 | if (Verbose) |
168 | llvm::errs() << "ignoring nonexistent directory \"" |
169 | << MappedPathStr << "\"\n" ; |
170 | return false; |
171 | } |
172 | |
173 | void InitHeaderSearch::(const llvm::Triple &triple, |
174 | const HeaderSearchOptions &HSOpts) { |
175 | if (!ShouldAddDefaultIncludePaths(triple)) |
176 | llvm_unreachable("Include management is handled in the driver." ); |
177 | |
178 | if (HSOpts.UseStandardSystemIncludes) { |
179 | // FIXME: temporary hack: hard-coded paths. |
180 | AddPath(Path: "/usr/local/include" , Group: System, isFramework: false); |
181 | } |
182 | |
183 | // Builtin includes use #include_next directives and should be positioned |
184 | // just prior C include dirs. |
185 | if (HSOpts.UseBuiltinIncludes) { |
186 | // Ignore the sys root, we *always* look for clang headers relative to |
187 | // supplied path. |
188 | SmallString<128> P = StringRef(HSOpts.ResourceDir); |
189 | llvm::sys::path::append(path&: P, a: "include" ); |
190 | AddUnmappedPath(Path: P, Group: ExternCSystem, isFramework: false); |
191 | } |
192 | |
193 | // All remaining additions are for system include directories, early exit if |
194 | // we aren't using them. |
195 | if (!HSOpts.UseStandardSystemIncludes) |
196 | return; |
197 | |
198 | // Add dirs specified via 'configure --with-c-include-dirs'. |
199 | StringRef CIncludeDirs(C_INCLUDE_DIRS); |
200 | if (CIncludeDirs != "" ) { |
201 | SmallVector<StringRef, 5> dirs; |
202 | CIncludeDirs.split(A&: dirs, Separator: ":" ); |
203 | for (StringRef dir : dirs) |
204 | AddPath(Path: dir, Group: ExternCSystem, isFramework: false); |
205 | return; |
206 | } |
207 | |
208 | AddPath(Path: "/usr/include" , Group: ExternCSystem, isFramework: false); |
209 | } |
210 | |
211 | bool InitHeaderSearch::( |
212 | const llvm::Triple &triple) { |
213 | switch (triple.getOS()) { |
214 | case llvm::Triple::AIX: |
215 | case llvm::Triple::DragonFly: |
216 | case llvm::Triple::ELFIAMCU: |
217 | case llvm::Triple::Emscripten: |
218 | case llvm::Triple::FreeBSD: |
219 | case llvm::Triple::Fuchsia: |
220 | case llvm::Triple::Haiku: |
221 | case llvm::Triple::Hurd: |
222 | case llvm::Triple::Linux: |
223 | case llvm::Triple::LiteOS: |
224 | case llvm::Triple::NaCl: |
225 | case llvm::Triple::NetBSD: |
226 | case llvm::Triple::OpenBSD: |
227 | case llvm::Triple::PS4: |
228 | case llvm::Triple::PS5: |
229 | case llvm::Triple::RTEMS: |
230 | case llvm::Triple::Solaris: |
231 | case llvm::Triple::UEFI: |
232 | case llvm::Triple::WASI: |
233 | case llvm::Triple::Win32: |
234 | case llvm::Triple::ZOS: |
235 | return false; |
236 | |
237 | case llvm::Triple::UnknownOS: |
238 | if (triple.isWasm() || triple.isAppleMachO()) |
239 | return false; |
240 | break; |
241 | |
242 | default: |
243 | break; |
244 | } |
245 | |
246 | if (triple.isOSDarwin()) |
247 | return false; |
248 | |
249 | return true; // Everything else uses AddDefaultIncludePaths(). |
250 | } |
251 | |
252 | void InitHeaderSearch::( |
253 | const LangOptions &Lang, const llvm::Triple &triple, |
254 | const HeaderSearchOptions &HSOpts) { |
255 | // NB: This code path is going away. All of the logic is moving into the |
256 | // driver which has the information necessary to do target-specific |
257 | // selections of default include paths. Each target which moves there will be |
258 | // exempted from this logic in ShouldAddDefaultIncludePaths() until we can |
259 | // delete the entire pile of code. |
260 | if (!ShouldAddDefaultIncludePaths(triple)) |
261 | return; |
262 | |
263 | if (Lang.CPlusPlus && !Lang.AsmPreprocessor && |
264 | HSOpts.UseStandardCXXIncludes && HSOpts.UseStandardSystemIncludes) { |
265 | if (HSOpts.UseLibcxx) { |
266 | AddPath(Path: "/usr/include/c++/v1" , Group: CXXSystem, isFramework: false); |
267 | } |
268 | } |
269 | |
270 | AddDefaultCIncludePaths(triple, HSOpts); |
271 | } |
272 | |
273 | /// If there are duplicate directory entries in the specified search list, |
274 | /// remove the later (dead) ones. Returns the number of non-system headers |
275 | /// removed, which is used to update NumAngled. |
276 | static unsigned RemoveDuplicates(std::vector<DirectoryLookupInfo> &SearchList, |
277 | unsigned First, bool Verbose) { |
278 | llvm::SmallPtrSet<const DirectoryEntry *, 8> SeenDirs; |
279 | llvm::SmallPtrSet<const DirectoryEntry *, 8> SeenFrameworkDirs; |
280 | llvm::SmallPtrSet<const HeaderMap *, 8> ; |
281 | unsigned NonSystemRemoved = 0; |
282 | for (unsigned i = First; i != SearchList.size(); ++i) { |
283 | unsigned DirToRemove = i; |
284 | |
285 | const DirectoryLookup &CurEntry = SearchList[i].Lookup; |
286 | |
287 | if (CurEntry.isNormalDir()) { |
288 | // If this isn't the first time we've seen this dir, remove it. |
289 | if (SeenDirs.insert(Ptr: CurEntry.getDir()).second) |
290 | continue; |
291 | } else if (CurEntry.isFramework()) { |
292 | // If this isn't the first time we've seen this framework dir, remove it. |
293 | if (SeenFrameworkDirs.insert(Ptr: CurEntry.getFrameworkDir()).second) |
294 | continue; |
295 | } else { |
296 | assert(CurEntry.isHeaderMap() && "Not a headermap or normal dir?" ); |
297 | // If this isn't the first time we've seen this headermap, remove it. |
298 | if (SeenHeaderMaps.insert(Ptr: CurEntry.getHeaderMap()).second) |
299 | continue; |
300 | } |
301 | |
302 | // If we have a normal #include dir/framework/headermap that is shadowed |
303 | // later in the chain by a system include location, we actually want to |
304 | // ignore the user's request and drop the user dir... keeping the system |
305 | // dir. This is weird, but required to emulate GCC's search path correctly. |
306 | // |
307 | // Since dupes of system dirs are rare, just rescan to find the original |
308 | // that we're nuking instead of using a DenseMap. |
309 | if (CurEntry.getDirCharacteristic() != SrcMgr::C_User) { |
310 | // Find the dir that this is the same of. |
311 | unsigned FirstDir; |
312 | for (FirstDir = First;; ++FirstDir) { |
313 | assert(FirstDir != i && "Didn't find dupe?" ); |
314 | |
315 | const DirectoryLookup &SearchEntry = SearchList[FirstDir].Lookup; |
316 | |
317 | // If these are different lookup types, then they can't be the dupe. |
318 | if (SearchEntry.getLookupType() != CurEntry.getLookupType()) |
319 | continue; |
320 | |
321 | bool isSame; |
322 | if (CurEntry.isNormalDir()) |
323 | isSame = SearchEntry.getDir() == CurEntry.getDir(); |
324 | else if (CurEntry.isFramework()) |
325 | isSame = SearchEntry.getFrameworkDir() == CurEntry.getFrameworkDir(); |
326 | else { |
327 | assert(CurEntry.isHeaderMap() && "Not a headermap or normal dir?" ); |
328 | isSame = SearchEntry.getHeaderMap() == CurEntry.getHeaderMap(); |
329 | } |
330 | |
331 | if (isSame) |
332 | break; |
333 | } |
334 | |
335 | // If the first dir in the search path is a non-system dir, zap it |
336 | // instead of the system one. |
337 | if (SearchList[FirstDir].Lookup.getDirCharacteristic() == SrcMgr::C_User) |
338 | DirToRemove = FirstDir; |
339 | } |
340 | |
341 | if (Verbose) { |
342 | llvm::errs() << "ignoring duplicate directory \"" |
343 | << CurEntry.getName() << "\"\n" ; |
344 | if (DirToRemove != i) |
345 | llvm::errs() << " as it is a non-system directory that duplicates " |
346 | << "a system directory\n" ; |
347 | } |
348 | if (DirToRemove != i) |
349 | ++NonSystemRemoved; |
350 | |
351 | // This is reached if the current entry is a duplicate. Remove the |
352 | // DirToRemove (usually the current dir). |
353 | SearchList.erase(position: SearchList.begin()+DirToRemove); |
354 | --i; |
355 | } |
356 | return NonSystemRemoved; |
357 | } |
358 | |
359 | /// Extract DirectoryLookups from DirectoryLookupInfos. |
360 | static std::vector<DirectoryLookup> |
361 | (const std::vector<DirectoryLookupInfo> &Infos) { |
362 | std::vector<DirectoryLookup> Lookups; |
363 | Lookups.reserve(n: Infos.size()); |
364 | llvm::transform(Range: Infos, d_first: std::back_inserter(x&: Lookups), |
365 | F: [](const DirectoryLookupInfo &Info) { return Info.Lookup; }); |
366 | return Lookups; |
367 | } |
368 | |
369 | /// Collect the mapping between indices of DirectoryLookups and UserEntries. |
370 | static llvm::DenseMap<unsigned, unsigned> |
371 | mapToUserEntries(const std::vector<DirectoryLookupInfo> &Infos) { |
372 | llvm::DenseMap<unsigned, unsigned> LookupsToUserEntries; |
373 | for (unsigned I = 0, E = Infos.size(); I < E; ++I) { |
374 | // Check whether this DirectoryLookup maps to a HeaderSearch::UserEntry. |
375 | if (Infos[I].UserEntryIdx) |
376 | LookupsToUserEntries.insert(KV: {I, *Infos[I].UserEntryIdx}); |
377 | } |
378 | return LookupsToUserEntries; |
379 | } |
380 | |
381 | void InitHeaderSearch::(const LangOptions &Lang) { |
382 | // Concatenate ANGLE+SYSTEM+AFTER chains together into SearchList. |
383 | std::vector<DirectoryLookupInfo> SearchList; |
384 | SearchList.reserve(n: IncludePath.size()); |
385 | |
386 | // Quoted arguments go first. |
387 | for (auto &Include : IncludePath) |
388 | if (Include.Group == Quoted) |
389 | SearchList.push_back(x: Include); |
390 | |
391 | // Deduplicate and remember index. |
392 | RemoveDuplicates(SearchList, First: 0, Verbose); |
393 | unsigned NumQuoted = SearchList.size(); |
394 | |
395 | for (auto &Include : IncludePath) |
396 | if (Include.Group == Angled) |
397 | SearchList.push_back(x: Include); |
398 | |
399 | RemoveDuplicates(SearchList, First: NumQuoted, Verbose); |
400 | unsigned NumAngled = SearchList.size(); |
401 | |
402 | for (auto &Include : IncludePath) |
403 | if (Include.Group == System || Include.Group == ExternCSystem || |
404 | (!Lang.ObjC && !Lang.CPlusPlus && Include.Group == CSystem) || |
405 | (/*FIXME !Lang.ObjC && */ Lang.CPlusPlus && |
406 | Include.Group == CXXSystem) || |
407 | (Lang.ObjC && !Lang.CPlusPlus && Include.Group == ObjCSystem) || |
408 | (Lang.ObjC && Lang.CPlusPlus && Include.Group == ObjCXXSystem)) |
409 | SearchList.push_back(x: Include); |
410 | |
411 | for (auto &Include : IncludePath) |
412 | if (Include.Group == After) |
413 | SearchList.push_back(x: Include); |
414 | |
415 | // Remove duplicates across both the Angled and System directories. GCC does |
416 | // this and failing to remove duplicates across these two groups breaks |
417 | // #include_next. |
418 | unsigned NonSystemRemoved = RemoveDuplicates(SearchList, First: NumQuoted, Verbose); |
419 | NumAngled -= NonSystemRemoved; |
420 | |
421 | Headers.SetSearchPaths(dirs: extractLookups(Infos: SearchList), angledDirIdx: NumQuoted, systemDirIdx: NumAngled, |
422 | searchDirToHSEntry: mapToUserEntries(Infos: SearchList)); |
423 | |
424 | Headers.SetSystemHeaderPrefixes(SystemHeaderPrefixes); |
425 | |
426 | // If verbose, print the list of directories that will be searched. |
427 | if (Verbose) { |
428 | llvm::errs() << "#include \"...\" search starts here:\n" ; |
429 | for (unsigned i = 0, e = SearchList.size(); i != e; ++i) { |
430 | if (i == NumQuoted) |
431 | llvm::errs() << "#include <...> search starts here:\n" ; |
432 | StringRef Name = SearchList[i].Lookup.getName(); |
433 | const char *Suffix; |
434 | if (SearchList[i].Lookup.isNormalDir()) |
435 | Suffix = "" ; |
436 | else if (SearchList[i].Lookup.isFramework()) |
437 | Suffix = " (framework directory)" ; |
438 | else { |
439 | assert(SearchList[i].Lookup.isHeaderMap() && "Unknown DirectoryLookup" ); |
440 | Suffix = " (headermap)" ; |
441 | } |
442 | llvm::errs() << " " << Name << Suffix << "\n" ; |
443 | } |
444 | llvm::errs() << "End of search list.\n" ; |
445 | } |
446 | } |
447 | |
448 | void clang::(HeaderSearch &HS, |
449 | const HeaderSearchOptions &HSOpts, |
450 | const LangOptions &Lang, |
451 | const llvm::Triple &Triple) { |
452 | InitHeaderSearch Init(HS, HSOpts.Verbose, HSOpts.Sysroot); |
453 | |
454 | // Add the user defined entries. |
455 | for (unsigned i = 0, e = HSOpts.UserEntries.size(); i != e; ++i) { |
456 | const HeaderSearchOptions::Entry &E = HSOpts.UserEntries[i]; |
457 | if (E.IgnoreSysRoot) { |
458 | Init.AddUnmappedPath(Path: E.Path, Group: E.Group, isFramework: E.IsFramework, UserEntryIdx: i); |
459 | } else { |
460 | Init.AddPath(Path: E.Path, Group: E.Group, isFramework: E.IsFramework, UserEntryIdx: i); |
461 | } |
462 | } |
463 | |
464 | Init.AddDefaultIncludePaths(Lang, triple: Triple, HSOpts); |
465 | |
466 | for (unsigned i = 0, e = HSOpts.SystemHeaderPrefixes.size(); i != e; ++i) |
467 | Init.AddSystemHeaderPrefix(Prefix: HSOpts.SystemHeaderPrefixes[i].Prefix, |
468 | IsSystemHeader: HSOpts.SystemHeaderPrefixes[i].IsSystemHeader); |
469 | |
470 | if (HSOpts.UseBuiltinIncludes) { |
471 | // Set up the builtin include directory in the module map. |
472 | SmallString<128> P = StringRef(HSOpts.ResourceDir); |
473 | llvm::sys::path::append(path&: P, a: "include" ); |
474 | if (auto Dir = HS.getFileMgr().getOptionalDirectoryRef(DirName: P)) |
475 | HS.getModuleMap().setBuiltinIncludeDir(*Dir); |
476 | } |
477 | |
478 | Init.Realize(Lang); |
479 | } |
480 | |