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/FileManager.h" 16 #include "clang/Basic/IdentifierTable.h" 17 #include "clang/Lex/HeaderMap.h" 18 #include "clang/Lex/HeaderSearchOptions.h" 19 #include "clang/Lex/LexDiagnostic.h" 20 #include "clang/Lex/Lexer.h" 21 #include "llvm/ADT/APInt.h" 22 #include "llvm/ADT/Hashing.h" 23 #include "llvm/ADT/SmallString.h" 24 #include "llvm/Support/Capacity.h" 25 #include "llvm/Support/FileSystem.h" 26 #include "llvm/Support/Path.h" 27 #include "llvm/Support/raw_ostream.h" 28 #include <cstdio> 29 #if defined(LLVM_ON_UNIX) 30 #include <limits.h> 31 #endif 32 using namespace clang; 33 34 const IdentifierInfo * 35 HeaderFileInfo::getControllingMacro(ExternalIdentifierLookup *External) { 36 if (ControllingMacro) 37 return ControllingMacro; 38 39 if (!ControllingMacroID || !External) 40 return nullptr; 41 42 ControllingMacro = External->GetIdentifier(ControllingMacroID); 43 return ControllingMacro; 44 } 45 46 ExternalHeaderFileInfoSource::~ExternalHeaderFileInfoSource() {} 47 48 HeaderSearch::HeaderSearch(IntrusiveRefCntPtr<HeaderSearchOptions> HSOpts, 49 SourceManager &SourceMgr, DiagnosticsEngine &Diags, 50 const LangOptions &LangOpts, 51 const TargetInfo *Target) 52 : HSOpts(HSOpts), Diags(Diags), FileMgr(SourceMgr.getFileManager()), 53 FrameworkMap(64), ModMap(SourceMgr, Diags, LangOpts, Target, *this) { 54 AngledDirIdx = 0; 55 SystemDirIdx = 0; 56 NoCurDirSearch = false; 57 58 ExternalLookup = nullptr; 59 ExternalSource = nullptr; 60 NumIncluded = 0; 61 NumMultiIncludeFileOptzn = 0; 62 NumFrameworkLookups = NumSubFrameworkLookups = 0; 63 64 EnabledModules = LangOpts.Modules; 65 } 66 67 HeaderSearch::~HeaderSearch() { 68 // Delete headermaps. 69 for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i) 70 delete HeaderMaps[i].second; 71 } 72 73 void HeaderSearch::PrintStats() { 74 fprintf(stderr, "\n*** HeaderSearch Stats:\n"); 75 fprintf(stderr, "%d files tracked.\n", (int)FileInfo.size()); 76 unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0; 77 for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) { 78 NumOnceOnlyFiles += FileInfo[i].isImport; 79 if (MaxNumIncludes < FileInfo[i].NumIncludes) 80 MaxNumIncludes = FileInfo[i].NumIncludes; 81 NumSingleIncludedFiles += FileInfo[i].NumIncludes == 1; 82 } 83 fprintf(stderr, " %d #import/#pragma once files.\n", NumOnceOnlyFiles); 84 fprintf(stderr, " %d included exactly once.\n", NumSingleIncludedFiles); 85 fprintf(stderr, " %d max times a file is included.\n", MaxNumIncludes); 86 87 fprintf(stderr, " %d #include/#include_next/#import.\n", NumIncluded); 88 fprintf(stderr, " %d #includes skipped due to" 89 " the multi-include optimization.\n", NumMultiIncludeFileOptzn); 90 91 fprintf(stderr, "%d framework lookups.\n", NumFrameworkLookups); 92 fprintf(stderr, "%d subframework lookups.\n", NumSubFrameworkLookups); 93 } 94 95 /// CreateHeaderMap - This method returns a HeaderMap for the specified 96 /// FileEntry, uniquing them through the 'HeaderMaps' datastructure. 97 const HeaderMap *HeaderSearch::CreateHeaderMap(const FileEntry *FE) { 98 // We expect the number of headermaps to be small, and almost always empty. 99 // If it ever grows, use of a linear search should be re-evaluated. 100 if (!HeaderMaps.empty()) { 101 for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i) 102 // Pointer equality comparison of FileEntries works because they are 103 // already uniqued by inode. 104 if (HeaderMaps[i].first == FE) 105 return HeaderMaps[i].second; 106 } 107 108 if (const HeaderMap *HM = HeaderMap::Create(FE, FileMgr)) { 109 HeaderMaps.push_back(std::make_pair(FE, HM)); 110 return HM; 111 } 112 113 return nullptr; 114 } 115 116 std::string HeaderSearch::getModuleFileName(Module *Module) { 117 const FileEntry *ModuleMap = 118 getModuleMap().getModuleMapFileForUniquing(Module); 119 return getModuleFileName(Module->Name, ModuleMap->getName()); 120 } 121 122 std::string HeaderSearch::getModuleFileName(StringRef ModuleName, 123 StringRef ModuleMapPath) { 124 // If we don't have a module cache path, we can't do anything. 125 if (ModuleCachePath.empty()) 126 return std::string(); 127 128 SmallString<256> Result(ModuleCachePath); 129 llvm::sys::fs::make_absolute(Result); 130 131 if (HSOpts->DisableModuleHash) { 132 llvm::sys::path::append(Result, ModuleName + ".pcm"); 133 } else { 134 // Construct the name <ModuleName>-<hash of ModuleMapPath>.pcm which should 135 // be globally unique to this particular module. To avoid false-negatives 136 // on case-insensitive filesystems, we use lower-case, which is safe because 137 // to cause a collision the modules must have the same name, which is an 138 // error if they are imported in the same translation. 139 SmallString<256> AbsModuleMapPath(ModuleMapPath); 140 llvm::sys::fs::make_absolute(AbsModuleMapPath); 141 llvm::APInt Code(64, llvm::hash_value(AbsModuleMapPath.str().lower())); 142 SmallString<128> HashStr; 143 Code.toStringUnsigned(HashStr, /*Radix*/36); 144 llvm::sys::path::append(Result, ModuleName + "-" + HashStr.str() + ".pcm"); 145 } 146 return Result.str().str(); 147 } 148 149 Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) { 150 // Look in the module map to determine if there is a module by this name. 151 Module *Module = ModMap.findModule(ModuleName); 152 if (Module || !AllowSearch) 153 return Module; 154 155 // Look through the various header search paths to load any available module 156 // maps, searching for a module map that describes this module. 157 for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) { 158 if (SearchDirs[Idx].isFramework()) { 159 // Search for or infer a module map for a framework. 160 SmallString<128> FrameworkDirName; 161 FrameworkDirName += SearchDirs[Idx].getFrameworkDir()->getName(); 162 llvm::sys::path::append(FrameworkDirName, ModuleName + ".framework"); 163 if (const DirectoryEntry *FrameworkDir 164 = FileMgr.getDirectory(FrameworkDirName)) { 165 bool IsSystem 166 = SearchDirs[Idx].getDirCharacteristic() != SrcMgr::C_User; 167 Module = loadFrameworkModule(ModuleName, FrameworkDir, IsSystem); 168 if (Module) 169 break; 170 } 171 } 172 173 // FIXME: Figure out how header maps and module maps will work together. 174 175 // Only deal with normal search directories. 176 if (!SearchDirs[Idx].isNormalDir()) 177 continue; 178 179 bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory(); 180 // Search for a module map file in this directory. 181 if (loadModuleMapFile(SearchDirs[Idx].getDir(), IsSystem, 182 /*IsFramework*/false) == LMM_NewlyLoaded) { 183 // We just loaded a module map file; check whether the module is 184 // available now. 185 Module = ModMap.findModule(ModuleName); 186 if (Module) 187 break; 188 } 189 190 // Search for a module map in a subdirectory with the same name as the 191 // module. 192 SmallString<128> NestedModuleMapDirName; 193 NestedModuleMapDirName = SearchDirs[Idx].getDir()->getName(); 194 llvm::sys::path::append(NestedModuleMapDirName, ModuleName); 195 if (loadModuleMapFile(NestedModuleMapDirName, IsSystem, 196 /*IsFramework*/false) == LMM_NewlyLoaded){ 197 // If we just loaded a module map file, look for the module again. 198 Module = ModMap.findModule(ModuleName); 199 if (Module) 200 break; 201 } 202 203 // If we've already performed the exhaustive search for module maps in this 204 // search directory, don't do it again. 205 if (SearchDirs[Idx].haveSearchedAllModuleMaps()) 206 continue; 207 208 // Load all module maps in the immediate subdirectories of this search 209 // directory. 210 loadSubdirectoryModuleMaps(SearchDirs[Idx]); 211 212 // Look again for the module. 213 Module = ModMap.findModule(ModuleName); 214 if (Module) 215 break; 216 } 217 218 return Module; 219 } 220 221 //===----------------------------------------------------------------------===// 222 // File lookup within a DirectoryLookup scope 223 //===----------------------------------------------------------------------===// 224 225 /// getName - Return the directory or filename corresponding to this lookup 226 /// object. 227 const char *DirectoryLookup::getName() const { 228 if (isNormalDir()) 229 return getDir()->getName(); 230 if (isFramework()) 231 return getFrameworkDir()->getName(); 232 assert(isHeaderMap() && "Unknown DirectoryLookup"); 233 return getHeaderMap()->getFileName(); 234 } 235 236 static const FileEntry * 237 getFileAndSuggestModule(HeaderSearch &HS, StringRef FileName, 238 const DirectoryEntry *Dir, bool IsSystemHeaderDir, 239 ModuleMap::KnownHeader *SuggestedModule) { 240 // If we have a module map that might map this header, load it and 241 // check whether we'll have a suggestion for a module. 242 HS.hasModuleMap(FileName, Dir, IsSystemHeaderDir); 243 if (SuggestedModule) { 244 const FileEntry *File = HS.getFileMgr().getFile(FileName, 245 /*OpenFile=*/false); 246 if (File) { 247 // If there is a module that corresponds to this header, suggest it. 248 *SuggestedModule = HS.findModuleForHeader(File); 249 250 // FIXME: This appears to be a no-op. We loaded the module map for this 251 // directory at the start of this function. 252 if (!SuggestedModule->getModule() && 253 HS.hasModuleMap(FileName, Dir, IsSystemHeaderDir)) 254 *SuggestedModule = HS.findModuleForHeader(File); 255 } 256 257 return File; 258 } 259 260 return HS.getFileMgr().getFile(FileName, /*openFile=*/true); 261 } 262 263 /// LookupFile - Lookup the specified file in this search path, returning it 264 /// if it exists or returning null if not. 265 const FileEntry *DirectoryLookup::LookupFile( 266 StringRef &Filename, 267 HeaderSearch &HS, 268 SmallVectorImpl<char> *SearchPath, 269 SmallVectorImpl<char> *RelativePath, 270 ModuleMap::KnownHeader *SuggestedModule, 271 bool &InUserSpecifiedSystemFramework, 272 bool &HasBeenMapped, 273 SmallVectorImpl<char> &MappedName) const { 274 InUserSpecifiedSystemFramework = false; 275 HasBeenMapped = false; 276 277 SmallString<1024> TmpDir; 278 if (isNormalDir()) { 279 // Concatenate the requested file onto the directory. 280 TmpDir = getDir()->getName(); 281 llvm::sys::path::append(TmpDir, Filename); 282 if (SearchPath) { 283 StringRef SearchPathRef(getDir()->getName()); 284 SearchPath->clear(); 285 SearchPath->append(SearchPathRef.begin(), SearchPathRef.end()); 286 } 287 if (RelativePath) { 288 RelativePath->clear(); 289 RelativePath->append(Filename.begin(), Filename.end()); 290 } 291 292 return getFileAndSuggestModule(HS, TmpDir.str(), getDir(), 293 isSystemHeaderDirectory(), 294 SuggestedModule); 295 } 296 297 if (isFramework()) 298 return DoFrameworkLookup(Filename, HS, SearchPath, RelativePath, 299 SuggestedModule, InUserSpecifiedSystemFramework); 300 301 assert(isHeaderMap() && "Unknown directory lookup"); 302 const HeaderMap *HM = getHeaderMap(); 303 SmallString<1024> Path; 304 StringRef Dest = HM->lookupFilename(Filename, Path); 305 if (Dest.empty()) 306 return nullptr; 307 308 const FileEntry *Result; 309 310 // Check if the headermap maps the filename to a framework include 311 // ("Foo.h" -> "Foo/Foo.h"), in which case continue header lookup using the 312 // framework include. 313 if (llvm::sys::path::is_relative(Dest)) { 314 MappedName.clear(); 315 MappedName.append(Dest.begin(), Dest.end()); 316 Filename = StringRef(MappedName.begin(), MappedName.size()); 317 HasBeenMapped = true; 318 Result = HM->LookupFile(Filename, HS.getFileMgr()); 319 320 } else { 321 Result = HS.getFileMgr().getFile(Dest); 322 } 323 324 if (Result) { 325 if (SearchPath) { 326 StringRef SearchPathRef(getName()); 327 SearchPath->clear(); 328 SearchPath->append(SearchPathRef.begin(), SearchPathRef.end()); 329 } 330 if (RelativePath) { 331 RelativePath->clear(); 332 RelativePath->append(Filename.begin(), Filename.end()); 333 } 334 } 335 return Result; 336 } 337 338 /// \brief Given a framework directory, find the top-most framework directory. 339 /// 340 /// \param FileMgr The file manager to use for directory lookups. 341 /// \param DirName The name of the framework directory. 342 /// \param SubmodulePath Will be populated with the submodule path from the 343 /// returned top-level module to the originally named framework. 344 static const DirectoryEntry * 345 getTopFrameworkDir(FileManager &FileMgr, StringRef DirName, 346 SmallVectorImpl<std::string> &SubmodulePath) { 347 assert(llvm::sys::path::extension(DirName) == ".framework" && 348 "Not a framework directory"); 349 350 // Note: as an egregious but useful hack we use the real path here, because 351 // frameworks moving between top-level frameworks to embedded frameworks tend 352 // to be symlinked, and we base the logical structure of modules on the 353 // physical layout. In particular, we need to deal with crazy includes like 354 // 355 // #include <Foo/Frameworks/Bar.framework/Headers/Wibble.h> 356 // 357 // where 'Bar' used to be embedded in 'Foo', is now a top-level framework 358 // which one should access with, e.g., 359 // 360 // #include <Bar/Wibble.h> 361 // 362 // Similar issues occur when a top-level framework has moved into an 363 // embedded framework. 364 const DirectoryEntry *TopFrameworkDir = FileMgr.getDirectory(DirName); 365 DirName = FileMgr.getCanonicalName(TopFrameworkDir); 366 do { 367 // Get the parent directory name. 368 DirName = llvm::sys::path::parent_path(DirName); 369 if (DirName.empty()) 370 break; 371 372 // Determine whether this directory exists. 373 const DirectoryEntry *Dir = FileMgr.getDirectory(DirName); 374 if (!Dir) 375 break; 376 377 // If this is a framework directory, then we're a subframework of this 378 // framework. 379 if (llvm::sys::path::extension(DirName) == ".framework") { 380 SubmodulePath.push_back(llvm::sys::path::stem(DirName)); 381 TopFrameworkDir = Dir; 382 } 383 } while (true); 384 385 return TopFrameworkDir; 386 } 387 388 /// DoFrameworkLookup - Do a lookup of the specified file in the current 389 /// DirectoryLookup, which is a framework directory. 390 const FileEntry *DirectoryLookup::DoFrameworkLookup( 391 StringRef Filename, 392 HeaderSearch &HS, 393 SmallVectorImpl<char> *SearchPath, 394 SmallVectorImpl<char> *RelativePath, 395 ModuleMap::KnownHeader *SuggestedModule, 396 bool &InUserSpecifiedSystemFramework) const 397 { 398 FileManager &FileMgr = HS.getFileMgr(); 399 400 // Framework names must have a '/' in the filename. 401 size_t SlashPos = Filename.find('/'); 402 if (SlashPos == StringRef::npos) return nullptr; 403 404 // Find out if this is the home for the specified framework, by checking 405 // HeaderSearch. Possible answers are yes/no and unknown. 406 HeaderSearch::FrameworkCacheEntry &CacheEntry = 407 HS.LookupFrameworkCache(Filename.substr(0, SlashPos)); 408 409 // If it is known and in some other directory, fail. 410 if (CacheEntry.Directory && CacheEntry.Directory != getFrameworkDir()) 411 return nullptr; 412 413 // Otherwise, construct the path to this framework dir. 414 415 // FrameworkName = "/System/Library/Frameworks/" 416 SmallString<1024> FrameworkName; 417 FrameworkName += getFrameworkDir()->getName(); 418 if (FrameworkName.empty() || FrameworkName.back() != '/') 419 FrameworkName.push_back('/'); 420 421 // FrameworkName = "/System/Library/Frameworks/Cocoa" 422 StringRef ModuleName(Filename.begin(), SlashPos); 423 FrameworkName += ModuleName; 424 425 // FrameworkName = "/System/Library/Frameworks/Cocoa.framework/" 426 FrameworkName += ".framework/"; 427 428 // If the cache entry was unresolved, populate it now. 429 if (!CacheEntry.Directory) { 430 HS.IncrementFrameworkLookupCount(); 431 432 // If the framework dir doesn't exist, we fail. 433 const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str()); 434 if (!Dir) return nullptr; 435 436 // Otherwise, if it does, remember that this is the right direntry for this 437 // framework. 438 CacheEntry.Directory = getFrameworkDir(); 439 440 // If this is a user search directory, check if the framework has been 441 // user-specified as a system framework. 442 if (getDirCharacteristic() == SrcMgr::C_User) { 443 SmallString<1024> SystemFrameworkMarker(FrameworkName); 444 SystemFrameworkMarker += ".system_framework"; 445 if (llvm::sys::fs::exists(SystemFrameworkMarker.str())) { 446 CacheEntry.IsUserSpecifiedSystemFramework = true; 447 } 448 } 449 } 450 451 // Set the 'user-specified system framework' flag. 452 InUserSpecifiedSystemFramework = CacheEntry.IsUserSpecifiedSystemFramework; 453 454 if (RelativePath) { 455 RelativePath->clear(); 456 RelativePath->append(Filename.begin()+SlashPos+1, Filename.end()); 457 } 458 459 // Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h" 460 unsigned OrigSize = FrameworkName.size(); 461 462 FrameworkName += "Headers/"; 463 464 if (SearchPath) { 465 SearchPath->clear(); 466 // Without trailing '/'. 467 SearchPath->append(FrameworkName.begin(), FrameworkName.end()-1); 468 } 469 470 FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end()); 471 const FileEntry *FE = FileMgr.getFile(FrameworkName.str(), 472 /*openFile=*/!SuggestedModule); 473 if (!FE) { 474 // Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h" 475 const char *Private = "Private"; 476 FrameworkName.insert(FrameworkName.begin()+OrigSize, Private, 477 Private+strlen(Private)); 478 if (SearchPath) 479 SearchPath->insert(SearchPath->begin()+OrigSize, Private, 480 Private+strlen(Private)); 481 482 FE = FileMgr.getFile(FrameworkName.str(), /*openFile=*/!SuggestedModule); 483 } 484 485 // If we found the header and are allowed to suggest a module, do so now. 486 if (FE && SuggestedModule) { 487 // Find the framework in which this header occurs. 488 StringRef FrameworkPath = FE->getDir()->getName(); 489 bool FoundFramework = false; 490 do { 491 // Determine whether this directory exists. 492 const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkPath); 493 if (!Dir) 494 break; 495 496 // If this is a framework directory, then we're a subframework of this 497 // framework. 498 if (llvm::sys::path::extension(FrameworkPath) == ".framework") { 499 FoundFramework = true; 500 break; 501 } 502 503 // Get the parent directory name. 504 FrameworkPath = llvm::sys::path::parent_path(FrameworkPath); 505 if (FrameworkPath.empty()) 506 break; 507 } while (true); 508 509 if (FoundFramework) { 510 // Find the top-level framework based on this framework. 511 SmallVector<std::string, 4> SubmodulePath; 512 const DirectoryEntry *TopFrameworkDir 513 = ::getTopFrameworkDir(FileMgr, FrameworkPath, SubmodulePath); 514 515 // Determine the name of the top-level framework. 516 StringRef ModuleName = llvm::sys::path::stem(TopFrameworkDir->getName()); 517 518 // Load this framework module. If that succeeds, find the suggested module 519 // for this header, if any. 520 bool IsSystem = getDirCharacteristic() != SrcMgr::C_User; 521 if (HS.loadFrameworkModule(ModuleName, TopFrameworkDir, IsSystem)) { 522 *SuggestedModule = HS.findModuleForHeader(FE); 523 } 524 } else { 525 *SuggestedModule = HS.findModuleForHeader(FE); 526 } 527 } 528 return FE; 529 } 530 531 void HeaderSearch::setTarget(const TargetInfo &Target) { 532 ModMap.setTarget(Target); 533 } 534 535 536 //===----------------------------------------------------------------------===// 537 // Header File Location. 538 //===----------------------------------------------------------------------===// 539 540 /// \brief Return true with a diagnostic if the file that MSVC would have found 541 /// fails to match the one that Clang would have found with MSVC header search 542 /// disabled. 543 static bool checkMSVCHeaderSearch(DiagnosticsEngine &Diags, 544 const FileEntry *MSFE, const FileEntry *FE, 545 SourceLocation IncludeLoc) { 546 if (MSFE && FE != MSFE) { 547 Diags.Report(IncludeLoc, diag::ext_pp_include_search_ms) << MSFE->getName(); 548 return true; 549 } 550 return false; 551 } 552 553 static const char *copyString(StringRef Str, llvm::BumpPtrAllocator &Alloc) { 554 assert(!Str.empty()); 555 char *CopyStr = Alloc.Allocate<char>(Str.size()+1); 556 std::copy(Str.begin(), Str.end(), CopyStr); 557 CopyStr[Str.size()] = '\0'; 558 return CopyStr; 559 } 560 561 /// LookupFile - Given a "foo" or \<foo> reference, look up the indicated file, 562 /// return null on failure. isAngled indicates whether the file reference is 563 /// for system \#include's or not (i.e. using <> instead of ""). Includers, if 564 /// non-empty, indicates where the \#including file(s) are, in case a relative 565 /// search is needed. Microsoft mode will pass all \#including files. 566 const FileEntry *HeaderSearch::LookupFile( 567 StringRef Filename, SourceLocation IncludeLoc, bool isAngled, 568 const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, 569 ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>> Includers, 570 SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath, 571 ModuleMap::KnownHeader *SuggestedModule, bool SkipCache) { 572 if (!HSOpts->ModuleMapFiles.empty()) { 573 // Preload all explicitly specified module map files. This enables modules 574 // map files lying in a directory structure separate from the header files 575 // that they describe. These cannot be loaded lazily upon encountering a 576 // header file, as there is no other known mapping from a header file to its 577 // module map file. 578 for (const auto &Filename : HSOpts->ModuleMapFiles) 579 if (const FileEntry *File = FileMgr.getFile(Filename)) 580 loadModuleMapFile(File, /*IsSystem=*/false); 581 HSOpts->ModuleMapFiles.clear(); 582 } 583 584 if (SuggestedModule) 585 *SuggestedModule = ModuleMap::KnownHeader(); 586 587 // If 'Filename' is absolute, check to see if it exists and no searching. 588 if (llvm::sys::path::is_absolute(Filename)) { 589 CurDir = nullptr; 590 591 // If this was an #include_next "/absolute/file", fail. 592 if (FromDir) return nullptr; 593 594 if (SearchPath) 595 SearchPath->clear(); 596 if (RelativePath) { 597 RelativePath->clear(); 598 RelativePath->append(Filename.begin(), Filename.end()); 599 } 600 // Otherwise, just return the file. 601 return FileMgr.getFile(Filename, /*openFile=*/true); 602 } 603 604 // This is the header that MSVC's header search would have found. 605 const FileEntry *MSFE = nullptr; 606 ModuleMap::KnownHeader MSSuggestedModule; 607 608 // Unless disabled, check to see if the file is in the #includer's 609 // directory. This cannot be based on CurDir, because each includer could be 610 // a #include of a subdirectory (#include "foo/bar.h") and a subsequent 611 // include of "baz.h" should resolve to "whatever/foo/baz.h". 612 // This search is not done for <> headers. 613 if (!Includers.empty() && !isAngled && !NoCurDirSearch) { 614 SmallString<1024> TmpDir; 615 bool First = true; 616 for (const auto &IncluderAndDir : Includers) { 617 const FileEntry *Includer = IncluderAndDir.first; 618 619 // Concatenate the requested file onto the directory. 620 // FIXME: Portability. Filename concatenation should be in sys::Path. 621 TmpDir = IncluderAndDir.second->getName(); 622 TmpDir.push_back('/'); 623 TmpDir.append(Filename.begin(), Filename.end()); 624 625 // FIXME: We don't cache the result of getFileInfo across the call to 626 // getFileAndSuggestModule, because it's a reference to an element of 627 // a container that could be reallocated across this call. 628 bool IncluderIsSystemHeader = 629 getFileInfo(Includer).DirInfo != SrcMgr::C_User; 630 if (const FileEntry *FE = getFileAndSuggestModule( 631 *this, TmpDir.str(), IncluderAndDir.second, 632 IncluderIsSystemHeader, SuggestedModule)) { 633 // Leave CurDir unset. 634 // This file is a system header or C++ unfriendly if the old file is. 635 // 636 // Note that we only use one of FromHFI/ToHFI at once, due to potential 637 // reallocation of the underlying vector potentially making the first 638 // reference binding dangling. 639 HeaderFileInfo &FromHFI = getFileInfo(Includer); 640 unsigned DirInfo = FromHFI.DirInfo; 641 bool IndexHeaderMapHeader = FromHFI.IndexHeaderMapHeader; 642 StringRef Framework = FromHFI.Framework; 643 644 HeaderFileInfo &ToHFI = getFileInfo(FE); 645 ToHFI.DirInfo = DirInfo; 646 ToHFI.IndexHeaderMapHeader = IndexHeaderMapHeader; 647 ToHFI.Framework = Framework; 648 649 if (SearchPath) { 650 StringRef SearchPathRef(IncluderAndDir.second->getName()); 651 SearchPath->clear(); 652 SearchPath->append(SearchPathRef.begin(), SearchPathRef.end()); 653 } 654 if (RelativePath) { 655 RelativePath->clear(); 656 RelativePath->append(Filename.begin(), Filename.end()); 657 } 658 if (First) 659 return FE; 660 661 // Otherwise, we found the path via MSVC header search rules. If 662 // -Wmsvc-include is enabled, we have to keep searching to see if we 663 // would've found this header in -I or -isystem directories. 664 if (Diags.isIgnored(diag::ext_pp_include_search_ms, IncludeLoc)) { 665 return FE; 666 } else { 667 MSFE = FE; 668 if (SuggestedModule) { 669 MSSuggestedModule = *SuggestedModule; 670 *SuggestedModule = ModuleMap::KnownHeader(); 671 } 672 break; 673 } 674 } 675 First = false; 676 } 677 } 678 679 CurDir = nullptr; 680 681 // If this is a system #include, ignore the user #include locs. 682 unsigned i = isAngled ? AngledDirIdx : 0; 683 684 // If this is a #include_next request, start searching after the directory the 685 // file was found in. 686 if (FromDir) 687 i = FromDir-&SearchDirs[0]; 688 689 // Cache all of the lookups performed by this method. Many headers are 690 // multiply included, and the "pragma once" optimization prevents them from 691 // being relex/pp'd, but they would still have to search through a 692 // (potentially huge) series of SearchDirs to find it. 693 LookupFileCacheInfo &CacheLookup = LookupFileCache[Filename]; 694 695 // If the entry has been previously looked up, the first value will be 696 // non-zero. If the value is equal to i (the start point of our search), then 697 // this is a matching hit. 698 if (!SkipCache && CacheLookup.StartIdx == i+1) { 699 // Skip querying potentially lots of directories for this lookup. 700 i = CacheLookup.HitIdx; 701 if (CacheLookup.MappedName) 702 Filename = CacheLookup.MappedName; 703 } else { 704 // Otherwise, this is the first query, or the previous query didn't match 705 // our search start. We will fill in our found location below, so prime the 706 // start point value. 707 CacheLookup.reset(/*StartIdx=*/i+1); 708 } 709 710 SmallString<64> MappedName; 711 712 // Check each directory in sequence to see if it contains this file. 713 for (; i != SearchDirs.size(); ++i) { 714 bool InUserSpecifiedSystemFramework = false; 715 bool HasBeenMapped = false; 716 const FileEntry *FE = 717 SearchDirs[i].LookupFile(Filename, *this, SearchPath, RelativePath, 718 SuggestedModule, InUserSpecifiedSystemFramework, 719 HasBeenMapped, MappedName); 720 if (HasBeenMapped) { 721 CacheLookup.MappedName = 722 copyString(Filename, LookupFileCache.getAllocator()); 723 } 724 if (!FE) continue; 725 726 CurDir = &SearchDirs[i]; 727 728 // This file is a system header or C++ unfriendly if the dir is. 729 HeaderFileInfo &HFI = getFileInfo(FE); 730 HFI.DirInfo = CurDir->getDirCharacteristic(); 731 732 // If the directory characteristic is User but this framework was 733 // user-specified to be treated as a system framework, promote the 734 // characteristic. 735 if (HFI.DirInfo == SrcMgr::C_User && InUserSpecifiedSystemFramework) 736 HFI.DirInfo = SrcMgr::C_System; 737 738 // If the filename matches a known system header prefix, override 739 // whether the file is a system header. 740 for (unsigned j = SystemHeaderPrefixes.size(); j; --j) { 741 if (Filename.startswith(SystemHeaderPrefixes[j-1].first)) { 742 HFI.DirInfo = SystemHeaderPrefixes[j-1].second ? SrcMgr::C_System 743 : SrcMgr::C_User; 744 break; 745 } 746 } 747 748 // If this file is found in a header map and uses the framework style of 749 // includes, then this header is part of a framework we're building. 750 if (CurDir->isIndexHeaderMap()) { 751 size_t SlashPos = Filename.find('/'); 752 if (SlashPos != StringRef::npos) { 753 HFI.IndexHeaderMapHeader = 1; 754 HFI.Framework = getUniqueFrameworkName(StringRef(Filename.begin(), 755 SlashPos)); 756 } 757 } 758 759 if (checkMSVCHeaderSearch(Diags, MSFE, FE, IncludeLoc)) { 760 if (SuggestedModule) 761 *SuggestedModule = MSSuggestedModule; 762 return MSFE; 763 } 764 765 // Remember this location for the next lookup we do. 766 CacheLookup.HitIdx = i; 767 return FE; 768 } 769 770 // If we are including a file with a quoted include "foo.h" from inside 771 // a header in a framework that is currently being built, and we couldn't 772 // resolve "foo.h" any other way, change the include to <Foo/foo.h>, where 773 // "Foo" is the name of the framework in which the including header was found. 774 if (!Includers.empty() && !isAngled && 775 Filename.find('/') == StringRef::npos) { 776 HeaderFileInfo &IncludingHFI = getFileInfo(Includers.front().first); 777 if (IncludingHFI.IndexHeaderMapHeader) { 778 SmallString<128> ScratchFilename; 779 ScratchFilename += IncludingHFI.Framework; 780 ScratchFilename += '/'; 781 ScratchFilename += Filename; 782 783 const FileEntry *FE = LookupFile( 784 ScratchFilename, IncludeLoc, /*isAngled=*/true, FromDir, CurDir, 785 Includers.front(), SearchPath, RelativePath, SuggestedModule); 786 787 if (checkMSVCHeaderSearch(Diags, MSFE, FE, IncludeLoc)) { 788 if (SuggestedModule) 789 *SuggestedModule = MSSuggestedModule; 790 return MSFE; 791 } 792 793 LookupFileCacheInfo &CacheLookup = LookupFileCache[Filename]; 794 CacheLookup.HitIdx = LookupFileCache[ScratchFilename].HitIdx; 795 // FIXME: SuggestedModule. 796 return FE; 797 } 798 } 799 800 if (checkMSVCHeaderSearch(Diags, MSFE, nullptr, IncludeLoc)) { 801 if (SuggestedModule) 802 *SuggestedModule = MSSuggestedModule; 803 return MSFE; 804 } 805 806 // Otherwise, didn't find it. Remember we didn't find this. 807 CacheLookup.HitIdx = SearchDirs.size(); 808 return nullptr; 809 } 810 811 /// LookupSubframeworkHeader - Look up a subframework for the specified 812 /// \#include file. For example, if \#include'ing <HIToolbox/HIToolbox.h> from 813 /// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox 814 /// is a subframework within Carbon.framework. If so, return the FileEntry 815 /// for the designated file, otherwise return null. 816 const FileEntry *HeaderSearch:: 817 LookupSubframeworkHeader(StringRef Filename, 818 const FileEntry *ContextFileEnt, 819 SmallVectorImpl<char> *SearchPath, 820 SmallVectorImpl<char> *RelativePath, 821 ModuleMap::KnownHeader *SuggestedModule) { 822 assert(ContextFileEnt && "No context file?"); 823 824 // Framework names must have a '/' in the filename. Find it. 825 // FIXME: Should we permit '\' on Windows? 826 size_t SlashPos = Filename.find('/'); 827 if (SlashPos == StringRef::npos) return nullptr; 828 829 // Look up the base framework name of the ContextFileEnt. 830 const char *ContextName = ContextFileEnt->getName(); 831 832 // If the context info wasn't a framework, couldn't be a subframework. 833 const unsigned DotFrameworkLen = 10; 834 const char *FrameworkPos = strstr(ContextName, ".framework"); 835 if (FrameworkPos == nullptr || 836 (FrameworkPos[DotFrameworkLen] != '/' && 837 FrameworkPos[DotFrameworkLen] != '\\')) 838 return nullptr; 839 840 SmallString<1024> FrameworkName(ContextName, FrameworkPos+DotFrameworkLen+1); 841 842 // Append Frameworks/HIToolbox.framework/ 843 FrameworkName += "Frameworks/"; 844 FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos); 845 FrameworkName += ".framework/"; 846 847 auto &CacheLookup = 848 *FrameworkMap.insert(std::make_pair(Filename.substr(0, SlashPos), 849 FrameworkCacheEntry())).first; 850 851 // Some other location? 852 if (CacheLookup.second.Directory && 853 CacheLookup.first().size() == FrameworkName.size() && 854 memcmp(CacheLookup.first().data(), &FrameworkName[0], 855 CacheLookup.first().size()) != 0) 856 return nullptr; 857 858 // Cache subframework. 859 if (!CacheLookup.second.Directory) { 860 ++NumSubFrameworkLookups; 861 862 // If the framework dir doesn't exist, we fail. 863 const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str()); 864 if (!Dir) return nullptr; 865 866 // Otherwise, if it does, remember that this is the right direntry for this 867 // framework. 868 CacheLookup.second.Directory = Dir; 869 } 870 871 const FileEntry *FE = nullptr; 872 873 if (RelativePath) { 874 RelativePath->clear(); 875 RelativePath->append(Filename.begin()+SlashPos+1, Filename.end()); 876 } 877 878 // Check ".../Frameworks/HIToolbox.framework/Headers/HIToolbox.h" 879 SmallString<1024> HeadersFilename(FrameworkName); 880 HeadersFilename += "Headers/"; 881 if (SearchPath) { 882 SearchPath->clear(); 883 // Without trailing '/'. 884 SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1); 885 } 886 887 HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end()); 888 if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true))) { 889 890 // Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h" 891 HeadersFilename = FrameworkName; 892 HeadersFilename += "PrivateHeaders/"; 893 if (SearchPath) { 894 SearchPath->clear(); 895 // Without trailing '/'. 896 SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1); 897 } 898 899 HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end()); 900 if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true))) 901 return nullptr; 902 } 903 904 // This file is a system header or C++ unfriendly if the old file is. 905 // 906 // Note that the temporary 'DirInfo' is required here, as either call to 907 // getFileInfo could resize the vector and we don't want to rely on order 908 // of evaluation. 909 unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo; 910 getFileInfo(FE).DirInfo = DirInfo; 911 912 // If we're supposed to suggest a module, look for one now. 913 if (SuggestedModule) { 914 // Find the top-level framework based on this framework. 915 FrameworkName.pop_back(); // remove the trailing '/' 916 SmallVector<std::string, 4> SubmodulePath; 917 const DirectoryEntry *TopFrameworkDir 918 = ::getTopFrameworkDir(FileMgr, FrameworkName, SubmodulePath); 919 920 // Determine the name of the top-level framework. 921 StringRef ModuleName = llvm::sys::path::stem(TopFrameworkDir->getName()); 922 923 // Load this framework module. If that succeeds, find the suggested module 924 // for this header, if any. 925 bool IsSystem = false; 926 if (loadFrameworkModule(ModuleName, TopFrameworkDir, IsSystem)) { 927 *SuggestedModule = findModuleForHeader(FE); 928 } 929 } 930 931 return FE; 932 } 933 934 //===----------------------------------------------------------------------===// 935 // File Info Management. 936 //===----------------------------------------------------------------------===// 937 938 /// \brief Merge the header file info provided by \p OtherHFI into the current 939 /// header file info (\p HFI) 940 static void mergeHeaderFileInfo(HeaderFileInfo &HFI, 941 const HeaderFileInfo &OtherHFI) { 942 HFI.isImport |= OtherHFI.isImport; 943 HFI.isPragmaOnce |= OtherHFI.isPragmaOnce; 944 HFI.isModuleHeader |= OtherHFI.isModuleHeader; 945 HFI.NumIncludes += OtherHFI.NumIncludes; 946 947 if (!HFI.ControllingMacro && !HFI.ControllingMacroID) { 948 HFI.ControllingMacro = OtherHFI.ControllingMacro; 949 HFI.ControllingMacroID = OtherHFI.ControllingMacroID; 950 } 951 952 if (OtherHFI.External) { 953 HFI.DirInfo = OtherHFI.DirInfo; 954 HFI.External = OtherHFI.External; 955 HFI.IndexHeaderMapHeader = OtherHFI.IndexHeaderMapHeader; 956 } 957 958 if (HFI.Framework.empty()) 959 HFI.Framework = OtherHFI.Framework; 960 961 HFI.Resolved = true; 962 } 963 964 /// getFileInfo - Return the HeaderFileInfo structure for the specified 965 /// FileEntry. 966 HeaderFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) { 967 if (FE->getUID() >= FileInfo.size()) 968 FileInfo.resize(FE->getUID()+1); 969 970 HeaderFileInfo &HFI = FileInfo[FE->getUID()]; 971 if (ExternalSource && !HFI.Resolved) 972 mergeHeaderFileInfo(HFI, ExternalSource->GetHeaderFileInfo(FE)); 973 HFI.IsValid = 1; 974 return HFI; 975 } 976 977 bool HeaderSearch::tryGetFileInfo(const FileEntry *FE, HeaderFileInfo &Result) const { 978 if (FE->getUID() >= FileInfo.size()) 979 return false; 980 const HeaderFileInfo &HFI = FileInfo[FE->getUID()]; 981 if (HFI.IsValid) { 982 Result = HFI; 983 return true; 984 } 985 return false; 986 } 987 988 bool HeaderSearch::isFileMultipleIncludeGuarded(const FileEntry *File) { 989 // Check if we've ever seen this file as a header. 990 if (File->getUID() >= FileInfo.size()) 991 return false; 992 993 // Resolve header file info from the external source, if needed. 994 HeaderFileInfo &HFI = FileInfo[File->getUID()]; 995 if (ExternalSource && !HFI.Resolved) 996 mergeHeaderFileInfo(HFI, ExternalSource->GetHeaderFileInfo(File)); 997 998 return HFI.isPragmaOnce || HFI.isImport || 999 HFI.ControllingMacro || HFI.ControllingMacroID; 1000 } 1001 1002 void HeaderSearch::MarkFileModuleHeader(const FileEntry *FE, 1003 ModuleMap::ModuleHeaderRole Role, 1004 bool isCompilingModuleHeader) { 1005 if (FE->getUID() >= FileInfo.size()) 1006 FileInfo.resize(FE->getUID()+1); 1007 1008 HeaderFileInfo &HFI = FileInfo[FE->getUID()]; 1009 HFI.isModuleHeader = true; 1010 HFI.isCompilingModuleHeader = isCompilingModuleHeader; 1011 HFI.setHeaderRole(Role); 1012 } 1013 1014 bool HeaderSearch::ShouldEnterIncludeFile(const FileEntry *File, bool isImport){ 1015 ++NumIncluded; // Count # of attempted #includes. 1016 1017 // Get information about this file. 1018 HeaderFileInfo &FileInfo = getFileInfo(File); 1019 1020 // If this is a #import directive, check that we have not already imported 1021 // this header. 1022 if (isImport) { 1023 // If this has already been imported, don't import it again. 1024 FileInfo.isImport = true; 1025 1026 // Has this already been #import'ed or #include'd? 1027 if (FileInfo.NumIncludes) return false; 1028 } else { 1029 // Otherwise, if this is a #include of a file that was previously #import'd 1030 // or if this is the second #include of a #pragma once file, ignore it. 1031 if (FileInfo.isImport) 1032 return false; 1033 } 1034 1035 // Next, check to see if the file is wrapped with #ifndef guards. If so, and 1036 // if the macro that guards it is defined, we know the #include has no effect. 1037 if (const IdentifierInfo *ControllingMacro 1038 = FileInfo.getControllingMacro(ExternalLookup)) 1039 if (ControllingMacro->hasMacroDefinition()) { 1040 ++NumMultiIncludeFileOptzn; 1041 return false; 1042 } 1043 1044 // Increment the number of times this file has been included. 1045 ++FileInfo.NumIncludes; 1046 1047 return true; 1048 } 1049 1050 size_t HeaderSearch::getTotalMemory() const { 1051 return SearchDirs.capacity() 1052 + llvm::capacity_in_bytes(FileInfo) 1053 + llvm::capacity_in_bytes(HeaderMaps) 1054 + LookupFileCache.getAllocator().getTotalMemory() 1055 + FrameworkMap.getAllocator().getTotalMemory(); 1056 } 1057 1058 StringRef HeaderSearch::getUniqueFrameworkName(StringRef Framework) { 1059 return FrameworkNames.insert(Framework).first->first(); 1060 } 1061 1062 bool HeaderSearch::hasModuleMap(StringRef FileName, 1063 const DirectoryEntry *Root, 1064 bool IsSystem) { 1065 if (!enabledModules()) 1066 return false; 1067 1068 SmallVector<const DirectoryEntry *, 2> FixUpDirectories; 1069 1070 StringRef DirName = FileName; 1071 do { 1072 // Get the parent directory name. 1073 DirName = llvm::sys::path::parent_path(DirName); 1074 if (DirName.empty()) 1075 return false; 1076 1077 // Determine whether this directory exists. 1078 const DirectoryEntry *Dir = FileMgr.getDirectory(DirName); 1079 if (!Dir) 1080 return false; 1081 1082 // Try to load the module map file in this directory. 1083 switch (loadModuleMapFile(Dir, IsSystem, /*IsFramework*/false)) { 1084 case LMM_NewlyLoaded: 1085 case LMM_AlreadyLoaded: 1086 // Success. All of the directories we stepped through inherit this module 1087 // map file. 1088 for (unsigned I = 0, N = FixUpDirectories.size(); I != N; ++I) 1089 DirectoryHasModuleMap[FixUpDirectories[I]] = true; 1090 return true; 1091 1092 case LMM_NoDirectory: 1093 case LMM_InvalidModuleMap: 1094 break; 1095 } 1096 1097 // If we hit the top of our search, we're done. 1098 if (Dir == Root) 1099 return false; 1100 1101 // Keep track of all of the directories we checked, so we can mark them as 1102 // having module maps if we eventually do find a module map. 1103 FixUpDirectories.push_back(Dir); 1104 } while (true); 1105 } 1106 1107 ModuleMap::KnownHeader 1108 HeaderSearch::findModuleForHeader(const FileEntry *File) const { 1109 if (ExternalSource) { 1110 // Make sure the external source has handled header info about this file, 1111 // which includes whether the file is part of a module. 1112 (void)getFileInfo(File); 1113 } 1114 return ModMap.findModuleForHeader(File); 1115 } 1116 1117 static const FileEntry *getPrivateModuleMap(StringRef ModuleMapPath, 1118 const DirectoryEntry *Directory, 1119 FileManager &FileMgr) { 1120 StringRef Filename = llvm::sys::path::filename(ModuleMapPath); 1121 SmallString<128> PrivateFilename(Directory->getName()); 1122 if (Filename == "module.map") 1123 llvm::sys::path::append(PrivateFilename, "module_private.map"); 1124 else if (Filename == "module.modulemap") 1125 llvm::sys::path::append(PrivateFilename, "module.private.modulemap"); 1126 else 1127 return nullptr; 1128 return FileMgr.getFile(PrivateFilename); 1129 } 1130 1131 bool HeaderSearch::loadModuleMapFile(const FileEntry *File, bool IsSystem) { 1132 switch (loadModuleMapFileImpl(File, IsSystem)) { 1133 case LMM_AlreadyLoaded: 1134 case LMM_NewlyLoaded: 1135 return false; 1136 case LMM_NoDirectory: 1137 case LMM_InvalidModuleMap: 1138 return true; 1139 } 1140 llvm_unreachable("Unknown load module map result"); 1141 } 1142 1143 HeaderSearch::LoadModuleMapResult 1144 HeaderSearch::loadModuleMapFileImpl(const FileEntry *File, bool IsSystem) { 1145 assert(File && "expected FileEntry"); 1146 1147 // Check whether we've already loaded this module map, and mark it as being 1148 // loaded in case we recursively try to load it from itself. 1149 auto AddResult = LoadedModuleMaps.insert(std::make_pair(File, true)); 1150 if (!AddResult.second) 1151 return AddResult.first->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap; 1152 1153 if (ModMap.parseModuleMapFile(File, IsSystem)) { 1154 LoadedModuleMaps[File] = false; 1155 return LMM_InvalidModuleMap; 1156 } 1157 1158 // Try to load a corresponding private module map. 1159 if (const FileEntry *PMMFile = 1160 getPrivateModuleMap(File->getName(), File->getDir(), FileMgr)) { 1161 if (ModMap.parseModuleMapFile(PMMFile, IsSystem)) { 1162 LoadedModuleMaps[File] = false; 1163 return LMM_InvalidModuleMap; 1164 } 1165 } 1166 1167 // This directory has a module map. 1168 return LMM_NewlyLoaded; 1169 } 1170 1171 const FileEntry * 1172 HeaderSearch::lookupModuleMapFile(const DirectoryEntry *Dir, bool IsFramework) { 1173 // For frameworks, the preferred spelling is Modules/module.modulemap, but 1174 // module.map at the framework root is also accepted. 1175 SmallString<128> ModuleMapFileName(Dir->getName()); 1176 if (IsFramework) 1177 llvm::sys::path::append(ModuleMapFileName, "Modules"); 1178 llvm::sys::path::append(ModuleMapFileName, "module.modulemap"); 1179 if (const FileEntry *F = FileMgr.getFile(ModuleMapFileName)) 1180 return F; 1181 1182 // Continue to allow module.map 1183 ModuleMapFileName = Dir->getName(); 1184 llvm::sys::path::append(ModuleMapFileName, "module.map"); 1185 return FileMgr.getFile(ModuleMapFileName); 1186 } 1187 1188 Module *HeaderSearch::loadFrameworkModule(StringRef Name, 1189 const DirectoryEntry *Dir, 1190 bool IsSystem) { 1191 if (Module *Module = ModMap.findModule(Name)) 1192 return Module; 1193 1194 // Try to load a module map file. 1195 switch (loadModuleMapFile(Dir, IsSystem, /*IsFramework*/true)) { 1196 case LMM_InvalidModuleMap: 1197 break; 1198 1199 case LMM_AlreadyLoaded: 1200 case LMM_NoDirectory: 1201 return nullptr; 1202 1203 case LMM_NewlyLoaded: 1204 return ModMap.findModule(Name); 1205 } 1206 1207 1208 // Try to infer a module map from the framework directory. 1209 return ModMap.inferFrameworkModule(Name, Dir, IsSystem, /*Parent=*/nullptr); 1210 } 1211 1212 1213 HeaderSearch::LoadModuleMapResult 1214 HeaderSearch::loadModuleMapFile(StringRef DirName, bool IsSystem, 1215 bool IsFramework) { 1216 if (const DirectoryEntry *Dir = FileMgr.getDirectory(DirName)) 1217 return loadModuleMapFile(Dir, IsSystem, IsFramework); 1218 1219 return LMM_NoDirectory; 1220 } 1221 1222 HeaderSearch::LoadModuleMapResult 1223 HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir, bool IsSystem, 1224 bool IsFramework) { 1225 auto KnownDir = DirectoryHasModuleMap.find(Dir); 1226 if (KnownDir != DirectoryHasModuleMap.end()) 1227 return KnownDir->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap; 1228 1229 if (const FileEntry *ModuleMapFile = lookupModuleMapFile(Dir, IsFramework)) { 1230 LoadModuleMapResult Result = loadModuleMapFileImpl(ModuleMapFile, IsSystem); 1231 // Add Dir explicitly in case ModuleMapFile is in a subdirectory. 1232 // E.g. Foo.framework/Modules/module.modulemap 1233 // ^Dir ^ModuleMapFile 1234 if (Result == LMM_NewlyLoaded) 1235 DirectoryHasModuleMap[Dir] = true; 1236 else if (Result == LMM_InvalidModuleMap) 1237 DirectoryHasModuleMap[Dir] = false; 1238 return Result; 1239 } 1240 return LMM_InvalidModuleMap; 1241 } 1242 1243 void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) { 1244 Modules.clear(); 1245 1246 // Load module maps for each of the header search directories. 1247 for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) { 1248 bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory(); 1249 if (SearchDirs[Idx].isFramework()) { 1250 std::error_code EC; 1251 SmallString<128> DirNative; 1252 llvm::sys::path::native(SearchDirs[Idx].getFrameworkDir()->getName(), 1253 DirNative); 1254 1255 // Search each of the ".framework" directories to load them as modules. 1256 for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd; 1257 Dir != DirEnd && !EC; Dir.increment(EC)) { 1258 if (llvm::sys::path::extension(Dir->path()) != ".framework") 1259 continue; 1260 1261 const DirectoryEntry *FrameworkDir = FileMgr.getDirectory(Dir->path()); 1262 if (!FrameworkDir) 1263 continue; 1264 1265 // Load this framework module. 1266 loadFrameworkModule(llvm::sys::path::stem(Dir->path()), FrameworkDir, 1267 IsSystem); 1268 } 1269 continue; 1270 } 1271 1272 // FIXME: Deal with header maps. 1273 if (SearchDirs[Idx].isHeaderMap()) 1274 continue; 1275 1276 // Try to load a module map file for the search directory. 1277 loadModuleMapFile(SearchDirs[Idx].getDir(), IsSystem, /*IsFramework*/false); 1278 1279 // Try to load module map files for immediate subdirectories of this search 1280 // directory. 1281 loadSubdirectoryModuleMaps(SearchDirs[Idx]); 1282 } 1283 1284 // Populate the list of modules. 1285 for (ModuleMap::module_iterator M = ModMap.module_begin(), 1286 MEnd = ModMap.module_end(); 1287 M != MEnd; ++M) { 1288 Modules.push_back(M->getValue()); 1289 } 1290 } 1291 1292 void HeaderSearch::loadTopLevelSystemModules() { 1293 // Load module maps for each of the header search directories. 1294 for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) { 1295 // We only care about normal header directories. 1296 if (!SearchDirs[Idx].isNormalDir()) { 1297 continue; 1298 } 1299 1300 // Try to load a module map file for the search directory. 1301 loadModuleMapFile(SearchDirs[Idx].getDir(), 1302 SearchDirs[Idx].isSystemHeaderDirectory(), 1303 SearchDirs[Idx].isFramework()); 1304 } 1305 } 1306 1307 void HeaderSearch::loadSubdirectoryModuleMaps(DirectoryLookup &SearchDir) { 1308 if (SearchDir.haveSearchedAllModuleMaps()) 1309 return; 1310 1311 std::error_code EC; 1312 SmallString<128> DirNative; 1313 llvm::sys::path::native(SearchDir.getDir()->getName(), DirNative); 1314 for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd; 1315 Dir != DirEnd && !EC; Dir.increment(EC)) { 1316 loadModuleMapFile(Dir->path(), SearchDir.isSystemHeaderDirectory(), 1317 SearchDir.isFramework()); 1318 } 1319 1320 SearchDir.setSearchedAllModuleMaps(true); 1321 } 1322