contrib/llvm/tools/clang/lib/Serialization/ASTReaderInternals.h

   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