head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.10 netbsd-11-0-RC3:1.1.1.10 netbsd-11-0-RC2:1.1.1.10 netbsd-11-0-RC1:1.1.1.10 perseant-exfatfs-base-20250801:1.1.1.10 netbsd-11:1.1.1.10.0.10 netbsd-11-base:1.1.1.10 netbsd-10-1-RELEASE:1.1.1.10 perseant-exfatfs-base-20240630:1.1.1.10 perseant-exfatfs:1.1.1.10.0.8 perseant-exfatfs-base:1.1.1.10 netbsd-8-3-RELEASE:1.1.1.7 netbsd-9-4-RELEASE:1.1.1.9 netbsd-10-0-RELEASE:1.1.1.10 netbsd-10-0-RC6:1.1.1.10 netbsd-10-0-RC5:1.1.1.10 netbsd-10-0-RC4:1.1.1.10 netbsd-10-0-RC3:1.1.1.10 netbsd-10-0-RC2:1.1.1.10 netbsd-10-0-RC1:1.1.1.10 netbsd-10:1.1.1.10.0.6 netbsd-10-base:1.1.1.10 netbsd-9-3-RELEASE:1.1.1.9 cjep_sun2x:1.1.1.10.0.4 cjep_sun2x-base:1.1.1.10 cjep_staticlib_x-base1:1.1.1.10 netbsd-9-2-RELEASE:1.1.1.9 cjep_staticlib_x:1.1.1.10.0.2 cjep_staticlib_x-base:1.1.1.10 netbsd-9-1-RELEASE:1.1.1.9 phil-wifi-20200421:1.1.1.10 phil-wifi-20200411:1.1.1.10 phil-wifi-20200406:1.1.1.10 netbsd-8-2-RELEASE:1.1.1.7 netbsd-9-0-RELEASE:1.1.1.9 netbsd-9-0-RC2:1.1.1.9 netbsd-9-0-RC1:1.1.1.9 netbsd-9:1.1.1.9.0.2 netbsd-9-base:1.1.1.9 phil-wifi-20190609:1.1.1.9 netbsd-8-1-RELEASE:1.1.1.7 netbsd-8-1-RC1:1.1.1.7 pgoyette-compat-merge-20190127:1.1.1.8.2.1 pgoyette-compat-20190127:1.1.1.9 pgoyette-compat-20190118:1.1.1.9 pgoyette-compat-1226:1.1.1.9 pgoyette-compat-1126:1.1.1.9 pgoyette-compat-1020:1.1.1.9 pgoyette-compat-0930:1.1.1.9 pgoyette-compat-0906:1.1.1.9 netbsd-7-2-RELEASE:1.1.1.4.2.1 pgoyette-compat-0728:1.1.1.9 clang-337282:1.1.1.9 netbsd-8-0-RELEASE:1.1.1.7 phil-wifi:1.1.1.8.0.4 phil-wifi-base:1.1.1.8 pgoyette-compat-0625:1.1.1.8 netbsd-8-0-RC2:1.1.1.7 pgoyette-compat-0521:1.1.1.8 pgoyette-compat-0502:1.1.1.8 pgoyette-compat-0422:1.1.1.8 netbsd-8-0-RC1:1.1.1.7 pgoyette-compat-0415:1.1.1.8 pgoyette-compat-0407:1.1.1.8 pgoyette-compat-0330:1.1.1.8 pgoyette-compat-0322:1.1.1.8 pgoyette-compat-0315:1.1.1.8 netbsd-7-1-2-RELEASE:1.1.1.4.2.1 pgoyette-compat:1.1.1.8.0.2 pgoyette-compat-base:1.1.1.8 netbsd-7-1-1-RELEASE:1.1.1.4.2.1 clang-319952:1.1.1.8 matt-nb8-mediatek:1.1.1.7.0.10 matt-nb8-mediatek-base:1.1.1.7 clang-309604:1.1.1.8 perseant-stdc-iso10646:1.1.1.7.0.8 perseant-stdc-iso10646-base:1.1.1.7 netbsd-8:1.1.1.7.0.6 netbsd-8-base:1.1.1.7 prg-localcount2-base3:1.1.1.7 prg-localcount2-base2:1.1.1.7 prg-localcount2-base1:1.1.1.7 prg-localcount2:1.1.1.7.0.4 prg-localcount2-base:1.1.1.7 pgoyette-localcount-20170426:1.1.1.7 bouyer-socketcan-base1:1.1.1.7 pgoyette-localcount-20170320:1.1.1.7 netbsd-7-1:1.1.1.4.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.4.2.1 netbsd-7-1-RC2:1.1.1.4.2.1 clang-294123:1.1.1.7 netbsd-7-nhusb-base-20170116:1.1.1.4.2.1 bouyer-socketcan:1.1.1.7.0.2 bouyer-socketcan-base:1.1.1.7 clang-291444:1.1.1.7 pgoyette-localcount-20170107:1.1.1.6 netbsd-7-1-RC1:1.1.1.4.2.1 pgoyette-localcount-20161104:1.1.1.6 netbsd-7-0-2-RELEASE:1.1.1.4.2.1 localcount-20160914:1.1.1.6 netbsd-7-nhusb:1.1.1.4.2.1.0.4 netbsd-7-nhusb-base:1.1.1.4.2.1 clang-280599:1.1.1.6 pgoyette-localcount-20160806:1.1.1.6 pgoyette-localcount-20160726:1.1.1.6 pgoyette-localcount:1.1.1.6.0.2 pgoyette-localcount-base:1.1.1.6 netbsd-7-0-1-RELEASE:1.1.1.4.2.1 clang-261930:1.1.1.6 netbsd-7-0:1.1.1.4.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.4.2.1 netbsd-7-0-RC3:1.1.1.4.2.1 netbsd-7-0-RC2:1.1.1.4.2.1 netbsd-7-0-RC1:1.1.1.4.2.1 clang-237755:1.1.1.5 clang-232565:1.1.1.5 clang-227398:1.1.1.5 tls-maxphys-base:1.1.1.4 tls-maxphys:1.1.1.4.0.4 netbsd-7:1.1.1.4.0.2 netbsd-7-base:1.1.1.4 clang-215315:1.1.1.4 clang-209886:1.1.1.3 yamt-pagecache:1.1.1.2.0.4 yamt-pagecache-base9:1.1.1.2 tls-earlyentropy:1.1.1.2.0.2 tls-earlyentropy-base:1.1.1.3 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.2 riastradh-drm2-base3:1.1.1.2 clang-202566:1.1.1.2 clang-201163:1.1.1.1 clang-199312:1.1.1.1 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.03.04.19.54.02; author joerg; state Exp; branches 1.1.1.2.2.1 1.1.1.2.4.1; next 1.1.1.3; commitid 29z1hJonZISIXprx; 1.1.1.3 date 2014.05.30.18.14.40; author joerg; state Exp; branches; next 1.1.1.4; commitid 8q0kdlBlCn09GACx; 1.1.1.4 date 2014.08.10.17.08.27; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid N85tXAN6Ex9VZPLx; 1.1.1.5 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.6; commitid mlISSizlPKvepX7y; 1.1.1.6 date 2016.02.27.22.11.54; author joerg; state Exp; branches 1.1.1.6.2.1; next 1.1.1.7; commitid tIimz3oDlh1NpBWy; 1.1.1.7 date 2017.01.11.10.34.54; author joerg; state Exp; branches; next 1.1.1.8; commitid CNnUNfII1jgNmxBz; 1.1.1.8 date 2017.08.01.19.34.55; author joerg; state Exp; branches 1.1.1.8.2.1 1.1.1.8.4.1; next 1.1.1.9; commitid pMuDy65V0VicSx1A; 1.1.1.9 date 2018.07.17.18.31.25; author joerg; state Exp; branches; next 1.1.1.10; commitid wDzL46ALjrCZgwKA; 1.1.1.10 date 2019.11.13.22.19.20; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.2.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.2.4.1 date 2014.03.04.19.54.02; author yamt; state dead; branches; next 1.1.1.2.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.2.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.4.4.1 date 2014.08.10.17.08.27; author tls; state dead; branches; next 1.1.1.4.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.4.4.2 date 2014.08.19.23.47.26; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2018.07.28.04.33.16; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.8.4.1 date 2019.06.10.21.45.20; author christos; state Exp; branches; next 1.1.1.8.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.8.4.2 date 2020.04.13.07.46.31; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- FileManager.cpp - File System Probing and Caching ----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the FileManager interface. // //===----------------------------------------------------------------------===// // // TODO: This should index all interesting directories with dirent calls. // getdirentries ? // opendir/readdir_r/closedir ? // //===----------------------------------------------------------------------===// #include "clang/Basic/FileManager.h" #include "clang/Basic/FileSystemStatCache.h" #include "llvm/ADT/SmallString.h" #include "llvm/Config/llvm-config.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/system_error.h" #include #include #include // FIXME: This is terrible, we need this for ::close. #if !defined(_MSC_VER) && !defined(__MINGW32__) #include #include #else #include #ifndef S_ISFIFO #define S_ISFIFO(x) (0) #endif #endif #if defined(LLVM_ON_UNIX) #include #endif using namespace clang; // FIXME: Enhance libsystem to support inode and other fields. #include /// NON_EXISTENT_DIR - A special value distinct from null that is used to /// represent a dir name that doesn't exist on the disk. #define NON_EXISTENT_DIR reinterpret_cast((intptr_t)-1) /// NON_EXISTENT_FILE - A special value distinct from null that is used to /// represent a filename that doesn't exist on the disk. #define NON_EXISTENT_FILE reinterpret_cast((intptr_t)-1) FileEntry::~FileEntry() { // If this FileEntry owns an open file descriptor that never got used, close // it. if (FD != -1) ::close(FD); } class FileManager::UniqueDirContainer { /// UniqueDirs - Cache from ID's to existing directories/files. std::map UniqueDirs; public: /// getDirectory - Return an existing DirectoryEntry with the given /// ID's if there is already one; otherwise create and return a /// default-constructed DirectoryEntry. DirectoryEntry &getDirectory(const llvm::sys::fs::UniqueID &UniqueID) { return UniqueDirs[UniqueID]; } size_t size() const { return UniqueDirs.size(); } }; class FileManager::UniqueFileContainer { /// UniqueFiles - Cache from ID's to existing directories/files. std::set UniqueFiles; public: /// getFile - Return an existing FileEntry with the given ID's if /// there is already one; otherwise create and return a /// default-constructed FileEntry. FileEntry &getFile(llvm::sys::fs::UniqueID UniqueID, bool IsNamedPipe, bool InPCH) { return const_cast( *UniqueFiles.insert(FileEntry(UniqueID, IsNamedPipe, InPCH)).first); } size_t size() const { return UniqueFiles.size(); } void erase(const FileEntry *Entry) { UniqueFiles.erase(*Entry); } }; //===----------------------------------------------------------------------===// // Common logic. //===----------------------------------------------------------------------===// FileManager::FileManager(const FileSystemOptions &FSO) : FileSystemOpts(FSO), UniqueRealDirs(*new UniqueDirContainer()), UniqueRealFiles(*new UniqueFileContainer()), SeenDirEntries(64), SeenFileEntries(64), NextFileUID(0) { NumDirLookups = NumFileLookups = 0; NumDirCacheMisses = NumFileCacheMisses = 0; } FileManager::~FileManager() { delete &UniqueRealDirs; delete &UniqueRealFiles; for (unsigned i = 0, e = VirtualFileEntries.size(); i != e; ++i) delete VirtualFileEntries[i]; for (unsigned i = 0, e = VirtualDirectoryEntries.size(); i != e; ++i) delete VirtualDirectoryEntries[i]; } void FileManager::addStatCache(FileSystemStatCache *statCache, bool AtBeginning) { assert(statCache && "No stat cache provided?"); if (AtBeginning || StatCache.get() == 0) { statCache->setNextStatCache(StatCache.take()); StatCache.reset(statCache); return; } FileSystemStatCache *LastCache = StatCache.get(); while (LastCache->getNextStatCache()) LastCache = LastCache->getNextStatCache(); LastCache->setNextStatCache(statCache); } void FileManager::removeStatCache(FileSystemStatCache *statCache) { if (!statCache) return; if (StatCache.get() == statCache) { // This is the first stat cache. StatCache.reset(StatCache->takeNextStatCache()); return; } // Find the stat cache in the list. FileSystemStatCache *PrevCache = StatCache.get(); while (PrevCache && PrevCache->getNextStatCache() != statCache) PrevCache = PrevCache->getNextStatCache(); assert(PrevCache && "Stat cache not found for removal"); PrevCache->setNextStatCache(statCache->getNextStatCache()); } void FileManager::clearStatCaches() { StatCache.reset(0); } /// \brief Retrieve the directory that the given file name resides in. /// Filename can point to either a real file or a virtual file. static const DirectoryEntry *getDirectoryFromFile(FileManager &FileMgr, StringRef Filename, bool CacheFailure) { if (Filename.empty()) return NULL; if (llvm::sys::path::is_separator(Filename[Filename.size() - 1])) return NULL; // If Filename is a directory. StringRef DirName = llvm::sys::path::parent_path(Filename); // Use the current directory if file has no path component. if (DirName.empty()) DirName = "."; return FileMgr.getDirectory(DirName, CacheFailure); } /// Add all ancestors of the given path (pointing to either a file or /// a directory) as virtual directories. void FileManager::addAncestorsAsVirtualDirs(StringRef Path) { StringRef DirName = llvm::sys::path::parent_path(Path); if (DirName.empty()) return; llvm::StringMapEntry &NamedDirEnt = SeenDirEntries.GetOrCreateValue(DirName); // When caching a virtual directory, we always cache its ancestors // at the same time. Therefore, if DirName is already in the cache, // we don't need to recurse as its ancestors must also already be in // the cache. if (NamedDirEnt.getValue()) return; // Add the virtual directory to the cache. DirectoryEntry *UDE = new DirectoryEntry; UDE->Name = NamedDirEnt.getKeyData(); NamedDirEnt.setValue(UDE); VirtualDirectoryEntries.push_back(UDE); // Recursively add the other ancestors. addAncestorsAsVirtualDirs(DirName); } const DirectoryEntry *FileManager::getDirectory(StringRef DirName, bool CacheFailure) { // stat doesn't like trailing separators except for root directory. // At least, on Win32 MSVCRT, stat() cannot strip trailing '/'. // (though it can strip '\\') if (DirName.size() > 1 && DirName != llvm::sys::path::root_path(DirName) && llvm::sys::path::is_separator(DirName.back())) DirName = DirName.substr(0, DirName.size()-1); #ifdef LLVM_ON_WIN32 // Fixing a problem with "clang C:test.c" on Windows. // Stat("C:") does not recognize "C:" as a valid directory std::string DirNameStr; if (DirName.size() > 1 && DirName.back() == ':' && DirName.equals_lower(llvm::sys::path::root_name(DirName))) { DirNameStr = DirName.str() + '.'; DirName = DirNameStr; } #endif ++NumDirLookups; llvm::StringMapEntry &NamedDirEnt = SeenDirEntries.GetOrCreateValue(DirName); // See if there was already an entry in the map. Note that the map // contains both virtual and real directories. if (NamedDirEnt.getValue()) return NamedDirEnt.getValue() == NON_EXISTENT_DIR ? 0 : NamedDirEnt.getValue(); ++NumDirCacheMisses; // By default, initialize it to invalid. NamedDirEnt.setValue(NON_EXISTENT_DIR); // Get the null-terminated directory name as stored as the key of the // SeenDirEntries map. const char *InterndDirName = NamedDirEnt.getKeyData(); // Check to see if the directory exists. FileData Data; if (getStatValue(InterndDirName, Data, false, 0 /*directory lookup*/)) { // There's no real directory at the given path. if (!CacheFailure) SeenDirEntries.erase(DirName); return 0; } // It exists. See if we have already opened a directory with the // same inode (this occurs on Unix-like systems when one dir is // symlinked to another, for example) or the same path (on // Windows). DirectoryEntry &UDE = UniqueRealDirs.getDirectory(Data.UniqueID); NamedDirEnt.setValue(&UDE); if (!UDE.getName()) { // We don't have this directory yet, add it. We use the string // key from the SeenDirEntries map as the string. UDE.Name = InterndDirName; } return &UDE; } const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, bool CacheFailure) { ++NumFileLookups; // See if there is already an entry in the map. llvm::StringMapEntry &NamedFileEnt = SeenFileEntries.GetOrCreateValue(Filename); // See if there is already an entry in the map. if (NamedFileEnt.getValue()) return NamedFileEnt.getValue() == NON_EXISTENT_FILE ? 0 : NamedFileEnt.getValue(); ++NumFileCacheMisses; // By default, initialize it to invalid. NamedFileEnt.setValue(NON_EXISTENT_FILE); // Get the null-terminated file name as stored as the key of the // SeenFileEntries map. const char *InterndFileName = NamedFileEnt.getKeyData(); // Look up the directory for the file. When looking up something like // sys/foo.h we'll discover all of the search directories that have a 'sys' // subdirectory. This will let us avoid having to waste time on known-to-fail // searches when we go to find sys/bar.h, because all the search directories // without a 'sys' subdir will get a cached failure result. const DirectoryEntry *DirInfo = getDirectoryFromFile(*this, Filename, CacheFailure); if (DirInfo == 0) { // Directory doesn't exist, file can't exist. if (!CacheFailure) SeenFileEntries.erase(Filename); return 0; } // FIXME: Use the directory info to prune this, before doing the stat syscall. // FIXME: This will reduce the # syscalls. // Nope, there isn't. Check to see if the file exists. int FileDescriptor = -1; FileData Data; if (getStatValue(InterndFileName, Data, true, openFile ? &FileDescriptor : 0)) { // There's no real file at the given path. if (!CacheFailure) SeenFileEntries.erase(Filename); return 0; } if (FileDescriptor != -1 && !openFile) { close(FileDescriptor); FileDescriptor = -1; } // It exists. See if we have already opened a file with the same inode. // This occurs when one dir is symlinked to another, for example. FileEntry &UFE = UniqueRealFiles.getFile(Data.UniqueID, Data.IsNamedPipe, Data.InPCH); NamedFileEnt.setValue(&UFE); if (UFE.getName()) { // Already have an entry with this inode, return it. // If the stat process opened the file, close it to avoid a FD leak. if (FileDescriptor != -1) close(FileDescriptor); return &UFE; } // Otherwise, we don't have this directory yet, add it. // FIXME: Change the name to be a char* that points back to the // 'SeenFileEntries' key. UFE.Name = InterndFileName; UFE.Size = Data.Size; UFE.ModTime = Data.ModTime; UFE.Dir = DirInfo; UFE.UID = NextFileUID++; UFE.FD = FileDescriptor; return &UFE; } const FileEntry * FileManager::getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime) { ++NumFileLookups; // See if there is already an entry in the map. llvm::StringMapEntry &NamedFileEnt = SeenFileEntries.GetOrCreateValue(Filename); // See if there is already an entry in the map. if (NamedFileEnt.getValue() && NamedFileEnt.getValue() != NON_EXISTENT_FILE) return NamedFileEnt.getValue(); ++NumFileCacheMisses; // By default, initialize it to invalid. NamedFileEnt.setValue(NON_EXISTENT_FILE); addAncestorsAsVirtualDirs(Filename); FileEntry *UFE = 0; // Now that all ancestors of Filename are in the cache, the // following call is guaranteed to find the DirectoryEntry from the // cache. const DirectoryEntry *DirInfo = getDirectoryFromFile(*this, Filename, /*CacheFailure=*/true); assert(DirInfo && "The directory of a virtual file should already be in the cache."); // Check to see if the file exists. If so, drop the virtual file FileData Data; const char *InterndFileName = NamedFileEnt.getKeyData(); if (getStatValue(InterndFileName, Data, true, 0) == 0) { Data.Size = Size; Data.ModTime = ModificationTime; UFE = &UniqueRealFiles.getFile(Data.UniqueID, Data.IsNamedPipe, Data.InPCH); NamedFileEnt.setValue(UFE); // If we had already opened this file, close it now so we don't // leak the descriptor. We're not going to use the file // descriptor anyway, since this is a virtual file. if (UFE->FD != -1) { close(UFE->FD); UFE->FD = -1; } // If we already have an entry with this inode, return it. if (UFE->getName()) return UFE; } if (!UFE) { UFE = new FileEntry(); VirtualFileEntries.push_back(UFE); NamedFileEnt.setValue(UFE); } UFE->Name = InterndFileName; UFE->Size = Size; UFE->ModTime = ModificationTime; UFE->Dir = DirInfo; UFE->UID = NextFileUID++; UFE->FD = -1; return UFE; } void FileManager::FixupRelativePath(SmallVectorImpl &path) const { StringRef pathRef(path.data(), path.size()); if (FileSystemOpts.WorkingDir.empty() || llvm::sys::path::is_absolute(pathRef)) return; SmallString<128> NewPath(FileSystemOpts.WorkingDir); llvm::sys::path::append(NewPath, pathRef); path = NewPath; } llvm::MemoryBuffer *FileManager:: getBufferForFile(const FileEntry *Entry, std::string *ErrorStr, bool isVolatile) { OwningPtr Result; llvm::error_code ec; uint64_t FileSize = Entry->getSize(); // If there's a high enough chance that the file have changed since we // got its size, force a stat before opening it. if (isVolatile) FileSize = -1; const char *Filename = Entry->getName(); // If the file is already open, use the open file descriptor. if (Entry->FD != -1) { ec = llvm::MemoryBuffer::getOpenFile(Entry->FD, Filename, Result, FileSize); if (ErrorStr) *ErrorStr = ec.message(); close(Entry->FD); Entry->FD = -1; return Result.take(); } // Otherwise, open the file. if (FileSystemOpts.WorkingDir.empty()) { ec = llvm::MemoryBuffer::getFile(Filename, Result, FileSize); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } SmallString<128> FilePath(Entry->getName()); FixupRelativePath(FilePath); ec = llvm::MemoryBuffer::getFile(FilePath.str(), Result, FileSize); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } llvm::MemoryBuffer *FileManager:: getBufferForFile(StringRef Filename, std::string *ErrorStr) { OwningPtr Result; llvm::error_code ec; if (FileSystemOpts.WorkingDir.empty()) { ec = llvm::MemoryBuffer::getFile(Filename, Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } SmallString<128> FilePath(Filename); FixupRelativePath(FilePath); ec = llvm::MemoryBuffer::getFile(FilePath.c_str(), Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } /// getStatValue - Get the 'stat' information for the specified path, /// using the cache to accelerate it if possible. This returns true /// if the path points to a virtual file or does not exist, or returns /// false if it's an existent real file. If FileDescriptor is NULL, /// do directory look-up instead of file look-up. bool FileManager::getStatValue(const char *Path, FileData &Data, bool isFile, int *FileDescriptor) { // FIXME: FileSystemOpts shouldn't be passed in here, all paths should be // absolute! if (FileSystemOpts.WorkingDir.empty()) return FileSystemStatCache::get(Path, Data, isFile, FileDescriptor, StatCache.get()); SmallString<128> FilePath(Path); FixupRelativePath(FilePath); return FileSystemStatCache::get(FilePath.c_str(), Data, isFile, FileDescriptor, StatCache.get()); } bool FileManager::getNoncachedStatValue(StringRef Path, llvm::sys::fs::file_status &Result) { SmallString<128> FilePath(Path); FixupRelativePath(FilePath); return llvm::sys::fs::status(FilePath.c_str(), Result); } void FileManager::invalidateCache(const FileEntry *Entry) { assert(Entry && "Cannot invalidate a NULL FileEntry"); SeenFileEntries.erase(Entry->getName()); // FileEntry invalidation should not block future optimizations in the file // caches. Possible alternatives are cache truncation (invalidate last N) or // invalidation of the whole cache. UniqueRealFiles.erase(Entry); } void FileManager::GetUniqueIDMapping( SmallVectorImpl &UIDToFiles) const { UIDToFiles.clear(); UIDToFiles.resize(NextFileUID); // Map file entries for (llvm::StringMap::const_iterator FE = SeenFileEntries.begin(), FEEnd = SeenFileEntries.end(); FE != FEEnd; ++FE) if (FE->getValue() && FE->getValue() != NON_EXISTENT_FILE) UIDToFiles[FE->getValue()->getUID()] = FE->getValue(); // Map virtual file entries for (SmallVectorImpl::const_iterator VFE = VirtualFileEntries.begin(), VFEEnd = VirtualFileEntries.end(); VFE != VFEEnd; ++VFE) if (*VFE && *VFE != NON_EXISTENT_FILE) UIDToFiles[(*VFE)->getUID()] = *VFE; } void FileManager::modifyFileEntry(FileEntry *File, off_t Size, time_t ModificationTime) { File->Size = Size; File->ModTime = ModificationTime; } StringRef FileManager::getCanonicalName(const DirectoryEntry *Dir) { // FIXME: use llvm::sys::fs::canonical() when it gets implemented #ifdef LLVM_ON_UNIX llvm::DenseMap::iterator Known = CanonicalDirNames.find(Dir); if (Known != CanonicalDirNames.end()) return Known->second; StringRef CanonicalName(Dir->getName()); char CanonicalNameBuf[PATH_MAX]; if (realpath(Dir->getName(), CanonicalNameBuf)) { unsigned Len = strlen(CanonicalNameBuf); char *Mem = static_cast(CanonicalNameStorage.Allocate(Len, 1)); memcpy(Mem, CanonicalNameBuf, Len); CanonicalName = StringRef(Mem, Len); } CanonicalDirNames.insert(std::make_pair(Dir, CanonicalName)); return CanonicalName; #else return StringRef(Dir->getName()); #endif } void FileManager::PrintStats() const { llvm::errs() << "\n*** File Manager Stats:\n"; llvm::errs() << UniqueRealFiles.size() << " real files found, " << UniqueRealDirs.size() << " real dirs found.\n"; llvm::errs() << VirtualFileEntries.size() << " virtual files found, " << VirtualDirectoryEntries.size() << " virtual dirs found.\n"; llvm::errs() << NumDirLookups << " dir lookups, " << NumDirCacheMisses << " dir cache misses.\n"; llvm::errs() << NumFileLookups << " file lookups, " << NumFileCacheMisses << " file cache misses.\n"; //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups; } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import Clang 3.5svn r202566. @ text @d33 13 d59 41 d104 4 a107 3 FileManager::FileManager(const FileSystemOptions &FSO, IntrusiveRefCntPtr FS) : FS(FS), FileSystemOpts(FSO), a110 5 // If the caller doesn't provide a virtual file system, just grab the real // file system. if (!FS) this->FS = vfs::getRealFileSystem(); d114 2 d259 2 a260 1 DirectoryEntry &UDE = UniqueRealDirs[Data.UniqueID]; d312 1 a312 1 vfs::File *F = 0; d314 2 a315 1 if (getStatValue(InterndFileName, Data, true, openFile ? &F : 0)) { d323 4 a326 1 assert((openFile || !F) && "undesired open file"); d330 2 a331 1 FileEntry &UFE = UniqueRealFiles[Data.UniqueID]; d334 1 a334 1 if (UFE.isValid()) { // Already have an entry with this inode, return it. d336 2 a337 2 if (F) delete F; d342 4 a345 2 // Otherwise, we don't have this file yet, add it. UFE.Name = Data.Name; d350 1 a350 5 UFE.UniqueID = Data.UniqueID; UFE.IsNamedPipe = Data.IsNamedPipe; UFE.InPCH = Data.InPCH; UFE.File.reset(F); UFE.IsValid = true; d389 1 a389 1 UFE = &UniqueRealFiles[Data.UniqueID]; d396 4 a399 2 if (UFE->File) UFE->closeFile(); d402 1 a402 1 if (UFE->isValid()) a403 4 UFE->UniqueID = Data.UniqueID; UFE->IsNamedPipe = Data.IsNamedPipe; UFE->InPCH = Data.InPCH; d417 1 a417 1 UFE->File.reset(); d447 2 a448 2 if (Entry->File) { ec = Entry->File->getBuffer(Filename, Result, FileSize); d451 3 a453 1 Entry->closeFile(); d460 1 a460 1 ec = FS->getBufferForFile(Filename, Result, FileSize); d468 1 a468 1 ec = FS->getBufferForFile(FilePath.str(), Result, FileSize); d479 1 a479 1 ec = FS->getBufferForFile(Filename, Result); d487 1 a487 1 ec = FS->getBufferForFile(FilePath.c_str(), Result); d499 1 a499 1 vfs::File **F) { d503 2 a504 1 return FileSystemStatCache::get(Path, Data, isFile, F,StatCache.get(), *FS); d509 2 a510 2 return FileSystemStatCache::get(FilePath.c_str(), Data, isFile, F, StatCache.get(), *FS); d514 1 a514 1 vfs::Status &Result) { d518 1 a518 5 llvm::ErrorOr S = FS->status(FilePath.c_str()); if (!S) return true; Result = *S; return false; d529 1 a529 1 UniqueRealFiles.erase(Entry->getUniqueID()); @ 1.1.1.2.2.1 log @Rebase. @ text @d73 2 a74 2 if (AtBeginning || !StatCache.get()) { statCache->setNextStatCache(StatCache.release()); d106 1 a106 1 StatCache.reset(nullptr); d115 1 a115 1 return nullptr; d118 1 a118 1 return nullptr; // If Filename is a directory. d182 2 a183 2 return NamedDirEnt.getValue() == NON_EXISTENT_DIR ? nullptr : NamedDirEnt.getValue(); d196 1 a196 1 if (getStatValue(InterndDirName, Data, false, nullptr /*directory lookup*/)) { d200 1 a200 1 return nullptr; d230 1 a230 1 ? nullptr : NamedFileEnt.getValue(); d248 1 a248 1 if (DirInfo == nullptr) { // Directory doesn't exist, file can't exist. d251 2 a252 2 return nullptr; d259 1 a259 1 vfs::File *F = nullptr; d261 1 a261 1 if (getStatValue(InterndFileName, Data, true, openFile ? &F : nullptr)) { d265 2 a266 2 return nullptr; a276 10 // FIXME: this hack ensures that if we look up a file by a virtual path in // the VFS that the getDir() will have the virtual path, even if we found // the file by a 'real' path first. This is required in order to find a // module's structure when its headers/module map are mapped in the VFS. // We should remove this as soon as we can properly support a file having // multiple names. if (DirInfo != UFE.Dir && Data.IsVFSMapped) UFE.Dir = DirInfo; d317 1 a317 1 FileEntry *UFE = nullptr; d330 1 a330 1 if (getStatValue(InterndFileName, Data, true, nullptr) == 0) { d382 1 a382 1 std::unique_ptr Result; d394 1 a394 2 ec = Entry->File->getBuffer(Filename, Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d398 1 a398 1 return Result.release(); d404 1 a404 2 ec = FS->getBufferForFile(Filename, Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d407 1 a407 1 return Result.release(); d412 1 a412 2 ec = FS->getBufferForFile(FilePath.str(), Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d415 1 a415 1 return Result.release(); d420 1 a420 1 std::unique_ptr Result; d426 1 a426 1 return Result.release(); d434 1 a434 1 return Result.release(); @ 1.1.1.3 log @Import Clang 3.5svn r209886. @ text @d73 2 a74 2 if (AtBeginning || !StatCache.get()) { statCache->setNextStatCache(StatCache.release()); d106 1 a106 1 StatCache.reset(nullptr); d115 1 a115 1 return nullptr; d118 1 a118 1 return nullptr; // If Filename is a directory. d182 2 a183 2 return NamedDirEnt.getValue() == NON_EXISTENT_DIR ? nullptr : NamedDirEnt.getValue(); d196 1 a196 1 if (getStatValue(InterndDirName, Data, false, nullptr /*directory lookup*/)) { d200 1 a200 1 return nullptr; d230 1 a230 1 ? nullptr : NamedFileEnt.getValue(); d248 1 a248 1 if (DirInfo == nullptr) { // Directory doesn't exist, file can't exist. d251 2 a252 2 return nullptr; d259 1 a259 1 vfs::File *F = nullptr; d261 1 a261 1 if (getStatValue(InterndFileName, Data, true, openFile ? &F : nullptr)) { d265 2 a266 2 return nullptr; a276 10 // FIXME: this hack ensures that if we look up a file by a virtual path in // the VFS that the getDir() will have the virtual path, even if we found // the file by a 'real' path first. This is required in order to find a // module's structure when its headers/module map are mapped in the VFS. // We should remove this as soon as we can properly support a file having // multiple names. if (DirInfo != UFE.Dir && Data.IsVFSMapped) UFE.Dir = DirInfo; d317 1 a317 1 FileEntry *UFE = nullptr; d330 1 a330 1 if (getStatValue(InterndFileName, Data, true, nullptr) == 0) { d382 1 a382 1 std::unique_ptr Result; d394 1 a394 2 ec = Entry->File->getBuffer(Filename, Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d398 1 a398 1 return Result.release(); d404 1 a404 2 ec = FS->getBufferForFile(Filename, Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d407 1 a407 1 return Result.release(); d412 1 a412 2 ec = FS->getBufferForFile(FilePath.str(), Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d415 1 a415 1 return Result.release(); d420 1 a420 1 std::unique_ptr Result; d426 1 a426 1 return Result.release(); d434 1 a434 1 return Result.release(); @ 1.1.1.4 log @Import clang 3.6svn r215315. @ text @d28 1 a31 1 #include d35 3 d106 1 a106 1 StatCache.reset(); d259 1 a259 1 std::unique_ptr F; d287 4 d303 1 a303 1 UFE.File = std::move(F); d391 1 a391 1 bool isVolatile, bool ShouldCloseOpenFile) { d393 1 a393 1 std::error_code ec; d408 1 a408 4 // FIXME: we need a set of APIs that can make guarantees about whether a // FileEntry is open or not. if (ShouldCloseOpenFile) Entry->closeFile(); d434 1 a434 1 std::error_code ec; d456 1 a456 1 std::unique_ptr *F) { @ 1.1.1.4.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d67 1 a67 1 void FileManager::addStatCache(std::unique_ptr statCache, d71 2 a72 2 statCache->setNextStatCache(std::move(StatCache)); StatCache = std::move(statCache); d79 2 a80 2 LastCache->setNextStatCache(std::move(statCache)); d89 1 a89 1 StatCache = StatCache->takeNextStatCache(); d99 1 a99 1 PrevCache->setNextStatCache(statCache->takeNextStatCache()); d132 2 a133 2 auto &NamedDirEnt = *SeenDirEntries.insert(std::make_pair(DirName, nullptr)).first; d139 1 a139 1 if (NamedDirEnt.second) d144 2 a145 2 UDE->Name = NamedDirEnt.first().data(); NamedDirEnt.second = UDE; d173 2 a174 2 auto &NamedDirEnt = *SeenDirEntries.insert(std::make_pair(DirName, nullptr)).first; d178 3 a180 3 if (NamedDirEnt.second) return NamedDirEnt.second == NON_EXISTENT_DIR ? nullptr : NamedDirEnt.second; d185 1 a185 1 NamedDirEnt.second = NON_EXISTENT_DIR; d189 1 a189 1 const char *InterndDirName = NamedDirEnt.first().data(); d206 1 a206 1 NamedDirEnt.second = &UDE; d221 2 a222 2 auto &NamedFileEnt = *SeenFileEntries.insert(std::make_pair(Filename, nullptr)).first; d225 3 a227 3 if (NamedFileEnt.second) return NamedFileEnt.second == NON_EXISTENT_FILE ? nullptr : NamedFileEnt.second; d232 1 a232 1 NamedFileEnt.second = NON_EXISTENT_FILE; d236 1 a236 1 const char *InterndFileName = NamedFileEnt.first().data(); d272 1 a272 15 NamedFileEnt.second = &UFE; // If the name returned by getStatValue is different than Filename, re-intern // the name. if (Data.Name != Filename) { auto &NamedFileEnt = *SeenFileEntries.insert(std::make_pair(Data.Name, nullptr)).first; if (!NamedFileEnt.second) NamedFileEnt.second = &UFE; else assert(NamedFileEnt.second == &UFE && "filename from getStatValue() refers to wrong file"); InterndFileName = NamedFileEnt.first().data(); } a283 7 // Always update the name to use the last name by which a file was accessed. // FIXME: Neither this nor always using the first name is correct; we want // to switch towards a design where we return a FileName object that // encapsulates both the name by which the file was accessed and the // corresponding FileEntry. UFE.Name = InterndFileName; d288 1 a288 1 UFE.Name = InterndFileName; d307 2 a308 2 auto &NamedFileEnt = *SeenFileEntries.insert(std::make_pair(Filename, nullptr)).first; d311 2 a312 2 if (NamedFileEnt.second && NamedFileEnt.second != NON_EXISTENT_FILE) return NamedFileEnt.second; d317 1 a317 1 NamedFileEnt.second = NON_EXISTENT_FILE; d332 1 a332 1 const char *InterndFileName = NamedFileEnt.first().data(); d338 1 a338 1 NamedFileEnt.second = UFE; d358 1 a358 1 NamedFileEnt.second = UFE; d382 6 a387 3 llvm::ErrorOr> FileManager::getBufferForFile(const FileEntry *Entry, bool isVolatile, bool ShouldCloseOpenFile) { d397 4 a400 3 auto Result = Entry->File->getBuffer(Filename, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d405 1 a405 1 return Result; d410 7 a416 3 if (FileSystemOpts.WorkingDir.empty()) return FS->getBufferForFile(Filename, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d420 17 a436 8 return FS->getBufferForFile(FilePath.str(), FileSize, /*RequiresNullTerminator=*/true, isVolatile); } llvm::ErrorOr> FileManager::getBufferForFile(StringRef Filename) { if (FileSystemOpts.WorkingDir.empty()) return FS->getBufferForFile(Filename); d440 4 a443 1 return FS->getBufferForFile(FilePath.c_str()); a514 31 /// Remove '.' path components from the given absolute path. /// \return \c true if any changes were made. // FIXME: Move this to llvm::sys::path. bool FileManager::removeDotPaths(SmallVectorImpl &Path) { using namespace llvm::sys; SmallVector ComponentStack; StringRef P(Path.data(), Path.size()); // Skip the root path, then look for traversal in the components. StringRef Rel = path::relative_path(P); bool AnyDots = false; for (StringRef C : llvm::make_range(path::begin(Rel), path::end(Rel))) { if (C == ".") { AnyDots = true; continue; } ComponentStack.push_back(C); } if (!AnyDots) return false; SmallString<256> Buffer = path::root_path(P); for (StringRef C : ComponentStack) path::append(Buffer, C); Path.swap(Buffer); return true; } d517 1 a523 2 #ifdef LLVM_ON_UNIX a530 6 #else SmallString<256> CanonicalNameBuf(CanonicalName); llvm::sys::fs::make_absolute(CanonicalNameBuf); llvm::sys::path::native(CanonicalNameBuf); removeDotPaths(CanonicalNameBuf); #endif d534 3 @ 1.1.1.5 log @Import Clang 3.6RC1 r227398. @ text @d67 1 a67 1 void FileManager::addStatCache(std::unique_ptr statCache, d71 2 a72 2 statCache->setNextStatCache(std::move(StatCache)); StatCache = std::move(statCache); d79 2 a80 2 LastCache->setNextStatCache(std::move(statCache)); d89 1 a89 1 StatCache = StatCache->takeNextStatCache(); d99 1 a99 1 PrevCache->setNextStatCache(statCache->takeNextStatCache()); d132 2 a133 2 auto &NamedDirEnt = *SeenDirEntries.insert(std::make_pair(DirName, nullptr)).first; d139 1 a139 1 if (NamedDirEnt.second) d144 2 a145 2 UDE->Name = NamedDirEnt.first().data(); NamedDirEnt.second = UDE; d173 2 a174 2 auto &NamedDirEnt = *SeenDirEntries.insert(std::make_pair(DirName, nullptr)).first; d178 3 a180 3 if (NamedDirEnt.second) return NamedDirEnt.second == NON_EXISTENT_DIR ? nullptr : NamedDirEnt.second; d185 1 a185 1 NamedDirEnt.second = NON_EXISTENT_DIR; d189 1 a189 1 const char *InterndDirName = NamedDirEnt.first().data(); d206 1 a206 1 NamedDirEnt.second = &UDE; d221 2 a222 2 auto &NamedFileEnt = *SeenFileEntries.insert(std::make_pair(Filename, nullptr)).first; d225 3 a227 3 if (NamedFileEnt.second) return NamedFileEnt.second == NON_EXISTENT_FILE ? nullptr : NamedFileEnt.second; d232 1 a232 1 NamedFileEnt.second = NON_EXISTENT_FILE; d236 1 a236 1 const char *InterndFileName = NamedFileEnt.first().data(); d272 1 a272 15 NamedFileEnt.second = &UFE; // If the name returned by getStatValue is different than Filename, re-intern // the name. if (Data.Name != Filename) { auto &NamedFileEnt = *SeenFileEntries.insert(std::make_pair(Data.Name, nullptr)).first; if (!NamedFileEnt.second) NamedFileEnt.second = &UFE; else assert(NamedFileEnt.second == &UFE && "filename from getStatValue() refers to wrong file"); InterndFileName = NamedFileEnt.first().data(); } a283 7 // Always update the name to use the last name by which a file was accessed. // FIXME: Neither this nor always using the first name is correct; we want // to switch towards a design where we return a FileName object that // encapsulates both the name by which the file was accessed and the // corresponding FileEntry. UFE.Name = InterndFileName; d288 1 a288 1 UFE.Name = InterndFileName; d307 2 a308 2 auto &NamedFileEnt = *SeenFileEntries.insert(std::make_pair(Filename, nullptr)).first; d311 2 a312 2 if (NamedFileEnt.second && NamedFileEnt.second != NON_EXISTENT_FILE) return NamedFileEnt.second; d317 1 a317 1 NamedFileEnt.second = NON_EXISTENT_FILE; d332 1 a332 1 const char *InterndFileName = NamedFileEnt.first().data(); d338 1 a338 1 NamedFileEnt.second = UFE; d358 1 a358 1 NamedFileEnt.second = UFE; d382 6 a387 3 llvm::ErrorOr> FileManager::getBufferForFile(const FileEntry *Entry, bool isVolatile, bool ShouldCloseOpenFile) { d397 4 a400 3 auto Result = Entry->File->getBuffer(Filename, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d405 1 a405 1 return Result; d410 7 a416 3 if (FileSystemOpts.WorkingDir.empty()) return FS->getBufferForFile(Filename, FileSize, /*RequiresNullTerminator=*/true, isVolatile); d420 17 a436 8 return FS->getBufferForFile(FilePath.str(), FileSize, /*RequiresNullTerminator=*/true, isVolatile); } llvm::ErrorOr> FileManager::getBufferForFile(StringRef Filename) { if (FileSystemOpts.WorkingDir.empty()) return FS->getBufferForFile(Filename); d440 4 a443 1 return FS->getBufferForFile(FilePath.c_str()); a514 31 /// Remove '.' path components from the given absolute path. /// \return \c true if any changes were made. // FIXME: Move this to llvm::sys::path. bool FileManager::removeDotPaths(SmallVectorImpl &Path) { using namespace llvm::sys; SmallVector ComponentStack; StringRef P(Path.data(), Path.size()); // Skip the root path, then look for traversal in the components. StringRef Rel = path::relative_path(P); bool AnyDots = false; for (StringRef C : llvm::make_range(path::begin(Rel), path::end(Rel))) { if (C == ".") { AnyDots = true; continue; } ComponentStack.push_back(C); } if (!AnyDots) return false; SmallString<256> Buffer = path::root_path(P); for (StringRef C : ComponentStack) path::append(Buffer, C); Path.swap(Buffer); return true; } d517 1 a523 2 #ifdef LLVM_ON_UNIX a530 6 #else SmallString<256> CanonicalNameBuf(CanonicalName); llvm::sys::fs::make_absolute(CanonicalNameBuf); llvm::sys::path::native(CanonicalNameBuf); removeDotPaths(CanonicalNameBuf); #endif d534 3 @ 1.1.1.6 log @Import Clang 3.8.0rc3 r261930. @ text @a21 1 #include "clang/Frontend/PCHContainerOperations.h" a23 1 #include "llvm/ADT/STLExtras.h" d60 6 a65 1 FileManager::~FileManager() = default; d139 1 a139 1 if (NamedDirEnt.second && NamedDirEnt.second != NON_EXISTENT_DIR) d143 1 a143 1 auto UDE = llvm::make_unique(); d145 2 a146 2 NamedDirEnt.second = UDE.get(); VirtualDirectoryEntries.push_back(std::move(UDE)); d377 2 a378 2 VirtualFileEntries.push_back(llvm::make_unique()); UFE = VirtualFileEntries.back().get(); d391 1 a391 1 bool FileManager::FixupRelativePath(SmallVectorImpl &path) const { d396 1 a396 1 return false; a400 12 return true; } bool FileManager::makeAbsolutePath(SmallVectorImpl &Path) const { bool Changed = FixupRelativePath(Path); if (!llvm::sys::path::is_absolute(StringRef(Path.data(), Path.size()))) { llvm::sys::fs::make_absolute(Path); Changed = true; } return Changed; d433 1 a433 1 return FS->getBufferForFile(FilePath, FileSize, d503 5 a507 3 for (const auto &VFE : VirtualFileEntries) if (VFE && VFE.get() != NON_EXISTENT_FILE) UIDToFiles[VFE->getUID()] = VFE.get(); d516 31 d558 6 a563 2 if (realpath(Dir->getName(), CanonicalNameBuf)) CanonicalName = StringRef(CanonicalNameBuf).copy(CanonicalNameStorage); d568 1 a568 8 // We've run into needing to remove '..' here in the wild though, so // remove it. // On Windows, symlinks are significantly less prevalent, so removing // '..' is pretty safe. // Ideally we'd have an equivalent of `realpath` and could implement // sys::fs::canonical across all the platforms. llvm::sys::path::remove_dots(CanonicalNameBuf, /* remove_dot_dot */ true); CanonicalName = StringRef(CanonicalNameBuf).copy(CanonicalNameStorage); a587 4 // Virtual destructors for abstract base classes that need live in Basic. PCHContainerWriter::~PCHContainerWriter() {} PCHContainerReader::~PCHContainerReader() {} @ 1.1.1.6.2.1 log @Sync with HEAD @ text @d22 1 d30 2 a31 5 #include #include #include #include #include d33 1 a33 1 #include d127 1 a127 1 DirName = "."; d141 1 a141 1 UDE->Name = NamedDirEnt.first(); d186 1 a186 1 StringRef InterndDirName = NamedDirEnt.first(); d204 1 a204 1 if (UDE.getName().empty()) { d233 1 a233 1 StringRef InterndFileName = NamedFileEnt.first(); a315 3 if (UFE.File) if (auto RealPathName = UFE.File->getName()) UFE.RealPathName = *RealPathName; d421 1 a421 1 StringRef Filename = Entry->getName(); d461 1 a461 1 bool FileManager::getStatValue(StringRef Path, FileData &Data, bool isFile, d498 1 d534 1 a534 1 if (realpath(Dir->getName().str().c_str(), CanonicalNameBuf)) d567 4 @ 1.1.1.7 log @Import Clang pre-4.0.0 r291444. @ text @d22 1 d30 2 a31 5 #include #include #include #include #include d33 1 a33 1 #include d127 1 a127 1 DirName = "."; d141 1 a141 1 UDE->Name = NamedDirEnt.first(); d186 1 a186 1 StringRef InterndDirName = NamedDirEnt.first(); d204 1 a204 1 if (UDE.getName().empty()) { d233 1 a233 1 StringRef InterndFileName = NamedFileEnt.first(); a315 3 if (UFE.File) if (auto RealPathName = UFE.File->getName()) UFE.RealPathName = *RealPathName; d421 1 a421 1 StringRef Filename = Entry->getName(); d461 1 a461 1 bool FileManager::getStatValue(StringRef Path, FileData &Data, bool isFile, d498 1 d534 1 a534 1 if (realpath(Dir->getName().str().c_str(), CanonicalNameBuf)) d567 4 @ 1.1.1.8 log @Import clang r309604 from branches/release_50 @ text @d53 2 a54 2 : FS(std::move(FS)), FileSystemOpts(FSO), SeenDirEntries(64), SeenFileEntries(64), NextFileUID(0) { d60 1 a60 1 if (!this->FS) a388 1 UFE->IsValid = true; @ 1.1.1.8.4.1 log @Sync with HEAD @ text @d105 1 a105 1 /// Retrieve the directory that the given file name resides in. d160 1 a160 1 #ifdef _WIN32 d411 1 a411 1 FS->makeAbsolute(Path); d453 1 a453 1 FileManager::getBufferForFile(StringRef Filename, bool isVolatile) { d455 1 a455 1 return FS->getBufferForFile(Filename, -1, true, isVolatile); d459 1 a459 1 return FS->getBufferForFile(FilePath.c_str(), -1, true, isVolatile); d537 3 a539 2 SmallString<4096> CanonicalNameBuf; if (!FS->getRealPath(Dir->getName(), CanonicalNameBuf)) d541 13 @ 1.1.1.8.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.8.2.1 log @Sync with HEAD @ text @d105 1 a105 1 /// Retrieve the directory that the given file name resides in. d160 1 a160 1 #ifdef _WIN32 d411 1 a411 1 FS->makeAbsolute(Path); d453 1 a453 1 FileManager::getBufferForFile(StringRef Filename, bool isVolatile) { d455 1 a455 1 return FS->getBufferForFile(Filename, -1, true, isVolatile); d459 1 a459 1 return FS->getBufferForFile(FilePath.c_str(), -1, true, isVolatile); d537 3 a539 2 SmallString<4096> CanonicalNameBuf; if (!FS->getRealPath(Dir->getName(), CanonicalNameBuf)) d541 13 @ 1.1.1.9 log @Import clang r337282 from trunk @ text @d105 1 a105 1 /// Retrieve the directory that the given file name resides in. d160 1 a160 1 #ifdef _WIN32 d411 1 a411 1 FS->makeAbsolute(Path); d453 1 a453 1 FileManager::getBufferForFile(StringRef Filename, bool isVolatile) { d455 1 a455 1 return FS->getBufferForFile(Filename, -1, true, isVolatile); d459 1 a459 1 return FS->getBufferForFile(FilePath.c_str(), -1, true, isVolatile); d537 3 a539 2 SmallString<4096> CanonicalNameBuf; if (!FS->getRealPath(Dir->getName(), CanonicalNameBuf)) d541 13 @ 1.1.1.10 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.4.4.1 log @file FileManager.cpp was added on branch tls-maxphys on 2014-08-19 23:47:26 +0000 @ text @d1 551 @ 1.1.1.4.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 551 //===--- FileManager.cpp - File System Probing and Caching ----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the FileManager interface. // //===----------------------------------------------------------------------===// // // TODO: This should index all interesting directories with dirent calls. // getdirentries ? // opendir/readdir_r/closedir ? // //===----------------------------------------------------------------------===// #include "clang/Basic/FileManager.h" #include "clang/Basic/FileSystemStatCache.h" #include "llvm/ADT/SmallString.h" #include "llvm/Config/llvm-config.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include #include #include #include using namespace clang; /// NON_EXISTENT_DIR - A special value distinct from null that is used to /// represent a dir name that doesn't exist on the disk. #define NON_EXISTENT_DIR reinterpret_cast((intptr_t)-1) /// NON_EXISTENT_FILE - A special value distinct from null that is used to /// represent a filename that doesn't exist on the disk. #define NON_EXISTENT_FILE reinterpret_cast((intptr_t)-1) //===----------------------------------------------------------------------===// // Common logic. //===----------------------------------------------------------------------===// FileManager::FileManager(const FileSystemOptions &FSO, IntrusiveRefCntPtr FS) : FS(FS), FileSystemOpts(FSO), SeenDirEntries(64), SeenFileEntries(64), NextFileUID(0) { NumDirLookups = NumFileLookups = 0; NumDirCacheMisses = NumFileCacheMisses = 0; // If the caller doesn't provide a virtual file system, just grab the real // file system. if (!FS) this->FS = vfs::getRealFileSystem(); } FileManager::~FileManager() { for (unsigned i = 0, e = VirtualFileEntries.size(); i != e; ++i) delete VirtualFileEntries[i]; for (unsigned i = 0, e = VirtualDirectoryEntries.size(); i != e; ++i) delete VirtualDirectoryEntries[i]; } void FileManager::addStatCache(FileSystemStatCache *statCache, bool AtBeginning) { assert(statCache && "No stat cache provided?"); if (AtBeginning || !StatCache.get()) { statCache->setNextStatCache(StatCache.release()); StatCache.reset(statCache); return; } FileSystemStatCache *LastCache = StatCache.get(); while (LastCache->getNextStatCache()) LastCache = LastCache->getNextStatCache(); LastCache->setNextStatCache(statCache); } void FileManager::removeStatCache(FileSystemStatCache *statCache) { if (!statCache) return; if (StatCache.get() == statCache) { // This is the first stat cache. StatCache.reset(StatCache->takeNextStatCache()); return; } // Find the stat cache in the list. FileSystemStatCache *PrevCache = StatCache.get(); while (PrevCache && PrevCache->getNextStatCache() != statCache) PrevCache = PrevCache->getNextStatCache(); assert(PrevCache && "Stat cache not found for removal"); PrevCache->setNextStatCache(statCache->getNextStatCache()); } void FileManager::clearStatCaches() { StatCache.reset(); } /// \brief Retrieve the directory that the given file name resides in. /// Filename can point to either a real file or a virtual file. static const DirectoryEntry *getDirectoryFromFile(FileManager &FileMgr, StringRef Filename, bool CacheFailure) { if (Filename.empty()) return nullptr; if (llvm::sys::path::is_separator(Filename[Filename.size() - 1])) return nullptr; // If Filename is a directory. StringRef DirName = llvm::sys::path::parent_path(Filename); // Use the current directory if file has no path component. if (DirName.empty()) DirName = "."; return FileMgr.getDirectory(DirName, CacheFailure); } /// Add all ancestors of the given path (pointing to either a file or /// a directory) as virtual directories. void FileManager::addAncestorsAsVirtualDirs(StringRef Path) { StringRef DirName = llvm::sys::path::parent_path(Path); if (DirName.empty()) return; llvm::StringMapEntry &NamedDirEnt = SeenDirEntries.GetOrCreateValue(DirName); // When caching a virtual directory, we always cache its ancestors // at the same time. Therefore, if DirName is already in the cache, // we don't need to recurse as its ancestors must also already be in // the cache. if (NamedDirEnt.getValue()) return; // Add the virtual directory to the cache. DirectoryEntry *UDE = new DirectoryEntry; UDE->Name = NamedDirEnt.getKeyData(); NamedDirEnt.setValue(UDE); VirtualDirectoryEntries.push_back(UDE); // Recursively add the other ancestors. addAncestorsAsVirtualDirs(DirName); } const DirectoryEntry *FileManager::getDirectory(StringRef DirName, bool CacheFailure) { // stat doesn't like trailing separators except for root directory. // At least, on Win32 MSVCRT, stat() cannot strip trailing '/'. // (though it can strip '\\') if (DirName.size() > 1 && DirName != llvm::sys::path::root_path(DirName) && llvm::sys::path::is_separator(DirName.back())) DirName = DirName.substr(0, DirName.size()-1); #ifdef LLVM_ON_WIN32 // Fixing a problem with "clang C:test.c" on Windows. // Stat("C:") does not recognize "C:" as a valid directory std::string DirNameStr; if (DirName.size() > 1 && DirName.back() == ':' && DirName.equals_lower(llvm::sys::path::root_name(DirName))) { DirNameStr = DirName.str() + '.'; DirName = DirNameStr; } #endif ++NumDirLookups; llvm::StringMapEntry &NamedDirEnt = SeenDirEntries.GetOrCreateValue(DirName); // See if there was already an entry in the map. Note that the map // contains both virtual and real directories. if (NamedDirEnt.getValue()) return NamedDirEnt.getValue() == NON_EXISTENT_DIR ? nullptr : NamedDirEnt.getValue(); ++NumDirCacheMisses; // By default, initialize it to invalid. NamedDirEnt.setValue(NON_EXISTENT_DIR); // Get the null-terminated directory name as stored as the key of the // SeenDirEntries map. const char *InterndDirName = NamedDirEnt.getKeyData(); // Check to see if the directory exists. FileData Data; if (getStatValue(InterndDirName, Data, false, nullptr /*directory lookup*/)) { // There's no real directory at the given path. if (!CacheFailure) SeenDirEntries.erase(DirName); return nullptr; } // It exists. See if we have already opened a directory with the // same inode (this occurs on Unix-like systems when one dir is // symlinked to another, for example) or the same path (on // Windows). DirectoryEntry &UDE = UniqueRealDirs[Data.UniqueID]; NamedDirEnt.setValue(&UDE); if (!UDE.getName()) { // We don't have this directory yet, add it. We use the string // key from the SeenDirEntries map as the string. UDE.Name = InterndDirName; } return &UDE; } const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, bool CacheFailure) { ++NumFileLookups; // See if there is already an entry in the map. llvm::StringMapEntry &NamedFileEnt = SeenFileEntries.GetOrCreateValue(Filename); // See if there is already an entry in the map. if (NamedFileEnt.getValue()) return NamedFileEnt.getValue() == NON_EXISTENT_FILE ? nullptr : NamedFileEnt.getValue(); ++NumFileCacheMisses; // By default, initialize it to invalid. NamedFileEnt.setValue(NON_EXISTENT_FILE); // Get the null-terminated file name as stored as the key of the // SeenFileEntries map. const char *InterndFileName = NamedFileEnt.getKeyData(); // Look up the directory for the file. When looking up something like // sys/foo.h we'll discover all of the search directories that have a 'sys' // subdirectory. This will let us avoid having to waste time on known-to-fail // searches when we go to find sys/bar.h, because all the search directories // without a 'sys' subdir will get a cached failure result. const DirectoryEntry *DirInfo = getDirectoryFromFile(*this, Filename, CacheFailure); if (DirInfo == nullptr) { // Directory doesn't exist, file can't exist. if (!CacheFailure) SeenFileEntries.erase(Filename); return nullptr; } // FIXME: Use the directory info to prune this, before doing the stat syscall. // FIXME: This will reduce the # syscalls. // Nope, there isn't. Check to see if the file exists. std::unique_ptr F; FileData Data; if (getStatValue(InterndFileName, Data, true, openFile ? &F : nullptr)) { // There's no real file at the given path. if (!CacheFailure) SeenFileEntries.erase(Filename); return nullptr; } assert((openFile || !F) && "undesired open file"); // It exists. See if we have already opened a file with the same inode. // This occurs when one dir is symlinked to another, for example. FileEntry &UFE = UniqueRealFiles[Data.UniqueID]; NamedFileEnt.setValue(&UFE); if (UFE.isValid()) { // Already have an entry with this inode, return it. // FIXME: this hack ensures that if we look up a file by a virtual path in // the VFS that the getDir() will have the virtual path, even if we found // the file by a 'real' path first. This is required in order to find a // module's structure when its headers/module map are mapped in the VFS. // We should remove this as soon as we can properly support a file having // multiple names. if (DirInfo != UFE.Dir && Data.IsVFSMapped) UFE.Dir = DirInfo; return &UFE; } // Otherwise, we don't have this file yet, add it. UFE.Name = Data.Name; UFE.Size = Data.Size; UFE.ModTime = Data.ModTime; UFE.Dir = DirInfo; UFE.UID = NextFileUID++; UFE.UniqueID = Data.UniqueID; UFE.IsNamedPipe = Data.IsNamedPipe; UFE.InPCH = Data.InPCH; UFE.File = std::move(F); UFE.IsValid = true; return &UFE; } const FileEntry * FileManager::getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime) { ++NumFileLookups; // See if there is already an entry in the map. llvm::StringMapEntry &NamedFileEnt = SeenFileEntries.GetOrCreateValue(Filename); // See if there is already an entry in the map. if (NamedFileEnt.getValue() && NamedFileEnt.getValue() != NON_EXISTENT_FILE) return NamedFileEnt.getValue(); ++NumFileCacheMisses; // By default, initialize it to invalid. NamedFileEnt.setValue(NON_EXISTENT_FILE); addAncestorsAsVirtualDirs(Filename); FileEntry *UFE = nullptr; // Now that all ancestors of Filename are in the cache, the // following call is guaranteed to find the DirectoryEntry from the // cache. const DirectoryEntry *DirInfo = getDirectoryFromFile(*this, Filename, /*CacheFailure=*/true); assert(DirInfo && "The directory of a virtual file should already be in the cache."); // Check to see if the file exists. If so, drop the virtual file FileData Data; const char *InterndFileName = NamedFileEnt.getKeyData(); if (getStatValue(InterndFileName, Data, true, nullptr) == 0) { Data.Size = Size; Data.ModTime = ModificationTime; UFE = &UniqueRealFiles[Data.UniqueID]; NamedFileEnt.setValue(UFE); // If we had already opened this file, close it now so we don't // leak the descriptor. We're not going to use the file // descriptor anyway, since this is a virtual file. if (UFE->File) UFE->closeFile(); // If we already have an entry with this inode, return it. if (UFE->isValid()) return UFE; UFE->UniqueID = Data.UniqueID; UFE->IsNamedPipe = Data.IsNamedPipe; UFE->InPCH = Data.InPCH; } if (!UFE) { UFE = new FileEntry(); VirtualFileEntries.push_back(UFE); NamedFileEnt.setValue(UFE); } UFE->Name = InterndFileName; UFE->Size = Size; UFE->ModTime = ModificationTime; UFE->Dir = DirInfo; UFE->UID = NextFileUID++; UFE->File.reset(); return UFE; } void FileManager::FixupRelativePath(SmallVectorImpl &path) const { StringRef pathRef(path.data(), path.size()); if (FileSystemOpts.WorkingDir.empty() || llvm::sys::path::is_absolute(pathRef)) return; SmallString<128> NewPath(FileSystemOpts.WorkingDir); llvm::sys::path::append(NewPath, pathRef); path = NewPath; } llvm::MemoryBuffer *FileManager:: getBufferForFile(const FileEntry *Entry, std::string *ErrorStr, bool isVolatile, bool ShouldCloseOpenFile) { std::unique_ptr Result; std::error_code ec; uint64_t FileSize = Entry->getSize(); // If there's a high enough chance that the file have changed since we // got its size, force a stat before opening it. if (isVolatile) FileSize = -1; const char *Filename = Entry->getName(); // If the file is already open, use the open file descriptor. if (Entry->File) { ec = Entry->File->getBuffer(Filename, Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); if (ErrorStr) *ErrorStr = ec.message(); // FIXME: we need a set of APIs that can make guarantees about whether a // FileEntry is open or not. if (ShouldCloseOpenFile) Entry->closeFile(); return Result.release(); } // Otherwise, open the file. if (FileSystemOpts.WorkingDir.empty()) { ec = FS->getBufferForFile(Filename, Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.release(); } SmallString<128> FilePath(Entry->getName()); FixupRelativePath(FilePath); ec = FS->getBufferForFile(FilePath.str(), Result, FileSize, /*RequiresNullTerminator=*/true, isVolatile); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.release(); } llvm::MemoryBuffer *FileManager:: getBufferForFile(StringRef Filename, std::string *ErrorStr) { std::unique_ptr Result; std::error_code ec; if (FileSystemOpts.WorkingDir.empty()) { ec = FS->getBufferForFile(Filename, Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.release(); } SmallString<128> FilePath(Filename); FixupRelativePath(FilePath); ec = FS->getBufferForFile(FilePath.c_str(), Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.release(); } /// getStatValue - Get the 'stat' information for the specified path, /// using the cache to accelerate it if possible. This returns true /// if the path points to a virtual file or does not exist, or returns /// false if it's an existent real file. If FileDescriptor is NULL, /// do directory look-up instead of file look-up. bool FileManager::getStatValue(const char *Path, FileData &Data, bool isFile, std::unique_ptr *F) { // FIXME: FileSystemOpts shouldn't be passed in here, all paths should be // absolute! if (FileSystemOpts.WorkingDir.empty()) return FileSystemStatCache::get(Path, Data, isFile, F,StatCache.get(), *FS); SmallString<128> FilePath(Path); FixupRelativePath(FilePath); return FileSystemStatCache::get(FilePath.c_str(), Data, isFile, F, StatCache.get(), *FS); } bool FileManager::getNoncachedStatValue(StringRef Path, vfs::Status &Result) { SmallString<128> FilePath(Path); FixupRelativePath(FilePath); llvm::ErrorOr S = FS->status(FilePath.c_str()); if (!S) return true; Result = *S; return false; } void FileManager::invalidateCache(const FileEntry *Entry) { assert(Entry && "Cannot invalidate a NULL FileEntry"); SeenFileEntries.erase(Entry->getName()); // FileEntry invalidation should not block future optimizations in the file // caches. Possible alternatives are cache truncation (invalidate last N) or // invalidation of the whole cache. UniqueRealFiles.erase(Entry->getUniqueID()); } void FileManager::GetUniqueIDMapping( SmallVectorImpl &UIDToFiles) const { UIDToFiles.clear(); UIDToFiles.resize(NextFileUID); // Map file entries for (llvm::StringMap::const_iterator FE = SeenFileEntries.begin(), FEEnd = SeenFileEntries.end(); FE != FEEnd; ++FE) if (FE->getValue() && FE->getValue() != NON_EXISTENT_FILE) UIDToFiles[FE->getValue()->getUID()] = FE->getValue(); // Map virtual file entries for (SmallVectorImpl::const_iterator VFE = VirtualFileEntries.begin(), VFEEnd = VirtualFileEntries.end(); VFE != VFEEnd; ++VFE) if (*VFE && *VFE != NON_EXISTENT_FILE) UIDToFiles[(*VFE)->getUID()] = *VFE; } void FileManager::modifyFileEntry(FileEntry *File, off_t Size, time_t ModificationTime) { File->Size = Size; File->ModTime = ModificationTime; } StringRef FileManager::getCanonicalName(const DirectoryEntry *Dir) { // FIXME: use llvm::sys::fs::canonical() when it gets implemented #ifdef LLVM_ON_UNIX llvm::DenseMap::iterator Known = CanonicalDirNames.find(Dir); if (Known != CanonicalDirNames.end()) return Known->second; StringRef CanonicalName(Dir->getName()); char CanonicalNameBuf[PATH_MAX]; if (realpath(Dir->getName(), CanonicalNameBuf)) { unsigned Len = strlen(CanonicalNameBuf); char *Mem = static_cast(CanonicalNameStorage.Allocate(Len, 1)); memcpy(Mem, CanonicalNameBuf, Len); CanonicalName = StringRef(Mem, Len); } CanonicalDirNames.insert(std::make_pair(Dir, CanonicalName)); return CanonicalName; #else return StringRef(Dir->getName()); #endif } void FileManager::PrintStats() const { llvm::errs() << "\n*** File Manager Stats:\n"; llvm::errs() << UniqueRealFiles.size() << " real files found, " << UniqueRealDirs.size() << " real dirs found.\n"; llvm::errs() << VirtualFileEntries.size() << " virtual files found, " << VirtualDirectoryEntries.size() << " virtual dirs found.\n"; llvm::errs() << NumDirLookups << " dir lookups, " << NumDirCacheMisses << " dir cache misses.\n"; llvm::errs() << NumFileLookups << " file lookups, " << NumFileCacheMisses << " file cache misses.\n"; //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups; } @ 1.1.1.2.4.1 log @file FileManager.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 542 @ 1.1.1.2.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 542 //===--- FileManager.cpp - File System Probing and Caching ----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the FileManager interface. // //===----------------------------------------------------------------------===// // // TODO: This should index all interesting directories with dirent calls. // getdirentries ? // opendir/readdir_r/closedir ? // //===----------------------------------------------------------------------===// #include "clang/Basic/FileManager.h" #include "clang/Basic/FileSystemStatCache.h" #include "llvm/ADT/SmallString.h" #include "llvm/Config/llvm-config.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/system_error.h" #include #include #include using namespace clang; // FIXME: Enhance libsystem to support inode and other fields. #include /// NON_EXISTENT_DIR - A special value distinct from null that is used to /// represent a dir name that doesn't exist on the disk. #define NON_EXISTENT_DIR reinterpret_cast((intptr_t)-1) /// NON_EXISTENT_FILE - A special value distinct from null that is used to /// represent a filename that doesn't exist on the disk. #define NON_EXISTENT_FILE reinterpret_cast((intptr_t)-1) //===----------------------------------------------------------------------===// // Common logic. //===----------------------------------------------------------------------===// FileManager::FileManager(const FileSystemOptions &FSO, IntrusiveRefCntPtr FS) : FS(FS), FileSystemOpts(FSO), SeenDirEntries(64), SeenFileEntries(64), NextFileUID(0) { NumDirLookups = NumFileLookups = 0; NumDirCacheMisses = NumFileCacheMisses = 0; // If the caller doesn't provide a virtual file system, just grab the real // file system. if (!FS) this->FS = vfs::getRealFileSystem(); } FileManager::~FileManager() { for (unsigned i = 0, e = VirtualFileEntries.size(); i != e; ++i) delete VirtualFileEntries[i]; for (unsigned i = 0, e = VirtualDirectoryEntries.size(); i != e; ++i) delete VirtualDirectoryEntries[i]; } void FileManager::addStatCache(FileSystemStatCache *statCache, bool AtBeginning) { assert(statCache && "No stat cache provided?"); if (AtBeginning || StatCache.get() == 0) { statCache->setNextStatCache(StatCache.take()); StatCache.reset(statCache); return; } FileSystemStatCache *LastCache = StatCache.get(); while (LastCache->getNextStatCache()) LastCache = LastCache->getNextStatCache(); LastCache->setNextStatCache(statCache); } void FileManager::removeStatCache(FileSystemStatCache *statCache) { if (!statCache) return; if (StatCache.get() == statCache) { // This is the first stat cache. StatCache.reset(StatCache->takeNextStatCache()); return; } // Find the stat cache in the list. FileSystemStatCache *PrevCache = StatCache.get(); while (PrevCache && PrevCache->getNextStatCache() != statCache) PrevCache = PrevCache->getNextStatCache(); assert(PrevCache && "Stat cache not found for removal"); PrevCache->setNextStatCache(statCache->getNextStatCache()); } void FileManager::clearStatCaches() { StatCache.reset(0); } /// \brief Retrieve the directory that the given file name resides in. /// Filename can point to either a real file or a virtual file. static const DirectoryEntry *getDirectoryFromFile(FileManager &FileMgr, StringRef Filename, bool CacheFailure) { if (Filename.empty()) return NULL; if (llvm::sys::path::is_separator(Filename[Filename.size() - 1])) return NULL; // If Filename is a directory. StringRef DirName = llvm::sys::path::parent_path(Filename); // Use the current directory if file has no path component. if (DirName.empty()) DirName = "."; return FileMgr.getDirectory(DirName, CacheFailure); } /// Add all ancestors of the given path (pointing to either a file or /// a directory) as virtual directories. void FileManager::addAncestorsAsVirtualDirs(StringRef Path) { StringRef DirName = llvm::sys::path::parent_path(Path); if (DirName.empty()) return; llvm::StringMapEntry &NamedDirEnt = SeenDirEntries.GetOrCreateValue(DirName); // When caching a virtual directory, we always cache its ancestors // at the same time. Therefore, if DirName is already in the cache, // we don't need to recurse as its ancestors must also already be in // the cache. if (NamedDirEnt.getValue()) return; // Add the virtual directory to the cache. DirectoryEntry *UDE = new DirectoryEntry; UDE->Name = NamedDirEnt.getKeyData(); NamedDirEnt.setValue(UDE); VirtualDirectoryEntries.push_back(UDE); // Recursively add the other ancestors. addAncestorsAsVirtualDirs(DirName); } const DirectoryEntry *FileManager::getDirectory(StringRef DirName, bool CacheFailure) { // stat doesn't like trailing separators except for root directory. // At least, on Win32 MSVCRT, stat() cannot strip trailing '/'. // (though it can strip '\\') if (DirName.size() > 1 && DirName != llvm::sys::path::root_path(DirName) && llvm::sys::path::is_separator(DirName.back())) DirName = DirName.substr(0, DirName.size()-1); #ifdef LLVM_ON_WIN32 // Fixing a problem with "clang C:test.c" on Windows. // Stat("C:") does not recognize "C:" as a valid directory std::string DirNameStr; if (DirName.size() > 1 && DirName.back() == ':' && DirName.equals_lower(llvm::sys::path::root_name(DirName))) { DirNameStr = DirName.str() + '.'; DirName = DirNameStr; } #endif ++NumDirLookups; llvm::StringMapEntry &NamedDirEnt = SeenDirEntries.GetOrCreateValue(DirName); // See if there was already an entry in the map. Note that the map // contains both virtual and real directories. if (NamedDirEnt.getValue()) return NamedDirEnt.getValue() == NON_EXISTENT_DIR ? 0 : NamedDirEnt.getValue(); ++NumDirCacheMisses; // By default, initialize it to invalid. NamedDirEnt.setValue(NON_EXISTENT_DIR); // Get the null-terminated directory name as stored as the key of the // SeenDirEntries map. const char *InterndDirName = NamedDirEnt.getKeyData(); // Check to see if the directory exists. FileData Data; if (getStatValue(InterndDirName, Data, false, 0 /*directory lookup*/)) { // There's no real directory at the given path. if (!CacheFailure) SeenDirEntries.erase(DirName); return 0; } // It exists. See if we have already opened a directory with the // same inode (this occurs on Unix-like systems when one dir is // symlinked to another, for example) or the same path (on // Windows). DirectoryEntry &UDE = UniqueRealDirs[Data.UniqueID]; NamedDirEnt.setValue(&UDE); if (!UDE.getName()) { // We don't have this directory yet, add it. We use the string // key from the SeenDirEntries map as the string. UDE.Name = InterndDirName; } return &UDE; } const FileEntry *FileManager::getFile(StringRef Filename, bool openFile, bool CacheFailure) { ++NumFileLookups; // See if there is already an entry in the map. llvm::StringMapEntry &NamedFileEnt = SeenFileEntries.GetOrCreateValue(Filename); // See if there is already an entry in the map. if (NamedFileEnt.getValue()) return NamedFileEnt.getValue() == NON_EXISTENT_FILE ? 0 : NamedFileEnt.getValue(); ++NumFileCacheMisses; // By default, initialize it to invalid. NamedFileEnt.setValue(NON_EXISTENT_FILE); // Get the null-terminated file name as stored as the key of the // SeenFileEntries map. const char *InterndFileName = NamedFileEnt.getKeyData(); // Look up the directory for the file. When looking up something like // sys/foo.h we'll discover all of the search directories that have a 'sys' // subdirectory. This will let us avoid having to waste time on known-to-fail // searches when we go to find sys/bar.h, because all the search directories // without a 'sys' subdir will get a cached failure result. const DirectoryEntry *DirInfo = getDirectoryFromFile(*this, Filename, CacheFailure); if (DirInfo == 0) { // Directory doesn't exist, file can't exist. if (!CacheFailure) SeenFileEntries.erase(Filename); return 0; } // FIXME: Use the directory info to prune this, before doing the stat syscall. // FIXME: This will reduce the # syscalls. // Nope, there isn't. Check to see if the file exists. vfs::File *F = 0; FileData Data; if (getStatValue(InterndFileName, Data, true, openFile ? &F : 0)) { // There's no real file at the given path. if (!CacheFailure) SeenFileEntries.erase(Filename); return 0; } assert((openFile || !F) && "undesired open file"); // It exists. See if we have already opened a file with the same inode. // This occurs when one dir is symlinked to another, for example. FileEntry &UFE = UniqueRealFiles[Data.UniqueID]; NamedFileEnt.setValue(&UFE); if (UFE.isValid()) { // Already have an entry with this inode, return it. // If the stat process opened the file, close it to avoid a FD leak. if (F) delete F; return &UFE; } // Otherwise, we don't have this file yet, add it. UFE.Name = Data.Name; UFE.Size = Data.Size; UFE.ModTime = Data.ModTime; UFE.Dir = DirInfo; UFE.UID = NextFileUID++; UFE.UniqueID = Data.UniqueID; UFE.IsNamedPipe = Data.IsNamedPipe; UFE.InPCH = Data.InPCH; UFE.File.reset(F); UFE.IsValid = true; return &UFE; } const FileEntry * FileManager::getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime) { ++NumFileLookups; // See if there is already an entry in the map. llvm::StringMapEntry &NamedFileEnt = SeenFileEntries.GetOrCreateValue(Filename); // See if there is already an entry in the map. if (NamedFileEnt.getValue() && NamedFileEnt.getValue() != NON_EXISTENT_FILE) return NamedFileEnt.getValue(); ++NumFileCacheMisses; // By default, initialize it to invalid. NamedFileEnt.setValue(NON_EXISTENT_FILE); addAncestorsAsVirtualDirs(Filename); FileEntry *UFE = 0; // Now that all ancestors of Filename are in the cache, the // following call is guaranteed to find the DirectoryEntry from the // cache. const DirectoryEntry *DirInfo = getDirectoryFromFile(*this, Filename, /*CacheFailure=*/true); assert(DirInfo && "The directory of a virtual file should already be in the cache."); // Check to see if the file exists. If so, drop the virtual file FileData Data; const char *InterndFileName = NamedFileEnt.getKeyData(); if (getStatValue(InterndFileName, Data, true, 0) == 0) { Data.Size = Size; Data.ModTime = ModificationTime; UFE = &UniqueRealFiles[Data.UniqueID]; NamedFileEnt.setValue(UFE); // If we had already opened this file, close it now so we don't // leak the descriptor. We're not going to use the file // descriptor anyway, since this is a virtual file. if (UFE->File) UFE->closeFile(); // If we already have an entry with this inode, return it. if (UFE->isValid()) return UFE; UFE->UniqueID = Data.UniqueID; UFE->IsNamedPipe = Data.IsNamedPipe; UFE->InPCH = Data.InPCH; } if (!UFE) { UFE = new FileEntry(); VirtualFileEntries.push_back(UFE); NamedFileEnt.setValue(UFE); } UFE->Name = InterndFileName; UFE->Size = Size; UFE->ModTime = ModificationTime; UFE->Dir = DirInfo; UFE->UID = NextFileUID++; UFE->File.reset(); return UFE; } void FileManager::FixupRelativePath(SmallVectorImpl &path) const { StringRef pathRef(path.data(), path.size()); if (FileSystemOpts.WorkingDir.empty() || llvm::sys::path::is_absolute(pathRef)) return; SmallString<128> NewPath(FileSystemOpts.WorkingDir); llvm::sys::path::append(NewPath, pathRef); path = NewPath; } llvm::MemoryBuffer *FileManager:: getBufferForFile(const FileEntry *Entry, std::string *ErrorStr, bool isVolatile) { OwningPtr Result; llvm::error_code ec; uint64_t FileSize = Entry->getSize(); // If there's a high enough chance that the file have changed since we // got its size, force a stat before opening it. if (isVolatile) FileSize = -1; const char *Filename = Entry->getName(); // If the file is already open, use the open file descriptor. if (Entry->File) { ec = Entry->File->getBuffer(Filename, Result, FileSize); if (ErrorStr) *ErrorStr = ec.message(); Entry->closeFile(); return Result.take(); } // Otherwise, open the file. if (FileSystemOpts.WorkingDir.empty()) { ec = FS->getBufferForFile(Filename, Result, FileSize); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } SmallString<128> FilePath(Entry->getName()); FixupRelativePath(FilePath); ec = FS->getBufferForFile(FilePath.str(), Result, FileSize); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } llvm::MemoryBuffer *FileManager:: getBufferForFile(StringRef Filename, std::string *ErrorStr) { OwningPtr Result; llvm::error_code ec; if (FileSystemOpts.WorkingDir.empty()) { ec = FS->getBufferForFile(Filename, Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } SmallString<128> FilePath(Filename); FixupRelativePath(FilePath); ec = FS->getBufferForFile(FilePath.c_str(), Result); if (ec && ErrorStr) *ErrorStr = ec.message(); return Result.take(); } /// getStatValue - Get the 'stat' information for the specified path, /// using the cache to accelerate it if possible. This returns true /// if the path points to a virtual file or does not exist, or returns /// false if it's an existent real file. If FileDescriptor is NULL, /// do directory look-up instead of file look-up. bool FileManager::getStatValue(const char *Path, FileData &Data, bool isFile, vfs::File **F) { // FIXME: FileSystemOpts shouldn't be passed in here, all paths should be // absolute! if (FileSystemOpts.WorkingDir.empty()) return FileSystemStatCache::get(Path, Data, isFile, F,StatCache.get(), *FS); SmallString<128> FilePath(Path); FixupRelativePath(FilePath); return FileSystemStatCache::get(FilePath.c_str(), Data, isFile, F, StatCache.get(), *FS); } bool FileManager::getNoncachedStatValue(StringRef Path, vfs::Status &Result) { SmallString<128> FilePath(Path); FixupRelativePath(FilePath); llvm::ErrorOr S = FS->status(FilePath.c_str()); if (!S) return true; Result = *S; return false; } void FileManager::invalidateCache(const FileEntry *Entry) { assert(Entry && "Cannot invalidate a NULL FileEntry"); SeenFileEntries.erase(Entry->getName()); // FileEntry invalidation should not block future optimizations in the file // caches. Possible alternatives are cache truncation (invalidate last N) or // invalidation of the whole cache. UniqueRealFiles.erase(Entry->getUniqueID()); } void FileManager::GetUniqueIDMapping( SmallVectorImpl &UIDToFiles) const { UIDToFiles.clear(); UIDToFiles.resize(NextFileUID); // Map file entries for (llvm::StringMap::const_iterator FE = SeenFileEntries.begin(), FEEnd = SeenFileEntries.end(); FE != FEEnd; ++FE) if (FE->getValue() && FE->getValue() != NON_EXISTENT_FILE) UIDToFiles[FE->getValue()->getUID()] = FE->getValue(); // Map virtual file entries for (SmallVectorImpl::const_iterator VFE = VirtualFileEntries.begin(), VFEEnd = VirtualFileEntries.end(); VFE != VFEEnd; ++VFE) if (*VFE && *VFE != NON_EXISTENT_FILE) UIDToFiles[(*VFE)->getUID()] = *VFE; } void FileManager::modifyFileEntry(FileEntry *File, off_t Size, time_t ModificationTime) { File->Size = Size; File->ModTime = ModificationTime; } StringRef FileManager::getCanonicalName(const DirectoryEntry *Dir) { // FIXME: use llvm::sys::fs::canonical() when it gets implemented #ifdef LLVM_ON_UNIX llvm::DenseMap::iterator Known = CanonicalDirNames.find(Dir); if (Known != CanonicalDirNames.end()) return Known->second; StringRef CanonicalName(Dir->getName()); char CanonicalNameBuf[PATH_MAX]; if (realpath(Dir->getName(), CanonicalNameBuf)) { unsigned Len = strlen(CanonicalNameBuf); char *Mem = static_cast(CanonicalNameStorage.Allocate(Len, 1)); memcpy(Mem, CanonicalNameBuf, Len); CanonicalName = StringRef(Mem, Len); } CanonicalDirNames.insert(std::make_pair(Dir, CanonicalName)); return CanonicalName; #else return StringRef(Dir->getName()); #endif } void FileManager::PrintStats() const { llvm::errs() << "\n*** File Manager Stats:\n"; llvm::errs() << UniqueRealFiles.size() << " real files found, " << UniqueRealDirs.size() << " real dirs found.\n"; llvm::errs() << VirtualFileEntries.size() << " virtual files found, " << VirtualDirectoryEntries.size() << " virtual dirs found.\n"; llvm::errs() << NumDirLookups << " dir lookups, " << NumDirCacheMisses << " dir cache misses.\n"; llvm::errs() << NumFileLookups << " file lookups, " << NumFileCacheMisses << " file cache misses.\n"; //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups; } @