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