2006-10-18 13:34:33 +08:00
|
|
|
//===--- HeaderSearch.cpp - Resolve Header File Locations ---===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 03:59:25 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2006-10-18 13:34:33 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the DirectoryLookup and HeaderSearch interfaces.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/Lex/HeaderSearch.h"
|
2007-12-17 14:36:45 +08:00
|
|
|
#include "clang/Lex/HeaderMap.h"
|
2011-12-09 09:33:57 +08:00
|
|
|
#include "clang/Lex/Lexer.h"
|
2011-11-12 03:10:28 +08:00
|
|
|
#include "clang/Basic/Diagnostic.h"
|
2007-10-07 16:58:51 +08:00
|
|
|
#include "clang/Basic/FileManager.h"
|
|
|
|
#include "clang/Basic/IdentifierTable.h"
|
2011-01-10 10:34:13 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2010-11-30 02:12:39 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2006-10-30 11:40:58 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2011-07-28 02:41:18 +08:00
|
|
|
#include "llvm/Support/Capacity.h"
|
2009-03-03 06:20:04 +08:00
|
|
|
#include <cstdio>
|
2006-10-18 13:34:33 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
2009-04-26 07:30:02 +08:00
|
|
|
const IdentifierInfo *
|
|
|
|
HeaderFileInfo::getControllingMacro(ExternalIdentifierLookup *External) {
|
|
|
|
if (ControllingMacro)
|
|
|
|
return ControllingMacro;
|
|
|
|
|
|
|
|
if (!ControllingMacroID || !External)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ControllingMacro = External->GetIdentifier(ControllingMacroID);
|
|
|
|
return ControllingMacro;
|
|
|
|
}
|
|
|
|
|
Implement two related optimizations that make de-serialization of
AST/PCH files more lazy:
- Don't preload all of the file source-location entries when reading
the AST file. Instead, load them lazily, when needed.
- Only look up header-search information (whether a header was already
#import'd, how many times it's been included, etc.) when it's needed
by the preprocessor, rather than pre-populating it.
Previously, we would pre-load all of the file source-location entries,
which also populated the header-search information structure. This was
a relatively minor performance issue, since we would end up stat()'ing
all of the headers stored within a AST/PCH file when the AST/PCH file
was loaded. In the normal PCH use case, the stat()s were cached, so
the cost--of preloading ~860 source-location entries in the Cocoa.h
case---was relatively low.
However, the recent optimization that replaced stat+open with
open+fstat turned this into a major problem, since the preloading of
source-location entries would now end up opening those files. Worse,
those files wouldn't be closed until the file manager was destroyed,
so just opening a Cocoa.h PCH file would hold on to ~860 file
descriptors, and it was easy to blow through the process's limit on
the number of open file descriptors.
By eliminating the preloading of these files, we neither open nor stat
the headers stored in the PCH/AST file until they're actually needed
for something. Concretely, we went from
*** HeaderSearch Stats:
835 files tracked.
364 #import/#pragma once files.
823 included exactly once.
6 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
835 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
with a trivial program that uses a chained PCH including a Cocoa PCH
to
*** HeaderSearch Stats:
4 files tracked.
1 #import/#pragma once files.
3 included exactly once.
2 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
3 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
for the same program.
llvm-svn: 125286
2011-02-11 01:09:37 +08:00
|
|
|
ExternalHeaderFileInfoSource::~ExternalHeaderFileInfoSource() {}
|
|
|
|
|
2011-12-31 12:05:44 +08:00
|
|
|
HeaderSearch::HeaderSearch(FileManager &FM, DiagnosticsEngine &Diags,
|
|
|
|
const LangOptions &LangOpts)
|
2011-11-12 03:10:28 +08:00
|
|
|
: FileMgr(FM), Diags(Diags), FrameworkMap(64),
|
2011-12-31 12:05:44 +08:00
|
|
|
ModMap(FileMgr, *Diags.getClient(), LangOpts)
|
2011-11-11 08:35:06 +08:00
|
|
|
{
|
2011-05-24 12:31:14 +08:00
|
|
|
AngledDirIdx = 0;
|
2006-10-20 14:23:14 +08:00
|
|
|
SystemDirIdx = 0;
|
|
|
|
NoCurDirSearch = false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-04-26 07:30:02 +08:00
|
|
|
ExternalLookup = 0;
|
Implement two related optimizations that make de-serialization of
AST/PCH files more lazy:
- Don't preload all of the file source-location entries when reading
the AST file. Instead, load them lazily, when needed.
- Only look up header-search information (whether a header was already
#import'd, how many times it's been included, etc.) when it's needed
by the preprocessor, rather than pre-populating it.
Previously, we would pre-load all of the file source-location entries,
which also populated the header-search information structure. This was
a relatively minor performance issue, since we would end up stat()'ing
all of the headers stored within a AST/PCH file when the AST/PCH file
was loaded. In the normal PCH use case, the stat()s were cached, so
the cost--of preloading ~860 source-location entries in the Cocoa.h
case---was relatively low.
However, the recent optimization that replaced stat+open with
open+fstat turned this into a major problem, since the preloading of
source-location entries would now end up opening those files. Worse,
those files wouldn't be closed until the file manager was destroyed,
so just opening a Cocoa.h PCH file would hold on to ~860 file
descriptors, and it was easy to blow through the process's limit on
the number of open file descriptors.
By eliminating the preloading of these files, we neither open nor stat
the headers stored in the PCH/AST file until they're actually needed
for something. Concretely, we went from
*** HeaderSearch Stats:
835 files tracked.
364 #import/#pragma once files.
823 included exactly once.
6 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
835 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
with a trivial program that uses a chained PCH including a Cocoa PCH
to
*** HeaderSearch Stats:
4 files tracked.
1 #import/#pragma once files.
3 included exactly once.
2 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
3 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
for the same program.
llvm-svn: 125286
2011-02-11 01:09:37 +08:00
|
|
|
ExternalSource = 0;
|
2006-10-20 14:23:14 +08:00
|
|
|
NumIncluded = 0;
|
|
|
|
NumMultiIncludeFileOptzn = 0;
|
|
|
|
NumFrameworkLookups = NumSubFrameworkLookups = 0;
|
|
|
|
}
|
|
|
|
|
2007-12-17 14:36:45 +08:00
|
|
|
HeaderSearch::~HeaderSearch() {
|
|
|
|
// Delete headermaps.
|
|
|
|
for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
|
|
|
|
delete HeaderMaps[i].second;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
void HeaderSearch::PrintStats() {
|
2007-06-16 07:05:46 +08:00
|
|
|
fprintf(stderr, "\n*** HeaderSearch Stats:\n");
|
|
|
|
fprintf(stderr, "%d files tracked.\n", (int)FileInfo.size());
|
2006-10-18 13:34:33 +08:00
|
|
|
unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
|
|
|
|
for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
|
|
|
|
NumOnceOnlyFiles += FileInfo[i].isImport;
|
|
|
|
if (MaxNumIncludes < FileInfo[i].NumIncludes)
|
|
|
|
MaxNumIncludes = FileInfo[i].NumIncludes;
|
|
|
|
NumSingleIncludedFiles += FileInfo[i].NumIncludes == 1;
|
|
|
|
}
|
2007-06-16 07:05:46 +08:00
|
|
|
fprintf(stderr, " %d #import/#pragma once files.\n", NumOnceOnlyFiles);
|
|
|
|
fprintf(stderr, " %d included exactly once.\n", NumSingleIncludedFiles);
|
|
|
|
fprintf(stderr, " %d max times a file is included.\n", MaxNumIncludes);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-06-16 07:05:46 +08:00
|
|
|
fprintf(stderr, " %d #include/#include_next/#import.\n", NumIncluded);
|
|
|
|
fprintf(stderr, " %d #includes skipped due to"
|
|
|
|
" the multi-include optimization.\n", NumMultiIncludeFileOptzn);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-06-16 07:05:46 +08:00
|
|
|
fprintf(stderr, "%d framework lookups.\n", NumFrameworkLookups);
|
|
|
|
fprintf(stderr, "%d subframework lookups.\n", NumSubFrameworkLookups);
|
2006-10-18 13:34:33 +08:00
|
|
|
}
|
|
|
|
|
2007-12-17 14:36:45 +08:00
|
|
|
/// CreateHeaderMap - This method returns a HeaderMap for the specified
|
|
|
|
/// FileEntry, uniquing them through the the 'HeaderMaps' datastructure.
|
2007-12-18 02:34:53 +08:00
|
|
|
const HeaderMap *HeaderSearch::CreateHeaderMap(const FileEntry *FE) {
|
2007-12-17 14:36:45 +08:00
|
|
|
// We expect the number of headermaps to be small, and almost always empty.
|
2007-12-17 15:52:39 +08:00
|
|
|
// If it ever grows, use of a linear search should be re-evaluated.
|
2007-12-17 14:36:45 +08:00
|
|
|
if (!HeaderMaps.empty()) {
|
|
|
|
for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
|
2007-12-17 15:52:39 +08:00
|
|
|
// Pointer equality comparison of FileEntries works because they are
|
|
|
|
// already uniqued by inode.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (HeaderMaps[i].first == FE)
|
2007-12-17 14:36:45 +08:00
|
|
|
return HeaderMaps[i].second;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-11-23 16:35:12 +08:00
|
|
|
if (const HeaderMap *HM = HeaderMap::Create(FE, FileMgr)) {
|
2007-12-17 14:36:45 +08:00
|
|
|
HeaderMaps.push_back(std::make_pair(FE, HM));
|
|
|
|
return HM;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 14:36:45 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-30 01:08:11 +08:00
|
|
|
std::string HeaderSearch::getModuleFileName(Module *Module) {
|
2011-09-13 04:41:59 +08:00
|
|
|
// If we don't have a module cache path, we can't do anything.
|
2012-01-30 01:08:11 +08:00
|
|
|
if (ModuleCachePath.empty())
|
|
|
|
return std::string();
|
|
|
|
|
|
|
|
|
|
|
|
llvm::SmallString<256> Result(ModuleCachePath);
|
|
|
|
llvm::sys::path::append(Result, Module->getTopLevelModule()->Name + ".pcm");
|
|
|
|
return Result.str().str();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string HeaderSearch::getModuleFileName(StringRef ModuleName) {
|
|
|
|
// If we don't have a module cache path, we can't do anything.
|
|
|
|
if (ModuleCachePath.empty())
|
|
|
|
return std::string();
|
2011-09-14 07:15:45 +08:00
|
|
|
|
2012-01-30 01:08:11 +08:00
|
|
|
|
|
|
|
llvm::SmallString<256> Result(ModuleCachePath);
|
|
|
|
llvm::sys::path::append(Result, ModuleName + ".pcm");
|
|
|
|
return Result.str().str();
|
|
|
|
}
|
|
|
|
|
|
|
|
Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {
|
2011-11-12 08:05:07 +08:00
|
|
|
// Look in the module map to determine if there is a module by this name.
|
2012-01-30 01:08:11 +08:00
|
|
|
Module *Module = ModMap.findModule(ModuleName);
|
|
|
|
if (Module || !AllowSearch)
|
|
|
|
return Module;
|
|
|
|
|
|
|
|
// Look through the various header search paths to load any avai;able module
|
|
|
|
// maps, searching for a module map that describes this module.
|
|
|
|
for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
|
|
|
|
if (SearchDirs[Idx].isFramework()) {
|
|
|
|
// Search for or infer a module map for a framework.
|
|
|
|
llvm::SmallString<128> FrameworkDirName;
|
|
|
|
FrameworkDirName += SearchDirs[Idx].getFrameworkDir()->getName();
|
|
|
|
llvm::sys::path::append(FrameworkDirName, ModuleName + ".framework");
|
|
|
|
if (const DirectoryEntry *FrameworkDir
|
|
|
|
= FileMgr.getDirectory(FrameworkDirName)) {
|
|
|
|
bool IsSystem
|
|
|
|
= SearchDirs[Idx].getDirCharacteristic() != SrcMgr::C_User;
|
|
|
|
Module = loadFrameworkModule(ModuleName, FrameworkDir, IsSystem);
|
2011-11-12 08:05:07 +08:00
|
|
|
if (Module)
|
|
|
|
break;
|
|
|
|
}
|
2012-01-30 01:08:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Figure out how header maps and module maps will work together.
|
|
|
|
|
|
|
|
// Only deal with normal search directories.
|
|
|
|
if (!SearchDirs[Idx].isNormalDir())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Search for a module map file in this directory.
|
|
|
|
if (loadModuleMapFile(SearchDirs[Idx].getDir()) == LMM_NewlyLoaded) {
|
|
|
|
// We just loaded a module map file; check whether the module is
|
|
|
|
// available now.
|
|
|
|
Module = ModMap.findModule(ModuleName);
|
|
|
|
if (Module)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search for a module map in a subdirectory with the same name as the
|
|
|
|
// module.
|
|
|
|
llvm::SmallString<128> NestedModuleMapDirName;
|
|
|
|
NestedModuleMapDirName = SearchDirs[Idx].getDir()->getName();
|
|
|
|
llvm::sys::path::append(NestedModuleMapDirName, ModuleName);
|
|
|
|
if (loadModuleMapFile(NestedModuleMapDirName) == LMM_NewlyLoaded) {
|
|
|
|
// If we just loaded a module map file, look for the module again.
|
|
|
|
Module = ModMap.findModule(ModuleName);
|
|
|
|
if (Module)
|
|
|
|
break;
|
2011-11-12 08:05:07 +08:00
|
|
|
}
|
|
|
|
}
|
2012-01-30 01:08:11 +08:00
|
|
|
|
|
|
|
return Module;
|
2011-09-13 04:41:59 +08:00
|
|
|
}
|
|
|
|
|
2007-12-17 15:52:39 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// File lookup within a DirectoryLookup scope
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2007-12-18 01:57:27 +08:00
|
|
|
/// getName - Return the directory or filename corresponding to this lookup
|
|
|
|
/// object.
|
|
|
|
const char *DirectoryLookup::getName() const {
|
|
|
|
if (isNormalDir())
|
|
|
|
return getDir()->getName();
|
|
|
|
if (isFramework())
|
|
|
|
return getFrameworkDir()->getName();
|
|
|
|
assert(isHeaderMap() && "Unknown DirectoryLookup");
|
|
|
|
return getHeaderMap()->getFileName();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-12-17 15:52:39 +08:00
|
|
|
/// LookupFile - Lookup the specified file in this search path, returning it
|
|
|
|
/// if it exists or returning null if not.
|
2011-03-17 02:34:36 +08:00
|
|
|
const FileEntry *DirectoryLookup::LookupFile(
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef Filename,
|
2011-04-27 05:50:03 +08:00
|
|
|
HeaderSearch &HS,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<char> *SearchPath,
|
2011-09-16 06:00:41 +08:00
|
|
|
SmallVectorImpl<char> *RelativePath,
|
2011-12-01 07:21:26 +08:00
|
|
|
Module **SuggestedModule) const {
|
2007-12-17 15:52:39 +08:00
|
|
|
llvm::SmallString<1024> TmpDir;
|
2007-12-17 16:13:48 +08:00
|
|
|
if (isNormalDir()) {
|
|
|
|
// Concatenate the requested file onto the directory.
|
2011-07-09 04:17:28 +08:00
|
|
|
TmpDir = getDir()->getName();
|
|
|
|
llvm::sys::path::append(TmpDir, Filename);
|
2011-04-27 05:50:03 +08:00
|
|
|
if (SearchPath != NULL) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef SearchPathRef(getDir()->getName());
|
2011-04-27 05:50:03 +08:00
|
|
|
SearchPath->clear();
|
|
|
|
SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
|
|
|
|
}
|
|
|
|
if (RelativePath != NULL) {
|
|
|
|
RelativePath->clear();
|
|
|
|
RelativePath->append(Filename.begin(), Filename.end());
|
|
|
|
}
|
2011-11-12 03:10:28 +08:00
|
|
|
|
|
|
|
// If we have a module map that might map this header, load it and
|
|
|
|
// check whether we'll have a suggestion for a module.
|
|
|
|
if (SuggestedModule && HS.hasModuleMap(TmpDir, getDir())) {
|
|
|
|
const FileEntry *File = HS.getFileMgr().getFile(TmpDir.str(),
|
|
|
|
/*openFile=*/false);
|
|
|
|
if (!File)
|
|
|
|
return File;
|
|
|
|
|
|
|
|
// If there is a module that corresponds to this header,
|
|
|
|
// suggest it.
|
2011-12-09 01:01:29 +08:00
|
|
|
*SuggestedModule = HS.findModuleForHeader(File);
|
2011-11-12 03:10:28 +08:00
|
|
|
return File;
|
|
|
|
}
|
|
|
|
|
2011-03-17 03:17:25 +08:00
|
|
|
return HS.getFileMgr().getFile(TmpDir.str(), /*openFile=*/true);
|
2007-12-17 16:13:48 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
if (isFramework())
|
2011-09-16 06:00:41 +08:00
|
|
|
return DoFrameworkLookup(Filename, HS, SearchPath, RelativePath,
|
2011-12-09 01:01:29 +08:00
|
|
|
SuggestedModule);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:17:39 +08:00
|
|
|
assert(isHeaderMap() && "Unknown directory lookup");
|
2011-04-27 05:50:03 +08:00
|
|
|
const FileEntry * const Result = getHeaderMap()->LookupFile(
|
|
|
|
Filename, HS.getFileMgr());
|
|
|
|
if (Result) {
|
|
|
|
if (SearchPath != NULL) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef SearchPathRef(getName());
|
2011-04-27 05:50:03 +08:00
|
|
|
SearchPath->clear();
|
|
|
|
SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
|
|
|
|
}
|
|
|
|
if (RelativePath != NULL) {
|
|
|
|
RelativePath->clear();
|
|
|
|
RelativePath->append(Filename.begin(), Filename.end());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Result;
|
2007-12-17 15:52:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
/// DoFrameworkLookup - Do a lookup of the specified file in the current
|
|
|
|
/// DirectoryLookup, which is a framework directory.
|
2011-03-17 02:34:36 +08:00
|
|
|
const FileEntry *DirectoryLookup::DoFrameworkLookup(
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef Filename,
|
2011-04-27 05:50:03 +08:00
|
|
|
HeaderSearch &HS,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<char> *SearchPath,
|
2011-09-16 06:00:41 +08:00
|
|
|
SmallVectorImpl<char> *RelativePath,
|
2011-12-01 07:21:26 +08:00
|
|
|
Module **SuggestedModule) const
|
2011-09-16 06:00:41 +08:00
|
|
|
{
|
2007-12-17 16:13:48 +08:00
|
|
|
FileManager &FileMgr = HS.getFileMgr();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Framework names must have a '/' in the filename.
|
2010-01-10 09:35:12 +08:00
|
|
|
size_t SlashPos = Filename.find('/');
|
2011-07-23 18:55:15 +08:00
|
|
|
if (SlashPos == StringRef::npos) return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
// Find out if this is the home for the specified framework, by checking
|
|
|
|
// HeaderSearch. Possible answer are yes/no and unknown.
|
2009-09-09 23:08:12 +08:00
|
|
|
const DirectoryEntry *&FrameworkDirCache =
|
2010-01-10 09:35:12 +08:00
|
|
|
HS.LookupFrameworkCache(Filename.substr(0, SlashPos));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
// If it is known and in some other directory, fail.
|
|
|
|
if (FrameworkDirCache && FrameworkDirCache != getFrameworkDir())
|
2006-10-22 15:24:13 +08:00
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
// Otherwise, construct the path to this framework dir.
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// FrameworkName = "/System/Library/Frameworks/"
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::SmallString<1024> FrameworkName;
|
2007-12-17 16:13:48 +08:00
|
|
|
FrameworkName += getFrameworkDir()->getName();
|
2006-10-30 13:09:49 +08:00
|
|
|
if (FrameworkName.empty() || FrameworkName.back() != '/')
|
|
|
|
FrameworkName.push_back('/');
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// FrameworkName = "/System/Library/Frameworks/Cocoa"
|
2011-11-17 09:41:17 +08:00
|
|
|
StringRef ModuleName(Filename.begin(), SlashPos);
|
|
|
|
FrameworkName += ModuleName;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// FrameworkName = "/System/Library/Frameworks/Cocoa.framework/"
|
|
|
|
FrameworkName += ".framework/";
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
// If the cache entry is still unresolved, query to see if the cache entry is
|
|
|
|
// still unresolved. If so, check its existence now.
|
|
|
|
if (FrameworkDirCache == 0) {
|
|
|
|
HS.IncrementFrameworkLookupCount();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-22 15:24:13 +08:00
|
|
|
// If the framework dir doesn't exist, we fail.
|
2007-12-17 16:13:48 +08:00
|
|
|
// FIXME: It's probably more efficient to query this with FileMgr.getDir.
|
2011-01-10 10:34:13 +08:00
|
|
|
bool Exists;
|
|
|
|
if (llvm::sys::fs::exists(FrameworkName.str(), Exists) || !Exists)
|
2006-10-22 15:24:13 +08:00
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-22 15:24:13 +08:00
|
|
|
// Otherwise, if it does, remember that this is the right direntry for this
|
|
|
|
// framework.
|
2007-12-17 16:13:48 +08:00
|
|
|
FrameworkDirCache = getFrameworkDir();
|
2006-10-22 15:24:13 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-04-27 05:50:03 +08:00
|
|
|
if (RelativePath != NULL) {
|
|
|
|
RelativePath->clear();
|
|
|
|
RelativePath->append(Filename.begin()+SlashPos+1, Filename.end());
|
|
|
|
}
|
|
|
|
|
2011-11-17 09:41:17 +08:00
|
|
|
// If we're allowed to look for modules, try to load or create the module
|
|
|
|
// corresponding to this framework.
|
2011-12-01 07:21:26 +08:00
|
|
|
Module *Module = 0;
|
2011-11-17 09:41:17 +08:00
|
|
|
if (SuggestedModule) {
|
|
|
|
if (const DirectoryEntry *FrameworkDir
|
2012-01-28 03:52:33 +08:00
|
|
|
= FileMgr.getDirectory(FrameworkName)) {
|
|
|
|
bool IsSystem = getDirCharacteristic() != SrcMgr::C_User;
|
2012-01-30 01:08:11 +08:00
|
|
|
Module = HS.loadFrameworkModule(ModuleName, FrameworkDir, IsSystem);
|
2012-01-28 03:52:33 +08:00
|
|
|
}
|
2011-11-17 09:41:17 +08:00
|
|
|
}
|
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h"
|
2006-10-30 13:09:49 +08:00
|
|
|
unsigned OrigSize = FrameworkName.size();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-30 13:09:49 +08:00
|
|
|
FrameworkName += "Headers/";
|
2011-04-27 05:50:03 +08:00
|
|
|
|
|
|
|
if (SearchPath != NULL) {
|
|
|
|
SearchPath->clear();
|
|
|
|
// Without trailing '/'.
|
|
|
|
SearchPath->append(FrameworkName.begin(), FrameworkName.end()-1);
|
|
|
|
}
|
|
|
|
|
2011-11-17 09:41:17 +08:00
|
|
|
// Determine whether this is the module we're building or not.
|
2011-12-07 01:31:28 +08:00
|
|
|
bool AutomaticImport = Module;
|
2010-01-10 09:35:12 +08:00
|
|
|
FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end());
|
2011-03-17 03:17:25 +08:00
|
|
|
if (const FileEntry *FE = FileMgr.getFile(FrameworkName.str(),
|
2011-09-16 06:00:41 +08:00
|
|
|
/*openFile=*/!AutomaticImport)) {
|
|
|
|
if (AutomaticImport)
|
2011-12-07 01:31:28 +08:00
|
|
|
*SuggestedModule = HS.findModuleForHeader(FE);
|
2006-10-20 12:55:45 +08:00
|
|
|
return FE;
|
2011-03-17 02:34:36 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h"
|
2006-10-30 13:09:49 +08:00
|
|
|
const char *Private = "Private";
|
2009-09-09 23:08:12 +08:00
|
|
|
FrameworkName.insert(FrameworkName.begin()+OrigSize, Private,
|
2006-10-30 13:09:49 +08:00
|
|
|
Private+strlen(Private));
|
2011-04-27 05:50:03 +08:00
|
|
|
if (SearchPath != NULL)
|
|
|
|
SearchPath->insert(SearchPath->begin()+OrigSize, Private,
|
|
|
|
Private+strlen(Private));
|
|
|
|
|
2011-09-16 06:00:41 +08:00
|
|
|
const FileEntry *FE = FileMgr.getFile(FrameworkName.str(),
|
|
|
|
/*openFile=*/!AutomaticImport);
|
|
|
|
if (FE && AutomaticImport)
|
2011-12-07 01:31:28 +08:00
|
|
|
*SuggestedModule = HS.findModuleForHeader(FE);
|
2011-09-16 06:00:41 +08:00
|
|
|
return FE;
|
2006-10-18 13:34:33 +08:00
|
|
|
}
|
|
|
|
|
2007-12-17 15:52:39 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Header File Location.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
/// LookupFile - Given a "foo" or <foo> reference, look up the indicated file,
|
|
|
|
/// return null on failure. isAngled indicates whether the file reference is
|
2010-08-08 15:49:23 +08:00
|
|
|
/// for system #include's or not (i.e. using <> instead of ""). CurFileEnt, if
|
|
|
|
/// non-null, indicates where the #including file is, in case a relative search
|
|
|
|
/// is needed.
|
2011-03-17 02:34:36 +08:00
|
|
|
const FileEntry *HeaderSearch::LookupFile(
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef Filename,
|
2011-03-17 02:34:36 +08:00
|
|
|
bool isAngled,
|
|
|
|
const DirectoryLookup *FromDir,
|
|
|
|
const DirectoryLookup *&CurDir,
|
|
|
|
const FileEntry *CurFileEnt,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<char> *SearchPath,
|
2011-09-16 06:00:41 +08:00
|
|
|
SmallVectorImpl<char> *RelativePath,
|
2011-12-01 07:21:26 +08:00
|
|
|
Module **SuggestedModule,
|
2011-11-21 01:46:46 +08:00
|
|
|
bool SkipCache)
|
2011-09-16 06:00:41 +08:00
|
|
|
{
|
|
|
|
if (SuggestedModule)
|
2011-11-18 06:44:56 +08:00
|
|
|
*SuggestedModule = 0;
|
2011-09-16 06:00:41 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// If 'Filename' is absolute, check to see if it exists and no searching.
|
2010-12-18 05:22:22 +08:00
|
|
|
if (llvm::sys::path::is_absolute(Filename)) {
|
2006-10-18 13:34:33 +08:00
|
|
|
CurDir = 0;
|
|
|
|
|
|
|
|
// If this was an #include_next "/absolute/file", fail.
|
|
|
|
if (FromDir) return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-04-27 05:50:03 +08:00
|
|
|
if (SearchPath != NULL)
|
|
|
|
SearchPath->clear();
|
|
|
|
if (RelativePath != NULL) {
|
|
|
|
RelativePath->clear();
|
|
|
|
RelativePath->append(Filename.begin(), Filename.end());
|
|
|
|
}
|
2006-10-18 13:34:33 +08:00
|
|
|
// Otherwise, just return the file.
|
2011-03-17 03:17:25 +08:00
|
|
|
return FileMgr.getFile(Filename, /*openFile=*/true);
|
2006-10-18 13:34:33 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-07-28 12:45:53 +08:00
|
|
|
// Unless disabled, check to see if the file is in the #includer's
|
2010-08-08 15:49:23 +08:00
|
|
|
// directory. This has to be based on CurFileEnt, not CurDir, because
|
|
|
|
// CurFileEnt could be a #include of a subdirectory (#include "foo/bar.h") and
|
2007-12-17 15:52:39 +08:00
|
|
|
// a subsequent include of "baz.h" should resolve to "whatever/foo/baz.h".
|
|
|
|
// This search is not done for <> headers.
|
2010-08-08 15:49:23 +08:00
|
|
|
if (CurFileEnt && !isAngled && !NoCurDirSearch) {
|
|
|
|
llvm::SmallString<1024> TmpDir;
|
|
|
|
// Concatenate the requested file onto the directory.
|
|
|
|
// FIXME: Portability. Filename concatenation should be in sys::Path.
|
|
|
|
TmpDir += CurFileEnt->getDir()->getName();
|
|
|
|
TmpDir.push_back('/');
|
|
|
|
TmpDir.append(Filename.begin(), Filename.end());
|
2011-03-17 03:17:25 +08:00
|
|
|
if (const FileEntry *FE = FileMgr.getFile(TmpDir.str(),/*openFile=*/true)) {
|
2006-10-18 13:34:33 +08:00
|
|
|
// Leave CurDir unset.
|
2010-08-08 15:49:23 +08:00
|
|
|
// This file is a system header or C++ unfriendly if the old file is.
|
|
|
|
//
|
|
|
|
// Note that the temporary 'DirInfo' is required here, as either call to
|
|
|
|
// getFileInfo could resize the vector and we don't want to rely on order
|
|
|
|
// of evaluation.
|
|
|
|
unsigned DirInfo = getFileInfo(CurFileEnt).DirInfo;
|
2008-02-26 05:38:21 +08:00
|
|
|
getFileInfo(FE).DirInfo = DirInfo;
|
2011-04-27 05:50:03 +08:00
|
|
|
if (SearchPath != NULL) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef SearchPathRef(CurFileEnt->getDir()->getName());
|
2011-04-27 05:50:03 +08:00
|
|
|
SearchPath->clear();
|
|
|
|
SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
|
|
|
|
}
|
|
|
|
if (RelativePath != NULL) {
|
|
|
|
RelativePath->clear();
|
|
|
|
RelativePath->append(Filename.begin(), Filename.end());
|
|
|
|
}
|
2006-10-18 13:34:33 +08:00
|
|
|
return FE;
|
|
|
|
}
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
CurDir = 0;
|
|
|
|
|
|
|
|
// If this is a system #include, ignore the user #include locs.
|
2011-05-24 12:31:14 +08:00
|
|
|
unsigned i = isAngled ? AngledDirIdx : 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// If this is a #include_next request, start searching after the directory the
|
|
|
|
// file was found in.
|
|
|
|
if (FromDir)
|
|
|
|
i = FromDir-&SearchDirs[0];
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-07-22 15:28:00 +08:00
|
|
|
// Cache all of the lookups performed by this method. Many headers are
|
|
|
|
// multiply included, and the "pragma once" optimization prevents them from
|
|
|
|
// being relex/pp'd, but they would still have to search through a
|
|
|
|
// (potentially huge) series of SearchDirs to find it.
|
|
|
|
std::pair<unsigned, unsigned> &CacheLookup =
|
2010-01-10 09:35:12 +08:00
|
|
|
LookupFileCache.GetOrCreateValue(Filename).getValue();
|
2007-07-22 15:28:00 +08:00
|
|
|
|
|
|
|
// If the entry has been previously looked up, the first value will be
|
|
|
|
// non-zero. If the value is equal to i (the start point of our search), then
|
|
|
|
// this is a matching hit.
|
2011-11-21 01:46:46 +08:00
|
|
|
if (!SkipCache && CacheLookup.first == i+1) {
|
2007-07-22 15:28:00 +08:00
|
|
|
// Skip querying potentially lots of directories for this lookup.
|
|
|
|
i = CacheLookup.second;
|
|
|
|
} else {
|
|
|
|
// Otherwise, this is the first query, or the previous query didn't match
|
|
|
|
// our search start. We will fill in our found location below, so prime the
|
|
|
|
// start point value.
|
|
|
|
CacheLookup.first = i+1;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Check each directory in sequence to see if it contains this file.
|
|
|
|
for (; i != SearchDirs.size(); ++i) {
|
2009-09-09 23:08:12 +08:00
|
|
|
const FileEntry *FE =
|
2011-09-16 06:00:41 +08:00
|
|
|
SearchDirs[i].LookupFile(Filename, *this, SearchPath, RelativePath,
|
2011-12-09 01:01:29 +08:00
|
|
|
SuggestedModule);
|
2007-12-17 16:13:48 +08:00
|
|
|
if (!FE) continue;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
CurDir = &SearchDirs[i];
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
// This file is a system header or C++ unfriendly if the dir is.
|
2011-07-28 12:45:53 +08:00
|
|
|
HeaderFileInfo &HFI = getFileInfo(FE);
|
|
|
|
HFI.DirInfo = CurDir->getDirCharacteristic();
|
|
|
|
|
|
|
|
// If this file is found in a header map and uses the framework style of
|
|
|
|
// includes, then this header is part of a framework we're building.
|
|
|
|
if (CurDir->isIndexHeaderMap()) {
|
|
|
|
size_t SlashPos = Filename.find('/');
|
|
|
|
if (SlashPos != StringRef::npos) {
|
|
|
|
HFI.IndexHeaderMapHeader = 1;
|
|
|
|
HFI.Framework = getUniqueFrameworkName(StringRef(Filename.begin(),
|
|
|
|
SlashPos));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-17 16:13:48 +08:00
|
|
|
// Remember this location for the next lookup we do.
|
|
|
|
CacheLookup.second = i;
|
|
|
|
return FE;
|
2006-10-18 13:34:33 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-07-30 14:28:34 +08:00
|
|
|
// If we are including a file with a quoted include "foo.h" from inside
|
|
|
|
// a header in a framework that is currently being built, and we couldn't
|
|
|
|
// resolve "foo.h" any other way, change the include to <Foo/foo.h>, where
|
|
|
|
// "Foo" is the name of the framework in which the including header was found.
|
|
|
|
if (CurFileEnt && !isAngled && Filename.find('/') == StringRef::npos) {
|
|
|
|
HeaderFileInfo &IncludingHFI = getFileInfo(CurFileEnt);
|
|
|
|
if (IncludingHFI.IndexHeaderMapHeader) {
|
|
|
|
llvm::SmallString<128> ScratchFilename;
|
|
|
|
ScratchFilename += IncludingHFI.Framework;
|
|
|
|
ScratchFilename += '/';
|
|
|
|
ScratchFilename += Filename;
|
|
|
|
|
|
|
|
const FileEntry *Result = LookupFile(ScratchFilename, /*isAngled=*/true,
|
|
|
|
FromDir, CurDir, CurFileEnt,
|
2011-09-16 06:00:41 +08:00
|
|
|
SearchPath, RelativePath,
|
|
|
|
SuggestedModule);
|
2011-07-30 14:28:34 +08:00
|
|
|
std::pair<unsigned, unsigned> &CacheLookup
|
|
|
|
= LookupFileCache.GetOrCreateValue(Filename).getValue();
|
|
|
|
CacheLookup.second
|
|
|
|
= LookupFileCache.GetOrCreateValue(ScratchFilename).getValue().second;
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-22 15:28:00 +08:00
|
|
|
// Otherwise, didn't find it. Remember we didn't find this.
|
|
|
|
CacheLookup.second = SearchDirs.size();
|
2006-10-18 13:34:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
/// LookupSubframeworkHeader - Look up a subframework for the specified
|
|
|
|
/// #include file. For example, if #include'ing <HIToolbox/HIToolbox.h> from
|
|
|
|
/// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox
|
|
|
|
/// is a subframework within Carbon.framework. If so, return the FileEntry
|
|
|
|
/// for the designated file, otherwise return null.
|
|
|
|
const FileEntry *HeaderSearch::
|
2011-07-23 18:55:15 +08:00
|
|
|
LookupSubframeworkHeader(StringRef Filename,
|
2011-03-17 02:34:36 +08:00
|
|
|
const FileEntry *ContextFileEnt,
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVectorImpl<char> *SearchPath,
|
|
|
|
SmallVectorImpl<char> *RelativePath) {
|
2008-02-01 13:34:02 +08:00
|
|
|
assert(ContextFileEnt && "No context file?");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
// Framework names must have a '/' in the filename. Find it.
|
2011-12-10 00:48:01 +08:00
|
|
|
// FIXME: Should we permit '\' on Windows?
|
2010-01-10 09:35:12 +08:00
|
|
|
size_t SlashPos = Filename.find('/');
|
2011-07-23 18:55:15 +08:00
|
|
|
if (SlashPos == StringRef::npos) return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
// Look up the base framework name of the ContextFileEnt.
|
2006-10-27 13:12:36 +08:00
|
|
|
const char *ContextName = ContextFileEnt->getName();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
// If the context info wasn't a framework, couldn't be a subframework.
|
2011-12-10 00:48:01 +08:00
|
|
|
const unsigned DotFrameworkLen = 10;
|
|
|
|
const char *FrameworkPos = strstr(ContextName, ".framework");
|
|
|
|
if (FrameworkPos == 0 ||
|
|
|
|
(FrameworkPos[DotFrameworkLen] != '/' &&
|
|
|
|
FrameworkPos[DotFrameworkLen] != '\\'))
|
2006-10-20 12:42:40 +08:00
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
llvm::SmallString<1024> FrameworkName(ContextName,
|
2011-12-10 00:48:01 +08:00
|
|
|
FrameworkPos+DotFrameworkLen+1);
|
2006-10-22 15:24:13 +08:00
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
// Append Frameworks/HIToolbox.framework/
|
|
|
|
FrameworkName += "Frameworks/";
|
2010-01-10 09:35:12 +08:00
|
|
|
FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
|
2006-10-20 12:42:40 +08:00
|
|
|
FrameworkName += ".framework/";
|
2006-10-20 12:55:45 +08:00
|
|
|
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::StringMapEntry<const DirectoryEntry *> &CacheLookup =
|
2010-11-21 17:55:08 +08:00
|
|
|
FrameworkMap.GetOrCreateValue(Filename.substr(0, SlashPos));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-22 15:24:13 +08:00
|
|
|
// Some other location?
|
2007-02-09 03:08:49 +08:00
|
|
|
if (CacheLookup.getValue() &&
|
|
|
|
CacheLookup.getKeyLength() == FrameworkName.size() &&
|
|
|
|
memcmp(CacheLookup.getKeyData(), &FrameworkName[0],
|
|
|
|
CacheLookup.getKeyLength()) != 0)
|
2006-10-22 15:24:13 +08:00
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-22 15:24:13 +08:00
|
|
|
// Cache subframework.
|
2007-02-09 03:08:49 +08:00
|
|
|
if (CacheLookup.getValue() == 0) {
|
2006-10-22 15:24:13 +08:00
|
|
|
++NumSubFrameworkLookups;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-22 15:24:13 +08:00
|
|
|
// If the framework dir doesn't exist, we fail.
|
2010-11-23 16:35:12 +08:00
|
|
|
const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str());
|
2006-10-22 15:24:13 +08:00
|
|
|
if (Dir == 0) return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-22 15:24:13 +08:00
|
|
|
// Otherwise, if it does, remember that this is the right direntry for this
|
|
|
|
// framework.
|
2007-02-09 03:08:49 +08:00
|
|
|
CacheLookup.setValue(Dir);
|
2006-10-22 15:24:13 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-20 12:55:45 +08:00
|
|
|
const FileEntry *FE = 0;
|
|
|
|
|
2011-04-27 05:50:03 +08:00
|
|
|
if (RelativePath != NULL) {
|
|
|
|
RelativePath->clear();
|
|
|
|
RelativePath->append(Filename.begin()+SlashPos+1, Filename.end());
|
|
|
|
}
|
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
// Check ".../Frameworks/HIToolbox.framework/Headers/HIToolbox.h"
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::SmallString<1024> HeadersFilename(FrameworkName);
|
2006-10-30 11:40:58 +08:00
|
|
|
HeadersFilename += "Headers/";
|
2011-04-27 05:50:03 +08:00
|
|
|
if (SearchPath != NULL) {
|
|
|
|
SearchPath->clear();
|
|
|
|
// Without trailing '/'.
|
|
|
|
SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);
|
|
|
|
}
|
|
|
|
|
2010-01-10 09:35:12 +08:00
|
|
|
HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
|
2011-03-17 03:17:25 +08:00
|
|
|
if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true))) {
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-20 12:42:40 +08:00
|
|
|
// Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h"
|
2006-10-30 11:40:58 +08:00
|
|
|
HeadersFilename = FrameworkName;
|
|
|
|
HeadersFilename += "PrivateHeaders/";
|
2011-04-27 05:50:03 +08:00
|
|
|
if (SearchPath != NULL) {
|
|
|
|
SearchPath->clear();
|
|
|
|
// Without trailing '/'.
|
|
|
|
SearchPath->append(HeadersFilename.begin(), HeadersFilename.end()-1);
|
|
|
|
}
|
|
|
|
|
2010-01-10 09:35:12 +08:00
|
|
|
HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
|
2011-03-17 03:17:25 +08:00
|
|
|
if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true)))
|
2006-10-20 12:42:40 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-20 12:55:45 +08:00
|
|
|
// This file is a system header or C++ unfriendly if the old file is.
|
2008-02-24 11:55:14 +08:00
|
|
|
//
|
2008-02-26 05:38:21 +08:00
|
|
|
// Note that the temporary 'DirInfo' is required here, as either call to
|
|
|
|
// getFileInfo could resize the vector and we don't want to rely on order
|
|
|
|
// of evaluation.
|
|
|
|
unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo;
|
|
|
|
getFileInfo(FE).DirInfo = DirInfo;
|
2006-10-20 12:55:45 +08:00
|
|
|
return FE;
|
2006-10-20 12:42:40 +08:00
|
|
|
}
|
|
|
|
|
2011-12-09 09:33:57 +08:00
|
|
|
/// \brief Helper static function to normalize a path for injection into
|
|
|
|
/// a synthetic header.
|
|
|
|
/*static*/ std::string
|
|
|
|
HeaderSearch::NormalizeDashIncludePath(StringRef File, FileManager &FileMgr) {
|
|
|
|
// Implicit include paths should be resolved relative to the current
|
|
|
|
// working directory first, and then use the regular header search
|
|
|
|
// mechanism. The proper way to handle this is to have the
|
|
|
|
// predefines buffer located at the current working directory, but
|
|
|
|
// it has no file entry. For now, workaround this by using an
|
|
|
|
// absolute path if we find the file here, and otherwise letting
|
|
|
|
// header search handle it.
|
|
|
|
llvm::SmallString<128> Path(File);
|
|
|
|
llvm::sys::fs::make_absolute(Path);
|
|
|
|
bool exists;
|
|
|
|
if (llvm::sys::fs::exists(Path.str(), exists) || !exists)
|
|
|
|
Path = File;
|
|
|
|
else if (exists)
|
|
|
|
FileMgr.getFile(File);
|
|
|
|
|
|
|
|
return Lexer::Stringify(Path.str());
|
|
|
|
}
|
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// File Info Management.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-09-17 13:35:18 +08:00
|
|
|
/// \brief Merge the header file info provided by \p OtherHFI into the current
|
|
|
|
/// header file info (\p HFI)
|
|
|
|
static void mergeHeaderFileInfo(HeaderFileInfo &HFI,
|
|
|
|
const HeaderFileInfo &OtherHFI) {
|
|
|
|
HFI.isImport |= OtherHFI.isImport;
|
|
|
|
HFI.isPragmaOnce |= OtherHFI.isPragmaOnce;
|
|
|
|
HFI.NumIncludes += OtherHFI.NumIncludes;
|
|
|
|
|
|
|
|
if (!HFI.ControllingMacro && !HFI.ControllingMacroID) {
|
|
|
|
HFI.ControllingMacro = OtherHFI.ControllingMacro;
|
|
|
|
HFI.ControllingMacroID = OtherHFI.ControllingMacroID;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (OtherHFI.External) {
|
|
|
|
HFI.DirInfo = OtherHFI.DirInfo;
|
|
|
|
HFI.External = OtherHFI.External;
|
|
|
|
HFI.IndexHeaderMapHeader = OtherHFI.IndexHeaderMapHeader;
|
|
|
|
}
|
2006-10-18 13:34:33 +08:00
|
|
|
|
2011-09-17 13:35:18 +08:00
|
|
|
if (HFI.Framework.empty())
|
|
|
|
HFI.Framework = OtherHFI.Framework;
|
|
|
|
|
|
|
|
HFI.Resolved = true;
|
|
|
|
}
|
|
|
|
|
2009-04-25 04:03:17 +08:00
|
|
|
/// getFileInfo - Return the HeaderFileInfo structure for the specified
|
2006-10-18 13:34:33 +08:00
|
|
|
/// FileEntry.
|
2009-04-25 04:03:17 +08:00
|
|
|
HeaderFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) {
|
2006-10-18 13:34:33 +08:00
|
|
|
if (FE->getUID() >= FileInfo.size())
|
|
|
|
FileInfo.resize(FE->getUID()+1);
|
Implement two related optimizations that make de-serialization of
AST/PCH files more lazy:
- Don't preload all of the file source-location entries when reading
the AST file. Instead, load them lazily, when needed.
- Only look up header-search information (whether a header was already
#import'd, how many times it's been included, etc.) when it's needed
by the preprocessor, rather than pre-populating it.
Previously, we would pre-load all of the file source-location entries,
which also populated the header-search information structure. This was
a relatively minor performance issue, since we would end up stat()'ing
all of the headers stored within a AST/PCH file when the AST/PCH file
was loaded. In the normal PCH use case, the stat()s were cached, so
the cost--of preloading ~860 source-location entries in the Cocoa.h
case---was relatively low.
However, the recent optimization that replaced stat+open with
open+fstat turned this into a major problem, since the preloading of
source-location entries would now end up opening those files. Worse,
those files wouldn't be closed until the file manager was destroyed,
so just opening a Cocoa.h PCH file would hold on to ~860 file
descriptors, and it was easy to blow through the process's limit on
the number of open file descriptors.
By eliminating the preloading of these files, we neither open nor stat
the headers stored in the PCH/AST file until they're actually needed
for something. Concretely, we went from
*** HeaderSearch Stats:
835 files tracked.
364 #import/#pragma once files.
823 included exactly once.
6 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
835 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
with a trivial program that uses a chained PCH including a Cocoa PCH
to
*** HeaderSearch Stats:
4 files tracked.
1 #import/#pragma once files.
3 included exactly once.
2 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
3 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
for the same program.
llvm-svn: 125286
2011-02-11 01:09:37 +08:00
|
|
|
|
|
|
|
HeaderFileInfo &HFI = FileInfo[FE->getUID()];
|
2011-09-17 13:35:18 +08:00
|
|
|
if (ExternalSource && !HFI.Resolved)
|
|
|
|
mergeHeaderFileInfo(HFI, ExternalSource->GetHeaderFileInfo(FE));
|
Implement two related optimizations that make de-serialization of
AST/PCH files more lazy:
- Don't preload all of the file source-location entries when reading
the AST file. Instead, load them lazily, when needed.
- Only look up header-search information (whether a header was already
#import'd, how many times it's been included, etc.) when it's needed
by the preprocessor, rather than pre-populating it.
Previously, we would pre-load all of the file source-location entries,
which also populated the header-search information structure. This was
a relatively minor performance issue, since we would end up stat()'ing
all of the headers stored within a AST/PCH file when the AST/PCH file
was loaded. In the normal PCH use case, the stat()s were cached, so
the cost--of preloading ~860 source-location entries in the Cocoa.h
case---was relatively low.
However, the recent optimization that replaced stat+open with
open+fstat turned this into a major problem, since the preloading of
source-location entries would now end up opening those files. Worse,
those files wouldn't be closed until the file manager was destroyed,
so just opening a Cocoa.h PCH file would hold on to ~860 file
descriptors, and it was easy to blow through the process's limit on
the number of open file descriptors.
By eliminating the preloading of these files, we neither open nor stat
the headers stored in the PCH/AST file until they're actually needed
for something. Concretely, we went from
*** HeaderSearch Stats:
835 files tracked.
364 #import/#pragma once files.
823 included exactly once.
6 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
835 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
with a trivial program that uses a chained PCH including a Cocoa PCH
to
*** HeaderSearch Stats:
4 files tracked.
1 #import/#pragma once files.
3 included exactly once.
2 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
3 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
for the same program.
llvm-svn: 125286
2011-02-11 01:09:37 +08:00
|
|
|
return HFI;
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
2006-10-18 13:34:33 +08:00
|
|
|
|
2011-05-04 08:14:37 +08:00
|
|
|
bool HeaderSearch::isFileMultipleIncludeGuarded(const FileEntry *File) {
|
|
|
|
// Check if we've ever seen this file as a header.
|
|
|
|
if (File->getUID() >= FileInfo.size())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Resolve header file info from the external source, if needed.
|
|
|
|
HeaderFileInfo &HFI = FileInfo[File->getUID()];
|
2011-09-17 13:35:18 +08:00
|
|
|
if (ExternalSource && !HFI.Resolved)
|
|
|
|
mergeHeaderFileInfo(HFI, ExternalSource->GetHeaderFileInfo(File));
|
2011-05-04 08:14:37 +08:00
|
|
|
|
|
|
|
return HFI.isPragmaOnce || HFI.ControllingMacro || HFI.ControllingMacroID;
|
|
|
|
}
|
|
|
|
|
2009-04-25 04:03:17 +08:00
|
|
|
void HeaderSearch::setHeaderFileInfoForUID(HeaderFileInfo HFI, unsigned UID) {
|
|
|
|
if (UID >= FileInfo.size())
|
|
|
|
FileInfo.resize(UID+1);
|
Implement two related optimizations that make de-serialization of
AST/PCH files more lazy:
- Don't preload all of the file source-location entries when reading
the AST file. Instead, load them lazily, when needed.
- Only look up header-search information (whether a header was already
#import'd, how many times it's been included, etc.) when it's needed
by the preprocessor, rather than pre-populating it.
Previously, we would pre-load all of the file source-location entries,
which also populated the header-search information structure. This was
a relatively minor performance issue, since we would end up stat()'ing
all of the headers stored within a AST/PCH file when the AST/PCH file
was loaded. In the normal PCH use case, the stat()s were cached, so
the cost--of preloading ~860 source-location entries in the Cocoa.h
case---was relatively low.
However, the recent optimization that replaced stat+open with
open+fstat turned this into a major problem, since the preloading of
source-location entries would now end up opening those files. Worse,
those files wouldn't be closed until the file manager was destroyed,
so just opening a Cocoa.h PCH file would hold on to ~860 file
descriptors, and it was easy to blow through the process's limit on
the number of open file descriptors.
By eliminating the preloading of these files, we neither open nor stat
the headers stored in the PCH/AST file until they're actually needed
for something. Concretely, we went from
*** HeaderSearch Stats:
835 files tracked.
364 #import/#pragma once files.
823 included exactly once.
6 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
835 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
with a trivial program that uses a chained PCH including a Cocoa PCH
to
*** HeaderSearch Stats:
4 files tracked.
1 #import/#pragma once files.
3 included exactly once.
2 max times a file is included.
3 #include/#include_next/#import.
0 #includes skipped due to the multi-include optimization.
1 framework lookups.
0 subframework lookups.
*** Source Manager Stats:
3 files mapped, 3 mem buffers mapped.
37460 SLocEntry's allocated, 11215575B of Sloc address space used.
62 bytes of files mapped, 0 files with line #'s computed.
for the same program.
llvm-svn: 125286
2011-02-11 01:09:37 +08:00
|
|
|
HFI.Resolved = true;
|
2009-04-25 04:03:17 +08:00
|
|
|
FileInfo[UID] = HFI;
|
|
|
|
}
|
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
/// ShouldEnterIncludeFile - Mark the specified file as a target of of a
|
|
|
|
/// #include, #include_next, or #import directive. Return false if #including
|
|
|
|
/// the file will have no effect or true if we should include it.
|
|
|
|
bool HeaderSearch::ShouldEnterIncludeFile(const FileEntry *File, bool isImport){
|
|
|
|
++NumIncluded; // Count # of attempted #includes.
|
|
|
|
|
|
|
|
// Get information about this file.
|
2009-04-25 04:03:17 +08:00
|
|
|
HeaderFileInfo &FileInfo = getFileInfo(File);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// If this is a #import directive, check that we have not already imported
|
|
|
|
// this header.
|
|
|
|
if (isImport) {
|
|
|
|
// If this has already been imported, don't import it again.
|
|
|
|
FileInfo.isImport = true;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Has this already been #import'ed or #include'd?
|
|
|
|
if (FileInfo.NumIncludes) return false;
|
|
|
|
} else {
|
|
|
|
// Otherwise, if this is a #include of a file that was previously #import'd
|
|
|
|
// or if this is the second #include of a #pragma once file, ignore it.
|
|
|
|
if (FileInfo.isImport)
|
|
|
|
return false;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Next, check to see if the file is wrapped with #ifndef guards. If so, and
|
|
|
|
// if the macro that guards it is defined, we know the #include has no effect.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const IdentifierInfo *ControllingMacro
|
2009-04-26 07:30:02 +08:00
|
|
|
= FileInfo.getControllingMacro(ExternalLookup))
|
|
|
|
if (ControllingMacro->hasMacroDefinition()) {
|
|
|
|
++NumMultiIncludeFileOptzn;
|
|
|
|
return false;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
// Increment the number of times this file has been included.
|
|
|
|
++FileInfo.NumIncludes;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-10-18 13:34:33 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-07-27 07:46:11 +08:00
|
|
|
size_t HeaderSearch::getTotalMemory() const {
|
|
|
|
return SearchDirs.capacity()
|
2011-07-28 02:41:18 +08:00
|
|
|
+ llvm::capacity_in_bytes(FileInfo)
|
|
|
|
+ llvm::capacity_in_bytes(HeaderMaps)
|
2011-07-27 07:46:11 +08:00
|
|
|
+ LookupFileCache.getAllocator().getTotalMemory()
|
|
|
|
+ FrameworkMap.getAllocator().getTotalMemory();
|
|
|
|
}
|
2011-07-28 12:45:53 +08:00
|
|
|
|
|
|
|
StringRef HeaderSearch::getUniqueFrameworkName(StringRef Framework) {
|
|
|
|
return FrameworkNames.GetOrCreateValue(Framework).getKey();
|
|
|
|
}
|
2011-11-12 03:10:28 +08:00
|
|
|
|
|
|
|
bool HeaderSearch::hasModuleMap(StringRef FileName,
|
|
|
|
const DirectoryEntry *Root) {
|
|
|
|
llvm::SmallVector<const DirectoryEntry *, 2> FixUpDirectories;
|
|
|
|
|
|
|
|
StringRef DirName = FileName;
|
|
|
|
do {
|
|
|
|
// Get the parent directory name.
|
|
|
|
DirName = llvm::sys::path::parent_path(DirName);
|
|
|
|
if (DirName.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Determine whether this directory exists.
|
|
|
|
const DirectoryEntry *Dir = FileMgr.getDirectory(DirName);
|
|
|
|
if (!Dir)
|
|
|
|
return false;
|
|
|
|
|
2011-11-12 08:05:07 +08:00
|
|
|
// Try to load the module map file in this directory.
|
2011-11-12 08:22:19 +08:00
|
|
|
switch (loadModuleMapFile(Dir)) {
|
|
|
|
case LMM_NewlyLoaded:
|
|
|
|
case LMM_AlreadyLoaded:
|
2011-11-12 08:05:07 +08:00
|
|
|
// Success. All of the directories we stepped through inherit this module
|
|
|
|
// map file.
|
2011-11-12 03:10:28 +08:00
|
|
|
for (unsigned I = 0, N = FixUpDirectories.size(); I != N; ++I)
|
|
|
|
DirectoryHasModuleMap[FixUpDirectories[I]] = true;
|
|
|
|
|
|
|
|
return true;
|
2011-11-12 08:22:19 +08:00
|
|
|
|
|
|
|
case LMM_NoDirectory:
|
|
|
|
case LMM_InvalidModuleMap:
|
|
|
|
break;
|
2011-11-12 03:10:28 +08:00
|
|
|
}
|
|
|
|
|
2011-11-12 08:05:07 +08:00
|
|
|
// If we hit the top of our search, we're done.
|
|
|
|
if (Dir == Root)
|
|
|
|
return false;
|
|
|
|
|
2011-11-12 03:10:28 +08:00
|
|
|
// Keep track of all of the directories we checked, so we can mark them as
|
|
|
|
// having module maps if we eventually do find a module map.
|
|
|
|
FixUpDirectories.push_back(Dir);
|
|
|
|
} while (true);
|
|
|
|
}
|
|
|
|
|
2011-12-01 07:21:26 +08:00
|
|
|
Module *HeaderSearch::findModuleForHeader(const FileEntry *File) {
|
2011-12-31 12:05:44 +08:00
|
|
|
if (Module *Mod = ModMap.findModuleForHeader(File))
|
|
|
|
return Mod;
|
2011-11-12 06:18:48 +08:00
|
|
|
|
2011-11-18 06:44:56 +08:00
|
|
|
return 0;
|
2011-11-12 03:10:28 +08:00
|
|
|
}
|
|
|
|
|
2011-11-16 08:09:06 +08:00
|
|
|
bool HeaderSearch::loadModuleMapFile(const FileEntry *File) {
|
|
|
|
const DirectoryEntry *Dir = File->getDir();
|
|
|
|
|
|
|
|
llvm::DenseMap<const DirectoryEntry *, bool>::iterator KnownDir
|
|
|
|
= DirectoryHasModuleMap.find(Dir);
|
|
|
|
if (KnownDir != DirectoryHasModuleMap.end())
|
|
|
|
return !KnownDir->second;
|
|
|
|
|
|
|
|
bool Result = ModMap.parseModuleMapFile(File);
|
2011-12-08 05:25:07 +08:00
|
|
|
if (!Result && llvm::sys::path::filename(File->getName()) == "module.map") {
|
|
|
|
// If the file we loaded was a module.map, look for the corresponding
|
|
|
|
// module_private.map.
|
|
|
|
llvm::SmallString<128> PrivateFilename(Dir->getName());
|
|
|
|
llvm::sys::path::append(PrivateFilename, "module_private.map");
|
|
|
|
if (const FileEntry *PrivateFile = FileMgr.getFile(PrivateFilename))
|
|
|
|
Result = ModMap.parseModuleMapFile(PrivateFile);
|
|
|
|
}
|
|
|
|
|
|
|
|
DirectoryHasModuleMap[Dir] = !Result;
|
2011-11-16 08:09:06 +08:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2012-01-30 01:08:11 +08:00
|
|
|
Module *HeaderSearch::loadFrameworkModule(StringRef Name,
|
|
|
|
const DirectoryEntry *Dir,
|
|
|
|
bool IsSystem) {
|
2011-12-01 07:21:26 +08:00
|
|
|
if (Module *Module = ModMap.findModule(Name))
|
2011-11-17 09:41:17 +08:00
|
|
|
return Module;
|
|
|
|
|
|
|
|
// Try to load a module map file.
|
|
|
|
switch (loadModuleMapFile(Dir)) {
|
|
|
|
case LMM_InvalidModuleMap:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LMM_AlreadyLoaded:
|
|
|
|
case LMM_NoDirectory:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case LMM_NewlyLoaded:
|
|
|
|
return ModMap.findModule(Name);
|
|
|
|
}
|
2012-01-14 06:31:52 +08:00
|
|
|
|
|
|
|
// The top-level framework directory, from which we'll infer a framework
|
|
|
|
// module.
|
|
|
|
const DirectoryEntry *TopFrameworkDir = Dir;
|
|
|
|
|
|
|
|
// The path from the module we're actually looking for back to the top-level
|
|
|
|
// framework name.
|
|
|
|
llvm::SmallVector<StringRef, 2> SubmodulePath;
|
|
|
|
SubmodulePath.push_back(Name);
|
2011-11-17 09:41:17 +08:00
|
|
|
|
2012-01-14 06:31:52 +08:00
|
|
|
// Walk the directory structure to find any enclosing frameworks.
|
|
|
|
StringRef DirName = Dir->getName();
|
|
|
|
do {
|
|
|
|
// Get the parent directory name.
|
|
|
|
DirName = llvm::sys::path::parent_path(DirName);
|
|
|
|
if (DirName.empty())
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Determine whether this directory exists.
|
|
|
|
Dir = FileMgr.getDirectory(DirName);
|
|
|
|
if (!Dir)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// If this is a framework directory, then we're a subframework of this
|
|
|
|
// framework.
|
|
|
|
if (llvm::sys::path::extension(DirName) == ".framework") {
|
|
|
|
SubmodulePath.push_back(llvm::sys::path::stem(DirName));
|
|
|
|
TopFrameworkDir = Dir;
|
|
|
|
}
|
|
|
|
} while (true);
|
|
|
|
|
|
|
|
// Try to infer a module map from the top-level framework directory.
|
|
|
|
Module *Result = ModMap.inferFrameworkModule(SubmodulePath.back(),
|
2012-01-28 03:52:33 +08:00
|
|
|
TopFrameworkDir,
|
|
|
|
IsSystem,
|
2012-01-14 06:31:52 +08:00
|
|
|
/*Parent=*/0);
|
|
|
|
|
|
|
|
// Follow the submodule path to find the requested (sub)framework module
|
|
|
|
// within the top-level framework module.
|
|
|
|
SubmodulePath.pop_back();
|
|
|
|
while (!SubmodulePath.empty() && Result) {
|
|
|
|
Result = ModMap.lookupModuleQualified(SubmodulePath.back(), Result);
|
|
|
|
SubmodulePath.pop_back();
|
|
|
|
}
|
|
|
|
return Result;
|
2011-11-17 09:41:17 +08:00
|
|
|
}
|
|
|
|
|
2011-11-16 08:09:06 +08:00
|
|
|
|
2011-11-12 08:22:19 +08:00
|
|
|
HeaderSearch::LoadModuleMapResult
|
|
|
|
HeaderSearch::loadModuleMapFile(StringRef DirName) {
|
2011-11-12 08:05:07 +08:00
|
|
|
if (const DirectoryEntry *Dir = FileMgr.getDirectory(DirName))
|
|
|
|
return loadModuleMapFile(Dir);
|
|
|
|
|
2011-11-12 08:22:19 +08:00
|
|
|
return LMM_NoDirectory;
|
2011-11-12 08:05:07 +08:00
|
|
|
}
|
|
|
|
|
2011-11-12 08:22:19 +08:00
|
|
|
HeaderSearch::LoadModuleMapResult
|
|
|
|
HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir) {
|
2011-11-12 08:05:07 +08:00
|
|
|
llvm::DenseMap<const DirectoryEntry *, bool>::iterator KnownDir
|
|
|
|
= DirectoryHasModuleMap.find(Dir);
|
|
|
|
if (KnownDir != DirectoryHasModuleMap.end())
|
2011-11-12 08:22:19 +08:00
|
|
|
return KnownDir->second? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
|
2011-11-12 08:05:07 +08:00
|
|
|
|
|
|
|
llvm::SmallString<128> ModuleMapFileName;
|
|
|
|
ModuleMapFileName += Dir->getName();
|
2011-12-07 10:23:45 +08:00
|
|
|
unsigned ModuleMapDirNameLen = ModuleMapFileName.size();
|
2011-11-12 08:05:07 +08:00
|
|
|
llvm::sys::path::append(ModuleMapFileName, "module.map");
|
|
|
|
if (const FileEntry *ModuleMapFile = FileMgr.getFile(ModuleMapFileName)) {
|
|
|
|
// We have found a module map file. Try to parse it.
|
2011-12-07 10:23:45 +08:00
|
|
|
if (ModMap.parseModuleMapFile(ModuleMapFile)) {
|
|
|
|
// No suitable module map.
|
|
|
|
DirectoryHasModuleMap[Dir] = false;
|
|
|
|
return LMM_InvalidModuleMap;
|
2011-11-12 08:05:07 +08:00
|
|
|
}
|
2011-12-07 10:23:45 +08:00
|
|
|
|
|
|
|
// This directory has a module map.
|
|
|
|
DirectoryHasModuleMap[Dir] = true;
|
|
|
|
|
|
|
|
// Check whether there is a private module map that we need to load as well.
|
|
|
|
ModuleMapFileName.erase(ModuleMapFileName.begin() + ModuleMapDirNameLen,
|
|
|
|
ModuleMapFileName.end());
|
|
|
|
llvm::sys::path::append(ModuleMapFileName, "module_private.map");
|
|
|
|
if (const FileEntry *PrivateModuleMapFile
|
|
|
|
= FileMgr.getFile(ModuleMapFileName)) {
|
|
|
|
if (ModMap.parseModuleMapFile(PrivateModuleMapFile)) {
|
|
|
|
// No suitable module map.
|
|
|
|
DirectoryHasModuleMap[Dir] = false;
|
|
|
|
return LMM_InvalidModuleMap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return LMM_NewlyLoaded;
|
2011-11-12 08:05:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// No suitable module map.
|
|
|
|
DirectoryHasModuleMap[Dir] = false;
|
2011-11-12 08:22:19 +08:00
|
|
|
return LMM_InvalidModuleMap;
|
2011-11-12 08:05:07 +08:00
|
|
|
}
|
2011-11-12 03:10:28 +08:00
|
|
|
|