contrib/llvm/tools/clang/lib/Lex/HeaderSearch.cpp

   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/Lex/HeaderMap.h"
  16 #include "clang/Lex/Lexer.h"
  17 #include "clang/Basic/Diagnostic.h"
  18 #include "clang/Basic/FileManager.h"
  19 #include "clang/Basic/IdentifierTable.h"
  20 #include "llvm/Support/FileSystem.h"
  21 #include "llvm/Support/Path.h"
  22 #include "llvm/ADT/SmallString.h"
  23 #include "llvm/Support/Capacity.h"
  24 #include <cstdio>
  25 using namespace clang;
  26
  27 const IdentifierInfo *
  28 HeaderFileInfo::getControllingMacro(ExternalIdentifierLookup *External) {
  29   if (ControllingMacro)
  30     return ControllingMacro;
  31
  32   if (!ControllingMacroID || !External)
  33     return 0;
  34
  35   ControllingMacro = External->GetIdentifier(ControllingMacroID);
  36   return ControllingMacro;
  37 }
  38
  39 ExternalHeaderFileInfoSource::~ExternalHeaderFileInfoSource() {}
  40
  41 HeaderSearch::HeaderSearch(FileManager &FM, DiagnosticsEngine &Diags,
  42                            const LangOptions &LangOpts,
  43                            const TargetInfo *Target)
  44   : FileMgr(FM), Diags(Diags), FrameworkMap(64),
  45     ModMap(FileMgr, *Diags.getClient(), LangOpts, Target)
  46 {
  47   AngledDirIdx = 0;
  48   SystemDirIdx = 0;
  49   NoCurDirSearch = false;
  50
  51   ExternalLookup = 0;
  52   ExternalSource = 0;
  53   NumIncluded = 0;
  54   NumMultiIncludeFileOptzn = 0;
  55   NumFrameworkLookups = NumSubFrameworkLookups = 0;
  56 }
  57
  58 HeaderSearch::~HeaderSearch() {
  59   // Delete headermaps.
  60   for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
  61     delete HeaderMaps[i].second;
  62 }
  63
  64 void HeaderSearch::PrintStats() {
  65   fprintf(stderr, "\n*** HeaderSearch Stats:\n");
  66   fprintf(stderr, "%d files tracked.\n", (int)FileInfo.size());
  67   unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
  68   for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
  69     NumOnceOnlyFiles += FileInfo[i].isImport;
  70     if (MaxNumIncludes < FileInfo[i].NumIncludes)
  71       MaxNumIncludes = FileInfo[i].NumIncludes;
  72     NumSingleIncludedFiles += FileInfo[i].NumIncludes == 1;
  73   }
  74   fprintf(stderr, "  %d #import/#pragma once files.\n", NumOnceOnlyFiles);
  75   fprintf(stderr, "  %d included exactly once.\n", NumSingleIncludedFiles);
  76   fprintf(stderr, "  %d max times a file is included.\n", MaxNumIncludes);
  77
  78   fprintf(stderr, "  %d #include/#include_next/#import.\n", NumIncluded);
  79   fprintf(stderr, "    %d #includes skipped due to"
  80           " the multi-include optimization.\n", NumMultiIncludeFileOptzn);
  81
  82   fprintf(stderr, "%d framework lookups.\n", NumFrameworkLookups);
  83   fprintf(stderr, "%d subframework lookups.\n", NumSubFrameworkLookups);
  84 }
  85
  86 /// CreateHeaderMap - This method returns a HeaderMap for the specified
  87 /// FileEntry, uniquing them through the the 'HeaderMaps' datastructure.
  88 const HeaderMap *HeaderSearch::CreateHeaderMap(const FileEntry *FE) {
  89   // We expect the number of headermaps to be small, and almost always empty.
  90   // If it ever grows, use of a linear search should be re-evaluated.
  91   if (!HeaderMaps.empty()) {
  92     for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
  93       // Pointer equality comparison of FileEntries works because they are
  94       // already uniqued by inode.
  95       if (HeaderMaps[i].first == FE)
  96         return HeaderMaps[i].second;
  97   }
  98
  99   if (const HeaderMap *HM = HeaderMap::Create(FE, FileMgr)) {
 100     HeaderMaps.push_back(std::make_pair(FE, HM));
 101     return HM;
 102   }
 103
 104   return 0;
 105 }
 106
 107 std::string HeaderSearch::getModuleFileName(Module *Module) {
 108   // If we don't have a module cache path, we can't do anything.
 109   if (ModuleCachePath.empty())
 110     return std::string();
 111
 112
 113   SmallString<256> Result(ModuleCachePath);
 114   llvm::sys::path::append(Result, Module->getTopLevelModule()->Name + ".pcm");
 115   return Result.str().str();
 116 }
 117
 118 std::string HeaderSearch::getModuleFileName(StringRef ModuleName) {
 119   // If we don't have a module cache path, we can't do anything.
 120   if (ModuleCachePath.empty())
 121     return std::string();
 122
 123
 124   SmallString<256> Result(ModuleCachePath);
 125   llvm::sys::path::append(Result, ModuleName + ".pcm");
 126   return Result.str().str();
 127 }
 128
 129 Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {
 130   // Look in the module map to determine if there is a module by this name.
 131   Module *Module = ModMap.findModule(ModuleName);
 132   if (Module || !AllowSearch)
 133     return Module;
 134
 135   // Look through the various header search paths to load any avai;able module
 136   // maps, searching for a module map that describes this module.
 137   for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
 138     if (SearchDirs[Idx].isFramework()) {
 139       // Search for or infer a module map for a framework.
 140       SmallString<128> FrameworkDirName;
 141       FrameworkDirName += SearchDirs[Idx].getFrameworkDir()->getName();
 142       llvm::sys::path::append(FrameworkDirName, ModuleName + ".framework");
 143       if (const DirectoryEntry *FrameworkDir
 144             = FileMgr.getDirectory(FrameworkDirName)) {
 145         bool IsSystem
 146           = SearchDirs[Idx].getDirCharacteristic() != SrcMgr::C_User;
 147         Module = loadFrameworkModule(ModuleName, FrameworkDir, IsSystem);
 148         if (Module)
 149           break;
 150       }
 151     }
 152
 153     // FIXME: Figure out how header maps and module maps will work together.
 154
 155     // Only deal with normal search directories.
 156     if (!SearchDirs[Idx].isNormalDir())
 157       continue;
 158
 159     // Search for a module map file in this directory.
 160     if (loadModuleMapFile(SearchDirs[Idx].getDir()) == LMM_NewlyLoaded) {
 161       // We just loaded a module map file; check whether the module is
 162       // available now.
 163       Module = ModMap.findModule(ModuleName);
 164       if (Module)
 165         break;
 166     }
 167
 168     // Search for a module map in a subdirectory with the same name as the
 169     // module.
 170     SmallString<128> NestedModuleMapDirName;
 171     NestedModuleMapDirName = SearchDirs[Idx].getDir()->getName();
 172     llvm::sys::path::append(NestedModuleMapDirName, ModuleName);
 173     if (loadModuleMapFile(NestedModuleMapDirName) == LMM_NewlyLoaded) {
 174       // If we just loaded a module map file, look for the module again.
 175       Module = ModMap.findModule(ModuleName);
 176       if (Module)
 177         break;
 178     }
 179   }
 180
 181   return Module;
 182 }
 183
 184 //===----------------------------------------------------------------------===//
 185 // File lookup within a DirectoryLookup scope
 186 //===----------------------------------------------------------------------===//
 187
 188 /// getName - Return the directory or filename corresponding to this lookup
 189 /// object.
 190 const char *DirectoryLookup::getName() const {
 191   if (isNormalDir())
 192     return getDir()->getName();
 193   if (isFramework())
 194     return getFrameworkDir()->getName();
 195   assert(isHeaderMap() && "Unknown DirectoryLookup");
 196   return getHeaderMap()->getFileName();
 197 }
 198
 199
 200 /// LookupFile - Lookup the specified file in this search path, returning it
 201 /// if it exists or returning null if not.
 202 const FileEntry *DirectoryLookup::LookupFile(
 203     StringRef Filename,
 204     HeaderSearch &HS,
 205     SmallVectorImpl<char> *SearchPath,
 206     SmallVectorImpl<char> *RelativePath,
 207     Module **SuggestedModule,
 208     bool &InUserSpecifiedSystemFramework) const {
 209   InUserSpecifiedSystemFramework = false;
 210
 211   SmallString<1024> TmpDir;
 212   if (isNormalDir()) {
 213     // Concatenate the requested file onto the directory.
 214     TmpDir = getDir()->getName();
 215     llvm::sys::path::append(TmpDir, Filename);
 216     if (SearchPath != NULL) {
 217       StringRef SearchPathRef(getDir()->getName());
 218       SearchPath->clear();
 219       SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
 220     }
 221     if (RelativePath != NULL) {
 222       RelativePath->clear();
 223       RelativePath->append(Filename.begin(), Filename.end());
 224     }
 225
 226     // If we have a module map that might map this header, load it and
 227     // check whether we'll have a suggestion for a module.
 228     if (SuggestedModule && HS.hasModuleMap(TmpDir, getDir())) {
 229       const FileEntry *File = HS.getFileMgr().getFile(TmpDir.str(),
 230                                                       /*openFile=*/false);
 231       if (!File)
 232         return File;
 233
 234       // If there is a module that corresponds to this header,
 235       // suggest it.
 236       *SuggestedModule = HS.findModuleForHeader(File);
 237       return File;
 238     }
 239
 240     return HS.getFileMgr().getFile(TmpDir.str(), /*openFile=*/true);
 241   }
 242
 243   if (isFramework())
 244     return DoFrameworkLookup(Filename, HS, SearchPath, RelativePath,
 245                              SuggestedModule, InUserSpecifiedSystemFramework);
 246
 247   assert(isHeaderMap() && "Unknown directory lookup");
 248   const FileEntry * const Result = getHeaderMap()->LookupFile(
 249       Filename, HS.getFileMgr());
 250   if (Result) {
 251     if (SearchPath != NULL) {
 252       StringRef SearchPathRef(getName());
 253       SearchPath->clear();
 254       SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
 255     }
 256     if (RelativePath != NULL) {
 257       RelativePath->clear();
 258       RelativePath->append(Filename.begin(), Filename.end());
 259     }
 260   }
 261   return Result;
 262 }
 263
 264
 265 /// DoFrameworkLookup - Do a lookup of the specified file in the current
 266 /// DirectoryLookup, which is a framework directory.
 267 const FileEntry *DirectoryLookup::DoFrameworkLookup(
 268     StringRef Filename,
 269     HeaderSearch &HS,
 270     SmallVectorImpl<char> *SearchPath,
 271     SmallVectorImpl<char> *RelativePath,
 272     Module **SuggestedModule,
 273     bool &InUserSpecifiedSystemFramework) const
 274 {
 275   FileManager &FileMgr = HS.getFileMgr();
 276
 277   // Framework names must have a '/' in the filename.
 278   size_t SlashPos = Filename.find('/');
 279   if (SlashPos == StringRef::npos) return 0;
 280
 281   // Find out if this is the home for the specified framework, by checking
 282   // HeaderSearch.  Possible answers are yes/no and unknown.
 283   HeaderSearch::FrameworkCacheEntry &CacheEntry =
 284     HS.LookupFrameworkCache(Filename.substr(0, SlashPos));
 285
 286   // If it is known and in some other directory, fail.
 287   if (CacheEntry.Directory && CacheEntry.Directory != getFrameworkDir())
 288     return 0;
 289
 290   // Otherwise, construct the path to this framework dir.
 291
 292   // FrameworkName = "/System/Library/Frameworks/"
 293   SmallString<1024> FrameworkName;
 294   FrameworkName += getFrameworkDir()->getName();
 295   if (FrameworkName.empty() || FrameworkName.back() != '/')
 296     FrameworkName.push_back('/');
 297
 298   // FrameworkName = "/System/Library/Frameworks/Cocoa"
 299   StringRef ModuleName(Filename.begin(), SlashPos);
 300   FrameworkName += ModuleName;
 301
 302   // FrameworkName = "/System/Library/Frameworks/Cocoa.framework/"
 303   FrameworkName += ".framework/";
 304
 305   // If the cache entry was unresolved, populate it now.
 306   if (CacheEntry.Directory == 0) {
 307     HS.IncrementFrameworkLookupCount();
 308
 309     // If the framework dir doesn't exist, we fail.
 310     const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str());
 311     if (Dir == 0) return 0;
 312
 313     // Otherwise, if it does, remember that this is the right direntry for this
 314     // framework.
 315     CacheEntry.Directory = getFrameworkDir();
 316
 317     // If this is a user search directory, check if the framework has been
 318     // user-specified as a system framework.
 319     if (getDirCharacteristic() == SrcMgr::C_User) {
 320       SmallString<1024> SystemFrameworkMarker(FrameworkName);
 321       SystemFrameworkMarker += ".system_framework";
 322       if (llvm::sys::fs::exists(SystemFrameworkMarker.str())) {
 323         CacheEntry.IsUserSpecifiedSystemFramework = true;
 324       }
 325     }
 326   }
 327
 328   // Set the 'user-specified system framework' flag.
 329   InUserSpecifiedSystemFramework = CacheEntry.IsUserSpecifiedSystemFramework;
 330
 331   if (RelativePath != NULL) {
 332     RelativePath->clear();
 333     RelativePath->append(Filename.begin()+SlashPos+1, Filename.end());
 334   }
 335
 336   // If we're allowed to look for modules, try to load or create the module
 337   // corresponding to this framework.
 338   Module *Module = 0;
 339   if (SuggestedModule) {
 340     if (const DirectoryEntry *FrameworkDir
 341                                         = FileMgr.getDirectory(FrameworkName)) {
 342       bool IsSystem = getDirCharacteristic() != SrcMgr::C_User;
 343       Module = HS.loadFrameworkModule(ModuleName, FrameworkDir, IsSystem);
 344     }
 345   }
 346
 347   // Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h"
 348   unsigned OrigSize = FrameworkName.size();
 349
 350   FrameworkName += "Headers/";
 351
 352   if (SearchPath != NULL) {
 353     SearchPath->clear();
 354     // Without trailing '/'.
 355     SearchPath->append(FrameworkName.begin(), FrameworkName.end()-1);
 356   }
 357
 358   // Determine whether this is the module we're building or not.
 359   bool AutomaticImport = Module;
 360   FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end());
 361   if (const FileEntry *FE = FileMgr.getFile(FrameworkName.str(),
 362                                             /*openFile=*/!AutomaticImport)) {
 363     if (AutomaticImport)
 364       *SuggestedModule = HS.findModuleForHeader(FE);
 365     return FE;
 366   }
 367
 368   // Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h"
 369   const char *Private = "Private";
 370   FrameworkName.insert(FrameworkName.begin()+OrigSize, Private,
 371                        Private+strlen(Private));
 372   if (SearchPath != NULL)
 373     SearchPath->insert(SearchPath->begin()+OrigSize, Private,
 374                        Private+strlen(Private));
 375
 376   const FileEntry *FE = FileMgr.getFile(FrameworkName.str(),
 377                                         /*openFile=*/!AutomaticImport);
 378   if (FE && AutomaticImport)
 379     *SuggestedModule = HS.findModuleForHeader(FE);
 380   return FE;
 381 }
 382
 383 void HeaderSearch::setTarget(const TargetInfo &Target) {
 384   ModMap.setTarget(Target);
 385 }
 386
 387
 388 //===----------------------------------------------------------------------===//
 389 // Header File Location.
 390 //===----------------------------------------------------------------------===//
 391
 392
 393 /// LookupFile - Given a "foo" or <foo> reference, look up the indicated file,
 394 /// return null on failure.  isAngled indicates whether the file reference is
 395 /// for system #include's or not (i.e. using <> instead of "").  CurFileEnt, if
 396 /// non-null, indicates where the #including file is, in case a relative search
 397 /// is needed.
 398 const FileEntry *HeaderSearch::LookupFile(
 399     StringRef Filename,
 400     bool isAngled,
 401     const DirectoryLookup *FromDir,
 402     const DirectoryLookup *&CurDir,
 403     const FileEntry *CurFileEnt,
 404     SmallVectorImpl<char> *SearchPath,
 405     SmallVectorImpl<char> *RelativePath,
 406     Module **SuggestedModule,
 407     bool SkipCache)
 408 {
 409   if (SuggestedModule)
 410     *SuggestedModule = 0;
 411
 412   // If 'Filename' is absolute, check to see if it exists and no searching.
 413   if (llvm::sys::path::is_absolute(Filename)) {
 414     CurDir = 0;
 415
 416     // If this was an #include_next "/absolute/file", fail.
 417     if (FromDir) return 0;
 418
 419     if (SearchPath != NULL)
 420       SearchPath->clear();
 421     if (RelativePath != NULL) {
 422       RelativePath->clear();
 423       RelativePath->append(Filename.begin(), Filename.end());
 424     }
 425     // Otherwise, just return the file.
 426     return FileMgr.getFile(Filename, /*openFile=*/true);
 427   }
 428
 429   // Unless disabled, check to see if the file is in the #includer's
 430   // directory.  This has to be based on CurFileEnt, not CurDir, because
 431   // CurFileEnt could be a #include of a subdirectory (#include "foo/bar.h") and
 432   // a subsequent include of "baz.h" should resolve to "whatever/foo/baz.h".
 433   // This search is not done for <> headers.
 434   if (CurFileEnt && !isAngled && !NoCurDirSearch) {
 435     SmallString<1024> TmpDir;
 436     // Concatenate the requested file onto the directory.
 437     // FIXME: Portability.  Filename concatenation should be in sys::Path.
 438     TmpDir += CurFileEnt->getDir()->getName();
 439     TmpDir.push_back('/');
 440     TmpDir.append(Filename.begin(), Filename.end());
 441     if (const FileEntry *FE = FileMgr.getFile(TmpDir.str(),/*openFile=*/true)) {
 442       // Leave CurDir unset.
 443       // This file is a system header or C++ unfriendly if the old file is.
 444       //
 445       // Note that the temporary 'DirInfo' is required here, as either call to
 446       // getFileInfo could resize the vector and we don't want to rely on order
 447       // of evaluation.
 448       unsigned DirInfo = getFileInfo(CurFileEnt).DirInfo;
 449       getFileInfo(FE).DirInfo = DirInfo;
 450       if (SearchPath != NULL) {
 451         StringRef SearchPathRef(CurFileEnt->getDir()->getName());
 452         SearchPath->clear();
 453         SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
 454       }
 455       if (RelativePath != NULL) {
 456         RelativePath->clear();
 457         RelativePath->append(Filename.begin(), Filename.end());
 458       }
 459       return FE;
 460     }
 461   }
 462
 463   CurDir = 0;
 464
 465   // If this is a system #include, ignore the user #include locs.
 466   unsigned i = isAngled ? AngledDirIdx : 0;
 467
 468   // If this is a #include_next request, start searching after the directory the
 469   // file was found in.
 470   if (FromDir)
 471     i = FromDir-&SearchDirs[0];
 472
 473   // Cache all of the lookups performed by this method.  Many headers are
 474   // multiply included, and the "pragma once" optimization prevents them from
 475   // being relex/pp'd, but they would still have to search through a
 476   // (potentially huge) series of SearchDirs to find it.
 477   std::pair<unsigned, unsigned> &CacheLookup =
 478     LookupFileCache.GetOrCreateValue(Filename).getValue();
 479
 480   // If the entry has been previously looked up, the first value will be
 481   // non-zero.  If the value is equal to i (the start point of our search), then
 482   // this is a matching hit.
 483   if (!SkipCache && CacheLookup.first == i+1) {
 484     // Skip querying potentially lots of directories for this lookup.
 485     i = CacheLookup.second;
 486   } else {
 487     // Otherwise, this is the first query, or the previous query didn't match
 488     // our search start.  We will fill in our found location below, so prime the
 489     // start point value.
 490     CacheLookup.first = i+1;
 491   }
 492
 493   // Check each directory in sequence to see if it contains this file.
 494   for (; i != SearchDirs.size(); ++i) {
 495     bool InUserSpecifiedSystemFramework = false;
 496     const FileEntry *FE =
 497       SearchDirs[i].LookupFile(Filename, *this, SearchPath, RelativePath,
 498                                SuggestedModule, InUserSpecifiedSystemFramework);
 499     if (!FE) continue;
 500
 501     CurDir = &SearchDirs[i];
 502
 503     // This file is a system header or C++ unfriendly if the dir is.
 504     HeaderFileInfo &HFI = getFileInfo(FE);
 505     HFI.DirInfo = CurDir->getDirCharacteristic();
 506
 507     // If the directory characteristic is User but this framework was
 508     // user-specified to be treated as a system framework, promote the
 509     // characteristic.
 510     if (HFI.DirInfo == SrcMgr::C_User && InUserSpecifiedSystemFramework)
 511       HFI.DirInfo = SrcMgr::C_System;
 512
 513     // If this file is found in a header map and uses the framework style of
 514     // includes, then this header is part of a framework we're building.
 515     if (CurDir->isIndexHeaderMap()) {
 516       size_t SlashPos = Filename.find('/');
 517       if (SlashPos != StringRef::npos) {
 518         HFI.IndexHeaderMapHeader = 1;
 519         HFI.Framework = getUniqueFrameworkName(StringRef(Filename.begin(),
 520                                                          SlashPos));
 521       }
 522     }
 523
 524     // Remember this location for the next lookup we do.
 525     CacheLookup.second = i;
 526     return FE;
 527   }
 528
 529   // If we are including a file with a quoted include "foo.h" from inside
 530   // a header in a framework that is currently being built, and we couldn't
 531   // resolve "foo.h" any other way, change the include to <Foo/foo.h>, where
 532   // "Foo" is the name of the framework in which the including header was found.
 533   if (CurFileEnt && !isAngled && Filename.find('/') == StringRef::npos) {
 534     HeaderFileInfo &IncludingHFI = getFileInfo(CurFileEnt);
 535     if (IncludingHFI.IndexHeaderMapHeader) {
 536       SmallString<128> ScratchFilename;
 537       ScratchFilename += IncludingHFI.Framework;
 538       ScratchFilename += '/';
 539       ScratchFilename += Filename;
 540
 541       const FileEntry *Result = LookupFile(ScratchFilename, /*isAngled=*/true,
 542                                            FromDir, CurDir, CurFileEnt,
 543                                            SearchPath, RelativePath,
 544                                            SuggestedModule);
 545       std::pair<unsigned, unsigned> &CacheLookup
 546         = LookupFileCache.GetOrCreateValue(Filename).getValue();
 547       CacheLookup.second
 548         = LookupFileCache.GetOrCreateValue(ScratchFilename).getValue().second;
 549       return Result;
 550     }
 551   }
 552
 553   // Otherwise, didn't find it. Remember we didn't find this.
 554   CacheLookup.second = SearchDirs.size();
 555   return 0;
 556 }
 557
 558 /// LookupSubframeworkHeader - Look up a subframework for the specified
 559 /// #include file.  For example, if #include'ing <HIToolbox/HIToolbox.h> from
 560 /// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox
 561 /// is a subframework within Carbon.framework.  If so, return the FileEntry
 562 /// for the designated file, otherwise return null.
 563 const FileEntry *HeaderSearch::
 564 LookupSubframeworkHeader(StringRef Filename,
 565                          const FileEntry *ContextFileEnt,
 566                          SmallVectorImpl<char> *SearchPath,
 567                          SmallVectorImpl<char> *RelativePath) {
 568   assert(ContextFileEnt && "No context file?");
 569
 570   // Framework names must have a '/' in the filename.  Find it.
 571   // FIXME: Should we permit '\' on Windows?
 572   size_t SlashPos = Filename.find('/');
 573   if (SlashPos == StringRef::npos) return 0;
 574
 575   // Look up the base framework name of the ContextFileEnt.
 576   const char *ContextName = ContextFileEnt->getName();
 577
 578   // If the context info wasn't a framework, couldn't be a subframework.
 579   const unsigned DotFrameworkLen = 10;
 580   const char *FrameworkPos = strstr(ContextName, ".framework");
 581   if (FrameworkPos == 0 ||
 582       (FrameworkPos[DotFrameworkLen] != '/' &&
 583        FrameworkPos[DotFrameworkLen] != '\\'))
 584     return 0;
 585
 586   SmallString<1024> FrameworkName(ContextName, FrameworkPos+DotFrameworkLen+1);
 587
 588   // Append Frameworks/HIToolbox.framework/
 589   FrameworkName += "Frameworks/";
 590   FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
 591   FrameworkName += ".framework/";
 592
 593   llvm::StringMapEntry<FrameworkCacheEntry> &CacheLookup =
 594     FrameworkMap.GetOrCreateValue(Filename.substr(0, SlashPos));
 595
 596   // Some other location?
 597   if (CacheLookup.getValue().Directory &&
 598       CacheLookup.getKeyLength() == FrameworkName.size() &&
 599       memcmp(CacheLookup.getKeyData(), &FrameworkName[0],
 600              CacheLookup.getKeyLength()) != 0)
 601     return 0;
 602
 603   // Cache subframework.
 604   if (CacheLookup.getValue().Directory == 0) {
 605     ++NumSubFrameworkLookups;
 606
 607     // If the framework dir doesn't exist, we fail.
 608     const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str());
 609     if (Dir == 0) return 0;
 610
 611     // Otherwise, if it does, remember that this is the right direntry for this
 612     // framework.
 613     CacheLookup.getValue().Directory = Dir;
 614   }
 615
 616   const FileEntry *FE = 0;
 617
 618   if (RelativePath != NULL) {
 619     RelativePath->clear();
 620     RelativePath->append(Filename.begin()+SlashPos+1, Filename.end());
 621   }
 622
 623   // Check ".../Frameworks/HIToolbox.framework/Headers/HIToolbox.h"
 624   SmallString<1024> HeadersFilename(FrameworkName);
 625   HeadersFilename += "Headers/";
 626   if (SearchPath != NULL) {
 627     SearchPath->clear();
 628     // Without trailing '/'.
 629     SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);
 630   }
 631
 632   HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
 633   if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true))) {
 634
 635     // Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h"
 636     HeadersFilename = FrameworkName;
 637     HeadersFilename += "PrivateHeaders/";
 638     if (SearchPath != NULL) {
 639       SearchPath->clear();
 640       // Without trailing '/'.
 641       SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);
 642     }
 643
 644     HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
 645     if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true)))
 646       return 0;
 647   }
 648
 649   // This file is a system header or C++ unfriendly if the old file is.
 650   //
 651   // Note that the temporary 'DirInfo' is required here, as either call to
 652   // getFileInfo could resize the vector and we don't want to rely on order
 653   // of evaluation.
 654   unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo;
 655   getFileInfo(FE).DirInfo = DirInfo;
 656   return FE;
 657 }
 658
 659 /// \brief Helper static function to normalize a path for injection into
 660 /// a synthetic header.
 661 /*static*/ std::string
 662 HeaderSearch::NormalizeDashIncludePath(StringRef File, FileManager &FileMgr) {
 663   // Implicit include paths should be resolved relative to the current
 664   // working directory first, and then use the regular header search
 665   // mechanism. The proper way to handle this is to have the
 666   // predefines buffer located at the current working directory, but
 667   // it has no file entry. For now, workaround this by using an
 668   // absolute path if we find the file here, and otherwise letting
 669   // header search handle it.
 670   SmallString<128> Path(File);
 671   llvm::sys::fs::make_absolute(Path);
 672   bool exists;
 673   if (llvm::sys::fs::exists(Path.str(), exists) || !exists)
 674     Path = File;
 675   else if (exists)
 676     FileMgr.getFile(File);
 677
 678   return Lexer::Stringify(Path.str());
 679 }
 680
 681 //===----------------------------------------------------------------------===//
 682 // File Info Management.
 683 //===----------------------------------------------------------------------===//
 684
 685 /// \brief Merge the header file info provided by \p OtherHFI into the current
 686 /// header file info (\p HFI)
 687 static void mergeHeaderFileInfo(HeaderFileInfo &HFI,
 688                                 const HeaderFileInfo &OtherHFI) {
 689   HFI.isImport |= OtherHFI.isImport;
 690   HFI.isPragmaOnce |= OtherHFI.isPragmaOnce;
 691   HFI.NumIncludes += OtherHFI.NumIncludes;
 692
 693   if (!HFI.ControllingMacro && !HFI.ControllingMacroID) {
 694     HFI.ControllingMacro = OtherHFI.ControllingMacro;
 695     HFI.ControllingMacroID = OtherHFI.ControllingMacroID;
 696   }
 697
 698   if (OtherHFI.External) {
 699     HFI.DirInfo = OtherHFI.DirInfo;
 700     HFI.External = OtherHFI.External;
 701     HFI.IndexHeaderMapHeader = OtherHFI.IndexHeaderMapHeader;
 702   }
 703
 704   if (HFI.Framework.empty())
 705     HFI.Framework = OtherHFI.Framework;
 706
 707   HFI.Resolved = true;
 708 }
 709
 710 /// getFileInfo - Return the HeaderFileInfo structure for the specified
 711 /// FileEntry.
 712 HeaderFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) {
 713   if (FE->getUID() >= FileInfo.size())
 714     FileInfo.resize(FE->getUID()+1);
 715
 716   HeaderFileInfo &HFI = FileInfo[FE->getUID()];
 717   if (ExternalSource && !HFI.Resolved)
 718     mergeHeaderFileInfo(HFI, ExternalSource->GetHeaderFileInfo(FE));
 719   return HFI;
 720 }
 721
 722 bool HeaderSearch::isFileMultipleIncludeGuarded(const FileEntry *File) {
 723   // Check if we've ever seen this file as a header.
 724   if (File->getUID() >= FileInfo.size())
 725     return false;
 726
 727   // Resolve header file info from the external source, if needed.
 728   HeaderFileInfo &HFI = FileInfo[File->getUID()];
 729   if (ExternalSource && !HFI.Resolved)
 730     mergeHeaderFileInfo(HFI, ExternalSource->GetHeaderFileInfo(File));
 731
 732   return HFI.isPragmaOnce || HFI.ControllingMacro || HFI.ControllingMacroID;
 733 }
 734
 735 void HeaderSearch::setHeaderFileInfoForUID(HeaderFileInfo HFI, unsigned UID) {
 736   if (UID >= FileInfo.size())
 737     FileInfo.resize(UID+1);
 738   HFI.Resolved = true;
 739   FileInfo[UID] = HFI;
 740 }
 741
 742 /// ShouldEnterIncludeFile - Mark the specified file as a target of of a
 743 /// #include, #include_next, or #import directive.  Return false if #including
 744 /// the file will have no effect or true if we should include it.
 745 bool HeaderSearch::ShouldEnterIncludeFile(const FileEntry *File, bool isImport){
 746   ++NumIncluded; // Count # of attempted #includes.
 747
 748   // Get information about this file.
 749   HeaderFileInfo &FileInfo = getFileInfo(File);
 750
 751   // If this is a #import directive, check that we have not already imported
 752   // this header.
 753   if (isImport) {
 754     // If this has already been imported, don't import it again.
 755     FileInfo.isImport = true;
 756
 757     // Has this already been #import'ed or #include'd?
 758     if (FileInfo.NumIncludes) return false;
 759   } else {
 760     // Otherwise, if this is a #include of a file that was previously #import'd
 761     // or if this is the second #include of a #pragma once file, ignore it.
 762     if (FileInfo.isImport)
 763       return false;
 764   }
 765
 766   // Next, check to see if the file is wrapped with #ifndef guards.  If so, and
 767   // if the macro that guards it is defined, we know the #include has no effect.
 768   if (const IdentifierInfo *ControllingMacro
 769       = FileInfo.getControllingMacro(ExternalLookup))
 770     if (ControllingMacro->hasMacroDefinition()) {
 771       ++NumMultiIncludeFileOptzn;
 772       return false;
 773     }
 774
 775   // Increment the number of times this file has been included.
 776   ++FileInfo.NumIncludes;
 777
 778   return true;
 779 }
 780
 781 size_t HeaderSearch::getTotalMemory() const {
 782   return SearchDirs.capacity()
 783     + llvm::capacity_in_bytes(FileInfo)
 784     + llvm::capacity_in_bytes(HeaderMaps)
 785     + LookupFileCache.getAllocator().getTotalMemory()
 786     + FrameworkMap.getAllocator().getTotalMemory();
 787 }
 788
 789 StringRef HeaderSearch::getUniqueFrameworkName(StringRef Framework) {
 790   return FrameworkNames.GetOrCreateValue(Framework).getKey();
 791 }
 792
 793 bool HeaderSearch::hasModuleMap(StringRef FileName,
 794                                 const DirectoryEntry *Root) {
 795   llvm::SmallVector<const DirectoryEntry *, 2> FixUpDirectories;
 796
 797   StringRef DirName = FileName;
 798   do {
 799     // Get the parent directory name.
 800     DirName = llvm::sys::path::parent_path(DirName);
 801     if (DirName.empty())
 802       return false;
 803
 804     // Determine whether this directory exists.
 805     const DirectoryEntry *Dir = FileMgr.getDirectory(DirName);
 806     if (!Dir)
 807       return false;
 808
 809     // Try to load the module map file in this directory.
 810     switch (loadModuleMapFile(Dir)) {
 811     case LMM_NewlyLoaded:
 812     case LMM_AlreadyLoaded:
 813       // Success. All of the directories we stepped through inherit this module
 814       // map file.
 815       for (unsigned I = 0, N = FixUpDirectories.size(); I != N; ++I)
 816         DirectoryHasModuleMap[FixUpDirectories[I]] = true;
 817
 818       return true;
 819
 820     case LMM_NoDirectory:
 821     case LMM_InvalidModuleMap:
 822       break;
 823     }
 824
 825     // If we hit the top of our search, we're done.
 826     if (Dir == Root)
 827       return false;
 828
 829     // Keep track of all of the directories we checked, so we can mark them as
 830     // having module maps if we eventually do find a module map.
 831     FixUpDirectories.push_back(Dir);
 832   } while (true);
 833 }
 834
 835 Module *HeaderSearch::findModuleForHeader(const FileEntry *File) {
 836   if (Module *Mod = ModMap.findModuleForHeader(File))
 837     return Mod;
 838
 839   return 0;
 840 }
 841
 842 bool HeaderSearch::loadModuleMapFile(const FileEntry *File) {
 843   const DirectoryEntry *Dir = File->getDir();
 844
 845   llvm::DenseMap<const DirectoryEntry *, bool>::iterator KnownDir
 846     = DirectoryHasModuleMap.find(Dir);
 847   if (KnownDir != DirectoryHasModuleMap.end())
 848     return !KnownDir->second;
 849
 850   bool Result = ModMap.parseModuleMapFile(File);
 851   if (!Result && llvm::sys::path::filename(File->getName()) == "module.map") {
 852     // If the file we loaded was a module.map, look for the corresponding
 853     // module_private.map.
 854     SmallString<128> PrivateFilename(Dir->getName());
 855     llvm::sys::path::append(PrivateFilename, "module_private.map");
 856     if (const FileEntry *PrivateFile = FileMgr.getFile(PrivateFilename))
 857       Result = ModMap.parseModuleMapFile(PrivateFile);
 858   }
 859
 860   DirectoryHasModuleMap[Dir] = !Result;
 861   return Result;
 862 }
 863
 864 Module *HeaderSearch::loadFrameworkModule(StringRef Name,
 865                                           const DirectoryEntry *Dir,
 866                                           bool IsSystem) {
 867   if (Module *Module = ModMap.findModule(Name))
 868     return Module;
 869
 870   // Try to load a module map file.
 871   switch (loadModuleMapFile(Dir)) {
 872   case LMM_InvalidModuleMap:
 873     break;
 874
 875   case LMM_AlreadyLoaded:
 876   case LMM_NoDirectory:
 877     return 0;
 878
 879   case LMM_NewlyLoaded:
 880     return ModMap.findModule(Name);
 881   }
 882
 883   // The top-level framework directory, from which we'll infer a framework
 884   // module.
 885   const DirectoryEntry *TopFrameworkDir = Dir;
 886
 887   // The path from the module we're actually looking for back to the top-level
 888   // framework name.
 889   llvm::SmallVector<StringRef, 2> SubmodulePath;
 890   SubmodulePath.push_back(Name);
 891
 892   // Walk the directory structure to find any enclosing frameworks.
 893   StringRef DirName = Dir->getName();
 894   do {
 895     // Get the parent directory name.
 896     DirName = llvm::sys::path::parent_path(DirName);
 897     if (DirName.empty())
 898       break;
 899
 900     // Determine whether this directory exists.
 901     Dir = FileMgr.getDirectory(DirName);
 902     if (!Dir)
 903       break;
 904
 905     // If this is a framework directory, then we're a subframework of this
 906     // framework.
 907     if (llvm::sys::path::extension(DirName) == ".framework") {
 908       SubmodulePath.push_back(llvm::sys::path::stem(DirName));
 909       TopFrameworkDir = Dir;
 910     }
 911   } while (true);
 912
 913   // Try to infer a module map from the top-level framework directory.
 914   Module *Result = ModMap.inferFrameworkModule(SubmodulePath.back(),
 915                                                TopFrameworkDir,
 916                                                IsSystem,
 917                                                /*Parent=*/0);
 918
 919   // Follow the submodule path to find the requested (sub)framework module
 920   // within the top-level framework module.
 921   SubmodulePath.pop_back();
 922   while (!SubmodulePath.empty() && Result) {
 923     Result = ModMap.lookupModuleQualified(SubmodulePath.back(), Result);
 924     SubmodulePath.pop_back();
 925   }
 926   return Result;
 927 }
 928
 929
 930 HeaderSearch::LoadModuleMapResult
 931 HeaderSearch::loadModuleMapFile(StringRef DirName) {
 932   if (const DirectoryEntry *Dir = FileMgr.getDirectory(DirName))
 933     return loadModuleMapFile(Dir);
 934
 935   return LMM_NoDirectory;
 936 }
 937
 938 HeaderSearch::LoadModuleMapResult
 939 HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir) {
 940   llvm::DenseMap<const DirectoryEntry *, bool>::iterator KnownDir
 941     = DirectoryHasModuleMap.find(Dir);
 942   if (KnownDir != DirectoryHasModuleMap.end())
 943     return KnownDir->second? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
 944
 945   SmallString<128> ModuleMapFileName;
 946   ModuleMapFileName += Dir->getName();
 947   unsigned ModuleMapDirNameLen = ModuleMapFileName.size();
 948   llvm::sys::path::append(ModuleMapFileName, "module.map");
 949   if (const FileEntry *ModuleMapFile = FileMgr.getFile(ModuleMapFileName)) {
 950     // We have found a module map file. Try to parse it.
 951     if (ModMap.parseModuleMapFile(ModuleMapFile)) {
 952       // No suitable module map.
 953       DirectoryHasModuleMap[Dir] = false;
 954       return LMM_InvalidModuleMap;
 955     }
 956
 957     // This directory has a module map.
 958     DirectoryHasModuleMap[Dir] = true;
 959
 960     // Check whether there is a private module map that we need to load as well.
 961     ModuleMapFileName.erase(ModuleMapFileName.begin() + ModuleMapDirNameLen,
 962                             ModuleMapFileName.end());
 963     llvm::sys::path::append(ModuleMapFileName, "module_private.map");
 964     if (const FileEntry *PrivateModuleMapFile
 965                                         = FileMgr.getFile(ModuleMapFileName)) {
 966       if (ModMap.parseModuleMapFile(PrivateModuleMapFile)) {
 967         // No suitable module map.
 968         DirectoryHasModuleMap[Dir] = false;
 969         return LMM_InvalidModuleMap;
 970       }
 971     }
 972
 973     return LMM_NewlyLoaded;
 974   }
 975
 976   // No suitable module map.
 977   DirectoryHasModuleMap[Dir] = false;
 978   return LMM_InvalidModuleMap;
 979 }
 980
 981 void HeaderSearch::collectAllModules(llvm::SmallVectorImpl<Module *> &Modules) {
 982   Modules.clear();
 983
 984   // Load module maps for each of the header search directories.
 985   for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
 986     if (SearchDirs[Idx].isFramework()) {
 987       llvm::error_code EC;
 988       SmallString<128> DirNative;
 989       llvm::sys::path::native(SearchDirs[Idx].getFrameworkDir()->getName(),
 990                               DirNative);
 991
 992       // Search each of the ".framework" directories to load them as modules.
 993       bool IsSystem = SearchDirs[Idx].getDirCharacteristic() != SrcMgr::C_User;
 994       for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
 995            Dir != DirEnd && !EC; Dir.increment(EC)) {
 996         if (llvm::sys::path::extension(Dir->path()) != ".framework")
 997           continue;
 998
 999         const DirectoryEntry *FrameworkDir = FileMgr.getDirectory(Dir->path());
1000         if (!FrameworkDir)
1001           continue;
1002
1003         // Load this framework module.
1004         loadFrameworkModule(llvm::sys::path::stem(Dir->path()), FrameworkDir,
1005                             IsSystem);
1006       }
1007       continue;
1008     }
1009
1010     // FIXME: Deal with header maps.
1011     if (SearchDirs[Idx].isHeaderMap())
1012       continue;
1013
1014     // Try to load a module map file for the search directory.
1015     loadModuleMapFile(SearchDirs[Idx].getDir());
1016
1017     // Try to load module map files for immediate subdirectories of this search
1018     // directory.
1019     llvm::error_code EC;
1020     SmallString<128> DirNative;
1021     llvm::sys::path::native(SearchDirs[Idx].getDir()->getName(), DirNative);
1022     for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
1023          Dir != DirEnd && !EC; Dir.increment(EC)) {
1024       loadModuleMapFile(Dir->path());
1025     }
1026   }
1027
1028   // Populate the list of modules.
1029   for (ModuleMap::module_iterator M = ModMap.module_begin(),
1030                                MEnd = ModMap.module_end();
1031        M != MEnd; ++M) {
1032     Modules.push_back(M->getValue());
1033   }
1034 }
1035