Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/lib/Serialization/ASTReaderInternals.h
Line
Count
Source (jump to first uncovered line)
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"
17
#include "clang/AST/DeclarationName.h"
18
#include "clang/Basic/LLVM.h"
19
#include "clang/Serialization/ASTBitCodes.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.
44
class ASTDeclContextNameLookupTrait {
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.
53
  using data_type = SmallVector<DeclID, 4>;
54
55
  struct data_type_builder {
56
    data_type &Data;
57
    llvm::DenseSet<DeclID> Found;
58
59
33.8k
    data_type_builder(data_type &D) : Data(D) {}
60
61
37.8k
    void insert(DeclID ID) {
62
37.8k
      // Just use a linear scan unless we have more than a few IDs.
63
37.8k
      if (Found.empty() && 
!Data.empty()22.8k
) {
64
1.93k
        if (Data.size() <= 4) {
65
1.39k
          for (auto I : Found)
66
0
            if (I == ID)
67
0
              return;
68
1.39k
          Data.push_back(ID);
69
1.39k
          return;
70
544
        }
71
544
72
544
        // Switch to tracking found IDs in the set.
73
544
        Found.insert(Data.begin(), Data.end());
74
544
      }
75
37.8k
76
37.8k
      
if (36.4k
Found.insert(ID).second36.4k
)
77
30.1k
        Data.push_back(ID);
78
36.4k
    }
79
  };
80
  using hash_value_type = unsigned;
81
  using offset_type = unsigned;
82
  using file_type = ModuleFile *;
83
84
  using external_key_type = DeclarationName;
85
  using internal_key_type = DeclarationNameKey;
86
87
  explicit ASTDeclContextNameLookupTrait(ASTReader &Reader, ModuleFile &F)
88
12.9k
      : Reader(Reader), F(F) {}
89
90
22.8k
  static bool EqualKey(const internal_key_type &a, const internal_key_type &b) {
91
22.8k
    return a == b;
92
22.8k
  }
93
94
31.4k
  static hash_value_type ComputeHash(const internal_key_type &Key) {
95
31.4k
    return Key.getHash();
96
31.4k
  }
97
98
31.4k
  static internal_key_type GetInternalKey(const external_key_type &Name) {
99
31.4k
    return Name;
100
31.4k
  }
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
0
  static void MergeDataInto(const data_type &From, data_type_builder &To) {
111
0
    To.Data.reserve(To.Data.size() + From.size());
112
0
    for (DeclID ID : From)
113
0
      To.insert(ID);
114
0
  }
115
116
  file_type ReadFileRef(const unsigned char *&d);
117
};
118
119
struct DeclContextLookupTable {
120
  MultiOnDiskHashTable<ASTDeclContextNameLookupTrait> Table;
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.
131
class ASTIdentifierLookupTraitBase {
132
public:
133
  using external_key_type = StringRef;
134
  using internal_key_type = StringRef;
135
  using hash_value_type = unsigned;
136
  using offset_type = unsigned;
137
138
442k
  static bool EqualKey(const internal_key_type& a, const internal_key_type& b) {
139
442k
    return a == b;
140
442k
  }
141
142
  static hash_value_type ComputeHash(const internal_key_type& a);
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
0
  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
195k
  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.
159
class ASTIdentifierLookupTrait : public ASTIdentifierLookupTraitBase {
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:
169
  using data_type = IdentifierInfo *;
170
171
  ASTIdentifierLookupTrait(ASTReader &Reader, ModuleFile &F,
172
                           IdentifierInfo *II = nullptr)
173
1.43M
      : Reader(Reader), F(F), KnownII(II) {}
174
175
  data_type ReadData(const internal_key_type& k,
176
                     const unsigned char* d,
177
                     unsigned DataLen);
178
179
  IdentID ReadIdentifierID(const unsigned char *d);
180
181
1.42M
  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.
186
using ASTIdentifierLookupTable =
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.
191
class ASTSelectorLookupTrait {
192
  ASTReader &Reader;
193
  ModuleFile &F;
194
195
public:
196
  struct data_type {
197
    SelectorID ID;
198
    unsigned InstanceBits;
199
    unsigned FactoryBits;
200
    bool InstanceHasMoreThanOneDecl;
201
    bool FactoryHasMoreThanOneDecl;
202
    SmallVector<ObjCMethodDecl *, 2> Instance;
203
    SmallVector<ObjCMethodDecl *, 2> Factory;
204
  };
205
206
  using external_key_type = Selector;
207
  using internal_key_type = external_key_type;
208
  using hash_value_type = unsigned;
209
  using offset_type = unsigned;
210
211
  ASTSelectorLookupTrait(ASTReader &Reader, ModuleFile &F)
212
631
      : Reader(Reader), F(F) {}
213
214
  static bool EqualKey(const internal_key_type& a,
215
81
                       const internal_key_type& b) {
216
81
    return a == b;
217
81
  }
218
219
  static hash_value_type ComputeHash(Selector Sel);
220
221
  static const internal_key_type&
222
219
  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.
232
using ASTSelectorLookupTable =
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.
244
class HeaderFileInfoTrait {
245
  ASTReader &Reader;
246
  ModuleFile &M;
247
  HeaderSearch *HS;
248
  const char *FrameworkStrings;
249
250
public:
251
  using external_key_type = const FileEntry *;
252
253
  struct internal_key_type {
254
    off_t Size;
255
    time_t ModTime;
256
    StringRef Filename;
257
    bool Imported;
258
  };
259
260
  using internal_key_ref = const internal_key_type &;
261
262
  using data_type = HeaderFileInfo;
263
  using hash_value_type = unsigned;
264
  using offset_type = unsigned;
265
266
  HeaderFileInfoTrait(ASTReader &Reader, ModuleFile &M, HeaderSearch *HS,
267
                      const char *FrameworkStrings)
268
6.13k
      : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings) {}
269
270
  static hash_value_type ComputeHash(internal_key_ref ikey);
271
  internal_key_type GetInternalKey(const FileEntry *FE);
272
  bool EqualKey(internal_key_ref a, internal_key_ref b);
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.
283
using HeaderFileInfoLookupTable =
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