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/Basic/FileManager.h"
  17 #include "clang/Basic/IdentifierTable.h"
  18 #include "llvm/System/Path.h"
  19 #include "llvm/ADT/SmallString.h"
  20 #include <cstdio>
  21 using namespace clang;
  22
  23 const IdentifierInfo *
  24 HeaderFileInfo::getControllingMacro(ExternalIdentifierLookup *External) {
  25   if (ControllingMacro)
  26     return ControllingMacro;
  27
  28   if (!ControllingMacroID || !External)
  29     return 0;
  30
  31   ControllingMacro = External->GetIdentifier(ControllingMacroID);
  32   return ControllingMacro;
  33 }
  34
  35 HeaderSearch::HeaderSearch(FileManager &FM) : FileMgr(FM), FrameworkMap(64) {
  36   SystemDirIdx = 0;
  37   NoCurDirSearch = false;
  38
  39   ExternalLookup = 0;
  40   NumIncluded = 0;
  41   NumMultiIncludeFileOptzn = 0;
  42   NumFrameworkLookups = NumSubFrameworkLookups = 0;
  43 }
  44
  45 HeaderSearch::~HeaderSearch() {
  46   // Delete headermaps.
  47   for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
  48     delete HeaderMaps[i].second;
  49 }
  50
  51 void HeaderSearch::PrintStats() {
  52   fprintf(stderr, "\n*** HeaderSearch Stats:\n");
  53   fprintf(stderr, "%d files tracked.\n", (int)FileInfo.size());
  54   unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
  55   for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
  56     NumOnceOnlyFiles += FileInfo[i].isImport;
  57     if (MaxNumIncludes < FileInfo[i].NumIncludes)
  58       MaxNumIncludes = FileInfo[i].NumIncludes;
  59     NumSingleIncludedFiles += FileInfo[i].NumIncludes == 1;
  60   }
  61   fprintf(stderr, "  %d #import/#pragma once files.\n", NumOnceOnlyFiles);
  62   fprintf(stderr, "  %d included exactly once.\n", NumSingleIncludedFiles);
  63   fprintf(stderr, "  %d max times a file is included.\n", MaxNumIncludes);
  64
  65   fprintf(stderr, "  %d #include/#include_next/#import.\n", NumIncluded);
  66   fprintf(stderr, "    %d #includes skipped due to"
  67           " the multi-include optimization.\n", NumMultiIncludeFileOptzn);
  68
  69   fprintf(stderr, "%d framework lookups.\n", NumFrameworkLookups);
  70   fprintf(stderr, "%d subframework lookups.\n", NumSubFrameworkLookups);
  71 }
  72
  73 /// CreateHeaderMap - This method returns a HeaderMap for the specified
  74 /// FileEntry, uniquing them through the the 'HeaderMaps' datastructure.
  75 const HeaderMap *HeaderSearch::CreateHeaderMap(const FileEntry *FE) {
  76   // We expect the number of headermaps to be small, and almost always empty.
  77   // If it ever grows, use of a linear search should be re-evaluated.
  78   if (!HeaderMaps.empty()) {
  79     for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
  80       // Pointer equality comparison of FileEntries works because they are
  81       // already uniqued by inode.
  82       if (HeaderMaps[i].first == FE)
  83         return HeaderMaps[i].second;
  84   }
  85
  86   if (const HeaderMap *HM = HeaderMap::Create(FE)) {
  87     HeaderMaps.push_back(std::make_pair(FE, HM));
  88     return HM;
  89   }
  90
  91   return 0;
  92 }
  93
  94 //===----------------------------------------------------------------------===//
  95 // File lookup within a DirectoryLookup scope
  96 //===----------------------------------------------------------------------===//
  97
  98 /// getName - Return the directory or filename corresponding to this lookup
  99 /// object.
 100 const char *DirectoryLookup::getName() const {
 101   if (isNormalDir())
 102     return getDir()->getName();
 103   if (isFramework())
 104     return getFrameworkDir()->getName();
 105   assert(isHeaderMap() && "Unknown DirectoryLookup");
 106   return getHeaderMap()->getFileName();
 107 }
 108
 109
 110 /// LookupFile - Lookup the specified file in this search path, returning it
 111 /// if it exists or returning null if not.
 112 const FileEntry *DirectoryLookup::LookupFile(llvm::StringRef Filename,
 113                                              HeaderSearch &HS) const {
 114   llvm::SmallString<1024> TmpDir;
 115   if (isNormalDir()) {
 116     // Concatenate the requested file onto the directory.
 117     // FIXME: Portability.  Filename concatenation should be in sys::Path.
 118     TmpDir += getDir()->getName();
 119     TmpDir.push_back('/');
 120     TmpDir.append(Filename.begin(), Filename.end());
 121     return HS.getFileMgr().getFile(TmpDir.begin(), TmpDir.end());
 122   }
 123
 124   if (isFramework())
 125     return DoFrameworkLookup(Filename, HS);
 126
 127   assert(isHeaderMap() && "Unknown directory lookup");
 128   return getHeaderMap()->LookupFile(Filename, HS.getFileMgr());
 129 }
 130
 131
 132 /// DoFrameworkLookup - Do a lookup of the specified file in the current
 133 /// DirectoryLookup, which is a framework directory.
 134 const FileEntry *DirectoryLookup::DoFrameworkLookup(llvm::StringRef Filename,
 135                                                     HeaderSearch &HS) const {
 136   FileManager &FileMgr = HS.getFileMgr();
 137
 138   // Framework names must have a '/' in the filename.
 139   size_t SlashPos = Filename.find('/');
 140   if (SlashPos == llvm::StringRef::npos) return 0;
 141
 142   // Find out if this is the home for the specified framework, by checking
 143   // HeaderSearch.  Possible answer are yes/no and unknown.
 144   const DirectoryEntry *&FrameworkDirCache =
 145     HS.LookupFrameworkCache(Filename.substr(0, SlashPos));
 146
 147   // If it is known and in some other directory, fail.
 148   if (FrameworkDirCache && FrameworkDirCache != getFrameworkDir())
 149     return 0;
 150
 151   // Otherwise, construct the path to this framework dir.
 152
 153   // FrameworkName = "/System/Library/Frameworks/"
 154   llvm::SmallString<1024> FrameworkName;
 155   FrameworkName += getFrameworkDir()->getName();
 156   if (FrameworkName.empty() || FrameworkName.back() != '/')
 157     FrameworkName.push_back('/');
 158
 159   // FrameworkName = "/System/Library/Frameworks/Cocoa"
 160   FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
 161
 162   // FrameworkName = "/System/Library/Frameworks/Cocoa.framework/"
 163   FrameworkName += ".framework/";
 164
 165   // If the cache entry is still unresolved, query to see if the cache entry is
 166   // still unresolved.  If so, check its existence now.
 167   if (FrameworkDirCache == 0) {
 168     HS.IncrementFrameworkLookupCount();
 169
 170     // If the framework dir doesn't exist, we fail.
 171     // FIXME: It's probably more efficient to query this with FileMgr.getDir.
 172     if (!llvm::sys::Path(std::string(FrameworkName.begin(),
 173                                      FrameworkName.end())).exists())
 174       return 0;
 175
 176     // Otherwise, if it does, remember that this is the right direntry for this
 177     // framework.
 178     FrameworkDirCache = getFrameworkDir();
 179   }
 180
 181   // Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h"
 182   unsigned OrigSize = FrameworkName.size();
 183
 184   FrameworkName += "Headers/";
 185   FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end());
 186   if (const FileEntry *FE = FileMgr.getFile(FrameworkName.begin(),
 187                                             FrameworkName.end())) {
 188     return FE;
 189   }
 190
 191   // Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h"
 192   const char *Private = "Private";
 193   FrameworkName.insert(FrameworkName.begin()+OrigSize, Private,
 194                        Private+strlen(Private));
 195   return FileMgr.getFile(FrameworkName.begin(), FrameworkName.end());
 196 }
 197
 198
 199 //===----------------------------------------------------------------------===//
 200 // Header File Location.
 201 //===----------------------------------------------------------------------===//
 202
 203
 204 /// LookupFile - Given a "foo" or <foo> reference, look up the indicated file,
 205 /// return null on failure.  isAngled indicates whether the file reference is
 206 /// for system #include's or not (i.e. using <> instead of "").  CurFileEnt, if
 207 /// non-null, indicates where the #including file is, in case a relative search
 208 /// is needed.
 209 const FileEntry *HeaderSearch::LookupFile(llvm::StringRef Filename,
 210                                           bool isAngled,
 211                                           const DirectoryLookup *FromDir,
 212                                           const DirectoryLookup *&CurDir,
 213                                           const FileEntry *CurFileEnt) {
 214   // If 'Filename' is absolute, check to see if it exists and no searching.
 215   if (llvm::sys::Path::isAbsolute(Filename.begin(), Filename.size())) {
 216     CurDir = 0;
 217
 218     // If this was an #include_next "/absolute/file", fail.
 219     if (FromDir) return 0;
 220
 221     // Otherwise, just return the file.
 222     return FileMgr.getFile(Filename);
 223   }
 224
 225   // Step #0, unless disabled, check to see if the file is in the #includer's
 226   // directory.  This has to be based on CurFileEnt, not CurDir, because
 227   // CurFileEnt could be a #include of a subdirectory (#include "foo/bar.h") and
 228   // a subsequent include of "baz.h" should resolve to "whatever/foo/baz.h".
 229   // This search is not done for <> headers.
 230   if (CurFileEnt && !isAngled && !NoCurDirSearch) {
 231     llvm::SmallString<1024> TmpDir;
 232     // Concatenate the requested file onto the directory.
 233     // FIXME: Portability.  Filename concatenation should be in sys::Path.
 234     TmpDir += CurFileEnt->getDir()->getName();
 235     TmpDir.push_back('/');
 236     TmpDir.append(Filename.begin(), Filename.end());
 237     if (const FileEntry *FE = FileMgr.getFile(TmpDir.str())) {
 238       // Leave CurDir unset.
 239       // This file is a system header or C++ unfriendly if the old file is.
 240       //
 241       // Note that the temporary 'DirInfo' is required here, as either call to
 242       // getFileInfo could resize the vector and we don't want to rely on order
 243       // of evaluation.
 244       unsigned DirInfo = getFileInfo(CurFileEnt).DirInfo;
 245       getFileInfo(FE).DirInfo = DirInfo;
 246       return FE;
 247     }
 248   }
 249
 250   CurDir = 0;
 251
 252   // If this is a system #include, ignore the user #include locs.
 253   unsigned i = isAngled ? SystemDirIdx : 0;
 254
 255   // If this is a #include_next request, start searching after the directory the
 256   // file was found in.
 257   if (FromDir)
 258     i = FromDir-&SearchDirs[0];
 259
 260   // Cache all of the lookups performed by this method.  Many headers are
 261   // multiply included, and the "pragma once" optimization prevents them from
 262   // being relex/pp'd, but they would still have to search through a
 263   // (potentially huge) series of SearchDirs to find it.
 264   std::pair<unsigned, unsigned> &CacheLookup =
 265     LookupFileCache.GetOrCreateValue(Filename).getValue();
 266
 267   // If the entry has been previously looked up, the first value will be
 268   // non-zero.  If the value is equal to i (the start point of our search), then
 269   // this is a matching hit.
 270   if (CacheLookup.first == i+1) {
 271     // Skip querying potentially lots of directories for this lookup.
 272     i = CacheLookup.second;
 273   } else {
 274     // Otherwise, this is the first query, or the previous query didn't match
 275     // our search start.  We will fill in our found location below, so prime the
 276     // start point value.
 277     CacheLookup.first = i+1;
 278   }
 279
 280   // Check each directory in sequence to see if it contains this file.
 281   for (; i != SearchDirs.size(); ++i) {
 282     const FileEntry *FE =
 283       SearchDirs[i].LookupFile(Filename, *this);
 284     if (!FE) continue;
 285
 286     CurDir = &SearchDirs[i];
 287
 288     // This file is a system header or C++ unfriendly if the dir is.
 289     getFileInfo(FE).DirInfo = CurDir->getDirCharacteristic();
 290
 291     // Remember this location for the next lookup we do.
 292     CacheLookup.second = i;
 293     return FE;
 294   }
 295
 296   // Otherwise, didn't find it. Remember we didn't find this.
 297   CacheLookup.second = SearchDirs.size();
 298   return 0;
 299 }
 300
 301 /// LookupSubframeworkHeader - Look up a subframework for the specified
 302 /// #include file.  For example, if #include'ing <HIToolbox/HIToolbox.h> from
 303 /// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox
 304 /// is a subframework within Carbon.framework.  If so, return the FileEntry
 305 /// for the designated file, otherwise return null.
 306 const FileEntry *HeaderSearch::
 307 LookupSubframeworkHeader(llvm::StringRef Filename,
 308                          const FileEntry *ContextFileEnt) {
 309   assert(ContextFileEnt && "No context file?");
 310
 311   // Framework names must have a '/' in the filename.  Find it.
 312   size_t SlashPos = Filename.find('/');
 313   if (SlashPos == llvm::StringRef::npos) return 0;
 314
 315   // Look up the base framework name of the ContextFileEnt.
 316   const char *ContextName = ContextFileEnt->getName();
 317
 318   // If the context info wasn't a framework, couldn't be a subframework.
 319   const char *FrameworkPos = strstr(ContextName, ".framework/");
 320   if (FrameworkPos == 0)
 321     return 0;
 322
 323   llvm::SmallString<1024> FrameworkName(ContextName,
 324                                         FrameworkPos+strlen(".framework/"));
 325
 326   // Append Frameworks/HIToolbox.framework/
 327   FrameworkName += "Frameworks/";
 328   FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
 329   FrameworkName += ".framework/";
 330
 331   llvm::StringMapEntry<const DirectoryEntry *> &CacheLookup =
 332     FrameworkMap.GetOrCreateValue(Filename.begin(), Filename.begin()+SlashPos);
 333
 334   // Some other location?
 335   if (CacheLookup.getValue() &&
 336       CacheLookup.getKeyLength() == FrameworkName.size() &&
 337       memcmp(CacheLookup.getKeyData(), &FrameworkName[0],
 338              CacheLookup.getKeyLength()) != 0)
 339     return 0;
 340
 341   // Cache subframework.
 342   if (CacheLookup.getValue() == 0) {
 343     ++NumSubFrameworkLookups;
 344
 345     // If the framework dir doesn't exist, we fail.
 346     const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.begin(),
 347                                                      FrameworkName.end());
 348     if (Dir == 0) return 0;
 349
 350     // Otherwise, if it does, remember that this is the right direntry for this
 351     // framework.
 352     CacheLookup.setValue(Dir);
 353   }
 354
 355   const FileEntry *FE = 0;
 356
 357   // Check ".../Frameworks/HIToolbox.framework/Headers/HIToolbox.h"
 358   llvm::SmallString<1024> HeadersFilename(FrameworkName);
 359   HeadersFilename += "Headers/";
 360   HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
 361   if (!(FE = FileMgr.getFile(HeadersFilename.begin(),
 362                              HeadersFilename.end()))) {
 363
 364     // Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h"
 365     HeadersFilename = FrameworkName;
 366     HeadersFilename += "PrivateHeaders/";
 367     HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
 368     if (!(FE = FileMgr.getFile(HeadersFilename.begin(), HeadersFilename.end())))
 369       return 0;
 370   }
 371
 372   // This file is a system header or C++ unfriendly if the old file is.
 373   //
 374   // Note that the temporary 'DirInfo' is required here, as either call to
 375   // getFileInfo could resize the vector and we don't want to rely on order
 376   // of evaluation.
 377   unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo;
 378   getFileInfo(FE).DirInfo = DirInfo;
 379   return FE;
 380 }
 381
 382 //===----------------------------------------------------------------------===//
 383 // File Info Management.
 384 //===----------------------------------------------------------------------===//
 385
 386
 387 /// getFileInfo - Return the HeaderFileInfo structure for the specified
 388 /// FileEntry.
 389 HeaderFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) {
 390   if (FE->getUID() >= FileInfo.size())
 391     FileInfo.resize(FE->getUID()+1);
 392   return FileInfo[FE->getUID()];
 393 }
 394
 395 void HeaderSearch::setHeaderFileInfoForUID(HeaderFileInfo HFI, unsigned UID) {
 396   if (UID >= FileInfo.size())
 397     FileInfo.resize(UID+1);
 398   FileInfo[UID] = HFI;
 399 }
 400
 401 /// ShouldEnterIncludeFile - Mark the specified file as a target of of a
 402 /// #include, #include_next, or #import directive.  Return false if #including
 403 /// the file will have no effect or true if we should include it.
 404 bool HeaderSearch::ShouldEnterIncludeFile(const FileEntry *File, bool isImport){
 405   ++NumIncluded; // Count # of attempted #includes.
 406
 407   // Get information about this file.
 408   HeaderFileInfo &FileInfo = getFileInfo(File);
 409
 410   // If this is a #import directive, check that we have not already imported
 411   // this header.
 412   if (isImport) {
 413     // If this has already been imported, don't import it again.
 414     FileInfo.isImport = true;
 415
 416     // Has this already been #import'ed or #include'd?
 417     if (FileInfo.NumIncludes) return false;
 418   } else {
 419     // Otherwise, if this is a #include of a file that was previously #import'd
 420     // or if this is the second #include of a #pragma once file, ignore it.
 421     if (FileInfo.isImport)
 422       return false;
 423   }
 424
 425   // Next, check to see if the file is wrapped with #ifndef guards.  If so, and
 426   // if the macro that guards it is defined, we know the #include has no effect.
 427   if (const IdentifierInfo *ControllingMacro
 428       = FileInfo.getControllingMacro(ExternalLookup))
 429     if (ControllingMacro->hasMacroDefinition()) {
 430       ++NumMultiIncludeFileOptzn;
 431       return false;
 432     }
 433
 434   // Increment the number of times this file has been included.
 435   ++FileInfo.NumIncludes;
 436
 437   return true;
 438 }
 439
 440