1 //===--- ASTReaderInternals.h - AST Reader Internals ------------*- 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 provides internal definitions used in the AST reader. 11 // 12 //===----------------------------------------------------------------------===// 13 #ifndef LLVM_CLANG_SERIALIZATION_ASTREADER_INTERNALS_H 14 #define LLVM_CLANG_SERIALIZATION_ASTREADER_INTERNALS_H 15 16 #include "clang/AST/DeclarationName.h" 17 #include "clang/Serialization/ASTBitCodes.h" 18 #include "llvm/Support/Endian.h" 19 #include "llvm/Support/OnDiskHashTable.h" 20 #include <utility> 21 22 namespace clang { 23 24 class ASTReader; 25 class HeaderSearch; 26 struct HeaderFileInfo; 27 class FileEntry; 28 29 namespace serialization { 30 31 class ModuleFile; 32 33 namespace reader { 34 35 /// \brief Class that performs name lookup into a DeclContext stored 36 /// in an AST file. 37 class ASTDeclContextNameLookupTrait { 38 ASTReader &Reader; 39 ModuleFile &F; 40 41 public: 42 /// \brief Pair of begin/end iterators for DeclIDs. 43 /// 44 /// Note that these declaration IDs are local to the module that contains this 45 /// particular lookup t 46 typedef llvm::support::ulittle32_t LE32DeclID; 47 typedef std::pair<LE32DeclID *, LE32DeclID *> data_type; 48 typedef unsigned hash_value_type; 49 typedef unsigned offset_type; 50 51 /// \brief Special internal key for declaration names. 52 /// The hash table creates keys for comparison; we do not create 53 /// a DeclarationName for the internal key to avoid deserializing types. 54 struct DeclNameKey { 55 DeclarationName::NameKind Kind; 56 uint64_t Data; 57 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { } 58 }; 59 60 typedef DeclarationName external_key_type; 61 typedef DeclNameKey internal_key_type; 62 63 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader, ModuleFile &F) 64 : Reader(Reader), F(F) { } 65 66 static bool EqualKey(const internal_key_type& a, 67 const internal_key_type& b) { 68 return a.Kind == b.Kind && a.Data == b.Data; 69 } 70 71 hash_value_type ComputeHash(const DeclNameKey &Key) const; 72 internal_key_type GetInternalKey(const external_key_type& Name) const; 73 74 static std::pair<unsigned, unsigned> 75 ReadKeyDataLength(const unsigned char*& d); 76 77 internal_key_type ReadKey(const unsigned char* d, unsigned); 78 79 data_type ReadData(internal_key_type, const unsigned char* d, 80 unsigned DataLen); 81 }; 82 83 /// \brief Base class for the trait describing the on-disk hash table for the 84 /// identifiers in an AST file. 85 /// 86 /// This class is not useful by itself; rather, it provides common 87 /// functionality for accessing the on-disk hash table of identifiers 88 /// in an AST file. Different subclasses customize that functionality 89 /// based on what information they are interested in. Those subclasses 90 /// must provide the \c data_type typedef and the ReadData operation, 91 /// only. 92 class ASTIdentifierLookupTraitBase { 93 public: 94 typedef StringRef external_key_type; 95 typedef StringRef internal_key_type; 96 typedef unsigned hash_value_type; 97 typedef unsigned offset_type; 98 99 static bool EqualKey(const internal_key_type& a, const internal_key_type& b) { 100 return a == b; 101 } 102 103 static hash_value_type ComputeHash(const internal_key_type& a); 104 105 static std::pair<unsigned, unsigned> 106 ReadKeyDataLength(const unsigned char*& d); 107 108 // This hopefully will just get inlined and removed by the optimizer. 109 static const internal_key_type& 110 GetInternalKey(const external_key_type& x) { return x; } 111 112 // This hopefully will just get inlined and removed by the optimizer. 113 static const external_key_type& 114 GetExternalKey(const internal_key_type& x) { return x; } 115 116 static internal_key_type ReadKey(const unsigned char* d, unsigned n); 117 }; 118 119 /// \brief Class that performs lookup for an identifier stored in an AST file. 120 class ASTIdentifierLookupTrait : public ASTIdentifierLookupTraitBase { 121 ASTReader &Reader; 122 ModuleFile &F; 123 124 // If we know the IdentifierInfo in advance, it is here and we will 125 // not build a new one. Used when deserializing information about an 126 // identifier that was constructed before the AST file was read. 127 IdentifierInfo *KnownII; 128 129 public: 130 typedef IdentifierInfo * data_type; 131 132 ASTIdentifierLookupTrait(ASTReader &Reader, ModuleFile &F, 133 IdentifierInfo *II = nullptr) 134 : Reader(Reader), F(F), KnownII(II) { } 135 136 data_type ReadData(const internal_key_type& k, 137 const unsigned char* d, 138 unsigned DataLen); 139 140 ASTReader &getReader() const { return Reader; } 141 }; 142 143 /// \brief The on-disk hash table used to contain information about 144 /// all of the identifiers in the program. 145 typedef llvm::OnDiskIterableChainedHashTable<ASTIdentifierLookupTrait> 146 ASTIdentifierLookupTable; 147 148 /// \brief Class that performs lookup for a selector's entries in the global 149 /// method pool stored in an AST file. 150 class ASTSelectorLookupTrait { 151 ASTReader &Reader; 152 ModuleFile &F; 153 154 public: 155 struct data_type { 156 SelectorID ID; 157 unsigned InstanceBits; 158 unsigned FactoryBits; 159 SmallVector<ObjCMethodDecl *, 2> Instance; 160 SmallVector<ObjCMethodDecl *, 2> Factory; 161 }; 162 163 typedef Selector external_key_type; 164 typedef external_key_type internal_key_type; 165 typedef unsigned hash_value_type; 166 typedef unsigned offset_type; 167 168 ASTSelectorLookupTrait(ASTReader &Reader, ModuleFile &F) 169 : Reader(Reader), F(F) { } 170 171 static bool EqualKey(const internal_key_type& a, 172 const internal_key_type& b) { 173 return a == b; 174 } 175 176 static hash_value_type ComputeHash(Selector Sel); 177 178 static const internal_key_type& 179 GetInternalKey(const external_key_type& x) { return x; } 180 181 static std::pair<unsigned, unsigned> 182 ReadKeyDataLength(const unsigned char*& d); 183 184 internal_key_type ReadKey(const unsigned char* d, unsigned); 185 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen); 186 }; 187 188 /// \brief The on-disk hash table used for the global method pool. 189 typedef llvm::OnDiskChainedHashTable<ASTSelectorLookupTrait> 190 ASTSelectorLookupTable; 191 192 /// \brief Trait class used to search the on-disk hash table containing all of 193 /// the header search information. 194 /// 195 /// The on-disk hash table contains a mapping from each header path to 196 /// information about that header (how many times it has been included, its 197 /// controlling macro, etc.). Note that we actually hash based on the 198 /// filename, and support "deep" comparisons of file names based on current 199 /// inode numbers, so that the search can cope with non-normalized path names 200 /// and symlinks. 201 class HeaderFileInfoTrait { 202 ASTReader &Reader; 203 ModuleFile &M; 204 HeaderSearch *HS; 205 const char *FrameworkStrings; 206 207 public: 208 typedef const FileEntry *external_key_type; 209 210 struct internal_key_type { 211 off_t Size; 212 time_t ModTime; 213 const char *Filename; 214 }; 215 typedef const internal_key_type &internal_key_ref; 216 217 typedef HeaderFileInfo data_type; 218 typedef unsigned hash_value_type; 219 typedef unsigned offset_type; 220 221 HeaderFileInfoTrait(ASTReader &Reader, ModuleFile &M, HeaderSearch *HS, 222 const char *FrameworkStrings) 223 : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings) { } 224 225 static hash_value_type ComputeHash(internal_key_ref ikey); 226 static internal_key_type GetInternalKey(const FileEntry *FE); 227 bool EqualKey(internal_key_ref a, internal_key_ref b); 228 229 static std::pair<unsigned, unsigned> 230 ReadKeyDataLength(const unsigned char*& d); 231 232 static internal_key_type ReadKey(const unsigned char *d, unsigned); 233 234 data_type ReadData(internal_key_ref,const unsigned char *d, unsigned DataLen); 235 }; 236 237 /// \brief The on-disk hash table used for known header files. 238 typedef llvm::OnDiskChainedHashTable<HeaderFileInfoTrait> 239 HeaderFileInfoLookupTable; 240 241 } // end namespace clang::serialization::reader 242 } // end namespace clang::serialization 243 } // end namespace clang 244 245 246 #endif 247