1 //===--- HeaderSearch.cpp - Resolve Header File Locations ---===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the DirectoryLookup and HeaderSearch interfaces.
12 //===----------------------------------------------------------------------===//
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"
21 using namespace clang;
23 const IdentifierInfo *
24 HeaderFileInfo::getControllingMacro(ExternalIdentifierLookup *External) {
26 return ControllingMacro;
28 if (!ControllingMacroID || !External)
31 ControllingMacro = External->GetIdentifier(ControllingMacroID);
32 return ControllingMacro;
35 HeaderSearch::HeaderSearch(FileManager &FM) : FileMgr(FM), FrameworkMap(64) {
37 NoCurDirSearch = false;
41 NumMultiIncludeFileOptzn = 0;
42 NumFrameworkLookups = NumSubFrameworkLookups = 0;
45 HeaderSearch::~HeaderSearch() {
47 for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
48 delete HeaderMaps[i].second;
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;
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);
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);
69 fprintf(stderr, "%d framework lookups.\n", NumFrameworkLookups);
70 fprintf(stderr, "%d subframework lookups.\n", NumSubFrameworkLookups);
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;
86 if (const HeaderMap *HM = HeaderMap::Create(FE)) {
87 HeaderMaps.push_back(std::make_pair(FE, HM));
94 //===----------------------------------------------------------------------===//
95 // File lookup within a DirectoryLookup scope
96 //===----------------------------------------------------------------------===//
98 /// getName - Return the directory or filename corresponding to this lookup
100 const char *DirectoryLookup::getName() const {
102 return getDir()->getName();
104 return getFrameworkDir()->getName();
105 assert(isHeaderMap() && "Unknown DirectoryLookup");
106 return getHeaderMap()->getFileName();
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;
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());
125 return DoFrameworkLookup(Filename, HS);
127 assert(isHeaderMap() && "Unknown directory lookup");
128 return getHeaderMap()->LookupFile(Filename, HS.getFileMgr());
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();
138 // Framework names must have a '/' in the filename.
139 size_t SlashPos = Filename.find('/');
140 if (SlashPos == llvm::StringRef::npos) return 0;
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));
147 // If it is known and in some other directory, fail.
148 if (FrameworkDirCache && FrameworkDirCache != getFrameworkDir())
151 // Otherwise, construct the path to this framework dir.
153 // FrameworkName = "/System/Library/Frameworks/"
154 llvm::SmallString<1024> FrameworkName;
155 FrameworkName += getFrameworkDir()->getName();
156 if (FrameworkName.empty() || FrameworkName.back() != '/')
157 FrameworkName.push_back('/');
159 // FrameworkName = "/System/Library/Frameworks/Cocoa"
160 FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
162 // FrameworkName = "/System/Library/Frameworks/Cocoa.framework/"
163 FrameworkName += ".framework/";
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();
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())
176 // Otherwise, if it does, remember that this is the right direntry for this
178 FrameworkDirCache = getFrameworkDir();
181 // Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h"
182 unsigned OrigSize = FrameworkName.size();
184 FrameworkName += "Headers/";
185 FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end());
186 if (const FileEntry *FE = FileMgr.getFile(FrameworkName.begin(),
187 FrameworkName.end())) {
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());
199 //===----------------------------------------------------------------------===//
200 // Header File Location.
201 //===----------------------------------------------------------------------===//
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
209 const FileEntry *HeaderSearch::LookupFile(llvm::StringRef Filename,
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())) {
218 // If this was an #include_next "/absolute/file", fail.
219 if (FromDir) return 0;
221 // Otherwise, just return the file.
222 return FileMgr.getFile(Filename);
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.
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
244 unsigned DirInfo = getFileInfo(CurFileEnt).DirInfo;
245 getFileInfo(FE).DirInfo = DirInfo;
252 // If this is a system #include, ignore the user #include locs.
253 unsigned i = isAngled ? SystemDirIdx : 0;
255 // If this is a #include_next request, start searching after the directory the
256 // file was found in.
258 i = FromDir-&SearchDirs[0];
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();
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;
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;
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);
286 CurDir = &SearchDirs[i];
288 // This file is a system header or C++ unfriendly if the dir is.
289 getFileInfo(FE).DirInfo = CurDir->getDirCharacteristic();
291 // Remember this location for the next lookup we do.
292 CacheLookup.second = i;
296 // Otherwise, didn't find it. Remember we didn't find this.
297 CacheLookup.second = SearchDirs.size();
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?");
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;
315 // Look up the base framework name of the ContextFileEnt.
316 const char *ContextName = ContextFileEnt->getName();
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)
323 llvm::SmallString<1024> FrameworkName(ContextName,
324 FrameworkPos+strlen(".framework/"));
326 // Append Frameworks/HIToolbox.framework/
327 FrameworkName += "Frameworks/";
328 FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
329 FrameworkName += ".framework/";
331 llvm::StringMapEntry<const DirectoryEntry *> &CacheLookup =
332 FrameworkMap.GetOrCreateValue(Filename.begin(), Filename.begin()+SlashPos);
334 // Some other location?
335 if (CacheLookup.getValue() &&
336 CacheLookup.getKeyLength() == FrameworkName.size() &&
337 memcmp(CacheLookup.getKeyData(), &FrameworkName[0],
338 CacheLookup.getKeyLength()) != 0)
341 // Cache subframework.
342 if (CacheLookup.getValue() == 0) {
343 ++NumSubFrameworkLookups;
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;
350 // Otherwise, if it does, remember that this is the right direntry for this
352 CacheLookup.setValue(Dir);
355 const FileEntry *FE = 0;
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()))) {
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())))
372 // This file is a system header or C++ unfriendly if the old file is.
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
377 unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo;
378 getFileInfo(FE).DirInfo = DirInfo;
382 //===----------------------------------------------------------------------===//
383 // File Info Management.
384 //===----------------------------------------------------------------------===//
387 /// getFileInfo - Return the HeaderFileInfo structure for the specified
389 HeaderFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) {
390 if (FE->getUID() >= FileInfo.size())
391 FileInfo.resize(FE->getUID()+1);
392 return FileInfo[FE->getUID()];
395 void HeaderSearch::setHeaderFileInfoForUID(HeaderFileInfo HFI, unsigned UID) {
396 if (UID >= FileInfo.size())
397 FileInfo.resize(UID+1);
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.
407 // Get information about this file.
408 HeaderFileInfo &FileInfo = getFileInfo(File);
410 // If this is a #import directive, check that we have not already imported
413 // If this has already been imported, don't import it again.
414 FileInfo.isImport = true;
416 // Has this already been #import'ed or #include'd?
417 if (FileInfo.NumIncludes) return false;
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)
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;
434 // Increment the number of times this file has been included.
435 ++FileInfo.NumIncludes;