1 //===--- FileSystemStatCache.h - Caching for 'stat' calls -------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 /// 10 /// \file 11 /// \brief Defines the FileSystemStatCache interface. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_BASIC_FILESYSTEMSTATCACHE_H 16 #define LLVM_CLANG_BASIC_FILESYSTEMSTATCACHE_H 17 18 #include "clang/Basic/LLVM.h" 19 #include "llvm/ADT/StringMap.h" 20 #include "llvm/Support/FileSystem.h" 21 #include <memory> 22 23 namespace clang { 24 25 namespace vfs { 26 class File; 27 class FileSystem; 28 } 29 30 // FIXME: should probably replace this with vfs::Status 31 struct FileData { 32 std::string Name; 33 uint64_t Size; 34 time_t ModTime; 35 llvm::sys::fs::UniqueID UniqueID; 36 bool IsDirectory; 37 bool IsNamedPipe; 38 bool InPCH; 39 bool IsVFSMapped; // FIXME: remove this when files support multiple names FileDataFileData40 FileData() 41 : Size(0), ModTime(0), IsDirectory(false), IsNamedPipe(false), 42 InPCH(false), IsVFSMapped(false) {} 43 }; 44 45 /// \brief Abstract interface for introducing a FileManager cache for 'stat' 46 /// system calls, which is used by precompiled and pretokenized headers to 47 /// improve performance. 48 class FileSystemStatCache { 49 virtual void anchor(); 50 protected: 51 std::unique_ptr<FileSystemStatCache> NextStatCache; 52 53 public: ~FileSystemStatCache()54 virtual ~FileSystemStatCache() {} 55 56 enum LookupResult { 57 CacheExists, ///< We know the file exists and its cached stat data. 58 CacheMissing ///< We know that the file doesn't exist. 59 }; 60 61 /// \brief Get the 'stat' information for the specified path, using the cache 62 /// to accelerate it if possible. 63 /// 64 /// \returns \c true if the path does not exist or \c false if it exists. 65 /// 66 /// If isFile is true, then this lookup should only return success for files 67 /// (not directories). If it is false this lookup should only return 68 /// success for directories (not files). On a successful file lookup, the 69 /// implementation can optionally fill in \p F with a valid \p File object and 70 /// the client guarantees that it will close it. 71 static bool get(const char *Path, FileData &Data, bool isFile, 72 std::unique_ptr<vfs::File> *F, FileSystemStatCache *Cache, 73 vfs::FileSystem &FS); 74 75 /// \brief Sets the next stat call cache in the chain of stat caches. 76 /// Takes ownership of the given stat cache. setNextStatCache(std::unique_ptr<FileSystemStatCache> Cache)77 void setNextStatCache(std::unique_ptr<FileSystemStatCache> Cache) { 78 NextStatCache = std::move(Cache); 79 } 80 81 /// \brief Retrieve the next stat call cache in the chain. getNextStatCache()82 FileSystemStatCache *getNextStatCache() { return NextStatCache.get(); } 83 84 /// \brief Retrieve the next stat call cache in the chain, transferring 85 /// ownership of this cache (and, transitively, all of the remaining caches) 86 /// to the caller. takeNextStatCache()87 std::unique_ptr<FileSystemStatCache> takeNextStatCache() { 88 return std::move(NextStatCache); 89 } 90 91 protected: 92 // FIXME: The pointer here is a non-owning/optional reference to the 93 // unique_ptr. Optional<unique_ptr<vfs::File>&> might be nicer, but 94 // Optional needs some work to support references so this isn't possible yet. 95 virtual LookupResult getStat(const char *Path, FileData &Data, bool isFile, 96 std::unique_ptr<vfs::File> *F, 97 vfs::FileSystem &FS) = 0; 98 statChained(const char * Path,FileData & Data,bool isFile,std::unique_ptr<vfs::File> * F,vfs::FileSystem & FS)99 LookupResult statChained(const char *Path, FileData &Data, bool isFile, 100 std::unique_ptr<vfs::File> *F, vfs::FileSystem &FS) { 101 if (FileSystemStatCache *Next = getNextStatCache()) 102 return Next->getStat(Path, Data, isFile, F, FS); 103 104 // If we hit the end of the list of stat caches to try, just compute and 105 // return it without a cache. 106 return get(Path, Data, isFile, F, nullptr, FS) ? CacheMissing : CacheExists; 107 } 108 }; 109 110 /// \brief A stat "cache" that can be used by FileManager to keep 111 /// track of the results of stat() calls that occur throughout the 112 /// execution of the front end. 113 class MemorizeStatCalls : public FileSystemStatCache { 114 public: 115 /// \brief The set of stat() calls that have been seen. 116 llvm::StringMap<FileData, llvm::BumpPtrAllocator> StatCalls; 117 118 typedef llvm::StringMap<FileData, llvm::BumpPtrAllocator>::const_iterator 119 iterator; 120 begin()121 iterator begin() const { return StatCalls.begin(); } end()122 iterator end() const { return StatCalls.end(); } 123 124 LookupResult getStat(const char *Path, FileData &Data, bool isFile, 125 std::unique_ptr<vfs::File> *F, 126 vfs::FileSystem &FS) override; 127 }; 128 129 } // end namespace clang 130 131 #endif 132