clang  8.0.0svn
HeaderSearch.cpp
Go to the documentation of this file.
1 //===- HeaderSearch.cpp - Resolve Header File Locations -------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the DirectoryLookup and HeaderSearch interfaces.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Lex/HeaderSearch.h"
15 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/Module.h"
22 #include "clang/Lex/HeaderMap.h"
25 #include "clang/Lex/ModuleMap.h"
26 #include "clang/Lex/Preprocessor.h"
27 #include "llvm/ADT/APInt.h"
28 #include "llvm/ADT/Hashing.h"
29 #include "llvm/ADT/SmallString.h"
30 #include "llvm/ADT/SmallVector.h"
31 #include "llvm/ADT/StringRef.h"
32 #include "llvm/Support/Allocator.h"
33 #include "llvm/Support/Capacity.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/FileSystem.h"
36 #include "llvm/Support/Path.h"
37 #include "llvm/Support/VirtualFileSystem.h"
38 #include <algorithm>
39 #include <cassert>
40 #include <cstddef>
41 #include <cstdio>
42 #include <cstring>
43 #include <string>
44 #include <system_error>
45 #include <utility>
46 
47 using namespace clang;
48 
49 const IdentifierInfo *
51  if (ControllingMacro) {
53  assert(External && "We must have an external source if we have a "
54  "controlling macro that is out of date.");
55  External->updateOutOfDateIdentifier(
56  *const_cast<IdentifierInfo *>(ControllingMacro));
57  }
58  return ControllingMacro;
59  }
60 
61  if (!ControllingMacroID || !External)
62  return nullptr;
63 
65  return ControllingMacro;
66 }
67 
69 
70 HeaderSearch::HeaderSearch(std::shared_ptr<HeaderSearchOptions> HSOpts,
71  SourceManager &SourceMgr, DiagnosticsEngine &Diags,
72  const LangOptions &LangOpts,
73  const TargetInfo *Target)
74  : HSOpts(std::move(HSOpts)), Diags(Diags),
75  FileMgr(SourceMgr.getFileManager()), FrameworkMap(64),
76  ModMap(SourceMgr, Diags, LangOpts, Target, *this) {}
77 
79  fprintf(stderr, "\n*** HeaderSearch Stats:\n");
80  fprintf(stderr, "%d files tracked.\n", (int)FileInfo.size());
81  unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
82  for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
83  NumOnceOnlyFiles += FileInfo[i].isImport;
84  if (MaxNumIncludes < FileInfo[i].NumIncludes)
85  MaxNumIncludes = FileInfo[i].NumIncludes;
86  NumSingleIncludedFiles += FileInfo[i].NumIncludes == 1;
87  }
88  fprintf(stderr, " %d #import/#pragma once files.\n", NumOnceOnlyFiles);
89  fprintf(stderr, " %d included exactly once.\n", NumSingleIncludedFiles);
90  fprintf(stderr, " %d max times a file is included.\n", MaxNumIncludes);
91 
92  fprintf(stderr, " %d #include/#include_next/#import.\n", NumIncluded);
93  fprintf(stderr, " %d #includes skipped due to"
94  " the multi-include optimization.\n", NumMultiIncludeFileOptzn);
95 
96  fprintf(stderr, "%d framework lookups.\n", NumFrameworkLookups);
97  fprintf(stderr, "%d subframework lookups.\n", NumSubFrameworkLookups);
98 }
99 
100 /// CreateHeaderMap - This method returns a HeaderMap for the specified
101 /// FileEntry, uniquing them through the 'HeaderMaps' datastructure.
103  // We expect the number of headermaps to be small, and almost always empty.
104  // If it ever grows, use of a linear search should be re-evaluated.
105  if (!HeaderMaps.empty()) {
106  for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
107  // Pointer equality comparison of FileEntries works because they are
108  // already uniqued by inode.
109  if (HeaderMaps[i].first == FE)
110  return HeaderMaps[i].second.get();
111  }
112 
113  if (std::unique_ptr<HeaderMap> HM = HeaderMap::Create(FE, FileMgr)) {
114  HeaderMaps.emplace_back(FE, std::move(HM));
115  return HeaderMaps.back().second.get();
116  }
117 
118  return nullptr;
119 }
120 
121 /// Get filenames for all registered header maps.
123  SmallVectorImpl<std::string> &Names) const {
124  for (auto &HM : HeaderMaps)
125  Names.push_back(HM.first->getName());
126 }
127 
129  const FileEntry *ModuleMap =
131  return getCachedModuleFileName(Module->Name, ModuleMap->getName());
132 }
133 
134 std::string HeaderSearch::getPrebuiltModuleFileName(StringRef ModuleName,
135  bool FileMapOnly) {
136  // First check the module name to pcm file map.
137  auto i (HSOpts->PrebuiltModuleFiles.find(ModuleName));
138  if (i != HSOpts->PrebuiltModuleFiles.end())
139  return i->second;
140 
141  if (FileMapOnly || HSOpts->PrebuiltModulePaths.empty())
142  return {};
143 
144  // Then go through each prebuilt module directory and try to find the pcm
145  // file.
146  for (const std::string &Dir : HSOpts->PrebuiltModulePaths) {
148  llvm::sys::fs::make_absolute(Result);
149  llvm::sys::path::append(Result, ModuleName + ".pcm");
150  if (getFileMgr().getFile(Result.str()))
151  return Result.str().str();
152  }
153  return {};
154 }
155 
156 std::string HeaderSearch::getCachedModuleFileName(StringRef ModuleName,
157  StringRef ModuleMapPath) {
158  // If we don't have a module cache path or aren't supposed to use one, we
159  // can't do anything.
160  if (getModuleCachePath().empty())
161  return {};
162 
164  llvm::sys::fs::make_absolute(Result);
165 
166  if (HSOpts->DisableModuleHash) {
167  llvm::sys::path::append(Result, ModuleName + ".pcm");
168  } else {
169  // Construct the name <ModuleName>-<hash of ModuleMapPath>.pcm which should
170  // ideally be globally unique to this particular module. Name collisions
171  // in the hash are safe (because any translation unit can only import one
172  // module with each name), but result in a loss of caching.
173  //
174  // To avoid false-negatives, we form as canonical a path as we can, and map
175  // to lower-case in case we're on a case-insensitive file system.
176  std::string Parent = llvm::sys::path::parent_path(ModuleMapPath);
177  if (Parent.empty())
178  Parent = ".";
179  auto *Dir = FileMgr.getDirectory(Parent);
180  if (!Dir)
181  return {};
182  auto DirName = FileMgr.getCanonicalName(Dir);
183  auto FileName = llvm::sys::path::filename(ModuleMapPath);
184 
185  llvm::hash_code Hash =
186  llvm::hash_combine(DirName.lower(), FileName.lower());
187 
188  SmallString<128> HashStr;
189  llvm::APInt(64, size_t(Hash)).toStringUnsigned(HashStr, /*Radix*/36);
190  llvm::sys::path::append(Result, ModuleName + "-" + HashStr + ".pcm");
191  }
192  return Result.str().str();
193 }
194 
195 Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch,
196  bool AllowExtraModuleMapSearch) {
197  // Look in the module map to determine if there is a module by this name.
198  Module *Module = ModMap.findModule(ModuleName);
199  if (Module || !AllowSearch || !HSOpts->ImplicitModuleMaps)
200  return Module;
201 
202  StringRef SearchName = ModuleName;
203  Module = lookupModule(ModuleName, SearchName, AllowExtraModuleMapSearch);
204 
205  // The facility for "private modules" -- adjacent, optional module maps named
206  // module.private.modulemap that are supposed to define private submodules --
207  // may have different flavors of names: FooPrivate, Foo_Private and Foo.Private.
208  //
209  // Foo.Private is now deprecated in favor of Foo_Private. Users of FooPrivate
210  // should also rename to Foo_Private. Representing private as submodules
211  // could force building unwanted dependencies into the parent module and cause
212  // dependency cycles.
213  if (!Module && SearchName.consume_back("_Private"))
214  Module = lookupModule(ModuleName, SearchName, AllowExtraModuleMapSearch);
215  if (!Module && SearchName.consume_back("Private"))
216  Module = lookupModule(ModuleName, SearchName, AllowExtraModuleMapSearch);
217  return Module;
218 }
219 
220 Module *HeaderSearch::lookupModule(StringRef ModuleName, StringRef SearchName,
221  bool AllowExtraModuleMapSearch) {
222  Module *Module = nullptr;
223 
224  // Look through the various header search paths to load any available module
225  // maps, searching for a module map that describes this module.
226  for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
227  if (SearchDirs[Idx].isFramework()) {
228  // Search for or infer a module map for a framework. Here we use
229  // SearchName rather than ModuleName, to permit finding private modules
230  // named FooPrivate in buggy frameworks named Foo.
231  SmallString<128> FrameworkDirName;
232  FrameworkDirName += SearchDirs[Idx].getFrameworkDir()->getName();
233  llvm::sys::path::append(FrameworkDirName, SearchName + ".framework");
234  if (const DirectoryEntry *FrameworkDir
235  = FileMgr.getDirectory(FrameworkDirName)) {
236  bool IsSystem
237  = SearchDirs[Idx].getDirCharacteristic() != SrcMgr::C_User;
238  Module = loadFrameworkModule(ModuleName, FrameworkDir, IsSystem);
239  if (Module)
240  break;
241  }
242  }
243 
244  // FIXME: Figure out how header maps and module maps will work together.
245 
246  // Only deal with normal search directories.
247  if (!SearchDirs[Idx].isNormalDir())
248  continue;
249 
250  bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory();
251  // Search for a module map file in this directory.
252  if (loadModuleMapFile(SearchDirs[Idx].getDir(), IsSystem,
253  /*IsFramework*/false) == LMM_NewlyLoaded) {
254  // We just loaded a module map file; check whether the module is
255  // available now.
256  Module = ModMap.findModule(ModuleName);
257  if (Module)
258  break;
259  }
260 
261  // Search for a module map in a subdirectory with the same name as the
262  // module.
263  SmallString<128> NestedModuleMapDirName;
264  NestedModuleMapDirName = SearchDirs[Idx].getDir()->getName();
265  llvm::sys::path::append(NestedModuleMapDirName, ModuleName);
266  if (loadModuleMapFile(NestedModuleMapDirName, IsSystem,
267  /*IsFramework*/false) == LMM_NewlyLoaded){
268  // If we just loaded a module map file, look for the module again.
269  Module = ModMap.findModule(ModuleName);
270  if (Module)
271  break;
272  }
273 
274  // If we've already performed the exhaustive search for module maps in this
275  // search directory, don't do it again.
276  if (SearchDirs[Idx].haveSearchedAllModuleMaps())
277  continue;
278 
279  // Load all module maps in the immediate subdirectories of this search
280  // directory if ModuleName was from @import.
281  if (AllowExtraModuleMapSearch)
282  loadSubdirectoryModuleMaps(SearchDirs[Idx]);
283 
284  // Look again for the module.
285  Module = ModMap.findModule(ModuleName);
286  if (Module)
287  break;
288  }
289 
290  return Module;
291 }
292 
293 //===----------------------------------------------------------------------===//
294 // File lookup within a DirectoryLookup scope
295 //===----------------------------------------------------------------------===//
296 
297 /// getName - Return the directory or filename corresponding to this lookup
298 /// object.
299 StringRef DirectoryLookup::getName() const {
300  if (isNormalDir())
301  return getDir()->getName();
302  if (isFramework())
303  return getFrameworkDir()->getName();
304  assert(isHeaderMap() && "Unknown DirectoryLookup");
305  return getHeaderMap()->getFileName();
306 }
307 
308 const FileEntry *HeaderSearch::getFileAndSuggestModule(
309  StringRef FileName, SourceLocation IncludeLoc, const DirectoryEntry *Dir,
310  bool IsSystemHeaderDir, Module *RequestingModule,
311  ModuleMap::KnownHeader *SuggestedModule) {
312  // If we have a module map that might map this header, load it and
313  // check whether we'll have a suggestion for a module.
314  const FileEntry *File = getFileMgr().getFile(FileName, /*OpenFile=*/true);
315  if (!File)
316  return nullptr;
317 
318  // If there is a module that corresponds to this header, suggest it.
319  if (!findUsableModuleForHeader(File, Dir ? Dir : File->getDir(),
320  RequestingModule, SuggestedModule,
321  IsSystemHeaderDir))
322  return nullptr;
323 
324  return File;
325 }
326 
327 /// LookupFile - Lookup the specified file in this search path, returning it
328 /// if it exists or returning null if not.
330  StringRef &Filename,
331  HeaderSearch &HS,
332  SourceLocation IncludeLoc,
333  SmallVectorImpl<char> *SearchPath,
334  SmallVectorImpl<char> *RelativePath,
335  Module *RequestingModule,
336  ModuleMap::KnownHeader *SuggestedModule,
337  bool &InUserSpecifiedSystemFramework,
338  bool &HasBeenMapped,
339  SmallVectorImpl<char> &MappedName) const {
340  InUserSpecifiedSystemFramework = false;
341  HasBeenMapped = false;
342 
343  SmallString<1024> TmpDir;
344  if (isNormalDir()) {
345  // Concatenate the requested file onto the directory.
346  TmpDir = getDir()->getName();
347  llvm::sys::path::append(TmpDir, Filename);
348  if (SearchPath) {
349  StringRef SearchPathRef(getDir()->getName());
350  SearchPath->clear();
351  SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
352  }
353  if (RelativePath) {
354  RelativePath->clear();
355  RelativePath->append(Filename.begin(), Filename.end());
356  }
357 
358  return HS.getFileAndSuggestModule(TmpDir, IncludeLoc, getDir(),
359  isSystemHeaderDirectory(),
360  RequestingModule, SuggestedModule);
361  }
362 
363  if (isFramework())
364  return DoFrameworkLookup(Filename, HS, SearchPath, RelativePath,
365  RequestingModule, SuggestedModule,
366  InUserSpecifiedSystemFramework);
367 
368  assert(isHeaderMap() && "Unknown directory lookup");
369  const HeaderMap *HM = getHeaderMap();
370  SmallString<1024> Path;
371  StringRef Dest = HM->lookupFilename(Filename, Path);
372  if (Dest.empty())
373  return nullptr;
374 
375  const FileEntry *Result;
376 
377  // Check if the headermap maps the filename to a framework include
378  // ("Foo.h" -> "Foo/Foo.h"), in which case continue header lookup using the
379  // framework include.
380  if (llvm::sys::path::is_relative(Dest)) {
381  MappedName.clear();
382  MappedName.append(Dest.begin(), Dest.end());
383  Filename = StringRef(MappedName.begin(), MappedName.size());
384  HasBeenMapped = true;
385  Result = HM->LookupFile(Filename, HS.getFileMgr());
386  } else {
387  Result = HS.getFileMgr().getFile(Dest);
388  }
389 
390  if (Result) {
391  if (SearchPath) {
392  StringRef SearchPathRef(getName());
393  SearchPath->clear();
394  SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
395  }
396  if (RelativePath) {
397  RelativePath->clear();
398  RelativePath->append(Filename.begin(), Filename.end());
399  }
400  }
401  return Result;
402 }
403 
404 /// Given a framework directory, find the top-most framework directory.
405 ///
406 /// \param FileMgr The file manager to use for directory lookups.
407 /// \param DirName The name of the framework directory.
408 /// \param SubmodulePath Will be populated with the submodule path from the
409 /// returned top-level module to the originally named framework.
410 static const DirectoryEntry *
411 getTopFrameworkDir(FileManager &FileMgr, StringRef DirName,
412  SmallVectorImpl<std::string> &SubmodulePath) {
413  assert(llvm::sys::path::extension(DirName) == ".framework" &&
414  "Not a framework directory");
415 
416  // Note: as an egregious but useful hack we use the real path here, because
417  // frameworks moving between top-level frameworks to embedded frameworks tend
418  // to be symlinked, and we base the logical structure of modules on the
419  // physical layout. In particular, we need to deal with crazy includes like
420  //
421  // #include <Foo/Frameworks/Bar.framework/Headers/Wibble.h>
422  //
423  // where 'Bar' used to be embedded in 'Foo', is now a top-level framework
424  // which one should access with, e.g.,
425  //
426  // #include <Bar/Wibble.h>
427  //
428  // Similar issues occur when a top-level framework has moved into an
429  // embedded framework.
430  const DirectoryEntry *TopFrameworkDir = FileMgr.getDirectory(DirName);
431  DirName = FileMgr.getCanonicalName(TopFrameworkDir);
432  do {
433  // Get the parent directory name.
434  DirName = llvm::sys::path::parent_path(DirName);
435  if (DirName.empty())
436  break;
437 
438  // Determine whether this directory exists.
439  const DirectoryEntry *Dir = FileMgr.getDirectory(DirName);
440  if (!Dir)
441  break;
442 
443  // If this is a framework directory, then we're a subframework of this
444  // framework.
445  if (llvm::sys::path::extension(DirName) == ".framework") {
446  SubmodulePath.push_back(llvm::sys::path::stem(DirName));
447  TopFrameworkDir = Dir;
448  }
449  } while (true);
450 
451  return TopFrameworkDir;
452 }
453 
454 static bool needModuleLookup(Module *RequestingModule,
455  bool HasSuggestedModule) {
456  return HasSuggestedModule ||
457  (RequestingModule && RequestingModule->NoUndeclaredIncludes);
458 }
459 
460 /// DoFrameworkLookup - Do a lookup of the specified file in the current
461 /// DirectoryLookup, which is a framework directory.
462 const FileEntry *DirectoryLookup::DoFrameworkLookup(
463  StringRef Filename, HeaderSearch &HS, SmallVectorImpl<char> *SearchPath,
464  SmallVectorImpl<char> *RelativePath, Module *RequestingModule,
465  ModuleMap::KnownHeader *SuggestedModule,
466  bool &InUserSpecifiedSystemFramework) const {
467  FileManager &FileMgr = HS.getFileMgr();
468 
469  // Framework names must have a '/' in the filename.
470  size_t SlashPos = Filename.find('/');
471  if (SlashPos == StringRef::npos) return nullptr;
472 
473  // Find out if this is the home for the specified framework, by checking
474  // HeaderSearch. Possible answers are yes/no and unknown.
475  HeaderSearch::FrameworkCacheEntry &CacheEntry =
476  HS.LookupFrameworkCache(Filename.substr(0, SlashPos));
477 
478  // If it is known and in some other directory, fail.
479  if (CacheEntry.Directory && CacheEntry.Directory != getFrameworkDir())
480  return nullptr;
481 
482  // Otherwise, construct the path to this framework dir.
483 
484  // FrameworkName = "/System/Library/Frameworks/"
485  SmallString<1024> FrameworkName;
486  FrameworkName += getFrameworkDir()->getName();
487  if (FrameworkName.empty() || FrameworkName.back() != '/')
488  FrameworkName.push_back('/');
489 
490  // FrameworkName = "/System/Library/Frameworks/Cocoa"
491  StringRef ModuleName(Filename.begin(), SlashPos);
492  FrameworkName += ModuleName;
493 
494  // FrameworkName = "/System/Library/Frameworks/Cocoa.framework/"
495  FrameworkName += ".framework/";
496 
497  // If the cache entry was unresolved, populate it now.
498  if (!CacheEntry.Directory) {
500 
501  // If the framework dir doesn't exist, we fail.
502  const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName);
503  if (!Dir) return nullptr;
504 
505  // Otherwise, if it does, remember that this is the right direntry for this
506  // framework.
507  CacheEntry.Directory = getFrameworkDir();
508 
509  // If this is a user search directory, check if the framework has been
510  // user-specified as a system framework.
511  if (getDirCharacteristic() == SrcMgr::C_User) {
512  SmallString<1024> SystemFrameworkMarker(FrameworkName);
513  SystemFrameworkMarker += ".system_framework";
514  if (llvm::sys::fs::exists(SystemFrameworkMarker)) {
515  CacheEntry.IsUserSpecifiedSystemFramework = true;
516  }
517  }
518  }
519 
520  // Set the 'user-specified system framework' flag.
521  InUserSpecifiedSystemFramework = CacheEntry.IsUserSpecifiedSystemFramework;
522 
523  if (RelativePath) {
524  RelativePath->clear();
525  RelativePath->append(Filename.begin()+SlashPos+1, Filename.end());
526  }
527 
528  // Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h"
529  unsigned OrigSize = FrameworkName.size();
530 
531  FrameworkName += "Headers/";
532 
533  if (SearchPath) {
534  SearchPath->clear();
535  // Without trailing '/'.
536  SearchPath->append(FrameworkName.begin(), FrameworkName.end()-1);
537  }
538 
539  FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end());
540  const FileEntry *FE = FileMgr.getFile(FrameworkName,
541  /*openFile=*/!SuggestedModule);
542  if (!FE) {
543  // Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h"
544  const char *Private = "Private";
545  FrameworkName.insert(FrameworkName.begin()+OrigSize, Private,
546  Private+strlen(Private));
547  if (SearchPath)
548  SearchPath->insert(SearchPath->begin()+OrigSize, Private,
549  Private+strlen(Private));
550 
551  FE = FileMgr.getFile(FrameworkName, /*openFile=*/!SuggestedModule);
552  }
553 
554  // If we found the header and are allowed to suggest a module, do so now.
555  if (FE && needModuleLookup(RequestingModule, SuggestedModule)) {
556  // Find the framework in which this header occurs.
557  StringRef FrameworkPath = FE->getDir()->getName();
558  bool FoundFramework = false;
559  do {
560  // Determine whether this directory exists.
561  const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkPath);
562  if (!Dir)
563  break;
564 
565  // If this is a framework directory, then we're a subframework of this
566  // framework.
567  if (llvm::sys::path::extension(FrameworkPath) == ".framework") {
568  FoundFramework = true;
569  break;
570  }
571 
572  // Get the parent directory name.
573  FrameworkPath = llvm::sys::path::parent_path(FrameworkPath);
574  if (FrameworkPath.empty())
575  break;
576  } while (true);
577 
578  bool IsSystem = getDirCharacteristic() != SrcMgr::C_User;
579  if (FoundFramework) {
580  if (!HS.findUsableModuleForFrameworkHeader(
581  FE, FrameworkPath, RequestingModule, SuggestedModule, IsSystem))
582  return nullptr;
583  } else {
584  if (!HS.findUsableModuleForHeader(FE, getDir(), RequestingModule,
585  SuggestedModule, IsSystem))
586  return nullptr;
587  }
588  }
589  return FE;
590 }
591 
593  ModMap.setTarget(Target);
594 }
595 
596 //===----------------------------------------------------------------------===//
597 // Header File Location.
598 //===----------------------------------------------------------------------===//
599 
600 /// Return true with a diagnostic if the file that MSVC would have found
601 /// fails to match the one that Clang would have found with MSVC header search
602 /// disabled.
604  const FileEntry *MSFE, const FileEntry *FE,
605  SourceLocation IncludeLoc) {
606  if (MSFE && FE != MSFE) {
607  Diags.Report(IncludeLoc, diag::ext_pp_include_search_ms) << MSFE->getName();
608  return true;
609  }
610  return false;
611 }
612 
613 static const char *copyString(StringRef Str, llvm::BumpPtrAllocator &Alloc) {
614  assert(!Str.empty());
615  char *CopyStr = Alloc.Allocate<char>(Str.size()+1);
616  std::copy(Str.begin(), Str.end(), CopyStr);
617  CopyStr[Str.size()] = '\0';
618  return CopyStr;
619 }
620 
621 static bool isFrameworkStylePath(StringRef Path, bool &IsPrivateHeader,
622  SmallVectorImpl<char> &FrameworkName) {
623  using namespace llvm::sys;
624  path::const_iterator I = path::begin(Path);
625  path::const_iterator E = path::end(Path);
626  IsPrivateHeader = false;
627 
628  // Detect different types of framework style paths:
629  //
630  // ...Foo.framework/{Headers,PrivateHeaders}
631  // ...Foo.framework/Versions/{A,Current}/{Headers,PrivateHeaders}
632  // ...Foo.framework/Frameworks/Nested.framework/{Headers,PrivateHeaders}
633  // ...<other variations with 'Versions' like in the above path>
634  //
635  // and some other variations among these lines.
636  int FoundComp = 0;
637  while (I != E) {
638  if (*I == "Headers")
639  ++FoundComp;
640  if (I->endswith(".framework")) {
641  FrameworkName.append(I->begin(), I->end());
642  ++FoundComp;
643  }
644  if (*I == "PrivateHeaders") {
645  ++FoundComp;
646  IsPrivateHeader = true;
647  }
648  ++I;
649  }
650 
651  return !FrameworkName.empty() && FoundComp >= 2;
652 }
653 
654 static void
656  StringRef Includer, StringRef IncludeFilename,
657  const FileEntry *IncludeFE, bool isAngled = false,
658  bool FoundByHeaderMap = false) {
659  bool IsIncluderPrivateHeader = false;
660  SmallString<128> FromFramework, ToFramework;
661  if (!isFrameworkStylePath(Includer, IsIncluderPrivateHeader, FromFramework))
662  return;
663  bool IsIncludeePrivateHeader = false;
664  bool IsIncludeeInFramework = isFrameworkStylePath(
665  IncludeFE->getName(), IsIncludeePrivateHeader, ToFramework);
666 
667  if (!isAngled && !FoundByHeaderMap) {
668  SmallString<128> NewInclude("<");
669  if (IsIncludeeInFramework) {
670  NewInclude += StringRef(ToFramework).drop_back(10); // drop .framework
671  NewInclude += "/";
672  }
673  NewInclude += IncludeFilename;
674  NewInclude += ">";
675  Diags.Report(IncludeLoc, diag::warn_quoted_include_in_framework_header)
676  << IncludeFilename
677  << FixItHint::CreateReplacement(IncludeLoc, NewInclude);
678  }
679 
680  // Headers in Foo.framework/Headers should not include headers
681  // from Foo.framework/PrivateHeaders, since this violates public/private
682  // API boundaries and can cause modular dependency cycles.
683  if (!IsIncluderPrivateHeader && IsIncludeeInFramework &&
684  IsIncludeePrivateHeader && FromFramework == ToFramework)
685  Diags.Report(IncludeLoc, diag::warn_framework_include_private_from_public)
686  << IncludeFilename;
687 }
688 
689 /// LookupFile - Given a "foo" or <foo> reference, look up the indicated file,
690 /// return null on failure. isAngled indicates whether the file reference is
691 /// for system \#include's or not (i.e. using <> instead of ""). Includers, if
692 /// non-empty, indicates where the \#including file(s) are, in case a relative
693 /// search is needed. Microsoft mode will pass all \#including files.
695  StringRef Filename, SourceLocation IncludeLoc, bool isAngled,
696  const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir,
697  ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>> Includers,
698  SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
699  Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule,
700  bool *IsMapped, bool SkipCache, bool BuildSystemModule) {
701  if (IsMapped)
702  *IsMapped = false;
703 
704  if (SuggestedModule)
705  *SuggestedModule = ModuleMap::KnownHeader();
706 
707  // If 'Filename' is absolute, check to see if it exists and no searching.
708  if (llvm::sys::path::is_absolute(Filename)) {
709  CurDir = nullptr;
710 
711  // If this was an #include_next "/absolute/file", fail.
712  if (FromDir) return nullptr;
713 
714  if (SearchPath)
715  SearchPath->clear();
716  if (RelativePath) {
717  RelativePath->clear();
718  RelativePath->append(Filename.begin(), Filename.end());
719  }
720  // Otherwise, just return the file.
721  return getFileAndSuggestModule(Filename, IncludeLoc, nullptr,
722  /*IsSystemHeaderDir*/false,
723  RequestingModule, SuggestedModule);
724  }
725 
726  // This is the header that MSVC's header search would have found.
727  const FileEntry *MSFE = nullptr;
728  ModuleMap::KnownHeader MSSuggestedModule;
729 
730  // Unless disabled, check to see if the file is in the #includer's
731  // directory. This cannot be based on CurDir, because each includer could be
732  // a #include of a subdirectory (#include "foo/bar.h") and a subsequent
733  // include of "baz.h" should resolve to "whatever/foo/baz.h".
734  // This search is not done for <> headers.
735  if (!Includers.empty() && !isAngled && !NoCurDirSearch) {
736  SmallString<1024> TmpDir;
737  bool First = true;
738  for (const auto &IncluderAndDir : Includers) {
739  const FileEntry *Includer = IncluderAndDir.first;
740 
741  // Concatenate the requested file onto the directory.
742  // FIXME: Portability. Filename concatenation should be in sys::Path.
743  TmpDir = IncluderAndDir.second->getName();
744  TmpDir.push_back('/');
745  TmpDir.append(Filename.begin(), Filename.end());
746 
747  // FIXME: We don't cache the result of getFileInfo across the call to
748  // getFileAndSuggestModule, because it's a reference to an element of
749  // a container that could be reallocated across this call.
750  //
751  // If we have no includer, that means we're processing a #include
752  // from a module build. We should treat this as a system header if we're
753  // building a [system] module.
754  bool IncluderIsSystemHeader =
755  Includer ? getFileInfo(Includer).DirInfo != SrcMgr::C_User :
756  BuildSystemModule;
757  if (const FileEntry *FE = getFileAndSuggestModule(
758  TmpDir, IncludeLoc, IncluderAndDir.second, IncluderIsSystemHeader,
759  RequestingModule, SuggestedModule)) {
760  if (!Includer) {
761  assert(First && "only first includer can have no file");
762  return FE;
763  }
764 
765  // Leave CurDir unset.
766  // This file is a system header or C++ unfriendly if the old file is.
767  //
768  // Note that we only use one of FromHFI/ToHFI at once, due to potential
769  // reallocation of the underlying vector potentially making the first
770  // reference binding dangling.
771  HeaderFileInfo &FromHFI = getFileInfo(Includer);
772  unsigned DirInfo = FromHFI.DirInfo;
773  bool IndexHeaderMapHeader = FromHFI.IndexHeaderMapHeader;
774  StringRef Framework = FromHFI.Framework;
775 
776  HeaderFileInfo &ToHFI = getFileInfo(FE);
777  ToHFI.DirInfo = DirInfo;
778  ToHFI.IndexHeaderMapHeader = IndexHeaderMapHeader;
779  ToHFI.Framework = Framework;
780 
781  if (SearchPath) {
782  StringRef SearchPathRef(IncluderAndDir.second->getName());
783  SearchPath->clear();
784  SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
785  }
786  if (RelativePath) {
787  RelativePath->clear();
788  RelativePath->append(Filename.begin(), Filename.end());
789  }
790  if (First) {
791  diagnoseFrameworkInclude(Diags, IncludeLoc,
792  IncluderAndDir.second->getName(), Filename,
793  FE);
794  return FE;
795  }
796 
797  // Otherwise, we found the path via MSVC header search rules. If
798  // -Wmsvc-include is enabled, we have to keep searching to see if we
799  // would've found this header in -I or -isystem directories.
800  if (Diags.isIgnored(diag::ext_pp_include_search_ms, IncludeLoc)) {
801  return FE;
802  } else {
803  MSFE = FE;
804  if (SuggestedModule) {
805  MSSuggestedModule = *SuggestedModule;
806  *SuggestedModule = ModuleMap::KnownHeader();
807  }
808  break;
809  }
810  }
811  First = false;
812  }
813  }
814 
815  CurDir = nullptr;
816 
817  // If this is a system #include, ignore the user #include locs.
818  unsigned i = isAngled ? AngledDirIdx : 0;
819 
820  // If this is a #include_next request, start searching after the directory the
821  // file was found in.
822  if (FromDir)
823  i = FromDir-&SearchDirs[0];
824 
825  // Cache all of the lookups performed by this method. Many headers are
826  // multiply included, and the "pragma once" optimization prevents them from
827  // being relex/pp'd, but they would still have to search through a
828  // (potentially huge) series of SearchDirs to find it.
829  LookupFileCacheInfo &CacheLookup = LookupFileCache[Filename];
830 
831  // If the entry has been previously looked up, the first value will be
832  // non-zero. If the value is equal to i (the start point of our search), then
833  // this is a matching hit.
834  if (!SkipCache && CacheLookup.StartIdx == i+1) {
835  // Skip querying potentially lots of directories for this lookup.
836  i = CacheLookup.HitIdx;
837  if (CacheLookup.MappedName) {
838  Filename = CacheLookup.MappedName;
839  if (IsMapped)
840  *IsMapped = true;
841  }
842  } else {
843  // Otherwise, this is the first query, or the previous query didn't match
844  // our search start. We will fill in our found location below, so prime the
845  // start point value.
846  CacheLookup.reset(/*StartIdx=*/i+1);
847  }
848 
849  SmallString<64> MappedName;
850 
851  // Check each directory in sequence to see if it contains this file.
852  for (; i != SearchDirs.size(); ++i) {
853  bool InUserSpecifiedSystemFramework = false;
854  bool HasBeenMapped = false;
855  const FileEntry *FE = SearchDirs[i].LookupFile(
856  Filename, *this, IncludeLoc, SearchPath, RelativePath, RequestingModule,
857  SuggestedModule, InUserSpecifiedSystemFramework, HasBeenMapped,
858  MappedName);
859  if (HasBeenMapped) {
860  CacheLookup.MappedName =
861  copyString(Filename, LookupFileCache.getAllocator());
862  if (IsMapped)
863  *IsMapped = true;
864  }
865  if (!FE) continue;
866 
867  CurDir = &SearchDirs[i];
868 
869  // This file is a system header or C++ unfriendly if the dir is.
870  HeaderFileInfo &HFI = getFileInfo(FE);
871  HFI.DirInfo = CurDir->getDirCharacteristic();
872 
873  // If the directory characteristic is User but this framework was
874  // user-specified to be treated as a system framework, promote the
875  // characteristic.
876  if (HFI.DirInfo == SrcMgr::C_User && InUserSpecifiedSystemFramework)
878 
879  // If the filename matches a known system header prefix, override
880  // whether the file is a system header.
881  for (unsigned j = SystemHeaderPrefixes.size(); j; --j) {
882  if (Filename.startswith(SystemHeaderPrefixes[j-1].first)) {
883  HFI.DirInfo = SystemHeaderPrefixes[j-1].second ? SrcMgr::C_System
884  : SrcMgr::C_User;
885  break;
886  }
887  }
888 
889  // If this file is found in a header map and uses the framework style of
890  // includes, then this header is part of a framework we're building.
891  if (CurDir->isIndexHeaderMap()) {
892  size_t SlashPos = Filename.find('/');
893  if (SlashPos != StringRef::npos) {
894  HFI.IndexHeaderMapHeader = 1;
895  HFI.Framework = getUniqueFrameworkName(StringRef(Filename.begin(),
896  SlashPos));
897  }
898  }
899 
900  if (checkMSVCHeaderSearch(Diags, MSFE, FE, IncludeLoc)) {
901  if (SuggestedModule)
902  *SuggestedModule = MSSuggestedModule;
903  return MSFE;
904  }
905 
906  bool FoundByHeaderMap = !IsMapped ? false : *IsMapped;
907  if (!Includers.empty())
908  diagnoseFrameworkInclude(Diags, IncludeLoc,
909  Includers.front().second->getName(), Filename,
910  FE, isAngled, FoundByHeaderMap);
911 
912  // Remember this location for the next lookup we do.
913  CacheLookup.HitIdx = i;
914  return FE;
915  }
916 
917  // If we are including a file with a quoted include "foo.h" from inside
918  // a header in a framework that is currently being built, and we couldn't
919  // resolve "foo.h" any other way, change the include to <Foo/foo.h>, where
920  // "Foo" is the name of the framework in which the including header was found.
921  if (!Includers.empty() && Includers.front().first && !isAngled &&
922  Filename.find('/') == StringRef::npos) {
923  HeaderFileInfo &IncludingHFI = getFileInfo(Includers.front().first);
924  if (IncludingHFI.IndexHeaderMapHeader) {
925  SmallString<128> ScratchFilename;
926  ScratchFilename += IncludingHFI.Framework;
927  ScratchFilename += '/';
928  ScratchFilename += Filename;
929 
930  const FileEntry *FE =
931  LookupFile(ScratchFilename, IncludeLoc, /*isAngled=*/true, FromDir,
932  CurDir, Includers.front(), SearchPath, RelativePath,
933  RequestingModule, SuggestedModule, IsMapped);
934 
935  if (checkMSVCHeaderSearch(Diags, MSFE, FE, IncludeLoc)) {
936  if (SuggestedModule)
937  *SuggestedModule = MSSuggestedModule;
938  return MSFE;
939  }
940 
941  LookupFileCacheInfo &CacheLookup = LookupFileCache[Filename];
942  CacheLookup.HitIdx = LookupFileCache[ScratchFilename].HitIdx;
943  // FIXME: SuggestedModule.
944  return FE;
945  }
946  }
947 
948  if (checkMSVCHeaderSearch(Diags, MSFE, nullptr, IncludeLoc)) {
949  if (SuggestedModule)
950  *SuggestedModule = MSSuggestedModule;
951  return MSFE;
952  }
953 
954  // Otherwise, didn't find it. Remember we didn't find this.
955  CacheLookup.HitIdx = SearchDirs.size();
956  return nullptr;
957 }
958 
959 /// LookupSubframeworkHeader - Look up a subframework for the specified
960 /// \#include file. For example, if \#include'ing <HIToolbox/HIToolbox.h> from
961 /// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox
962 /// is a subframework within Carbon.framework. If so, return the FileEntry
963 /// for the designated file, otherwise return null.
966  const FileEntry *ContextFileEnt,
967  SmallVectorImpl<char> *SearchPath,
968  SmallVectorImpl<char> *RelativePath,
969  Module *RequestingModule,
970  ModuleMap::KnownHeader *SuggestedModule) {
971  assert(ContextFileEnt && "No context file?");
972 
973  // Framework names must have a '/' in the filename. Find it.
974  // FIXME: Should we permit '\' on Windows?
975  size_t SlashPos = Filename.find('/');
976  if (SlashPos == StringRef::npos) return nullptr;
977 
978  // Look up the base framework name of the ContextFileEnt.
979  StringRef ContextName = ContextFileEnt->getName();
980 
981  // If the context info wasn't a framework, couldn't be a subframework.
982  const unsigned DotFrameworkLen = 10;
983  auto FrameworkPos = ContextName.find(".framework");
984  if (FrameworkPos == StringRef::npos ||
985  (ContextName[FrameworkPos + DotFrameworkLen] != '/' &&
986  ContextName[FrameworkPos + DotFrameworkLen] != '\\'))
987  return nullptr;
988 
989  SmallString<1024> FrameworkName(ContextName.data(), ContextName.data() +
990  FrameworkPos +
991  DotFrameworkLen + 1);
992 
993  // Append Frameworks/HIToolbox.framework/
994  FrameworkName += "Frameworks/";
995  FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
996  FrameworkName += ".framework/";
997 
998  auto &CacheLookup =
999  *FrameworkMap.insert(std::make_pair(Filename.substr(0, SlashPos),
1000  FrameworkCacheEntry())).first;
1001 
1002  // Some other location?
1003  if (CacheLookup.second.Directory &&
1004  CacheLookup.first().size() == FrameworkName.size() &&
1005  memcmp(CacheLookup.first().data(), &FrameworkName[0],
1006  CacheLookup.first().size()) != 0)
1007  return nullptr;
1008 
1009  // Cache subframework.
1010  if (!CacheLookup.second.Directory) {
1011  ++NumSubFrameworkLookups;
1012 
1013  // If the framework dir doesn't exist, we fail.
1014  const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName);
1015  if (!Dir) return nullptr;
1016 
1017  // Otherwise, if it does, remember that this is the right direntry for this
1018  // framework.
1019  CacheLookup.second.Directory = Dir;
1020  }
1021 
1022  const FileEntry *FE = nullptr;
1023 
1024  if (RelativePath) {
1025  RelativePath->clear();
1026  RelativePath->append(Filename.begin()+SlashPos+1, Filename.end());
1027  }
1028 
1029  // Check ".../Frameworks/HIToolbox.framework/Headers/HIToolbox.h"
1030  SmallString<1024> HeadersFilename(FrameworkName);
1031  HeadersFilename += "Headers/";
1032  if (SearchPath) {
1033  SearchPath->clear();
1034  // Without trailing '/'.
1035  SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);
1036  }
1037 
1038  HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
1039  if (!(FE = FileMgr.getFile(HeadersFilename, /*openFile=*/true))) {
1040  // Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h"
1041  HeadersFilename = FrameworkName;
1042  HeadersFilename += "PrivateHeaders/";
1043  if (SearchPath) {
1044  SearchPath->clear();
1045  // Without trailing '/'.
1046  SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);
1047  }
1048 
1049  HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
1050  if (!(FE = FileMgr.getFile(HeadersFilename, /*openFile=*/true)))
1051  return nullptr;
1052  }
1053 
1054  // This file is a system header or C++ unfriendly if the old file is.
1055  //
1056  // Note that the temporary 'DirInfo' is required here, as either call to
1057  // getFileInfo could resize the vector and we don't want to rely on order
1058  // of evaluation.
1059  unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo;
1060  getFileInfo(FE).DirInfo = DirInfo;
1061 
1062  FrameworkName.pop_back(); // remove the trailing '/'
1063  if (!findUsableModuleForFrameworkHeader(FE, FrameworkName, RequestingModule,
1064  SuggestedModule, /*IsSystem*/ false))
1065  return nullptr;
1066 
1067  return FE;
1068 }
1069 
1070 //===----------------------------------------------------------------------===//
1071 // File Info Management.
1072 //===----------------------------------------------------------------------===//
1073 
1074 /// Merge the header file info provided by \p OtherHFI into the current
1075 /// header file info (\p HFI)
1077  const HeaderFileInfo &OtherHFI) {
1078  assert(OtherHFI.External && "expected to merge external HFI");
1079 
1080  HFI.isImport |= OtherHFI.isImport;
1081  HFI.isPragmaOnce |= OtherHFI.isPragmaOnce;
1082  HFI.isModuleHeader |= OtherHFI.isModuleHeader;
1083  HFI.NumIncludes += OtherHFI.NumIncludes;
1084 
1085  if (!HFI.ControllingMacro && !HFI.ControllingMacroID) {
1086  HFI.ControllingMacro = OtherHFI.ControllingMacro;
1087  HFI.ControllingMacroID = OtherHFI.ControllingMacroID;
1088  }
1089 
1090  HFI.DirInfo = OtherHFI.DirInfo;
1091  HFI.External = (!HFI.IsValid || HFI.External);
1092  HFI.IsValid = true;
1094 
1095  if (HFI.Framework.empty())
1096  HFI.Framework = OtherHFI.Framework;
1097 }
1098 
1099 /// getFileInfo - Return the HeaderFileInfo structure for the specified
1100 /// FileEntry.
1102  if (FE->getUID() >= FileInfo.size())
1103  FileInfo.resize(FE->getUID() + 1);
1104 
1105  HeaderFileInfo *HFI = &FileInfo[FE->getUID()];
1106  // FIXME: Use a generation count to check whether this is really up to date.
1107  if (ExternalSource && !HFI->Resolved) {
1108  HFI->Resolved = true;
1109  auto ExternalHFI = ExternalSource->GetHeaderFileInfo(FE);
1110 
1111  HFI = &FileInfo[FE->getUID()];
1112  if (ExternalHFI.External)
1113  mergeHeaderFileInfo(*HFI, ExternalHFI);
1114  }
1115 
1116  HFI->IsValid = true;
1117  // We have local information about this header file, so it's no longer
1118  // strictly external.
1119  HFI->External = false;
1120  return *HFI;
1121 }
1122 
1123 const HeaderFileInfo *
1125  bool WantExternal) const {
1126  // If we have an external source, ensure we have the latest information.
1127  // FIXME: Use a generation count to check whether this is really up to date.
1128  HeaderFileInfo *HFI;
1129  if (ExternalSource) {
1130  if (FE->getUID() >= FileInfo.size()) {
1131  if (!WantExternal)
1132  return nullptr;
1133  FileInfo.resize(FE->getUID() + 1);
1134  }
1135 
1136  HFI = &FileInfo[FE->getUID()];
1137  if (!WantExternal && (!HFI->IsValid || HFI->External))
1138  return nullptr;
1139  if (!HFI->Resolved) {
1140  HFI->Resolved = true;
1141  auto ExternalHFI = ExternalSource->GetHeaderFileInfo(FE);
1142 
1143  HFI = &FileInfo[FE->getUID()];
1144  if (ExternalHFI.External)
1145  mergeHeaderFileInfo(*HFI, ExternalHFI);
1146  }
1147  } else if (FE->getUID() >= FileInfo.size()) {
1148  return nullptr;
1149  } else {
1150  HFI = &FileInfo[FE->getUID()];
1151  }
1152 
1153  if (!HFI->IsValid || (HFI->External && !WantExternal))
1154  return nullptr;
1155 
1156  return HFI;
1157 }
1158 
1160  // Check if we've ever seen this file as a header.
1161  if (auto *HFI = getExistingFileInfo(File))
1162  return HFI->isPragmaOnce || HFI->isImport || HFI->ControllingMacro ||
1163  HFI->ControllingMacroID;
1164  return false;
1165 }
1166 
1169  bool isCompilingModuleHeader) {
1170  bool isModularHeader = !(Role & ModuleMap::TextualHeader);
1171 
1172  // Don't mark the file info as non-external if there's nothing to change.
1173  if (!isCompilingModuleHeader) {
1174  if (!isModularHeader)
1175  return;
1176  auto *HFI = getExistingFileInfo(FE);
1177  if (HFI && HFI->isModuleHeader)
1178  return;
1179  }
1180 
1181  auto &HFI = getFileInfo(FE);
1182  HFI.isModuleHeader |= isModularHeader;
1183  HFI.isCompilingModuleHeader |= isCompilingModuleHeader;
1184 }
1185 
1187  const FileEntry *File, bool isImport,
1188  bool ModulesEnabled, Module *M) {
1189  ++NumIncluded; // Count # of attempted #includes.
1190 
1191  // Get information about this file.
1192  HeaderFileInfo &FileInfo = getFileInfo(File);
1193 
1194  // FIXME: this is a workaround for the lack of proper modules-aware support
1195  // for #import / #pragma once
1196  auto TryEnterImported = [&]() -> bool {
1197  if (!ModulesEnabled)
1198  return false;
1199  // Ensure FileInfo bits are up to date.
1200  ModMap.resolveHeaderDirectives(File);
1201  // Modules with builtins are special; multiple modules use builtins as
1202  // modular headers, example:
1203  //
1204  // module stddef { header "stddef.h" export * }
1205  //
1206  // After module map parsing, this expands to:
1207  //
1208  // module stddef {
1209  // header "/path_to_builtin_dirs/stddef.h"
1210  // textual "stddef.h"
1211  // }
1212  //
1213  // It's common that libc++ and system modules will both define such
1214  // submodules. Make sure cached results for a builtin header won't
1215  // prevent other builtin modules to potentially enter the builtin header.
1216  // Note that builtins are header guarded and the decision to actually
1217  // enter them is postponed to the controlling macros logic below.
1218  bool TryEnterHdr = false;
1219  if (FileInfo.isCompilingModuleHeader && FileInfo.isModuleHeader)
1220  TryEnterHdr = File->getDir() == ModMap.getBuiltinDir() &&
1222  llvm::sys::path::filename(File->getName()));
1223 
1224  // Textual headers can be #imported from different modules. Since ObjC
1225  // headers find in the wild might rely only on #import and do not contain
1226  // controlling macros, be conservative and only try to enter textual headers
1227  // if such macro is present.
1228  if (!FileInfo.isModuleHeader &&
1229  FileInfo.getControllingMacro(ExternalLookup))
1230  TryEnterHdr = true;
1231  return TryEnterHdr;
1232  };
1233 
1234  // If this is a #import directive, check that we have not already imported
1235  // this header.
1236  if (isImport) {
1237  // If this has already been imported, don't import it again.
1238  FileInfo.isImport = true;
1239 
1240  // Has this already been #import'ed or #include'd?
1241  if (FileInfo.NumIncludes && !TryEnterImported())
1242  return false;
1243  } else {
1244  // Otherwise, if this is a #include of a file that was previously #import'd
1245  // or if this is the second #include of a #pragma once file, ignore it.
1246  if (FileInfo.isImport && !TryEnterImported())
1247  return false;
1248  }
1249 
1250  // Next, check to see if the file is wrapped with #ifndef guards. If so, and
1251  // if the macro that guards it is defined, we know the #include has no effect.
1252  if (const IdentifierInfo *ControllingMacro
1253  = FileInfo.getControllingMacro(ExternalLookup)) {
1254  // If the header corresponds to a module, check whether the macro is already
1255  // defined in that module rather than checking in the current set of visible
1256  // modules.
1257  if (M ? PP.isMacroDefinedInLocalModule(ControllingMacro, M)
1258  : PP.isMacroDefined(ControllingMacro)) {
1259  ++NumMultiIncludeFileOptzn;
1260  return false;
1261  }
1262  }
1263 
1264  // Increment the number of times this file has been included.
1265  ++FileInfo.NumIncludes;
1266 
1267  return true;
1268 }
1269 
1271  return SearchDirs.capacity()
1272  + llvm::capacity_in_bytes(FileInfo)
1273  + llvm::capacity_in_bytes(HeaderMaps)
1274  + LookupFileCache.getAllocator().getTotalMemory()
1275  + FrameworkMap.getAllocator().getTotalMemory();
1276 }
1277 
1278 StringRef HeaderSearch::getUniqueFrameworkName(StringRef Framework) {
1279  return FrameworkNames.insert(Framework).first->first();
1280 }
1281 
1282 bool HeaderSearch::hasModuleMap(StringRef FileName,
1283  const DirectoryEntry *Root,
1284  bool IsSystem) {
1285  if (!HSOpts->ImplicitModuleMaps)
1286  return false;
1287 
1288  SmallVector<const DirectoryEntry *, 2> FixUpDirectories;
1289 
1290  StringRef DirName = FileName;
1291  do {
1292  // Get the parent directory name.
1293  DirName = llvm::sys::path::parent_path(DirName);
1294  if (DirName.empty())
1295  return false;
1296 
1297  // Determine whether this directory exists.
1298  const DirectoryEntry *Dir = FileMgr.getDirectory(DirName);
1299  if (!Dir)
1300  return false;
1301 
1302  // Try to load the module map file in this directory.
1303  switch (loadModuleMapFile(Dir, IsSystem,
1304  llvm::sys::path::extension(Dir->getName()) ==
1305  ".framework")) {
1306  case LMM_NewlyLoaded:
1307  case LMM_AlreadyLoaded:
1308  // Success. All of the directories we stepped through inherit this module
1309  // map file.
1310  for (unsigned I = 0, N = FixUpDirectories.size(); I != N; ++I)
1311  DirectoryHasModuleMap[FixUpDirectories[I]] = true;
1312  return true;
1313 
1314  case LMM_NoDirectory:
1315  case LMM_InvalidModuleMap:
1316  break;
1317  }
1318 
1319  // If we hit the top of our search, we're done.
1320  if (Dir == Root)
1321  return false;
1322 
1323  // Keep track of all of the directories we checked, so we can mark them as
1324  // having module maps if we eventually do find a module map.
1325  FixUpDirectories.push_back(Dir);
1326  } while (true);
1327 }
1328 
1331  bool AllowTextual) const {
1332  if (ExternalSource) {
1333  // Make sure the external source has handled header info about this file,
1334  // which includes whether the file is part of a module.
1335  (void)getExistingFileInfo(File);
1336  }
1337  return ModMap.findModuleForHeader(File, AllowTextual);
1338 }
1339 
1340 static bool suggestModule(HeaderSearch &HS, const FileEntry *File,
1341  Module *RequestingModule,
1342  ModuleMap::KnownHeader *SuggestedModule) {
1344  HS.findModuleForHeader(File, /*AllowTextual*/true);
1345  if (SuggestedModule)
1346  *SuggestedModule = (Module.getRole() & ModuleMap::TextualHeader)
1348  : Module;
1349 
1350  // If this module specifies [no_undeclared_includes], we cannot find any
1351  // file that's in a non-dependency module.
1352  if (RequestingModule && Module && RequestingModule->NoUndeclaredIncludes) {
1353  HS.getModuleMap().resolveUses(RequestingModule, /*Complain*/false);
1354  if (!RequestingModule->directlyUses(Module.getModule())) {
1355  return false;
1356  }
1357  }
1358 
1359  return true;
1360 }
1361 
1362 bool HeaderSearch::findUsableModuleForHeader(
1363  const FileEntry *File, const DirectoryEntry *Root, Module *RequestingModule,
1364  ModuleMap::KnownHeader *SuggestedModule, bool IsSystemHeaderDir) {
1365  if (File && needModuleLookup(RequestingModule, SuggestedModule)) {
1366  // If there is a module that corresponds to this header, suggest it.
1367  hasModuleMap(File->getName(), Root, IsSystemHeaderDir);
1368  return suggestModule(*this, File, RequestingModule, SuggestedModule);
1369  }
1370  return true;
1371 }
1372 
1373 bool HeaderSearch::findUsableModuleForFrameworkHeader(
1374  const FileEntry *File, StringRef FrameworkName, Module *RequestingModule,
1375  ModuleMap::KnownHeader *SuggestedModule, bool IsSystemFramework) {
1376  // If we're supposed to suggest a module, look for one now.
1377  if (needModuleLookup(RequestingModule, SuggestedModule)) {
1378  // Find the top-level framework based on this framework.
1379  SmallVector<std::string, 4> SubmodulePath;
1380  const DirectoryEntry *TopFrameworkDir
1381  = ::getTopFrameworkDir(FileMgr, FrameworkName, SubmodulePath);
1382 
1383  // Determine the name of the top-level framework.
1384  StringRef ModuleName = llvm::sys::path::stem(TopFrameworkDir->getName());
1385 
1386  // Load this framework module. If that succeeds, find the suggested module
1387  // for this header, if any.
1388  loadFrameworkModule(ModuleName, TopFrameworkDir, IsSystemFramework);
1389 
1390  // FIXME: This can find a module not part of ModuleName, which is
1391  // important so that we're consistent about whether this header
1392  // corresponds to a module. Possibly we should lock down framework modules
1393  // so that this is not possible.
1394  return suggestModule(*this, File, RequestingModule, SuggestedModule);
1395  }
1396  return true;
1397 }
1398 
1399 static const FileEntry *getPrivateModuleMap(const FileEntry *File,
1400  FileManager &FileMgr) {
1401  StringRef Filename = llvm::sys::path::filename(File->getName());
1402  SmallString<128> PrivateFilename(File->getDir()->getName());
1403  if (Filename == "module.map")
1404  llvm::sys::path::append(PrivateFilename, "module_private.map");
1405  else if (Filename == "module.modulemap")
1406  llvm::sys::path::append(PrivateFilename, "module.private.modulemap");
1407  else
1408  return nullptr;
1409  return FileMgr.getFile(PrivateFilename);
1410 }
1411 
1412 bool HeaderSearch::loadModuleMapFile(const FileEntry *File, bool IsSystem,
1413  FileID ID, unsigned *Offset,
1414  StringRef OriginalModuleMapFile) {
1415  // Find the directory for the module. For frameworks, that may require going
1416  // up from the 'Modules' directory.
1417  const DirectoryEntry *Dir = nullptr;
1418  if (getHeaderSearchOpts().ModuleMapFileHomeIsCwd)
1419  Dir = FileMgr.getDirectory(".");
1420  else {
1421  if (!OriginalModuleMapFile.empty()) {
1422  // We're building a preprocessed module map. Find or invent the directory
1423  // that it originally occupied.
1424  Dir = FileMgr.getDirectory(
1425  llvm::sys::path::parent_path(OriginalModuleMapFile));
1426  if (!Dir) {
1427  auto *FakeFile = FileMgr.getVirtualFile(OriginalModuleMapFile, 0, 0);
1428  Dir = FakeFile->getDir();
1429  }
1430  } else {
1431  Dir = File->getDir();
1432  }
1433 
1434  StringRef DirName(Dir->getName());
1435  if (llvm::sys::path::filename(DirName) == "Modules") {
1436  DirName = llvm::sys::path::parent_path(DirName);
1437  if (DirName.endswith(".framework"))
1438  Dir = FileMgr.getDirectory(DirName);
1439  // FIXME: This assert can fail if there's a race between the above check
1440  // and the removal of the directory.
1441  assert(Dir && "parent must exist");
1442  }
1443  }
1444 
1445  switch (loadModuleMapFileImpl(File, IsSystem, Dir, ID, Offset)) {
1446  case LMM_AlreadyLoaded:
1447  case LMM_NewlyLoaded:
1448  return false;
1449  case LMM_NoDirectory:
1450  case LMM_InvalidModuleMap:
1451  return true;
1452  }
1453  llvm_unreachable("Unknown load module map result");
1454 }
1455 
1456 HeaderSearch::LoadModuleMapResult
1457 HeaderSearch::loadModuleMapFileImpl(const FileEntry *File, bool IsSystem,
1458  const DirectoryEntry *Dir, FileID ID,
1459  unsigned *Offset) {
1460  assert(File && "expected FileEntry");
1461 
1462  // Check whether we've already loaded this module map, and mark it as being
1463  // loaded in case we recursively try to load it from itself.
1464  auto AddResult = LoadedModuleMaps.insert(std::make_pair(File, true));
1465  if (!AddResult.second)
1466  return AddResult.first->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
1467 
1468  if (ModMap.parseModuleMapFile(File, IsSystem, Dir, ID, Offset)) {
1469  LoadedModuleMaps[File] = false;
1470  return LMM_InvalidModuleMap;
1471  }
1472 
1473  // Try to load a corresponding private module map.
1474  if (const FileEntry *PMMFile = getPrivateModuleMap(File, FileMgr)) {
1475  if (ModMap.parseModuleMapFile(PMMFile, IsSystem, Dir)) {
1476  LoadedModuleMaps[File] = false;
1477  return LMM_InvalidModuleMap;
1478  }
1479  }
1480 
1481  // This directory has a module map.
1482  return LMM_NewlyLoaded;
1483 }
1484 
1485 const FileEntry *
1486 HeaderSearch::lookupModuleMapFile(const DirectoryEntry *Dir, bool IsFramework) {
1487  if (!HSOpts->ImplicitModuleMaps)
1488  return nullptr;
1489  // For frameworks, the preferred spelling is Modules/module.modulemap, but
1490  // module.map at the framework root is also accepted.
1491  SmallString<128> ModuleMapFileName(Dir->getName());
1492  if (IsFramework)
1493  llvm::sys::path::append(ModuleMapFileName, "Modules");
1494  llvm::sys::path::append(ModuleMapFileName, "module.modulemap");
1495  if (const FileEntry *F = FileMgr.getFile(ModuleMapFileName))
1496  return F;
1497 
1498  // Continue to allow module.map
1499  ModuleMapFileName = Dir->getName();
1500  llvm::sys::path::append(ModuleMapFileName, "module.map");
1501  return FileMgr.getFile(ModuleMapFileName);
1502 }
1503 
1504 Module *HeaderSearch::loadFrameworkModule(StringRef Name,
1505  const DirectoryEntry *Dir,
1506  bool IsSystem) {
1507  if (Module *Module = ModMap.findModule(Name))
1508  return Module;
1509 
1510  // Try to load a module map file.
1511  switch (loadModuleMapFile(Dir, IsSystem, /*IsFramework*/true)) {
1512  case LMM_InvalidModuleMap:
1513  // Try to infer a module map from the framework directory.
1514  if (HSOpts->ImplicitModuleMaps)
1515  ModMap.inferFrameworkModule(Dir, IsSystem, /*Parent=*/nullptr);
1516  break;
1517 
1518  case LMM_AlreadyLoaded:
1519  case LMM_NoDirectory:
1520  return nullptr;
1521 
1522  case LMM_NewlyLoaded:
1523  break;
1524  }
1525 
1526  return ModMap.findModule(Name);
1527 }
1528 
1529 HeaderSearch::LoadModuleMapResult
1530 HeaderSearch::loadModuleMapFile(StringRef DirName, bool IsSystem,
1531  bool IsFramework) {
1532  if (const DirectoryEntry *Dir = FileMgr.getDirectory(DirName))
1533  return loadModuleMapFile(Dir, IsSystem, IsFramework);
1534 
1535  return LMM_NoDirectory;
1536 }
1537 
1538 HeaderSearch::LoadModuleMapResult
1539 HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir, bool IsSystem,
1540  bool IsFramework) {
1541  auto KnownDir = DirectoryHasModuleMap.find(Dir);
1542  if (KnownDir != DirectoryHasModuleMap.end())
1543  return KnownDir->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
1544 
1545  if (const FileEntry *ModuleMapFile = lookupModuleMapFile(Dir, IsFramework)) {
1546  LoadModuleMapResult Result =
1547  loadModuleMapFileImpl(ModuleMapFile, IsSystem, Dir);
1548  // Add Dir explicitly in case ModuleMapFile is in a subdirectory.
1549  // E.g. Foo.framework/Modules/module.modulemap
1550  // ^Dir ^ModuleMapFile
1551  if (Result == LMM_NewlyLoaded)
1552  DirectoryHasModuleMap[Dir] = true;
1553  else if (Result == LMM_InvalidModuleMap)
1554  DirectoryHasModuleMap[Dir] = false;
1555  return Result;
1556  }
1557  return LMM_InvalidModuleMap;
1558 }
1559 
1561  Modules.clear();
1562 
1563  if (HSOpts->ImplicitModuleMaps) {
1564  // Load module maps for each of the header search directories.
1565  for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
1566  bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory();
1567  if (SearchDirs[Idx].isFramework()) {
1568  std::error_code EC;
1569  SmallString<128> DirNative;
1570  llvm::sys::path::native(SearchDirs[Idx].getFrameworkDir()->getName(),
1571  DirNative);
1572 
1573  // Search each of the ".framework" directories to load them as modules.
1574  llvm::vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
1575  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
1576  DirEnd;
1577  Dir != DirEnd && !EC; Dir.increment(EC)) {
1578  if (llvm::sys::path::extension(Dir->path()) != ".framework")
1579  continue;
1580 
1581  const DirectoryEntry *FrameworkDir =
1582  FileMgr.getDirectory(Dir->path());
1583  if (!FrameworkDir)
1584  continue;
1585 
1586  // Load this framework module.
1587  loadFrameworkModule(llvm::sys::path::stem(Dir->path()), FrameworkDir,
1588  IsSystem);
1589  }
1590  continue;
1591  }
1592 
1593  // FIXME: Deal with header maps.
1594  if (SearchDirs[Idx].isHeaderMap())
1595  continue;
1596 
1597  // Try to load a module map file for the search directory.
1598  loadModuleMapFile(SearchDirs[Idx].getDir(), IsSystem,
1599  /*IsFramework*/ false);
1600 
1601  // Try to load module map files for immediate subdirectories of this
1602  // search directory.
1603  loadSubdirectoryModuleMaps(SearchDirs[Idx]);
1604  }
1605  }
1606 
1607  // Populate the list of modules.
1608  for (ModuleMap::module_iterator M = ModMap.module_begin(),
1609  MEnd = ModMap.module_end();
1610  M != MEnd; ++M) {
1611  Modules.push_back(M->getValue());
1612  }
1613 }
1614 
1616  if (!HSOpts->ImplicitModuleMaps)
1617  return;
1618 
1619  // Load module maps for each of the header search directories.
1620  for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
1621  // We only care about normal header directories.
1622  if (!SearchDirs[Idx].isNormalDir()) {
1623  continue;
1624  }
1625 
1626  // Try to load a module map file for the search directory.
1627  loadModuleMapFile(SearchDirs[Idx].getDir(),
1628  SearchDirs[Idx].isSystemHeaderDirectory(),
1629  SearchDirs[Idx].isFramework());
1630  }
1631 }
1632 
1633 void HeaderSearch::loadSubdirectoryModuleMaps(DirectoryLookup &SearchDir) {
1634  assert(HSOpts->ImplicitModuleMaps &&
1635  "Should not be loading subdirectory module maps");
1636 
1637  if (SearchDir.haveSearchedAllModuleMaps())
1638  return;
1639 
1640  std::error_code EC;
1641  SmallString<128> Dir = SearchDir.getDir()->getName();
1642  FileMgr.makeAbsolutePath(Dir);
1643  SmallString<128> DirNative;
1644  llvm::sys::path::native(Dir, DirNative);
1645  llvm::vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
1646  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
1647  Dir != DirEnd && !EC; Dir.increment(EC)) {
1648  bool IsFramework = llvm::sys::path::extension(Dir->path()) == ".framework";
1649  if (IsFramework == SearchDir.isFramework())
1650  loadModuleMapFile(Dir->path(), SearchDir.isSystemHeaderDirectory(),
1651  SearchDir.isFramework());
1652  }
1653 
1654  SearchDir.setSearchedAllModuleMaps(true);
1655 }
1656 
1658  bool *IsSystem) {
1659  // FIXME: We assume that the path name currently cached in the FileEntry is
1660  // the most appropriate one for this analysis (and that it's spelled the
1661  // same way as the corresponding header search path).
1662  return suggestPathToFileForDiagnostics(File->getName(), /*BuildDir=*/"",
1663  IsSystem);
1664 }
1665 
1667  llvm::StringRef File, llvm::StringRef WorkingDir, bool *IsSystem) {
1668  using namespace llvm::sys;
1669 
1670  unsigned BestPrefixLength = 0;
1671  unsigned BestSearchDir;
1672 
1673  for (unsigned I = 0; I != SearchDirs.size(); ++I) {
1674  // FIXME: Support this search within frameworks and header maps.
1675  if (!SearchDirs[I].isNormalDir())
1676  continue;
1677 
1678  StringRef Dir = SearchDirs[I].getDir()->getName();
1679  llvm::SmallString<32> DirPath(Dir.begin(), Dir.end());
1680  if (!WorkingDir.empty() && !path::is_absolute(Dir)) {
1681  auto err = fs::make_absolute(WorkingDir, DirPath);
1682  if (!err)
1683  path::remove_dots(DirPath, /*remove_dot_dot=*/true);
1684  Dir = DirPath;
1685  }
1686  for (auto NI = path::begin(File), NE = path::end(File),
1687  DI = path::begin(Dir), DE = path::end(Dir);
1688  /*termination condition in loop*/; ++NI, ++DI) {
1689  // '.' components in File are ignored.
1690  while (NI != NE && *NI == ".")
1691  ++NI;
1692  if (NI == NE)
1693  break;
1694 
1695  // '.' components in Dir are ignored.
1696  while (DI != DE && *DI == ".")
1697  ++DI;
1698  if (DI == DE) {
1699  // Dir is a prefix of File, up to '.' components and choice of path
1700  // separators.
1701  unsigned PrefixLength = NI - path::begin(File);
1702  if (PrefixLength > BestPrefixLength) {
1703  BestPrefixLength = PrefixLength;
1704  BestSearchDir = I;
1705  }
1706  break;
1707  }
1708 
1709  if (*NI != *DI)
1710  break;
1711  }
1712  }
1713 
1714  if (IsSystem)
1715  *IsSystem = BestPrefixLength ? BestSearchDir >= SystemDirIdx : false;
1716  return File.drop_front(BestPrefixLength);
1717 }
ModuleHeaderRole getRole() const
The role of this header within the module.
Definition: ModuleMap.h:167
std::string Name
The name of this module.
Definition: Module.h:68
static const DirectoryEntry * getTopFrameworkDir(FileManager &FileMgr, StringRef DirName, SmallVectorImpl< std::string > &SubmodulePath)
Given a framework directory, find the top-most framework directory.
std::string getPrebuiltModuleFileName(StringRef ModuleName, bool FileMapOnly=false)
Retrieve the name of the prebuilt module file that should be used to load a module with the given nam...
unsigned DirInfo
Keep track of whether this is a system header, and if so, whether it is C++ clean or not...
Definition: HeaderSearch.h:62
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
bool isIndexHeaderMap() const
Whether this header map is building a framework or not.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:117
Defines the clang::FileManager interface and associated types.
This header is part of the module (for layering purposes) but should be textually included...
Definition: ModuleMap.h:131
unsigned isPragmaOnce
True if this is a #pragma once file.
Definition: HeaderSearch.h:56
Defines the SourceManager interface.
void loadTopLevelSystemModules()
Load all known, top-level system modules.
Defines the clang::Module class, which describes a module in the source code.
void collectAllModules(SmallVectorImpl< Module *> &Modules)
Collect the set of all known, top-level modules.
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Definition: ModuleMap.cpp:1212
virtual IdentifierInfo * GetIdentifier(unsigned ID)=0
Return the identifier associated with the given ID number.
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
StringRef getName() const
getName - Return the directory or filename corresponding to this lookup object.
llvm::StringMap< Module * >::const_iterator module_iterator
Definition: ModuleMap.h:678
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1260
bool isFileMultipleIncludeGuarded(const FileEntry *File)
Determine whether this file is intended to be safe from multiple inclusions, e.g., it has #pragma once or a controlling macro.
FrameworkCacheEntry & LookupFrameworkCache(StringRef FWName)
Look up the specified framework name in our framework cache.
Definition: HeaderSearch.h:415
const FileEntry * lookupModuleMapFile(const DirectoryEntry *Dir, bool IsFramework)
Try to find a module map file in the given directory, returning nullptr if none is found...
unsigned isCompilingModuleHeader
Whether this header is part of the module that we are building.
Definition: HeaderSearch.h:72
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:655
StringRef lookupFilename(StringRef Filename, SmallVectorImpl< char > &DestPath) const
If the specified relative filename is located in this HeaderMap return the filename it is mapped to...
Definition: HeaderMap.cpp:211
unsigned isImport
True if this is a #import&#39;d or #pragma once file.
Definition: HeaderSearch.h:53
const HeaderFileInfo * getExistingFileInfo(const FileEntry *FE, bool WantExternal=true) const
Return the HeaderFileInfo structure for the specified FileEntry, if it has ever been filled in...
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
One of these records is kept for each identifier that is lexed.
This class represents an Apple concept known as a &#39;header map&#39;.
Definition: HeaderMap.h:67
unsigned getUID() const
Definition: FileManager.h:89
Definition: Format.h:2072
const FileEntry * LookupSubframeworkHeader(StringRef Filename, const FileEntry *ContextFileEnt, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule)
Look up a subframework for the specified #include file.
void setTarget(const TargetInfo &Target)
Set the target information for the header search, if not already known.
FileManager & getFileMgr() const
Definition: HeaderSearch.h:271
const IdentifierInfo * getControllingMacro(ExternalPreprocessorSource *External)
Retrieve the controlling macro for this header file, if any.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
Describes a module or submodule.
Definition: Module.h:65
unsigned External
Whether this header file info was supplied by an external source, and has not changed since...
Definition: HeaderSearch.h:66
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
Definition: ModuleMap.cpp:763
static bool isBuiltinHeader(StringRef FileName)
Is this a compiler builtin header?
Definition: ModuleMap.cpp:373
static bool needModuleLookup(Module *RequestingModule, bool HasSuggestedModule)
static void hash_combine(std::size_t &seed, const T &v)
std::string getCachedModuleFileName(Module *Module)
Retrieve the name of the cached module file that should be used to load the given module...
uint32_t Offset
Definition: CacheTokens.cpp:43
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
unsigned short NumIncludes
The number of times the file has been included already.
Definition: HeaderSearch.h:91
bool isMacroDefinedInLocalModule(const IdentifierInfo *II, Module *M)
Determine whether II is defined as a macro within the module M, if that is a module that we&#39;ve alread...
Definition: Preprocessor.h:943
Defines the Diagnostic-related interfaces.
bool loadModuleMapFile(const FileEntry *File, bool IsSystem, FileID ID=FileID(), unsigned *Offset=nullptr, StringRef OriginalModuleMapFile=StringRef())
Read the contents of the given module map file.
unsigned Resolved
Whether this structure is considered to already have been "resolved", meaning that it was loaded from...
Definition: HeaderSearch.h:76
The preprocessor keeps track of this information for each file that is #included. ...
Definition: HeaderSearch.h:51
void setTarget(const TargetInfo &Target)
Set the target information.
Definition: ModuleMap.cpp:327
unsigned NoUndeclaredIncludes
Whether files in this module can only include non-modular headers and headers from used modules...
Definition: Module.h:259
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:148
NodeId Parent
Definition: ASTDiff.cpp:192
StringRef getModuleCachePath() const
Retrieve the path to the module cache.
Definition: HeaderSearch.h:335
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
HeaderFileInfo & getFileInfo(const FileEntry *FE)
Return the HeaderFileInfo structure for the specified FileEntry, in preparation for updating it in so...
const DirectoryEntry * getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
ModuleHeaderRole
Flags describing the role of a module header.
Definition: ModuleMap.h:122
StringRef Filename
Definition: Format.cpp:1629
Exposes information about the current target.
Definition: TargetInfo.h:54
Abstract interface for external sources of preprocessor information.
Defines the clang::Preprocessor interface.
std::string suggestPathToFileForDiagnostics(const FileEntry *File, bool *IsSystem=nullptr)
Suggest a path by which the specified file could be found, for use in diagnostics to suggest a #inclu...
static const FileEntry * getPrivateModuleMap(const FileEntry *File, FileManager &FileMgr)
bool isFramework() const
isFramework - True if this is a framework directory.
HeaderSearchOptions & getHeaderSearchOpts() const
Retrieve the header-search options with which this header search was initialized. ...
Definition: HeaderSearch.h:269
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
static void diagnoseFrameworkInclude(DiagnosticsEngine &Diags, SourceLocation IncludeLoc, StringRef Includer, StringRef IncludeFilename, const FileEntry *IncludeFE, bool isAngled=false, bool FoundByHeaderMap=false)
const FileEntry * LookupFile(StringRef &Filename, HeaderSearch &HS, SourceLocation IncludeLoc, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool &InUserSpecifiedSystemFramework, bool &HasBeenMapped, SmallVectorImpl< char > &MappedName) const
LookupFile - Lookup the specified file in this search path, returning it if it exists or returning nu...
The result type of a method or function.
static const char * copyString(StringRef Str, llvm::BumpPtrAllocator &Alloc)
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:95
ModuleMap::KnownHeader findModuleForHeader(const FileEntry *File, bool AllowTextual=false) const
Retrieve the module that corresponds to the given file, if any.
const FileEntry * LookupFile(StringRef Filename, FileManager &FM) const
Check to see if the specified relative filename is located in this HeaderMap.
Definition: HeaderMap.cpp:200
unsigned isModuleHeader
Whether this header is part of a module.
Definition: HeaderSearch.h:69
#define false
Definition: stdbool.h:33
Encodes a location in the source.
bool isSystemHeaderDirectory() const
Whether this describes a system header directory.
StringRef getName() const
Definition: FileManager.h:85
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:60
static bool checkMSVCHeaderSearch(DiagnosticsEngine &Diags, const FileEntry *MSFE, const FileEntry *FE, SourceLocation IncludeLoc)
Return true with a diagnostic if the file that MSVC would have found fails to match the one that Clan...
SrcMgr::CharacteristicKind getDirCharacteristic() const
DirCharacteristic - The type of directory this is, one of the DirType enum values.
const IdentifierInfo * ControllingMacro
If this file has a #ifndef XXX (or equivalent) guard that protects the entire contents of the file...
Definition: HeaderSearch.h:108
bool ShouldEnterIncludeFile(Preprocessor &PP, const FileEntry *File, bool isImport, bool ModulesEnabled, Module *M)
Mark the specified file as a target of a #include, #include_next, or #import directive.
bool haveSearchedAllModuleMaps() const
Determine whether we have already searched this entire directory for module maps. ...
const FileEntry * LookupFile(StringRef Filename, SourceLocation IncludeLoc, bool isAngled, const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, ArrayRef< std::pair< const FileEntry *, const DirectoryEntry *>> Includers, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool SkipCache=false, bool BuildSystemModule=false)
Given a "foo" or <foo> reference, look up the indicated file, return null on failure.
bool isMacroDefined(StringRef Id)
Definition: Preprocessor.h:932
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
unsigned ControllingMacroID
The ID number of the controlling macro.
Definition: HeaderSearch.h:98
StringRef getCanonicalName(const DirectoryEntry *Dir)
Retrieve the canonical name for a given directory.
void getHeaderMapFileNames(SmallVectorImpl< std::string > &Names) const
Get filenames for all registered header maps.
Dataflow Directional Tag Classes.
const DirectoryEntry * getDir() const
getDir - Return the directory that this entry refers to.
void IncrementFrameworkLookupCount()
Definition: HeaderSearch.h:542
void MarkFileModuleHeader(const FileEntry *FE, ModuleMap::ModuleHeaderRole Role, bool isCompilingModuleHeader)
Mark the specified file as part of a module.
static bool suggestModule(HeaderSearch &HS, const FileEntry *File, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule)
virtual void updateOutOfDateIdentifier(IdentifierInfo &II)=0
Update an out-of-date identifier.
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
static void mergeHeaderFileInfo(HeaderFileInfo &HFI, const HeaderFileInfo &OtherHFI)
Merge the header file info provided by OtherHFI into the current header file info (HFI) ...
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:46
StringRef Framework
If this header came from a framework include, this is the name of the framework.
Definition: HeaderSearch.h:112
HeaderSearch(std::shared_ptr< HeaderSearchOptions > HSOpts, SourceManager &SourceMgr, DiagnosticsEngine &Diags, const LangOptions &LangOpts, const TargetInfo *Target)
Module * getModule() const
Retrieve the module the header is stored in.
Definition: ModuleMap.h:164
bool hasModuleMap(StringRef Filename, const DirectoryEntry *Root, bool IsSystem)
Determine whether there is a module map that may map the header with the given file name to a (sub)mo...
static bool isFrameworkStylePath(StringRef Path, bool &IsPrivateHeader, SmallVectorImpl< char > &FrameworkName)
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
bool directlyUses(const Module *Requested) const
Determine whether this module has declared its intention to directly use another module.
Definition: Module.cpp:259
const HeaderMap * CreateHeaderMap(const FileEntry *FE)
This method returns a HeaderMap for the specified FileEntry, uniquing them through the &#39;HeaderMaps&#39; d...
unsigned IndexHeaderMapHeader
Whether this is a header inside a framework that is currently being built.
Definition: HeaderSearch.h:85
unsigned IsValid
Whether this file has been looked up as a header.
Definition: HeaderSearch.h:88
void setSearchedAllModuleMaps(bool SAMM)
Specify whether we have already searched all of the subdirectories for module maps.
A header that is known to reside within a given module, whether it was included or excluded...
Definition: ModuleMap.h:149
This class handles loading and caching of source files into memory.
static std::unique_ptr< HeaderMap > Create(const FileEntry *FE, FileManager &FM)
This attempts to load the specified file as a header map.
Definition: HeaderMap.cpp:51
StringRef getUniqueFrameworkName(StringRef Framework)
Retrieve a uniqued framework name.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
StringRef getName() const
Definition: FileManager.h:52
size_t getTotalMemory() const