clang  14.0.0git
ASTReaderInternals.h
Go to the documentation of this file.
1 //===- ASTReaderInternals.h - AST Reader Internals --------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file provides internal definitions used in the AST reader.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_LIB_SERIALIZATION_ASTREADERINTERNALS_H
14 #define LLVM_CLANG_LIB_SERIALIZATION_ASTREADERINTERNALS_H
15 
16 #include "MultiOnDiskHashTable.h"
18 #include "clang/Basic/LLVM.h"
20 #include "llvm/ADT/DenseSet.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/Support/OnDiskHashTable.h"
24 #include <ctime>
25 #include <utility>
26 
27 namespace clang {
28 
29 class ASTReader;
30 class FileEntry;
31 struct HeaderFileInfo;
32 class HeaderSearch;
33 class IdentifierTable;
34 class ObjCMethodDecl;
35 
36 namespace serialization {
37 
38 class ModuleFile;
39 
40 namespace reader {
41 
42 /// Class that performs name lookup into a DeclContext stored
43 /// in an AST file.
45  ASTReader &Reader;
46  ModuleFile &F;
47 
48 public:
49  // Maximum number of lookup tables we allow before condensing the tables.
50  static const int MaxTables = 4;
51 
52  /// The lookup result is a list of global declaration IDs.
54 
58 
60 
61  void insert(DeclID ID) {
62  // Just use a linear scan unless we have more than a few IDs.
63  if (Found.empty() && !Data.empty()) {
64  if (Data.size() <= 4) {
65  for (auto I : Found)
66  if (I == ID)
67  return;
68  Data.push_back(ID);
69  return;
70  }
71 
72  // Switch to tracking found IDs in the set.
73  Found.insert(Data.begin(), Data.end());
74  }
75 
76  if (Found.insert(ID).second)
77  Data.push_back(ID);
78  }
79  };
82  using file_type = ModuleFile *;
83 
86 
88  : Reader(Reader), F(F) {}
89 
90  static bool EqualKey(const internal_key_type &a, const internal_key_type &b) {
91  return a == b;
92  }
93 
95  return Key.getHash();
96  }
97 
99  return Name;
100  }
101 
102  static std::pair<unsigned, unsigned>
103  ReadKeyDataLength(const unsigned char *&d);
104 
105  internal_key_type ReadKey(const unsigned char *d, unsigned);
106 
107  void ReadDataInto(internal_key_type, const unsigned char *d,
108  unsigned DataLen, data_type_builder &Val);
109 
110  static void MergeDataInto(const data_type &From, data_type_builder &To) {
111  To.Data.reserve(To.Data.size() + From.size());
112  for (DeclID ID : From)
113  To.insert(ID);
114  }
115 
116  file_type ReadFileRef(const unsigned char *&d);
117 };
118 
121 };
122 
123 /// Base class for the trait describing the on-disk hash table for the
124 /// identifiers in an AST file.
125 ///
126 /// This class is not useful by itself; rather, it provides common
127 /// functionality for accessing the on-disk hash table of identifiers
128 /// in an AST file. Different subclasses customize that functionality
129 /// based on what information they are interested in. Those subclasses
130 /// must provide the \c data_type type and the ReadData operation, only.
132 public:
133  using external_key_type = StringRef;
134  using internal_key_type = StringRef;
137 
138  static bool EqualKey(const internal_key_type& a, const internal_key_type& b) {
139  return a == b;
140  }
141 
143 
144  static std::pair<unsigned, unsigned>
145  ReadKeyDataLength(const unsigned char*& d);
146 
147  // This hopefully will just get inlined and removed by the optimizer.
148  static const internal_key_type&
149  GetInternalKey(const external_key_type& x) { return x; }
150 
151  // This hopefully will just get inlined and removed by the optimizer.
152  static const external_key_type&
153  GetExternalKey(const internal_key_type& x) { return x; }
154 
155  static internal_key_type ReadKey(const unsigned char* d, unsigned n);
156 };
157 
158 /// Class that performs lookup for an identifier stored in an AST file.
160  ASTReader &Reader;
161  ModuleFile &F;
162 
163  // If we know the IdentifierInfo in advance, it is here and we will
164  // not build a new one. Used when deserializing information about an
165  // identifier that was constructed before the AST file was read.
166  IdentifierInfo *KnownII;
167 
168 public:
170 
172  IdentifierInfo *II = nullptr)
173  : Reader(Reader), F(F), KnownII(II) {}
174 
176  const unsigned char* d,
177  unsigned DataLen);
178 
179  IdentID ReadIdentifierID(const unsigned char *d);
180 
181  ASTReader &getReader() const { return Reader; }
182 };
183 
184 /// The on-disk hash table used to contain information about
185 /// all of the identifiers in the program.
187  llvm::OnDiskIterableChainedHashTable<ASTIdentifierLookupTrait>;
188 
189 /// Class that performs lookup for a selector's entries in the global
190 /// method pool stored in an AST file.
192  ASTReader &Reader;
193  ModuleFile &F;
194 
195 public:
196  struct data_type {
198  unsigned InstanceBits;
199  unsigned FactoryBits;
204  };
205 
210 
212  : Reader(Reader), F(F) {}
213 
214  static bool EqualKey(const internal_key_type& a,
215  const internal_key_type& b) {
216  return a == b;
217  }
218 
220 
221  static const internal_key_type&
222  GetInternalKey(const external_key_type& x) { return x; }
223 
224  static std::pair<unsigned, unsigned>
225  ReadKeyDataLength(const unsigned char*& d);
226 
227  internal_key_type ReadKey(const unsigned char* d, unsigned);
228  data_type ReadData(Selector, const unsigned char* d, unsigned DataLen);
229 };
230 
231 /// The on-disk hash table used for the global method pool.
233  llvm::OnDiskChainedHashTable<ASTSelectorLookupTrait>;
234 
235 /// Trait class used to search the on-disk hash table containing all of
236 /// the header search information.
237 ///
238 /// The on-disk hash table contains a mapping from each header path to
239 /// information about that header (how many times it has been included, its
240 /// controlling macro, etc.). Note that we actually hash based on the size
241 /// and mtime, and support "deep" comparisons of file names based on current
242 /// inode numbers, so that the search can cope with non-normalized path names
243 /// and symlinks.
245  ASTReader &Reader;
246  ModuleFile &M;
247  HeaderSearch *HS;
248  const char *FrameworkStrings;
249 
250 public:
251  using external_key_type = const FileEntry *;
252 
254  off_t Size;
255  time_t ModTime;
256  StringRef Filename;
257  bool Imported;
258  };
259 
261 
265 
267  const char *FrameworkStrings)
268  : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings) {}
269 
271  internal_key_type GetInternalKey(const FileEntry *FE);
273 
274  static std::pair<unsigned, unsigned>
275  ReadKeyDataLength(const unsigned char*& d);
276 
277  static internal_key_type ReadKey(const unsigned char *d, unsigned);
278 
279  data_type ReadData(internal_key_ref,const unsigned char *d, unsigned DataLen);
280 };
281 
282 /// The on-disk hash table used for known header files.
284  llvm::OnDiskChainedHashTable<HeaderFileInfoTrait>;
285 
286 } // namespace reader
287 
288 } // namespace serialization
289 
290 } // namespace clang
291 
292 #endif // LLVM_CLANG_LIB_SERIALIZATION_ASTREADERINTERNALS_H
clang::serialization::reader::ASTDeclContextNameLookupTrait::data_type_builder::Data
data_type & Data
Definition: ASTReaderInternals.h:56
clang::serialization::reader::ASTSelectorLookupTrait::EqualKey
static bool EqualKey(const internal_key_type &a, const internal_key_type &b)
Definition: ASTReaderInternals.h:214
clang::serialization::reader::ASTIdentifierLookupTrait::ASTIdentifierLookupTrait
ASTIdentifierLookupTrait(ASTReader &Reader, ModuleFile &F, IdentifierInfo *II=nullptr)
Definition: ASTReaderInternals.h:171
clang::serialization::reader::ASTSelectorLookupTrait::data_type::ID
SelectorID ID
Definition: ASTReaderInternals.h:197
clang::serialization::reader::ASTSelectorLookupTrait::data_type::InstanceHasMoreThanOneDecl
bool InstanceHasMoreThanOneDecl
Definition: ASTReaderInternals.h:200
clang::serialization::reader::ASTIdentifierLookupTrait::getReader
ASTReader & getReader() const
Definition: ASTReaderInternals.h:181
clang::serialization::reader::ASTIdentifierLookupTrait
Class that performs lookup for an identifier stored in an AST file.
Definition: ASTReaderInternals.h:159
llvm::SmallVector
Definition: LLVM.h:38
clang::serialization::IdentID
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:134
clang::serialization::reader::ASTIdentifierLookupTraitBase::ComputeHash
static hash_value_type ComputeHash(const internal_key_type &a)
Definition: ASTReader.cpp:914
clang::serialization::reader::ASTDeclContextNameLookupTrait::MaxTables
static const int MaxTables
Definition: ASTReaderInternals.h:50
clang::serialization::reader::ASTSelectorLookupTrait::internal_key_type
external_key_type internal_key_type
Definition: ASTReaderInternals.h:207
clang::serialization::DeclarationNameKey
A key used when looking up entities by DeclarationName.
Definition: ASTBitCodes.h:2075
clang::serialization::reader::HeaderFileInfoTrait::hash_value_type
unsigned hash_value_type
Definition: ASTReaderInternals.h:263
clang::serialization::reader::HeaderFileInfoLookupTable
llvm::OnDiskChainedHashTable< HeaderFileInfoTrait > HeaderFileInfoLookupTable
The on-disk hash table used for known header files.
Definition: ASTReaderInternals.h:284
clang::serialization::reader::HeaderFileInfoTrait::internal_key_type
Definition: ASTReaderInternals.h:253
clang::serialization::reader::ASTDeclContextNameLookupTrait::GetInternalKey
static internal_key_type GetInternalKey(const external_key_type &Name)
Definition: ASTReaderInternals.h:98
clang::serialization::reader::ASTDeclContextNameLookupTrait::ComputeHash
static hash_value_type ComputeHash(const internal_key_type &Key)
Definition: ASTReaderInternals.h:94
clang::serialization::reader::ASTSelectorLookupTrait::data_type::InstanceBits
unsigned InstanceBits
Definition: ASTReaderInternals.h:198
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:145
b
__device__ __2f16 b
Definition: __clang_hip_libdevice_declares.h:314
clang::serialization::reader::ASTIdentifierLookupTable
llvm::OnDiskIterableChainedHashTable< ASTIdentifierLookupTrait > ASTIdentifierLookupTable
The on-disk hash table used to contain information about all of the identifiers in the program.
Definition: ASTReaderInternals.h:187
clang::serialization::reader::ASTSelectorLookupTrait::data_type::Factory
SmallVector< ObjCMethodDecl *, 2 > Factory
Definition: ASTReaderInternals.h:203
clang::serialization::reader::ASTDeclContextNameLookupTrait::ReadKeyDataLength
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:1107
clang::serialization::reader::ASTSelectorLookupTrait::ReadKeyDataLength
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:853
clang::HeaderSearch
Encapsulates the information needed to find the file referenced by a #include or #include_next,...
Definition: HeaderSearch.h:162
clang::serialization::reader::ASTDeclContextNameLookupTrait::ReadDataInto
void ReadDataInto(internal_key_type, const unsigned char *d, unsigned DataLen, data_type_builder &Val)
Definition: ASTReader.cpp:1146
clang::serialization::reader::HeaderFileInfoTrait::data_type
HeaderFileInfo data_type
Definition: ASTReaderInternals.h:262
clang::serialization::reader::HeaderFileInfoTrait::ReadKey
static internal_key_type ReadKey(const unsigned char *d, unsigned)
Definition: ASTReader.cpp:1867
clang::serialization::reader::ASTIdentifierLookupTraitBase::external_key_type
StringRef external_key_type
Definition: ASTReaderInternals.h:133
clang::serialization::reader::ASTIdentifierLookupTraitBase::ReadKey
static internal_key_type ReadKey(const unsigned char *d, unsigned n)
Definition: ASTReader.cpp:924
clang::serialization::reader::ASTDeclContextNameLookupTrait::file_type
ModuleFile * file_type
Definition: ASTReaderInternals.h:82
clang::serialization::reader::ASTSelectorLookupTrait::data_type
Definition: ASTReaderInternals.h:196
clang::serialization::reader::ASTIdentifierLookupTrait::data_type
IdentifierInfo * data_type
Definition: ASTReaderInternals.h:169
clang::serialization::reader::ASTDeclContextNameLookupTrait::MergeDataInto
static void MergeDataInto(const data_type &From, data_type_builder &To)
Definition: ASTReaderInternals.h:110
clang::serialization::reader::HeaderFileInfoTrait::internal_key_type::Imported
bool Imported
Definition: ASTReaderInternals.h:257
clang::serialization::reader::ASTSelectorLookupTrait::ASTSelectorLookupTrait
ASTSelectorLookupTrait(ASTReader &Reader, ModuleFile &F)
Definition: ASTReaderInternals.h:211
clang::serialization::reader::HeaderFileInfoTrait::HeaderFileInfoTrait
HeaderFileInfoTrait(ASTReader &Reader, ModuleFile &M, HeaderSearch *HS, const char *FrameworkStrings)
Definition: ASTReaderInternals.h:266
clang::serialization::reader::ASTIdentifierLookupTraitBase
Base class for the trait describing the on-disk hash table for the identifiers in an AST file.
Definition: ASTReaderInternals.h:131
clang::serialization::reader::HeaderFileInfoTrait::internal_key_type::ModTime
time_t ModTime
Definition: ASTReaderInternals.h:255
clang::serialization::reader::ASTSelectorLookupTrait::data_type::FactoryBits
unsigned FactoryBits
Definition: ASTReaderInternals.h:199
clang::serialization::reader::ASTIdentifierLookupTraitBase::GetExternalKey
static const external_key_type & GetExternalKey(const internal_key_type &x)
Definition: ASTReaderInternals.h:153
clang::serialization::reader::ASTIdentifierLookupTraitBase::GetInternalKey
static const internal_key_type & GetInternalKey(const external_key_type &x)
Definition: ASTReaderInternals.h:149
llvm::DenseSet< DeclID >
clang::serialization::reader::ASTSelectorLookupTrait::GetInternalKey
static const internal_key_type & GetInternalKey(const external_key_type &x)
Definition: ASTReaderInternals.h:222
clang::serialization::reader::ASTDeclContextNameLookupTrait::data_type_builder::data_type_builder
data_type_builder(data_type &D)
Definition: ASTReaderInternals.h:59
clang::serialization::reader::ASTSelectorLookupTrait::ComputeHash
static hash_value_type ComputeHash(Selector Sel)
Definition: ASTReader.cpp:848
clang::serialization::reader::ASTDeclContextNameLookupTrait::data_type_builder::Found
llvm::DenseSet< DeclID > Found
Definition: ASTReaderInternals.h:57
clang::serialization::reader::ASTIdentifierLookupTrait::ReadData
data_type ReadData(const internal_key_type &k, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:961
x
IRgen optimization opportunities The common pattern of short x
Definition: README.txt:7
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
clang::serialization::reader::ASTIdentifierLookupTraitBase::hash_value_type
unsigned hash_value_type
Definition: ASTReaderInternals.h:135
clang::serialization::MultiOnDiskHashTable
A collection of on-disk hash tables, merged when relevant for performance.
Definition: MultiOnDiskHashTable.h:40
clang::serialization::reader::HeaderFileInfoTrait::ComputeHash
static hash_value_type ComputeHash(internal_key_ref ikey)
Definition: ASTReader.cpp:1821
ASTBitCodes.h
clang::serialization::reader::ASTDeclContextNameLookupTrait::ReadFileRef
file_type ReadFileRef(const unsigned char *&d)
Definition: ASTReader.cpp:1099
clang::serialization::reader::HeaderFileInfoTrait::internal_key_type::Filename
StringRef Filename
Definition: ASTReaderInternals.h:256
clang::serialization::reader::ASTSelectorLookupTrait
Class that performs lookup for a selector's entries in the global method pool stored in an AST file.
Definition: ASTReaderInternals.h:191
MultiOnDiskHashTable.h
LLVM.h
clang::serialization::reader::HeaderFileInfoTrait::internal_key_ref
const internal_key_type & internal_key_ref
Definition: ASTReaderInternals.h:260
clang::serialization::reader::HeaderFileInfoTrait::ReadKeyDataLength
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:1862
clang::serialization::reader::ASTSelectorLookupTrait::hash_value_type
unsigned hash_value_type
Definition: ASTReaderInternals.h:208
clang::HeaderFileInfo
The preprocessor keeps track of this information for each file that is #included.
Definition: HeaderSearch.h:53
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::serialization::reader::ASTDeclContextNameLookupTrait
Class that performs name lookup into a DeclContext stored in an AST file.
Definition: ASTReaderInternals.h:44
clang::serialization::reader::ASTSelectorLookupTrait::external_key_type
Selector external_key_type
Definition: ASTReaderInternals.h:206
clang::serialization::reader::ASTSelectorLookupTrait::ReadData
data_type ReadData(Selector, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:880
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:342
clang::serialization::reader::HeaderFileInfoTrait::ReadData
data_type ReadData(internal_key_ref, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:1879
clang::serialization::reader::HeaderFileInfoTrait
Trait class used to search the on-disk hash table containing all of the header search information.
Definition: ASTReaderInternals.h:244
DeclarationName.h
clang::serialization::reader::ASTSelectorLookupTable
llvm::OnDiskChainedHashTable< ASTSelectorLookupTrait > ASTSelectorLookupTable
The on-disk hash table used for the global method pool.
Definition: ASTReaderInternals.h:233
clang::serialization::reader::ASTDeclContextNameLookupTrait::ReadKey
internal_key_type ReadKey(const unsigned char *d, unsigned)
Definition: ASTReader.cpp:1112
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang::serialization::reader::DeclContextLookupTable
Definition: ASTReaderInternals.h:119
clang
Definition: CalledOnceCheck.h:17
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:748
clang::serialization::reader::HeaderFileInfoTrait::EqualKey
bool EqualKey(internal_key_ref a, internal_key_ref b)
Definition: ASTReader.cpp:1833
clang::serialization::reader::ASTSelectorLookupTrait::ReadKey
internal_key_type ReadKey(const unsigned char *d, unsigned)
Definition: ASTReader.cpp:858
unsigned
clang::serialization::reader::ASTDeclContextNameLookupTrait::EqualKey
static bool EqualKey(const internal_key_type &a, const internal_key_type &b)
Definition: ASTReaderInternals.h:90
clang::serialization::reader::HeaderFileInfoTrait::internal_key_type::Size
off_t Size
Definition: ASTReaderInternals.h:254
clang::serialization::reader::ASTDeclContextNameLookupTrait::ASTDeclContextNameLookupTrait
ASTDeclContextNameLookupTrait(ASTReader &Reader, ModuleFile &F)
Definition: ASTReaderInternals.h:87
clang::serialization::reader::DeclContextLookupTable::Table
MultiOnDiskHashTable< ASTDeclContextNameLookupTrait > Table
Definition: ASTReaderInternals.h:120
clang::serialization::reader::HeaderFileInfoTrait::GetInternalKey
internal_key_type GetInternalKey(const FileEntry *FE)
Definition: ASTReader.cpp:1826
clang::serialization::reader::ASTIdentifierLookupTraitBase::internal_key_type
StringRef internal_key_type
Definition: ASTReaderInternals.h:134
clang::serialization::DeclID
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
clang::serialization::reader::ASTIdentifierLookupTrait::ReadIdentifierID
IdentID ReadIdentifierID(const unsigned char *d)
Definition: ASTReader.cpp:945
clang::serialization::reader::ASTSelectorLookupTrait::data_type::FactoryHasMoreThanOneDecl
bool FactoryHasMoreThanOneDecl
Definition: ASTReaderInternals.h:201
clang::serialization::reader::ASTSelectorLookupTrait::data_type::Instance
SmallVector< ObjCMethodDecl *, 2 > Instance
Definition: ASTReaderInternals.h:202
clang::serialization::SelectorID
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
Definition: ASTBitCodes.h:153
clang::serialization::reader::ASTDeclContextNameLookupTrait::internal_key_type
DeclarationNameKey internal_key_type
Definition: ASTReaderInternals.h:85
clang::serialization::reader::ASTDeclContextNameLookupTrait::data_type_builder::insert
void insert(DeclID ID)
Definition: ASTReaderInternals.h:61
clang::serialization::reader::ASTDeclContextNameLookupTrait::data_type_builder
Definition: ASTReaderInternals.h:55
clang::serialization::ModuleFile
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:111
clang::serialization::reader::ASTIdentifierLookupTraitBase::ReadKeyDataLength
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:919
clang::serialization::DeclarationNameKey::getHash
unsigned getHash() const
Compute a fingerprint of this key for use in on-disk hash table.
Definition: ASTReader.cpp:1070
clang::serialization::reader::ASTIdentifierLookupTraitBase::EqualKey
static bool EqualKey(const internal_key_type &a, const internal_key_type &b)
Definition: ASTReaderInternals.h:138