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
22namespace clang {
23
24class ASTReader;
25class HeaderSearch;
26struct HeaderFileInfo;
27class FileEntry;
28
29namespace serialization {
30
31class ModuleFile;
32
33namespace reader {
34
35/// \brief Class that performs name lookup into a DeclContext stored
36/// in an AST file.
37class ASTDeclContextNameLookupTrait {
38  ASTReader &Reader;
39  ModuleFile &F;
40
41public:
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.
92class ASTIdentifierLookupTraitBase {
93public:
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.
120class 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
129public:
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.
145typedef 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.
150class ASTSelectorLookupTrait {
151  ASTReader &Reader;
152  ModuleFile &F;
153
154public:
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.
189typedef 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.
201class HeaderFileInfoTrait {
202  ASTReader &Reader;
203  ModuleFile &M;
204  HeaderSearch *HS;
205  const char *FrameworkStrings;
206
207public:
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.
238typedef 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