1 //===--- PTHManager.h - Manager object for PTH processing -------*- 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 // This file defines the PTHManager interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_LEX_PTHMANAGER_H 15 #define LLVM_CLANG_LEX_PTHMANAGER_H 16 17 #include "clang/Basic/Diagnostic.h" 18 #include "clang/Basic/IdentifierTable.h" 19 #include "clang/Basic/LangOptions.h" 20 #include "clang/Lex/PTHLexer.h" 21 #include "llvm/ADT/DenseMap.h" 22 #include "llvm/ADT/STLExtras.h" 23 #include "llvm/Support/Allocator.h" 24 #include "llvm/Support/OnDiskHashTable.h" 25 #include <string> 26 27 namespace llvm { 28 class MemoryBuffer; 29 } 30 31 namespace clang { 32 33 class FileEntry; 34 class PTHLexer; 35 class DiagnosticsEngine; 36 class FileSystemStatCache; 37 38 class PTHManager : public IdentifierInfoLookup { 39 friend class PTHLexer; 40 41 friend class PTHStatCache; 42 43 class PTHStringLookupTrait; 44 class PTHFileLookupTrait; 45 typedef llvm::OnDiskChainedHashTable<PTHStringLookupTrait> PTHStringIdLookup; 46 typedef llvm::OnDiskChainedHashTable<PTHFileLookupTrait> PTHFileLookup; 47 48 /// The memory mapped PTH file. 49 std::unique_ptr<const llvm::MemoryBuffer> Buf; 50 51 /// Alloc - Allocator used for IdentifierInfo objects. 52 llvm::BumpPtrAllocator Alloc; 53 54 /// IdMap - A lazily generated cache mapping from persistent identifiers to 55 /// IdentifierInfo*. 56 std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> PerIDCache; 57 58 /// FileLookup - Abstract data structure used for mapping between files 59 /// and token data in the PTH file. 60 std::unique_ptr<PTHFileLookup> FileLookup; 61 62 /// IdDataTable - Array representing the mapping from persistent IDs to the 63 /// data offset within the PTH file containing the information to 64 /// reconsitute an IdentifierInfo. 65 const unsigned char* const IdDataTable; 66 67 /// SortedIdTable - Abstract data structure mapping from strings to 68 /// persistent IDs. This is used by get(). 69 std::unique_ptr<PTHStringIdLookup> StringIdLookup; 70 71 /// NumIds - The number of identifiers in the PTH file. 72 const unsigned NumIds; 73 74 /// PP - The Preprocessor object that will use this PTHManager to create 75 /// PTHLexer objects. 76 Preprocessor* PP; 77 78 /// SpellingBase - The base offset within the PTH memory buffer that 79 /// contains the cached spellings for literals. 80 const unsigned char* const SpellingBase; 81 82 /// OriginalSourceFile - A null-terminated C-string that specifies the name 83 /// if the file (if any) that was to used to generate the PTH cache. 84 const char* OriginalSourceFile; 85 86 /// This constructor is intended to only be called by the static 'Create' 87 /// method. 88 PTHManager(std::unique_ptr<const llvm::MemoryBuffer> buf, 89 std::unique_ptr<PTHFileLookup> fileLookup, 90 const unsigned char *idDataTable, 91 std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> perIDCache, 92 std::unique_ptr<PTHStringIdLookup> stringIdLookup, unsigned numIds, 93 const unsigned char *spellingBase, const char *originalSourceFile); 94 95 PTHManager(const PTHManager &) = delete; 96 void operator=(const PTHManager &) = delete; 97 98 /// getSpellingAtPTHOffset - Used by PTHLexer classes to get the cached 99 /// spelling for a token. 100 unsigned getSpellingAtPTHOffset(unsigned PTHOffset, const char*& Buffer); 101 102 /// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the 103 /// PTH file. 104 inline IdentifierInfo* GetIdentifierInfo(unsigned PersistentID) { 105 // Check if the IdentifierInfo has already been resolved. 106 if (IdentifierInfo* II = PerIDCache[PersistentID]) 107 return II; 108 return LazilyCreateIdentifierInfo(PersistentID); 109 } 110 IdentifierInfo* LazilyCreateIdentifierInfo(unsigned PersistentID); 111 112 public: 113 // The current PTH version. 114 enum { Version = 10 }; 115 116 ~PTHManager() override; 117 118 /// getOriginalSourceFile - Return the full path to the original header 119 /// file name that was used to generate the PTH cache. 120 const char* getOriginalSourceFile() const { 121 return OriginalSourceFile; 122 } 123 124 /// get - Return the identifier token info for the specified named identifier. 125 /// Unlike the version in IdentifierTable, this returns a pointer instead 126 /// of a reference. If the pointer is NULL then the IdentifierInfo cannot 127 /// be found. 128 IdentifierInfo *get(StringRef Name) override; 129 130 /// Create - This method creates PTHManager objects. The 'file' argument 131 /// is the name of the PTH file. This method returns NULL upon failure. 132 static PTHManager *Create(const std::string& file, DiagnosticsEngine &Diags); 133 134 void setPreprocessor(Preprocessor *pp) { PP = pp; } 135 136 /// CreateLexer - Return a PTHLexer that "lexes" the cached tokens for the 137 /// specified file. This method returns NULL if no cached tokens exist. 138 /// It is the responsibility of the caller to 'delete' the returned object. 139 PTHLexer *CreateLexer(FileID FID); 140 141 /// createStatCache - Returns a FileSystemStatCache object for use with 142 /// FileManager objects. These objects use the PTH data to speed up 143 /// calls to stat by memoizing their results from when the PTH file 144 /// was generated. 145 std::unique_ptr<FileSystemStatCache> createStatCache(); 146 }; 147 148 } // end namespace clang 149 150 #endif 151
