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