Coverage Report

Created: 2021-09-21 08:58

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Serialization/ASTReader.h
Line
Count
Source (jump to first uncovered line)
1
//===- ASTReader.h - AST File Reader ----------------------------*- 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 defines the ASTReader class, which reads AST files.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_SERIALIZATION_ASTREADER_H
14
#define LLVM_CLANG_SERIALIZATION_ASTREADER_H
15
16
#include "clang/AST/Type.h"
17
#include "clang/Basic/Diagnostic.h"
18
#include "clang/Basic/DiagnosticOptions.h"
19
#include "clang/Basic/IdentifierTable.h"
20
#include "clang/Basic/OpenCLOptions.h"
21
#include "clang/Basic/SourceLocation.h"
22
#include "clang/Basic/Version.h"
23
#include "clang/Lex/ExternalPreprocessorSource.h"
24
#include "clang/Lex/HeaderSearch.h"
25
#include "clang/Lex/PreprocessingRecord.h"
26
#include "clang/Lex/PreprocessorOptions.h"
27
#include "clang/Sema/ExternalSemaSource.h"
28
#include "clang/Sema/IdentifierResolver.h"
29
#include "clang/Sema/Sema.h"
30
#include "clang/Serialization/ASTBitCodes.h"
31
#include "clang/Serialization/ContinuousRangeMap.h"
32
#include "clang/Serialization/ModuleFile.h"
33
#include "clang/Serialization/ModuleFileExtension.h"
34
#include "clang/Serialization/ModuleManager.h"
35
#include "llvm/ADT/ArrayRef.h"
36
#include "llvm/ADT/DenseMap.h"
37
#include "llvm/ADT/DenseSet.h"
38
#include "llvm/ADT/IntrusiveRefCntPtr.h"
39
#include "llvm/ADT/MapVector.h"
40
#include "llvm/ADT/Optional.h"
41
#include "llvm/ADT/STLExtras.h"
42
#include "llvm/ADT/SetVector.h"
43
#include "llvm/ADT/SmallPtrSet.h"
44
#include "llvm/ADT/SmallVector.h"
45
#include "llvm/ADT/StringMap.h"
46
#include "llvm/ADT/StringRef.h"
47
#include "llvm/ADT/iterator.h"
48
#include "llvm/ADT/iterator_range.h"
49
#include "llvm/Bitstream/BitstreamReader.h"
50
#include "llvm/Support/MemoryBuffer.h"
51
#include "llvm/Support/Timer.h"
52
#include "llvm/Support/VersionTuple.h"
53
#include <cassert>
54
#include <cstddef>
55
#include <cstdint>
56
#include <ctime>
57
#include <deque>
58
#include <memory>
59
#include <set>
60
#include <string>
61
#include <utility>
62
#include <vector>
63
64
namespace clang {
65
66
class ASTConsumer;
67
class ASTContext;
68
class ASTDeserializationListener;
69
class ASTReader;
70
class ASTRecordReader;
71
class CXXTemporary;
72
class Decl;
73
class DeclarationName;
74
class DeclaratorDecl;
75
class DeclContext;
76
class EnumDecl;
77
class Expr;
78
class FieldDecl;
79
class FileEntry;
80
class FileManager;
81
class FileSystemOptions;
82
class FunctionDecl;
83
class GlobalModuleIndex;
84
struct HeaderFileInfo;
85
class HeaderSearchOptions;
86
class LangOptions;
87
class LazyASTUnresolvedSet;
88
class MacroInfo;
89
class InMemoryModuleCache;
90
class NamedDecl;
91
class NamespaceDecl;
92
class ObjCCategoryDecl;
93
class ObjCInterfaceDecl;
94
class PCHContainerReader;
95
class Preprocessor;
96
class PreprocessorOptions;
97
struct QualifierInfo;
98
class Sema;
99
class SourceManager;
100
class Stmt;
101
class SwitchCase;
102
class TargetOptions;
103
class Token;
104
class TypedefNameDecl;
105
class ValueDecl;
106
class VarDecl;
107
108
/// Abstract interface for callback invocations by the ASTReader.
109
///
110
/// While reading an AST file, the ASTReader will call the methods of the
111
/// listener to pass on specific information. Some of the listener methods can
112
/// return true to indicate to the ASTReader that the information (and
113
/// consequently the AST file) is invalid.
114
class ASTReaderListener {
115
public:
116
  virtual ~ASTReaderListener();
117
118
  /// Receives the full Clang version information.
119
  ///
120
  /// \returns true to indicate that the version is invalid. Subclasses should
121
  /// generally defer to this implementation.
122
31
  virtual bool ReadFullVersionInformation(StringRef FullVersion) {
123
31
    return FullVersion != getClangFullRepositoryVersion();
124
31
  }
125
126
17.9k
  virtual void ReadModuleName(StringRef ModuleName) {}
127
18.9k
  virtual void ReadModuleMapFile(StringRef ModuleMapPath) {}
128
129
  /// Receives the language options.
130
  ///
131
  /// \returns true to indicate the options are invalid or false otherwise.
132
  virtual bool ReadLanguageOptions(const LangOptions &LangOpts,
133
                                   bool Complain,
134
1.63k
                                   bool AllowCompatibleDifferences) {
135
1.63k
    return false;
136
1.63k
  }
137
138
  /// Receives the target options.
139
  ///
140
  /// \returns true to indicate the target options are invalid, or false
141
  /// otherwise.
142
  virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
143
1.63k
                                 bool AllowCompatibleDifferences) {
144
1.63k
    return false;
145
1.63k
  }
146
147
  /// Receives the diagnostic options.
148
  ///
149
  /// \returns true to indicate the diagnostic options are invalid, or false
150
  /// otherwise.
151
  virtual bool
152
  ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
153
1.35k
                        bool Complain) {
154
1.35k
    return false;
155
1.35k
  }
156
157
  /// Receives the file system options.
158
  ///
159
  /// \returns true to indicate the file system options are invalid, or false
160
  /// otherwise.
161
  virtual bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,
162
8.52k
                                     bool Complain) {
163
8.52k
    return false;
164
8.52k
  }
165
166
  /// Receives the header search options.
167
  ///
168
  /// \returns true to indicate the header search options are invalid, or false
169
  /// otherwise.
170
  virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
171
                                       StringRef SpecificModuleCachePath,
172
1.20k
                                       bool Complain) {
173
1.20k
    return false;
174
1.20k
  }
175
176
  /// Receives the preprocessor options.
177
  ///
178
  /// \param SuggestedPredefines Can be filled in with the set of predefines
179
  /// that are suggested by the preprocessor options. Typically only used when
180
  /// loading a precompiled header.
181
  ///
182
  /// \returns true to indicate the preprocessor options are invalid, or false
183
  /// otherwise.
184
  virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
185
                                       bool Complain,
186
804
                                       std::string &SuggestedPredefines) {
187
804
    return false;
188
804
  }
189
190
  /// Receives __COUNTER__ value.
191
  virtual void ReadCounter(const serialization::ModuleFile &M,
192
1
                           unsigned Value) {}
193
194
  /// This is called for each AST file loaded.
195
  virtual void visitModuleFile(StringRef Filename,
196
19.1k
                               serialization::ModuleKind Kind) {}
197
198
  /// Returns true if this \c ASTReaderListener wants to receive the
199
  /// input files of the AST file via \c visitInputFile, false otherwise.
200
501k
  virtual bool needsInputFileVisitation() { return false; }
201
202
  /// Returns true if this \c ASTReaderListener wants to receive the
203
  /// system input files of the AST file via \c visitInputFile, false otherwise.
204
31
  virtual bool needsSystemInputFileVisitation() { return false; }
205
206
  /// if \c needsInputFileVisitation returns true, this is called for
207
  /// each non-system input file of the AST File. If
208
  /// \c needsSystemInputFileVisitation is true, then it is called for all
209
  /// system input files as well.
210
  ///
211
  /// \returns true to continue receiving the next input file, false to stop.
212
  virtual bool visitInputFile(StringRef Filename, bool isSystem,
213
0
                              bool isOverridden, bool isExplicitModule) {
214
0
    return true;
215
0
  }
216
217
  /// Returns true if this \c ASTReaderListener wants to receive the
218
  /// imports of the AST file via \c visitImport, false otherwise.
219
12
  virtual bool needsImportVisitation() const { return false; }
220
221
  /// If needsImportVisitation returns \c true, this is called for each
222
  /// AST file imported by this AST file.
223
0
  virtual void visitImport(StringRef ModuleName, StringRef Filename) {}
224
225
  /// Indicates that a particular module file extension has been read.
226
  virtual void readModuleFileExtension(
227
0
                 const ModuleFileExtensionMetadata &Metadata) {}
228
};
229
230
/// Simple wrapper class for chaining listeners.
231
class ChainedASTReaderListener : public ASTReaderListener {
232
  std::unique_ptr<ASTReaderListener> First;
233
  std::unique_ptr<ASTReaderListener> Second;
234
235
public:
236
  /// Takes ownership of \p First and \p Second.
237
  ChainedASTReaderListener(std::unique_ptr<ASTReaderListener> First,
238
                           std::unique_ptr<ASTReaderListener> Second)
239
1.37k
      : First(std::move(First)), Second(std::move(Second)) {}
240
241
0
  std::unique_ptr<ASTReaderListener> takeFirst() { return std::move(First); }
242
430
  std::unique_ptr<ASTReaderListener> takeSecond() { return std::move(Second); }
243
244
  bool ReadFullVersionInformation(StringRef FullVersion) override;
245
  void ReadModuleName(StringRef ModuleName) override;
246
  void ReadModuleMapFile(StringRef ModuleMapPath) override;
247
  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
248
                           bool AllowCompatibleDifferences) override;
249
  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
250
                         bool AllowCompatibleDifferences) override;
251
  bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
252
                             bool Complain) override;
253
  bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,
254
                             bool Complain) override;
255
256
  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
257
                               StringRef SpecificModuleCachePath,
258
                               bool Complain) override;
259
  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
260
                               bool Complain,
261
                               std::string &SuggestedPredefines) override;
262
263
  void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override;
264
  bool needsInputFileVisitation() override;
265
  bool needsSystemInputFileVisitation() override;
266
  void visitModuleFile(StringRef Filename,
267
                       serialization::ModuleKind Kind) override;
268
  bool visitInputFile(StringRef Filename, bool isSystem,
269
                      bool isOverridden, bool isExplicitModule) override;
270
  void readModuleFileExtension(
271
         const ModuleFileExtensionMetadata &Metadata) override;
272
};
273
274
/// ASTReaderListener implementation to validate the information of
275
/// the PCH file against an initialized Preprocessor.
276
class PCHValidator : public ASTReaderListener {
277
  Preprocessor &PP;
278
  ASTReader &Reader;
279
280
public:
281
  PCHValidator(Preprocessor &PP, ASTReader &Reader)
282
12.9k
      : PP(PP), Reader(Reader) {}
283
284
  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
285
                           bool AllowCompatibleDifferences) override;
286
  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
287
                         bool AllowCompatibleDifferences) override;
288
  bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
289
                             bool Complain) override;
290
  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
291
                               std::string &SuggestedPredefines) override;
292
  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
293
                               StringRef SpecificModuleCachePath,
294
                               bool Complain) override;
295
  void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override;
296
297
private:
298
  void Error(const char *Msg);
299
};
300
301
/// ASTReaderListenter implementation to set SuggestedPredefines of
302
/// ASTReader which is required to use a pch file. This is the replacement
303
/// of PCHValidator or SimplePCHValidator when using a pch file without
304
/// validating it.
305
class SimpleASTReaderListener : public ASTReaderListener {
306
  Preprocessor &PP;
307
308
public:
309
405
  SimpleASTReaderListener(Preprocessor &PP) : PP(PP) {}
310
311
  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
312
                               std::string &SuggestedPredefines) override;
313
};
314
315
namespace serialization {
316
317
class ReadMethodPoolVisitor;
318
319
namespace reader {
320
321
class ASTIdentifierLookupTrait;
322
323
/// The on-disk hash table(s) used for DeclContext name lookup.
324
struct DeclContextLookupTable;
325
326
} // namespace reader
327
328
} // namespace serialization
329
330
/// Reads an AST files chain containing the contents of a translation
331
/// unit.
332
///
333
/// The ASTReader class reads bitstreams (produced by the ASTWriter
334
/// class) containing the serialized representation of a given
335
/// abstract syntax tree and its supporting data structures. An
336
/// instance of the ASTReader can be attached to an ASTContext object,
337
/// which will provide access to the contents of the AST files.
338
///
339
/// The AST reader provides lazy de-serialization of declarations, as
340
/// required when traversing the AST. Only those AST nodes that are
341
/// actually required will be de-serialized.
342
class ASTReader
343
  : public ExternalPreprocessorSource,
344
    public ExternalPreprocessingRecordSource,
345
    public ExternalHeaderFileInfoSource,
346
    public ExternalSemaSource,
347
    public IdentifierInfoLookup,
348
    public ExternalSLocEntrySource
349
{
350
public:
351
  /// Types of AST files.
352
  friend class ASTDeclReader;
353
  friend class ASTIdentifierIterator;
354
  friend class ASTRecordReader;
355
  friend class ASTUnit; // ASTUnit needs to remap source locations.
356
  friend class ASTWriter;
357
  friend class PCHValidator;
358
  friend class serialization::reader::ASTIdentifierLookupTrait;
359
  friend class serialization::ReadMethodPoolVisitor;
360
  friend class TypeLocReader;
361
362
  using RecordData = SmallVector<uint64_t, 64>;
363
  using RecordDataImpl = SmallVectorImpl<uint64_t>;
364
365
  /// The result of reading the control block of an AST file, which
366
  /// can fail for various reasons.
367
  enum ASTReadResult {
368
    /// The control block was read successfully. Aside from failures,
369
    /// the AST file is safe to read into the current context.
370
    Success,
371
372
    /// The AST file itself appears corrupted.
373
    Failure,
374
375
    /// The AST file was missing.
376
    Missing,
377
378
    /// The AST file is out-of-date relative to its input files,
379
    /// and needs to be regenerated.
380
    OutOfDate,
381
382
    /// The AST file was written by a different version of Clang.
383
    VersionMismatch,
384
385
    /// The AST file was writtten with a different language/target
386
    /// configuration.
387
    ConfigurationMismatch,
388
389
    /// The AST file has errors.
390
    HadErrors
391
  };
392
393
  using ModuleFile = serialization::ModuleFile;
394
  using ModuleKind = serialization::ModuleKind;
395
  using ModuleManager = serialization::ModuleManager;
396
  using ModuleIterator = ModuleManager::ModuleIterator;
397
  using ModuleConstIterator = ModuleManager::ModuleConstIterator;
398
  using ModuleReverseIterator = ModuleManager::ModuleReverseIterator;
399
400
private:
401
  /// The receiver of some callbacks invoked by ASTReader.
402
  std::unique_ptr<ASTReaderListener> Listener;
403
404
  /// The receiver of deserialization events.
405
  ASTDeserializationListener *DeserializationListener = nullptr;
406
407
  bool OwnsDeserializationListener = false;
408
409
  SourceManager &SourceMgr;
410
  FileManager &FileMgr;
411
  const PCHContainerReader &PCHContainerRdr;
412
  DiagnosticsEngine &Diags;
413
414
  /// The semantic analysis object that will be processing the
415
  /// AST files and the translation unit that uses it.
416
  Sema *SemaObj = nullptr;
417
418
  /// The preprocessor that will be loading the source file.
419
  Preprocessor &PP;
420
421
  /// The AST context into which we'll read the AST files.
422
  ASTContext *ContextObj = nullptr;
423
424
  /// The AST consumer.
425
  ASTConsumer *Consumer = nullptr;
426
427
  /// The module manager which manages modules and their dependencies
428
  ModuleManager ModuleMgr;
429
430
  /// A dummy identifier resolver used to merge TU-scope declarations in
431
  /// C, for the cases where we don't have a Sema object to provide a real
432
  /// identifier resolver.
433
  IdentifierResolver DummyIdResolver;
434
435
  /// A mapping from extension block names to module file extensions.
436
  llvm::StringMap<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions;
437
438
  /// A timer used to track the time spent deserializing.
439
  std::unique_ptr<llvm::Timer> ReadTimer;
440
441
  /// The location where the module file will be considered as
442
  /// imported from. For non-module AST types it should be invalid.
443
  SourceLocation CurrentImportLoc;
444
445
  /// The module kind that is currently deserializing.
446
  Optional<ModuleKind> CurrentDeserializingModuleKind;
447
448
  /// The global module index, if loaded.
449
  std::unique_ptr<GlobalModuleIndex> GlobalIndex;
450
451
  /// A map of global bit offsets to the module that stores entities
452
  /// at those bit offsets.
453
  ContinuousRangeMap<uint64_t, ModuleFile*, 4> GlobalBitOffsetsMap;
454
455
  /// A map of negated SLocEntryIDs to the modules containing them.
456
  ContinuousRangeMap<unsigned, ModuleFile*, 64> GlobalSLocEntryMap;
457
458
  using GlobalSLocOffsetMapType =
459
      ContinuousRangeMap<unsigned, ModuleFile *, 64>;
460
461
  /// A map of reversed (SourceManager::MaxLoadedOffset - SLocOffset)
462
  /// SourceLocation offsets to the modules containing them.
463
  GlobalSLocOffsetMapType GlobalSLocOffsetMap;
464
465
  /// Types that have already been loaded from the chain.
466
  ///
467
  /// When the pointer at index I is non-NULL, the type with
468
  /// ID = (I + 1) << FastQual::Width has already been loaded
469
  std::vector<QualType> TypesLoaded;
470
471
  using GlobalTypeMapType =
472
      ContinuousRangeMap<serialization::TypeID, ModuleFile *, 4>;
473
474
  /// Mapping from global type IDs to the module in which the
475
  /// type resides along with the offset that should be added to the
476
  /// global type ID to produce a local ID.
477
  GlobalTypeMapType GlobalTypeMap;
478
479
  /// Declarations that have already been loaded from the chain.
480
  ///
481
  /// When the pointer at index I is non-NULL, the declaration with ID
482
  /// = I + 1 has already been loaded.
483
  std::vector<Decl *> DeclsLoaded;
484
485
  using GlobalDeclMapType =
486
      ContinuousRangeMap<serialization::DeclID, ModuleFile *, 4>;
487
488
  /// Mapping from global declaration IDs to the module in which the
489
  /// declaration resides.
490
  GlobalDeclMapType GlobalDeclMap;
491
492
  using FileOffset = std::pair<ModuleFile *, uint64_t>;
493
  using FileOffsetsTy = SmallVector<FileOffset, 2>;
494
  using DeclUpdateOffsetsMap =
495
      llvm::DenseMap<serialization::DeclID, FileOffsetsTy>;
496
497
  /// Declarations that have modifications residing in a later file
498
  /// in the chain.
499
  DeclUpdateOffsetsMap DeclUpdateOffsets;
500
501
  struct PendingUpdateRecord {
502
    Decl *D;
503
    serialization::GlobalDeclID ID;
504
505
    // Whether the declaration was just deserialized.
506
    bool JustLoaded;
507
508
    PendingUpdateRecord(serialization::GlobalDeclID ID, Decl *D,
509
                        bool JustLoaded)
510
7.69M
        : D(D), ID(ID), JustLoaded(JustLoaded) {}
511
  };
512
513
  /// Declaration updates for already-loaded declarations that we need
514
  /// to apply once we finish processing an import.
515
  llvm::SmallVector<PendingUpdateRecord, 16> PendingUpdateRecords;
516
517
  enum class PendingFakeDefinitionKind { NotFake, Fake, FakeLoaded };
518
519
  /// The DefinitionData pointers that we faked up for class definitions
520
  /// that we needed but hadn't loaded yet.
521
  llvm::DenseMap<void *, PendingFakeDefinitionKind> PendingFakeDefinitionData;
522
523
  /// Exception specification updates that have been loaded but not yet
524
  /// propagated across the relevant redeclaration chain. The map key is the
525
  /// canonical declaration (used only for deduplication) and the value is a
526
  /// declaration that has an exception specification.
527
  llvm::SmallMapVector<Decl *, FunctionDecl *, 4> PendingExceptionSpecUpdates;
528
529
  /// Deduced return type updates that have been loaded but not yet propagated
530
  /// across the relevant redeclaration chain. The map key is the canonical
531
  /// declaration and the value is the deduced return type.
532
  llvm::SmallMapVector<FunctionDecl *, QualType, 4> PendingDeducedTypeUpdates;
533
534
  /// Declarations that have been imported and have typedef names for
535
  /// linkage purposes.
536
  llvm::DenseMap<std::pair<DeclContext *, IdentifierInfo *>, NamedDecl *>
537
      ImportedTypedefNamesForLinkage;
538
539
  /// Mergeable declaration contexts that have anonymous declarations
540
  /// within them, and those anonymous declarations.
541
  llvm::DenseMap<Decl*, llvm::SmallVector<NamedDecl*, 2>>
542
    AnonymousDeclarationsForMerging;
543
544
  /// Key used to identify LifetimeExtendedTemporaryDecl for merging,
545
  /// containing the lifetime-extending declaration and the mangling number.
546
  using LETemporaryKey = std::pair<Decl *, unsigned>;
547
548
  /// Map of already deserialiazed temporaries.
549
  llvm::DenseMap<LETemporaryKey, LifetimeExtendedTemporaryDecl *>
550
      LETemporaryForMerging;
551
552
  struct FileDeclsInfo {
553
    ModuleFile *Mod = nullptr;
554
    ArrayRef<serialization::LocalDeclID> Decls;
555
556
536k
    FileDeclsInfo() = default;
557
    FileDeclsInfo(ModuleFile *Mod, ArrayRef<serialization::LocalDeclID> Decls)
558
536k
        : Mod(Mod), Decls(Decls) {}
559
  };
560
561
  /// Map from a FileID to the file-level declarations that it contains.
562
  llvm::DenseMap<FileID, FileDeclsInfo> FileDeclIDs;
563
564
  /// An array of lexical contents of a declaration context, as a sequence of
565
  /// Decl::Kind, DeclID pairs.
566
  using LexicalContents = ArrayRef<llvm::support::unaligned_uint32_t>;
567
568
  /// Map from a DeclContext to its lexical contents.
569
  llvm::DenseMap<const DeclContext*, std::pair<ModuleFile*, LexicalContents>>
570
      LexicalDecls;
571
572
  /// Map from the TU to its lexical contents from each module file.
573
  std::vector<std::pair<ModuleFile*, LexicalContents>> TULexicalDecls;
574
575
  /// Map from a DeclContext to its lookup tables.
576
  llvm::DenseMap<const DeclContext *,
577
                 serialization::reader::DeclContextLookupTable> Lookups;
578
579
  // Updates for visible decls can occur for other contexts than just the
580
  // TU, and when we read those update records, the actual context may not
581
  // be available yet, so have this pending map using the ID as a key. It
582
  // will be realized when the context is actually loaded.
583
  struct PendingVisibleUpdate {
584
    ModuleFile *Mod;
585
    const unsigned char *Data;
586
  };
587
  using DeclContextVisibleUpdates = SmallVector<PendingVisibleUpdate, 1>;
588
589
  /// Updates to the visible declarations of declaration contexts that
590
  /// haven't been loaded yet.
591
  llvm::DenseMap<serialization::DeclID, DeclContextVisibleUpdates>
592
      PendingVisibleUpdates;
593
594
  /// The set of C++ or Objective-C classes that have forward
595
  /// declarations that have not yet been linked to their definitions.
596
  llvm::SmallPtrSet<Decl *, 4> PendingDefinitions;
597
598
  using PendingBodiesMap =
599
      llvm::MapVector<Decl *, uint64_t,
600
                      llvm::SmallDenseMap<Decl *, unsigned, 4>,
601
                      SmallVector<std::pair<Decl *, uint64_t>, 4>>;
602
603
  /// Functions or methods that have bodies that will be attached.
604
  PendingBodiesMap PendingBodies;
605
606
  /// Definitions for which we have added merged definitions but not yet
607
  /// performed deduplication.
608
  llvm::SetVector<NamedDecl *> PendingMergedDefinitionsToDeduplicate;
609
610
  /// Read the record that describes the lexical contents of a DC.
611
  bool ReadLexicalDeclContextStorage(ModuleFile &M,
612
                                     llvm::BitstreamCursor &Cursor,
613
                                     uint64_t Offset, DeclContext *DC);
614
615
  /// Read the record that describes the visible contents of a DC.
616
  bool ReadVisibleDeclContextStorage(ModuleFile &M,
617
                                     llvm::BitstreamCursor &Cursor,
618
                                     uint64_t Offset, serialization::DeclID ID);
619
620
  /// A vector containing identifiers that have already been
621
  /// loaded.
622
  ///
623
  /// If the pointer at index I is non-NULL, then it refers to the
624
  /// IdentifierInfo for the identifier with ID=I+1 that has already
625
  /// been loaded.
626
  std::vector<IdentifierInfo *> IdentifiersLoaded;
627
628
  using GlobalIdentifierMapType =
629
      ContinuousRangeMap<serialization::IdentID, ModuleFile *, 4>;
630
631
  /// Mapping from global identifier IDs to the module in which the
632
  /// identifier resides along with the offset that should be added to the
633
  /// global identifier ID to produce a local ID.
634
  GlobalIdentifierMapType GlobalIdentifierMap;
635
636
  /// A vector containing macros that have already been
637
  /// loaded.
638
  ///
639
  /// If the pointer at index I is non-NULL, then it refers to the
640
  /// MacroInfo for the identifier with ID=I+1 that has already
641
  /// been loaded.
642
  std::vector<MacroInfo *> MacrosLoaded;
643
644
  using LoadedMacroInfo =
645
      std::pair<IdentifierInfo *, serialization::SubmoduleID>;
646
647
  /// A set of #undef directives that we have loaded; used to
648
  /// deduplicate the same #undef information coming from multiple module
649
  /// files.
650
  llvm::DenseSet<LoadedMacroInfo> LoadedUndefs;
651
652
  using GlobalMacroMapType =
653
      ContinuousRangeMap<serialization::MacroID, ModuleFile *, 4>;
654
655
  /// Mapping from global macro IDs to the module in which the
656
  /// macro resides along with the offset that should be added to the
657
  /// global macro ID to produce a local ID.
658
  GlobalMacroMapType GlobalMacroMap;
659
660
  /// A vector containing submodules that have already been loaded.
661
  ///
662
  /// This vector is indexed by the Submodule ID (-1). NULL submodule entries
663
  /// indicate that the particular submodule ID has not yet been loaded.
664
  SmallVector<Module *, 2> SubmodulesLoaded;
665
666
  using GlobalSubmoduleMapType =
667
      ContinuousRangeMap<serialization::SubmoduleID, ModuleFile *, 4>;
668
669
  /// Mapping from global submodule IDs to the module file in which the
670
  /// submodule resides along with the offset that should be added to the
671
  /// global submodule ID to produce a local ID.
672
  GlobalSubmoduleMapType GlobalSubmoduleMap;
673
674
  /// A set of hidden declarations.
675
  using HiddenNames = SmallVector<Decl *, 2>;
676
  using HiddenNamesMapType = llvm::DenseMap<Module *, HiddenNames>;
677
678
  /// A mapping from each of the hidden submodules to the deserialized
679
  /// declarations in that submodule that could be made visible.
680
  HiddenNamesMapType HiddenNamesMap;
681
682
  /// A module import, export, or conflict that hasn't yet been resolved.
683
  struct UnresolvedModuleRef {
684
    /// The file in which this module resides.
685
    ModuleFile *File;
686
687
    /// The module that is importing or exporting.
688
    Module *Mod;
689
690
    /// The kind of module reference.
691
    enum { Import, Export, Conflict } Kind;
692
693
    /// The local ID of the module that is being exported.
694
    unsigned ID;
695
696
    /// Whether this is a wildcard export.
697
    unsigned IsWildcard : 1;
698
699
    /// String data.
700
    StringRef String;
701
  };
702
703
  /// The set of module imports and exports that still need to be
704
  /// resolved.
705
  SmallVector<UnresolvedModuleRef, 2> UnresolvedModuleRefs;
706
707
  /// A vector containing selectors that have already been loaded.
708
  ///
709
  /// This vector is indexed by the Selector ID (-1). NULL selector
710
  /// entries indicate that the particular selector ID has not yet
711
  /// been loaded.
712
  SmallVector<Selector, 16> SelectorsLoaded;
713
714
  using GlobalSelectorMapType =
715
      ContinuousRangeMap<serialization::SelectorID, ModuleFile *, 4>;
716
717
  /// Mapping from global selector IDs to the module in which the
718
  /// global selector ID to produce a local ID.
719
  GlobalSelectorMapType GlobalSelectorMap;
720
721
  /// The generation number of the last time we loaded data from the
722
  /// global method pool for this selector.
723
  llvm::DenseMap<Selector, unsigned> SelectorGeneration;
724
725
  /// Whether a selector is out of date. We mark a selector as out of date
726
  /// if we load another module after the method pool entry was pulled in.
727
  llvm::DenseMap<Selector, bool> SelectorOutOfDate;
728
729
  struct PendingMacroInfo {
730
    ModuleFile *M;
731
    /// Offset relative to ModuleFile::MacroOffsetsBase.
732
    uint32_t MacroDirectivesOffset;
733
734
    PendingMacroInfo(ModuleFile *M, uint32_t MacroDirectivesOffset)
735
1.71M
        : M(M), MacroDirectivesOffset(MacroDirectivesOffset) {}
736
  };
737
738
  using PendingMacroIDsMap =
739
      llvm::MapVector<IdentifierInfo *, SmallVector<PendingMacroInfo, 2>>;
740
741
  /// Mapping from identifiers that have a macro history to the global
742
  /// IDs have not yet been deserialized to the global IDs of those macros.
743
  PendingMacroIDsMap PendingMacroIDs;
744
745
  using GlobalPreprocessedEntityMapType =
746
      ContinuousRangeMap<unsigned, ModuleFile *, 4>;
747
748
  /// Mapping from global preprocessing entity IDs to the module in
749
  /// which the preprocessed entity resides along with the offset that should be
750
  /// added to the global preprocessing entity ID to produce a local ID.
751
  GlobalPreprocessedEntityMapType GlobalPreprocessedEntityMap;
752
753
  using GlobalSkippedRangeMapType =
754
      ContinuousRangeMap<unsigned, ModuleFile *, 4>;
755
756
  /// Mapping from global skipped range base IDs to the module in which
757
  /// the skipped ranges reside.
758
  GlobalSkippedRangeMapType GlobalSkippedRangeMap;
759
760
  /// \name CodeGen-relevant special data
761
  /// Fields containing data that is relevant to CodeGen.
762
  //@{
763
764
  /// The IDs of all declarations that fulfill the criteria of
765
  /// "interesting" decls.
766
  ///
767
  /// This contains the data loaded from all EAGERLY_DESERIALIZED_DECLS blocks
768
  /// in the chain. The referenced declarations are deserialized and passed to
769
  /// the consumer eagerly.
770
  SmallVector<serialization::DeclID, 16> EagerlyDeserializedDecls;
771
772
  /// The IDs of all tentative definitions stored in the chain.
773
  ///
774
  /// Sema keeps track of all tentative definitions in a TU because it has to
775
  /// complete them and pass them on to CodeGen. Thus, tentative definitions in
776
  /// the PCH chain must be eagerly deserialized.
777
  SmallVector<serialization::DeclID, 16> TentativeDefinitions;
778
779
  /// The IDs of all CXXRecordDecls stored in the chain whose VTables are
780
  /// used.
781
  ///
782
  /// CodeGen has to emit VTables for these records, so they have to be eagerly
783
  /// deserialized.
784
  SmallVector<serialization::DeclID, 64> VTableUses;
785
786
  /// A snapshot of the pending instantiations in the chain.
787
  ///
788
  /// This record tracks the instantiations that Sema has to perform at the
789
  /// end of the TU. It consists of a pair of values for every pending
790
  /// instantiation where the first value is the ID of the decl and the second
791
  /// is the instantiation location.
792
  SmallVector<serialization::DeclID, 64> PendingInstantiations;
793
794
  //@}
795
796
  /// \name DiagnosticsEngine-relevant special data
797
  /// Fields containing data that is used for generating diagnostics
798
  //@{
799
800
  /// A snapshot of Sema's unused file-scoped variable tracking, for
801
  /// generating warnings.
802
  SmallVector<serialization::DeclID, 16> UnusedFileScopedDecls;
803
804
  /// A list of all the delegating constructors we've seen, to diagnose
805
  /// cycles.
806
  SmallVector<serialization::DeclID, 4> DelegatingCtorDecls;
807
808
  /// Method selectors used in a @selector expression. Used for
809
  /// implementation of -Wselector.
810
  SmallVector<serialization::SelectorID, 64> ReferencedSelectorsData;
811
812
  /// A snapshot of Sema's weak undeclared identifier tracking, for
813
  /// generating warnings.
814
  SmallVector<serialization::IdentifierID, 64> WeakUndeclaredIdentifiers;
815
816
  /// The IDs of type aliases for ext_vectors that exist in the chain.
817
  ///
818
  /// Used by Sema for finding sugared names for ext_vectors in diagnostics.
819
  SmallVector<serialization::DeclID, 4> ExtVectorDecls;
820
821
  //@}
822
823
  /// \name Sema-relevant special data
824
  /// Fields containing data that is used for semantic analysis
825
  //@{
826
827
  /// The IDs of all potentially unused typedef names in the chain.
828
  ///
829
  /// Sema tracks these to emit warnings.
830
  SmallVector<serialization::DeclID, 16> UnusedLocalTypedefNameCandidates;
831
832
  /// Our current depth in #pragma cuda force_host_device begin/end
833
  /// macros.
834
  unsigned ForceCUDAHostDeviceDepth = 0;
835
836
  /// The IDs of the declarations Sema stores directly.
837
  ///
838
  /// Sema tracks a few important decls, such as namespace std, directly.
839
  SmallVector<serialization::DeclID, 4> SemaDeclRefs;
840
841
  /// The IDs of the types ASTContext stores directly.
842
  ///
843
  /// The AST context tracks a few important types, such as va_list, directly.
844
  SmallVector<serialization::TypeID, 16> SpecialTypes;
845
846
  /// The IDs of CUDA-specific declarations ASTContext stores directly.
847
  ///
848
  /// The AST context tracks a few important decls, currently cudaConfigureCall,
849
  /// directly.
850
  SmallVector<serialization::DeclID, 2> CUDASpecialDeclRefs;
851
852
  /// The floating point pragma option settings.
853
  SmallVector<uint64_t, 1> FPPragmaOptions;
854
855
  /// The pragma clang optimize location (if the pragma state is "off").
856
  SourceLocation OptimizeOffPragmaLocation;
857
858
  /// The PragmaMSStructKind pragma ms_struct state if set, or -1.
859
  int PragmaMSStructState = -1;
860
861
  /// The PragmaMSPointersToMembersKind pragma pointers_to_members state.
862
  int PragmaMSPointersToMembersState = -1;
863
  SourceLocation PointersToMembersPragmaLocation;
864
865
  /// The pragma float_control state.
866
  Optional<FPOptionsOverride> FpPragmaCurrentValue;
867
  SourceLocation FpPragmaCurrentLocation;
868
  struct FpPragmaStackEntry {
869
    FPOptionsOverride Value;
870
    SourceLocation Location;
871
    SourceLocation PushLocation;
872
    StringRef SlotLabel;
873
  };
874
  llvm::SmallVector<FpPragmaStackEntry, 2> FpPragmaStack;
875
  llvm::SmallVector<std::string, 2> FpPragmaStrings;
876
877
  /// The pragma align/pack state.
878
  Optional<Sema::AlignPackInfo> PragmaAlignPackCurrentValue;
879
  SourceLocation PragmaAlignPackCurrentLocation;
880
  struct PragmaAlignPackStackEntry {
881
    Sema::AlignPackInfo Value;
882
    SourceLocation Location;
883
    SourceLocation PushLocation;
884
    StringRef SlotLabel;
885
  };
886
  llvm::SmallVector<PragmaAlignPackStackEntry, 2> PragmaAlignPackStack;
887
  llvm::SmallVector<std::string, 2> PragmaAlignPackStrings;
888
889
  /// The OpenCL extension settings.
890
  OpenCLOptions OpenCLExtensions;
891
892
  /// Extensions required by an OpenCL type.
893
  llvm::DenseMap<const Type *, std::set<std::string>> OpenCLTypeExtMap;
894
895
  /// Extensions required by an OpenCL declaration.
896
  llvm::DenseMap<const Decl *, std::set<std::string>> OpenCLDeclExtMap;
897
898
  /// A list of the namespaces we've seen.
899
  SmallVector<serialization::DeclID, 4> KnownNamespaces;
900
901
  /// A list of undefined decls with internal linkage followed by the
902
  /// SourceLocation of a matching ODR-use.
903
  SmallVector<serialization::DeclID, 8> UndefinedButUsed;
904
905
  /// Delete expressions to analyze at the end of translation unit.
906
  SmallVector<uint64_t, 8> DelayedDeleteExprs;
907
908
  // A list of late parsed template function data with their module files.
909
  SmallVector<std::pair<ModuleFile *, SmallVector<uint64_t, 1>>, 4>
910
      LateParsedTemplates;
911
912
  /// The IDs of all decls to be checked for deferred diags.
913
  ///
914
  /// Sema tracks these to emit deferred diags.
915
  llvm::SmallSetVector<serialization::DeclID, 4> DeclsToCheckForDeferredDiags;
916
917
public:
918
  struct ImportedSubmodule {
919
    serialization::SubmoduleID ID;
920
    SourceLocation ImportLoc;
921
922
    ImportedSubmodule(serialization::SubmoduleID ID, SourceLocation ImportLoc)
923
76
        : ID(ID), ImportLoc(ImportLoc) {}
924
  };
925
926
private:
927
  /// A list of modules that were imported by precompiled headers or
928
  /// any other non-module AST file.
929
  SmallVector<ImportedSubmodule, 2> ImportedModules;
930
  //@}
931
932
  /// The system include root to be used when loading the
933
  /// precompiled header.
934
  std::string isysroot;
935
936
  /// Whether to disable the normal validation performed on precompiled
937
  /// headers and module files when they are loaded.
938
  DisableValidationForModuleKind DisableValidationKind;
939
940
  /// Whether to accept an AST file with compiler errors.
941
  bool AllowASTWithCompilerErrors;
942
943
  /// Whether to accept an AST file that has a different configuration
944
  /// from the current compiler instance.
945
  bool AllowConfigurationMismatch;
946
947
  /// Whether validate system input files.
948
  bool ValidateSystemInputs;
949
950
  /// Whether validate headers and module maps using hash based on contents.
951
  bool ValidateASTInputFilesContent;
952
953
  /// Whether we are allowed to use the global module index.
954
  bool UseGlobalIndex;
955
956
  /// Whether we have tried loading the global module index yet.
957
  bool TriedLoadingGlobalIndex = false;
958
959
  ///Whether we are currently processing update records.
960
  bool ProcessingUpdateRecords = false;
961
962
  using SwitchCaseMapTy = llvm::DenseMap<unsigned, SwitchCase *>;
963
964
  /// Mapping from switch-case IDs in the chain to switch-case statements
965
  ///
966
  /// Statements usually don't have IDs, but switch cases need them, so that the
967
  /// switch statement can refer to them.
968
  SwitchCaseMapTy SwitchCaseStmts;
969
970
  SwitchCaseMapTy *CurrSwitchCaseStmts;
971
972
  /// The number of source location entries de-serialized from
973
  /// the PCH file.
974
  unsigned NumSLocEntriesRead = 0;
975
976
  /// The number of source location entries in the chain.
977
  unsigned TotalNumSLocEntries = 0;
978
979
  /// The number of statements (and expressions) de-serialized
980
  /// from the chain.
981
  unsigned NumStatementsRead = 0;
982
983
  /// The total number of statements (and expressions) stored
984
  /// in the chain.
985
  unsigned TotalNumStatements = 0;
986
987
  /// The number of macros de-serialized from the chain.
988
  unsigned NumMacrosRead = 0;
989
990
  /// The total number of macros stored in the chain.
991
  unsigned TotalNumMacros = 0;
992
993
  /// The number of lookups into identifier tables.
994
  unsigned NumIdentifierLookups = 0;
995
996
  /// The number of lookups into identifier tables that succeed.
997
  unsigned NumIdentifierLookupHits = 0;
998
999
  /// The number of selectors that have been read.
1000
  unsigned NumSelectorsRead = 0;
1001
1002
  /// The number of method pool entries that have been read.
1003
  unsigned NumMethodPoolEntriesRead = 0;
1004
1005
  /// The number of times we have looked up a selector in the method
1006
  /// pool.
1007
  unsigned NumMethodPoolLookups = 0;
1008
1009
  /// The number of times we have looked up a selector in the method
1010
  /// pool and found something.
1011
  unsigned NumMethodPoolHits = 0;
1012
1013
  /// The number of times we have looked up a selector in the method
1014
  /// pool within a specific module.
1015
  unsigned NumMethodPoolTableLookups = 0;
1016
1017
  /// The number of times we have looked up a selector in the method
1018
  /// pool within a specific module and found something.
1019
  unsigned NumMethodPoolTableHits = 0;
1020
1021
  /// The total number of method pool entries in the selector table.
1022
  unsigned TotalNumMethodPoolEntries = 0;
1023
1024
  /// Number of lexical decl contexts read/total.
1025
  unsigned NumLexicalDeclContextsRead = 0, TotalLexicalDeclContexts = 0;
1026
1027
  /// Number of visible decl contexts read/total.
1028
  unsigned NumVisibleDeclContextsRead = 0, TotalVisibleDeclContexts = 0;
1029
1030
  /// Total size of modules, in bits, currently loaded
1031
  uint64_t TotalModulesSizeInBits = 0;
1032
1033
  /// Number of Decl/types that are currently deserializing.
1034
  unsigned NumCurrentElementsDeserializing = 0;
1035
1036
  /// Set true while we are in the process of passing deserialized
1037
  /// "interesting" decls to consumer inside FinishedDeserializing().
1038
  /// This is used as a guard to avoid recursively repeating the process of
1039
  /// passing decls to consumer.
1040
  bool PassingDeclsToConsumer = false;
1041
1042
  /// The set of identifiers that were read while the AST reader was
1043
  /// (recursively) loading declarations.
1044
  ///
1045
  /// The declarations on the identifier chain for these identifiers will be
1046
  /// loaded once the recursive loading has completed.
1047
  llvm::MapVector<IdentifierInfo *, SmallVector<uint32_t, 4>>
1048
    PendingIdentifierInfos;
1049
1050
  /// The set of lookup results that we have faked in order to support
1051
  /// merging of partially deserialized decls but that we have not yet removed.
1052
  llvm::SmallMapVector<IdentifierInfo *, SmallVector<NamedDecl*, 2>, 16>
1053
    PendingFakeLookupResults;
1054
1055
  /// The generation number of each identifier, which keeps track of
1056
  /// the last time we loaded information about this identifier.
1057
  llvm::DenseMap<IdentifierInfo *, unsigned> IdentifierGeneration;
1058
1059
  class InterestingDecl {
1060
    Decl *D;
1061
    bool DeclHasPendingBody;
1062
1063
  public:
1064
    InterestingDecl(Decl *D, bool HasBody)
1065
7.67M
        : D(D), DeclHasPendingBody(HasBody) {}
1066
1067
8.12M
    Decl *getDecl() { return D; }
1068
1069
    /// Whether the declaration has a pending body.
1070
7.65M
    bool hasPendingBody() { return DeclHasPendingBody; }
1071
  };
1072
1073
  /// Contains declarations and definitions that could be
1074
  /// "interesting" to the ASTConsumer, when we get that AST consumer.
1075
  ///
1076
  /// "Interesting" declarations are those that have data that may
1077
  /// need to be emitted, such as inline function definitions or
1078
  /// Objective-C protocols.
1079
  std::deque<InterestingDecl> PotentiallyInterestingDecls;
1080
1081
  /// The list of deduced function types that we have not yet read, because
1082
  /// they might contain a deduced return type that refers to a local type
1083
  /// declared within the function.
1084
  SmallVector<std::pair<FunctionDecl *, serialization::TypeID>, 16>
1085
      PendingFunctionTypes;
1086
1087
  /// The list of redeclaration chains that still need to be
1088
  /// reconstructed, and the local offset to the corresponding list
1089
  /// of redeclarations.
1090
  SmallVector<std::pair<Decl *, uint64_t>, 16> PendingDeclChains;
1091
1092
  /// The list of canonical declarations whose redeclaration chains
1093
  /// need to be marked as incomplete once we're done deserializing things.
1094
  SmallVector<Decl *, 16> PendingIncompleteDeclChains;
1095
1096
  /// The Decl IDs for the Sema/Lexical DeclContext of a Decl that has
1097
  /// been loaded but its DeclContext was not set yet.
1098
  struct PendingDeclContextInfo {
1099
    Decl *D;
1100
    serialization::GlobalDeclID SemaDC;
1101
    serialization::GlobalDeclID LexicalDC;
1102
  };
1103
1104
  /// The set of Decls that have been loaded but their DeclContexts are
1105
  /// not set yet.
1106
  ///
1107
  /// The DeclContexts for these Decls will be set once recursive loading has
1108
  /// been completed.
1109
  std::deque<PendingDeclContextInfo> PendingDeclContextInfos;
1110
1111
  /// The set of NamedDecls that have been loaded, but are members of a
1112
  /// context that has been merged into another context where the corresponding
1113
  /// declaration is either missing or has not yet been loaded.
1114
  ///
1115
  /// We will check whether the corresponding declaration is in fact missing
1116
  /// once recursing loading has been completed.
1117
  llvm::SmallVector<NamedDecl *, 16> PendingOdrMergeChecks;
1118
1119
  using DataPointers =
1120
      std::pair<CXXRecordDecl *, struct CXXRecordDecl::DefinitionData *>;
1121
1122
  /// Record definitions in which we found an ODR violation.
1123
  llvm::SmallDenseMap<CXXRecordDecl *, llvm::SmallVector<DataPointers, 2>, 2>
1124
      PendingOdrMergeFailures;
1125
1126
  /// Function definitions in which we found an ODR violation.
1127
  llvm::SmallDenseMap<FunctionDecl *, llvm::SmallVector<FunctionDecl *, 2>, 2>
1128
      PendingFunctionOdrMergeFailures;
1129
1130
  /// Enum definitions in which we found an ODR violation.
1131
  llvm::SmallDenseMap<EnumDecl *, llvm::SmallVector<EnumDecl *, 2>, 2>
1132
      PendingEnumOdrMergeFailures;
1133
1134
  /// DeclContexts in which we have diagnosed an ODR violation.
1135
  llvm::SmallPtrSet<DeclContext*, 2> DiagnosedOdrMergeFailures;
1136
1137
  /// The set of Objective-C categories that have been deserialized
1138
  /// since the last time the declaration chains were linked.
1139
  llvm::SmallPtrSet<ObjCCategoryDecl *, 16> CategoriesDeserialized;
1140
1141
  /// The set of Objective-C class definitions that have already been
1142
  /// loaded, for which we will need to check for categories whenever a new
1143
  /// module is loaded.
1144
  SmallVector<ObjCInterfaceDecl *, 16> ObjCClassesLoaded;
1145
1146
  using KeyDeclsMap =
1147
      llvm::DenseMap<Decl *, SmallVector<serialization::DeclID, 2>>;
1148
1149
  /// A mapping from canonical declarations to the set of global
1150
  /// declaration IDs for key declaration that have been merged with that
1151
  /// canonical declaration. A key declaration is a formerly-canonical
1152
  /// declaration whose module did not import any other key declaration for that
1153
  /// entity. These are the IDs that we use as keys when finding redecl chains.
1154
  KeyDeclsMap KeyDecls;
1155
1156
  /// A mapping from DeclContexts to the semantic DeclContext that we
1157
  /// are treating as the definition of the entity. This is used, for instance,
1158
  /// when merging implicit instantiations of class templates across modules.
1159
  llvm::DenseMap<DeclContext *, DeclContext *> MergedDeclContexts;
1160
1161
  /// A mapping from canonical declarations of enums to their canonical
1162
  /// definitions. Only populated when using modules in C++.
1163
  llvm::DenseMap<EnumDecl *, EnumDecl *> EnumDefinitions;
1164
1165
  /// A mapping from canonical declarations of records to their canonical
1166
  /// definitions. Doesn't cover CXXRecordDecl.
1167
  llvm::DenseMap<RecordDecl *, RecordDecl *> RecordDefinitions;
1168
1169
  /// When reading a Stmt tree, Stmt operands are placed in this stack.
1170
  SmallVector<Stmt *, 16> StmtStack;
1171
1172
  /// What kind of records we are reading.
1173
  enum ReadingKind {
1174
    Read_None, Read_Decl, Read_Type, Read_Stmt
1175
  };
1176
1177
  /// What kind of records we are reading.
1178
  ReadingKind ReadingKind = Read_None;
1179
1180
  /// RAII object to change the reading kind.
1181
  class ReadingKindTracker {
1182
    ASTReader &Reader;
1183
    enum ReadingKind PrevKind;
1184
1185
  public:
1186
    ReadingKindTracker(enum ReadingKind newKind, ASTReader &reader)
1187
24.1M
        : Reader(reader), PrevKind(Reader.ReadingKind) {
1188
24.1M
      Reader.ReadingKind = newKind;
1189
24.1M
    }
1190
1191
    ReadingKindTracker(const ReadingKindTracker &) = delete;
1192
    ReadingKindTracker &operator=(const ReadingKindTracker &) = delete;
1193
24.1M
    ~ReadingKindTracker() { Reader.ReadingKind = PrevKind; }
1194
  };
1195
1196
  /// RAII object to mark the start of processing updates.
1197
  class ProcessingUpdatesRAIIObj {
1198
    ASTReader &Reader;
1199
    bool PrevState;
1200
1201
  public:
1202
    ProcessingUpdatesRAIIObj(ASTReader &reader)
1203
7.69M
        : Reader(reader), PrevState(Reader.ProcessingUpdateRecords) {
1204
7.69M
      Reader.ProcessingUpdateRecords = true;
1205
7.69M
    }
1206
1207
    ProcessingUpdatesRAIIObj(const ProcessingUpdatesRAIIObj &) = delete;
1208
    ProcessingUpdatesRAIIObj &
1209
    operator=(const ProcessingUpdatesRAIIObj &) = delete;
1210
7.69M
    ~ProcessingUpdatesRAIIObj() { Reader.ProcessingUpdateRecords = PrevState; }
1211
  };
1212
1213
  /// Suggested contents of the predefines buffer, after this
1214
  /// PCH file has been processed.
1215
  ///
1216
  /// In most cases, this string will be empty, because the predefines
1217
  /// buffer computed to build the PCH file will be identical to the
1218
  /// predefines buffer computed from the command line. However, when
1219
  /// there are differences that the PCH reader can work around, this
1220
  /// predefines buffer may contain additional definitions.
1221
  std::string SuggestedPredefines;
1222
1223
  llvm::DenseMap<const Decl *, bool> DefinitionSource;
1224
1225
  bool shouldDisableValidationForFile(const serialization::ModuleFile &M) const;
1226
1227
  /// Reads a statement from the specified cursor.
1228
  Stmt *ReadStmtFromStream(ModuleFile &F);
1229
1230
  struct InputFileInfo {
1231
    std::string Filename;
1232
    uint64_t ContentHash;
1233
    off_t StoredSize;
1234
    time_t StoredTime;
1235
    bool Overridden;
1236
    bool Transient;
1237
    bool TopLevelModuleMap;
1238
  };
1239
1240
  /// Reads the stored information about an input file.
1241
  InputFileInfo readInputFileInfo(ModuleFile &F, unsigned ID);
1242
1243
  /// Retrieve the file entry and 'overridden' bit for an input
1244
  /// file in the given module file.
1245
  serialization::InputFile getInputFile(ModuleFile &F, unsigned ID,
1246
                                        bool Complain = true);
1247
1248
public:
1249
  void ResolveImportedPath(ModuleFile &M, std::string &Filename);
1250
  static void ResolveImportedPath(std::string &Filename, StringRef Prefix);
1251
1252
  /// Returns the first key declaration for the given declaration. This
1253
  /// is one that is formerly-canonical (or still canonical) and whose module
1254
  /// did not import any other key declaration of the entity.
1255
9.37k
  Decl *getKeyDeclaration(Decl *D) {
1256
9.37k
    D = D->getCanonicalDecl();
1257
9.37k
    if (D->isFromASTFile())
1258
7.93k
      return D;
1259
1260
1.44k
    auto I = KeyDecls.find(D);
1261
1.44k
    if (I == KeyDecls.end() || 
I->second.empty()40
)
1262
1.40k
      return D;
1263
40
    return GetExistingDecl(I->second[0]);
1264
1.44k
  }
1265
108
  const Decl *getKeyDeclaration(const Decl *D) {
1266
108
    return getKeyDeclaration(const_cast<Decl*>(D));
1267
108
  }
1268
1269
  /// Run a callback on each imported key declaration of \p D.
1270
  template <typename Fn>
1271
30.8k
  void forEachImportedKeyDecl(const Decl *D, Fn Visit) {
1272
30.8k
    D = D->getCanonicalDecl();
1273
30.8k
    if (D->isFromASTFile())
1274
30
      Visit(D);
1275
1276
30.8k
    auto It = KeyDecls.find(const_cast<Decl*>(D));
1277
30.8k
    if (It != KeyDecls.end())
1278
5
      for (auto ID : It->second)
1279
11
        Visit(GetExistingDecl(ID));
1280
30.8k
  }
ASTWriter.cpp:void clang::ASTReader::forEachImportedKeyDecl<clang::ASTWriter::ResolvedExceptionSpec(clang::FunctionDecl const*)::$_11>(clang::Decl const*, clang::ASTWriter::ResolvedExceptionSpec(clang::FunctionDecl const*)::$_11)
Line
Count
Source
1271
30.7k
  void forEachImportedKeyDecl(const Decl *D, Fn Visit) {
1272
30.7k
    D = D->getCanonicalDecl();
1273
30.7k
    if (D->isFromASTFile())
1274
25
      Visit(D);
1275
1276
30.7k
    auto It = KeyDecls.find(const_cast<Decl*>(D));
1277
30.7k
    if (It != KeyDecls.end())
1278
3
      for (auto ID : It->second)
1279
9
        Visit(GetExistingDecl(ID));
1280
30.7k
  }
ASTWriter.cpp:void clang::ASTReader::forEachImportedKeyDecl<clang::ASTWriter::DeducedReturnType(clang::FunctionDecl const*, clang::QualType)::$_12>(clang::Decl const*, clang::ASTWriter::DeducedReturnType(clang::FunctionDecl const*, clang::QualType)::$_12)
Line
Count
Source
1271
40
  void forEachImportedKeyDecl(const Decl *D, Fn Visit) {
1272
40
    D = D->getCanonicalDecl();
1273
40
    if (D->isFromASTFile())
1274
2
      Visit(D);
1275
1276
40
    auto It = KeyDecls.find(const_cast<Decl*>(D));
1277
40
    if (It != KeyDecls.end())
1278
0
      for (auto ID : It->second)
1279
0
        Visit(GetExistingDecl(ID));
1280
40
  }
ASTWriter.cpp:void clang::ASTReader::forEachImportedKeyDecl<clang::ASTWriter::ResolvedOperatorDelete(clang::CXXDestructorDecl const*, clang::FunctionDecl const*, clang::Expr*)::$_13>(clang::Decl const*, clang::ASTWriter::ResolvedOperatorDelete(clang::CXXDestructorDecl const*, clang::FunctionDecl const*, clang::Expr*)::$_13)
Line
Count
Source
1271
42
  void forEachImportedKeyDecl(const Decl *D, Fn Visit) {
1272
42
    D = D->getCanonicalDecl();
1273
42
    if (D->isFromASTFile())
1274
3
      Visit(D);
1275
1276
42
    auto It = KeyDecls.find(const_cast<Decl*>(D));
1277
42
    if (It != KeyDecls.end())
1278
2
      for (auto ID : It->second)
1279
2
        Visit(GetExistingDecl(ID));
1280
42
  }
1281
1282
  /// Get the loaded lookup tables for \p Primary, if any.
1283
  const serialization::reader::DeclContextLookupTable *
1284
  getLoadedLookupTables(DeclContext *Primary) const;
1285
1286
private:
1287
  struct ImportedModule {
1288
    ModuleFile *Mod;
1289
    ModuleFile *ImportedBy;
1290
    SourceLocation ImportLoc;
1291
1292
    ImportedModule(ModuleFile *Mod,
1293
                   ModuleFile *ImportedBy,
1294
                   SourceLocation ImportLoc)
1295
17.8k
        : Mod(Mod), ImportedBy(ImportedBy), ImportLoc(ImportLoc) {}
1296
  };
1297
1298
  ASTReadResult ReadASTCore(StringRef FileName, ModuleKind Type,
1299
                            SourceLocation ImportLoc, ModuleFile *ImportedBy,
1300
                            SmallVectorImpl<ImportedModule> &Loaded,
1301
                            off_t ExpectedSize, time_t ExpectedModTime,
1302
                            ASTFileSignature ExpectedSignature,
1303
                            unsigned ClientLoadCapabilities);
1304
  ASTReadResult ReadControlBlock(ModuleFile &F,
1305
                                 SmallVectorImpl<ImportedModule> &Loaded,
1306
                                 const ModuleFile *ImportedBy,
1307
                                 unsigned ClientLoadCapabilities);
1308
  static ASTReadResult ReadOptionsBlock(
1309
      llvm::BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
1310
      bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
1311
      std::string &SuggestedPredefines);
1312
1313
  /// Read the unhashed control block.
1314
  ///
1315
  /// This has no effect on \c F.Stream, instead creating a fresh cursor from
1316
  /// \c F.Data and reading ahead.
1317
  ASTReadResult readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
1318
                                         unsigned ClientLoadCapabilities);
1319
1320
  static ASTReadResult
1321
  readUnhashedControlBlockImpl(ModuleFile *F, llvm::StringRef StreamData,
1322
                               unsigned ClientLoadCapabilities,
1323
                               bool AllowCompatibleConfigurationMismatch,
1324
                               ASTReaderListener *Listener,
1325
                               bool ValidateDiagnosticOptions);
1326
1327
  llvm::Error ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities);
1328
  llvm::Error ReadExtensionBlock(ModuleFile &F);
1329
  void ReadModuleOffsetMap(ModuleFile &F) const;
1330
  void ParseLineTable(ModuleFile &F, const RecordData &Record);
1331
  llvm::Error ReadSourceManagerBlock(ModuleFile &F);
1332
  llvm::BitstreamCursor &SLocCursorForID(int ID);
1333
  SourceLocation getImportLocation(ModuleFile *F);
1334
  ASTReadResult ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
1335
                                       const ModuleFile *ImportedBy,
1336
                                       unsigned ClientLoadCapabilities);
1337
  llvm::Error ReadSubmoduleBlock(ModuleFile &F,
1338
                                 unsigned ClientLoadCapabilities);
1339
  static bool ParseLanguageOptions(const RecordData &Record, bool Complain,
1340
                                   ASTReaderListener &Listener,
1341
                                   bool AllowCompatibleDifferences);
1342
  static bool ParseTargetOptions(const RecordData &Record, bool Complain,
1343
                                 ASTReaderListener &Listener,
1344
                                 bool AllowCompatibleDifferences);
1345
  static bool ParseDiagnosticOptions(const RecordData &Record, bool Complain,
1346
                                     ASTReaderListener &Listener);
1347
  static bool ParseFileSystemOptions(const RecordData &Record, bool Complain,
1348
                                     ASTReaderListener &Listener);
1349
  static bool ParseHeaderSearchOptions(const RecordData &Record, bool Complain,
1350
                                       ASTReaderListener &Listener);
1351
  static bool ParsePreprocessorOptions(const RecordData &Record, bool Complain,
1352
                                       ASTReaderListener &Listener,
1353
                                       std::string &SuggestedPredefines);
1354
1355
  struct RecordLocation {
1356
    ModuleFile *F;
1357
    uint64_t Offset;
1358
1359
15.1M
    RecordLocation(ModuleFile *M, uint64_t O) : F(M), Offset(O) {}
1360
  };
1361
1362
  QualType readTypeRecord(unsigned Index);
1363
  RecordLocation TypeCursorForIndex(unsigned Index);
1364
  void LoadedDecl(unsigned Index, Decl *D);
1365
  Decl *ReadDeclRecord(serialization::DeclID ID);
1366
  void markIncompleteDeclChain(Decl *Canon);
1367
1368
  /// Returns the most recent declaration of a declaration (which must be
1369
  /// of a redeclarable kind) that is either local or has already been loaded
1370
  /// merged into its redecl chain.
1371
  Decl *getMostRecentExistingDecl(Decl *D);
1372
1373
  RecordLocation DeclCursorForID(serialization::DeclID ID,
1374
                                 SourceLocation &Location);
1375
  void loadDeclUpdateRecords(PendingUpdateRecord &Record);
1376
  void loadPendingDeclChain(Decl *D, uint64_t LocalOffset);
1377
  void loadObjCCategories(serialization::GlobalDeclID ID, ObjCInterfaceDecl *D,
1378
                          unsigned PreviousGeneration = 0);
1379
1380
  RecordLocation getLocalBitOffset(uint64_t GlobalOffset);
1381
  uint64_t getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset);
1382
1383
  /// Returns the first preprocessed entity ID that begins or ends after
1384
  /// \arg Loc.
1385
  serialization::PreprocessedEntityID
1386
  findPreprocessedEntity(SourceLocation Loc, bool EndsAfter) const;
1387
1388
  /// Find the next module that contains entities and return the ID
1389
  /// of the first entry.
1390
  ///
1391
  /// \param SLocMapI points at a chunk of a module that contains no
1392
  /// preprocessed entities or the entities it contains are not the
1393
  /// ones we are looking for.
1394
  serialization::PreprocessedEntityID
1395
    findNextPreprocessedEntity(
1396
                        GlobalSLocOffsetMapType::const_iterator SLocMapI) const;
1397
1398
  /// Returns (ModuleFile, Local index) pair for \p GlobalIndex of a
1399
  /// preprocessed entity.
1400
  std::pair<ModuleFile *, unsigned>
1401
    getModulePreprocessedEntity(unsigned GlobalIndex);
1402
1403
  /// Returns (begin, end) pair for the preprocessed entities of a
1404
  /// particular module.
1405
  llvm::iterator_range<PreprocessingRecord::iterator>
1406
  getModulePreprocessedEntities(ModuleFile &Mod) const;
1407
1408
  bool canRecoverFromOutOfDate(StringRef ModuleFileName,
1409
                               unsigned ClientLoadCapabilities);
1410
1411
public:
1412
  class ModuleDeclIterator
1413
      : public llvm::iterator_adaptor_base<
1414
            ModuleDeclIterator, const serialization::LocalDeclID *,
1415
            std::random_access_iterator_tag, const Decl *, ptrdiff_t,
1416
            const Decl *, const Decl *> {
1417
    ASTReader *Reader = nullptr;
1418
    ModuleFile *Mod = nullptr;
1419
1420
  public:
1421
0
    ModuleDeclIterator() : iterator_adaptor_base(nullptr) {}
1422
1423
    ModuleDeclIterator(ASTReader *Reader, ModuleFile *Mod,
1424
                       const serialization::LocalDeclID *Pos)
1425
24
        : iterator_adaptor_base(Pos), Reader(Reader), Mod(Mod) {}
1426
1427
72
    value_type operator*() const {
1428
72
      return Reader->GetDecl(Reader->getGlobalDeclID(*Mod, *I));
1429
72
    }
1430
1431
0
    value_type operator->() const { return **this; }
1432
1433
84
    bool operator==(const ModuleDeclIterator &RHS) const {
1434
84
      assert(Reader == RHS.Reader && Mod == RHS.Mod);
1435
0
      return I == RHS.I;
1436
84
    }
1437
  };
1438
1439
  llvm::iterator_range<ModuleDeclIterator>
1440
  getModuleFileLevelDecls(ModuleFile &Mod);
1441
1442
private:
1443
  void PassInterestingDeclsToConsumer();
1444
  void PassInterestingDeclToConsumer(Decl *D);
1445
1446
  void finishPendingActions();
1447
  void diagnoseOdrViolations();
1448
1449
  void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name);
1450
1451
  void addPendingDeclContextInfo(Decl *D,
1452
                                 serialization::GlobalDeclID SemaDC,
1453
2.42M
                                 serialization::GlobalDeclID LexicalDC) {
1454
2.42M
    assert(D);
1455
0
    PendingDeclContextInfo Info = { D, SemaDC, LexicalDC };
1456
2.42M
    PendingDeclContextInfos.push_back(Info);
1457
2.42M
  }
1458
1459
  /// Produce an error diagnostic and return true.
1460
  ///
1461
  /// This routine should only be used for fatal errors that have to
1462
  /// do with non-routine failures (e.g., corrupted AST file).
1463
  void Error(StringRef Msg) const;
1464
  void Error(unsigned DiagID, StringRef Arg1 = StringRef(),
1465
             StringRef Arg2 = StringRef(), StringRef Arg3 = StringRef()) const;
1466
  void Error(llvm::Error &&Err) const;
1467
1468
public:
1469
  /// Load the AST file and validate its contents against the given
1470
  /// Preprocessor.
1471
  ///
1472
  /// \param PP the preprocessor associated with the context in which this
1473
  /// precompiled header will be loaded.
1474
  ///
1475
  /// \param Context the AST context that this precompiled header will be
1476
  /// loaded into, if any.
1477
  ///
1478
  /// \param PCHContainerRdr the PCHContainerOperations to use for loading and
1479
  /// creating modules.
1480
  ///
1481
  /// \param Extensions the list of module file extensions that can be loaded
1482
  /// from the AST files.
1483
  ///
1484
  /// \param isysroot If non-NULL, the system include path specified by the
1485
  /// user. This is only used with relocatable PCH files. If non-NULL,
1486
  /// a relocatable PCH file will use the default path "/".
1487
  ///
1488
  /// \param DisableValidationKind If set, the AST reader will suppress most
1489
  /// of its regular consistency checking, allowing the use of precompiled
1490
  /// headers and module files that cannot be determined to be compatible.
1491
  ///
1492
  /// \param AllowASTWithCompilerErrors If true, the AST reader will accept an
1493
  /// AST file the was created out of an AST with compiler errors,
1494
  /// otherwise it will reject it.
1495
  ///
1496
  /// \param AllowConfigurationMismatch If true, the AST reader will not check
1497
  /// for configuration differences between the AST file and the invocation.
1498
  ///
1499
  /// \param ValidateSystemInputs If true, the AST reader will validate
1500
  /// system input files in addition to user input files. This is only
1501
  /// meaningful if \p DisableValidation is false.
1502
  ///
1503
  /// \param UseGlobalIndex If true, the AST reader will try to load and use
1504
  /// the global module index.
1505
  ///
1506
  /// \param ReadTimer If non-null, a timer used to track the time spent
1507
  /// deserializing.
1508
  ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
1509
            ASTContext *Context, const PCHContainerReader &PCHContainerRdr,
1510
            ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
1511
            StringRef isysroot = "",
1512
            DisableValidationForModuleKind DisableValidationKind =
1513
                DisableValidationForModuleKind::None,
1514
            bool AllowASTWithCompilerErrors = false,
1515
            bool AllowConfigurationMismatch = false,
1516
            bool ValidateSystemInputs = false,
1517
            bool ValidateASTInputFilesContent = false,
1518
            bool UseGlobalIndex = true,
1519
            std::unique_ptr<llvm::Timer> ReadTimer = {});
1520
  ASTReader(const ASTReader &) = delete;
1521
  ASTReader &operator=(const ASTReader &) = delete;
1522
  ~ASTReader() override;
1523
1524
1.00M
  SourceManager &getSourceManager() const { return SourceMgr; }
1525
193k
  FileManager &getFileManager() const { return FileMgr; }
1526
2
  DiagnosticsEngine &getDiags() const { return Diags; }
1527
1528
  /// Flags that indicate what kind of AST loading failures the client
1529
  /// of the AST reader can directly handle.
1530
  ///
1531
  /// When a client states that it can handle a particular kind of failure,
1532
  /// the AST reader will not emit errors when producing that kind of failure.
1533
  enum LoadFailureCapabilities {
1534
    /// The client can't handle any AST loading failures.
1535
    ARR_None = 0,
1536
1537
    /// The client can handle an AST file that cannot load because it
1538
    /// is missing.
1539
    ARR_Missing = 0x1,
1540
1541
    /// The client can handle an AST file that cannot load because it
1542
    /// is out-of-date relative to its input files.
1543
    ARR_OutOfDate = 0x2,
1544
1545
    /// The client can handle an AST file that cannot load because it
1546
    /// was built with a different version of Clang.
1547
    ARR_VersionMismatch = 0x4,
1548
1549
    /// The client can handle an AST file that cannot load because it's
1550
    /// compiled configuration doesn't match that of the context it was
1551
    /// loaded into.
1552
    ARR_ConfigurationMismatch = 0x8,
1553
1554
    /// If a module file is marked with errors treat it as out-of-date so the
1555
    /// caller can rebuild it.
1556
    ARR_TreatModuleWithErrorsAsOutOfDate = 0x10
1557
  };
1558
1559
  /// Load the AST file designated by the given file name.
1560
  ///
1561
  /// \param FileName The name of the AST file to load.
1562
  ///
1563
  /// \param Type The kind of AST being loaded, e.g., PCH, module, main file,
1564
  /// or preamble.
1565
  ///
1566
  /// \param ImportLoc the location where the module file will be considered as
1567
  /// imported from. For non-module AST types it should be invalid.
1568
  ///
1569
  /// \param ClientLoadCapabilities The set of client load-failure
1570
  /// capabilities, represented as a bitset of the enumerators of
1571
  /// LoadFailureCapabilities.
1572
  ///
1573
  /// \param Imported optional out-parameter to append the list of modules
1574
  /// that were imported by precompiled headers or any other non-module AST file
1575
  ASTReadResult ReadAST(StringRef FileName, ModuleKind Type,
1576
                        SourceLocation ImportLoc,
1577
                        unsigned ClientLoadCapabilities,
1578
                        SmallVectorImpl<ImportedSubmodule> *Imported = nullptr);
1579
1580
  /// Make the entities in the given module and any of its (non-explicit)
1581
  /// submodules visible to name lookup.
1582
  ///
1583
  /// \param Mod The module whose names should be made visible.
1584
  ///
1585
  /// \param NameVisibility The level of visibility to give the names in the
1586
  /// module.  Visibility can only be increased over time.
1587
  ///
1588
  /// \param ImportLoc The location at which the import occurs.
1589
  void makeModuleVisible(Module *Mod,
1590
                         Module::NameVisibilityKind NameVisibility,
1591
                         SourceLocation ImportLoc);
1592
1593
  /// Make the names within this set of hidden names visible.
1594
  void makeNamesVisible(const HiddenNames &Names, Module *Owner);
1595
1596
  /// Note that MergedDef is a redefinition of the canonical definition
1597
  /// Def, so Def should be visible whenever MergedDef is.
1598
  void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef);
1599
1600
  /// Take the AST callbacks listener.
1601
860
  std::unique_ptr<ASTReaderListener> takeListener() {
1602
860
    return std::move(Listener);
1603
860
  }
1604
1605
  /// Set the AST callbacks listener.
1606
1.01k
  void setListener(std::unique_ptr<ASTReaderListener> Listener) {
1607
1.01k
    this->Listener = std::move(Listener);
1608
1.01k
  }
1609
1610
  /// Add an AST callback listener.
1611
  ///
1612
  /// Takes ownership of \p L.
1613
946
  void addListener(std::unique_ptr<ASTReaderListener> L) {
1614
946
    if (Listener)
1615
948
      L = std::make_unique<ChainedASTReaderListener>(std::move(L),
1616
948
                                                      std::move(Listener));
1617
946
    Listener = std::move(L);
1618
946
  }
1619
1620
  /// RAII object to temporarily add an AST callback listener.
1621
  class ListenerScope {
1622
    ASTReader &Reader;
1623
    bool Chained = false;
1624
1625
  public:
1626
    ListenerScope(ASTReader &Reader, std::unique_ptr<ASTReaderListener> L)
1627
430
        : Reader(Reader) {
1628
430
      auto Old = Reader.takeListener();
1629
430
      if (Old) {
1630
430
        Chained = true;
1631
430
        L = std::make_unique<ChainedASTReaderListener>(std::move(L),
1632
430
                                                        std::move(Old));
1633
430
      }
1634
430
      Reader.setListener(std::move(L));
1635
430
    }
1636
1637
430
    ~ListenerScope() {
1638
430
      auto New = Reader.takeListener();
1639
430
      if (Chained)
1640
430
        Reader.setListener(static_cast<ChainedASTReaderListener *>(New.get())
1641
430
                               ->takeSecond());
1642
430
    }
1643
  };
1644
1645
  /// Set the AST deserialization listener.
1646
  void setDeserializationListener(ASTDeserializationListener *Listener,
1647
                                  bool TakeOwnership = false);
1648
1649
  /// Get the AST deserialization listener.
1650
0
  ASTDeserializationListener *getDeserializationListener() {
1651
0
    return DeserializationListener;
1652
0
  }
1653
1654
  /// Determine whether this AST reader has a global index.
1655
6.64k
  bool hasGlobalIndex() const { return (bool)GlobalIndex; }
1656
1657
  /// Return global module index.
1658
3
  GlobalModuleIndex *getGlobalIndex() { return GlobalIndex.get(); }
1659
1660
  /// Reset reader for a reload try.
1661
2
  void resetForReload() { TriedLoadingGlobalIndex = false; }
1662
1663
  /// Attempts to load the global index.
1664
  ///
1665
  /// \returns true if loading the global index has failed for any reason.
1666
  bool loadGlobalIndex();
1667
1668
  /// Determine whether we tried to load the global index, but failed,
1669
  /// e.g., because it is out-of-date or does not exist.
1670
  bool isGlobalIndexUnavailable() const;
1671
1672
  /// Initializes the ASTContext
1673
  void InitializeContext();
1674
1675
  /// Update the state of Sema after loading some additional modules.
1676
  void UpdateSema();
1677
1678
  /// Add in-memory (virtual file) buffer.
1679
  void addInMemoryBuffer(StringRef &FileName,
1680
75
                         std::unique_ptr<llvm::MemoryBuffer> Buffer) {
1681
75
    ModuleMgr.addInMemoryBuffer(FileName, std::move(Buffer));
1682
75
  }
1683
1684
  /// Finalizes the AST reader's state before writing an AST file to
1685
  /// disk.
1686
  ///
1687
  /// This operation may undo temporary state in the AST that should not be
1688
  /// emitted.
1689
  void finalizeForWriting();
1690
1691
  /// Retrieve the module manager.
1692
27.4k
  ModuleManager &getModuleManager() { return ModuleMgr; }
1693
1694
  /// Retrieve the preprocessor.
1695
18.4M
  Preprocessor &getPreprocessor() const { return PP; }
1696
1697
  /// Retrieve the name of the original source file name for the primary
1698
  /// module file.
1699
149
  StringRef getOriginalSourceFile() {
1700
149
    return ModuleMgr.getPrimaryModule().OriginalSourceFileName;
1701
149
  }
1702
1703
  /// Retrieve the name of the original source file name directly from
1704
  /// the AST file, without actually loading the AST file.
1705
  static std::string
1706
  getOriginalSourceFile(const std::string &ASTFileName, FileManager &FileMgr,
1707
                        const PCHContainerReader &PCHContainerRdr,
1708
                        DiagnosticsEngine &Diags);
1709
1710
  /// Read the control block for the named AST file.
1711
  ///
1712
  /// \returns true if an error occurred, false otherwise.
1713
  static bool
1714
  readASTFileControlBlock(StringRef Filename, FileManager &FileMgr,
1715
                          const PCHContainerReader &PCHContainerRdr,
1716
                          bool FindModuleFileExtensions,
1717
                          ASTReaderListener &Listener,
1718
                          bool ValidateDiagnosticOptions);
1719
1720
  /// Determine whether the given AST file is acceptable to load into a
1721
  /// translation unit with the given language and target options.
1722
  static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
1723
                                  const PCHContainerReader &PCHContainerRdr,
1724
                                  const LangOptions &LangOpts,
1725
                                  const TargetOptions &TargetOpts,
1726
                                  const PreprocessorOptions &PPOpts,
1727
                                  StringRef ExistingModuleCachePath);
1728
1729
  /// Returns the suggested contents of the predefines buffer,
1730
  /// which contains a (typically-empty) subset of the predefines
1731
  /// build prior to including the precompiled header.
1732
3.66k
  const std::string &getSuggestedPredefines() { return SuggestedPredefines; }
1733
1734
  /// Read a preallocated preprocessed entity from the external source.
1735
  ///
1736
  /// \returns null if an error occurred that prevented the preprocessed
1737
  /// entity from being loaded.
1738
  PreprocessedEntity *ReadPreprocessedEntity(unsigned Index) override;
1739
1740
  /// Returns a pair of [Begin, End) indices of preallocated
1741
  /// preprocessed entities that \p Range encompasses.
1742
  std::pair<unsigned, unsigned>
1743
      findPreprocessedEntitiesInRange(SourceRange Range) override;
1744
1745
  /// Optionally returns true or false if the preallocated preprocessed
1746
  /// entity with index \p Index came from file \p FID.
1747
  Optional<bool> isPreprocessedEntityInFileID(unsigned Index,
1748
                                              FileID FID) override;
1749
1750
  /// Read a preallocated skipped range from the external source.
1751
  SourceRange ReadSkippedRange(unsigned Index) override;
1752
1753
  /// Read the header file information for the given file entry.
1754
  HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE) override;
1755
1756
  void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag);
1757
1758
  /// Returns the number of source locations found in the chain.
1759
8.97M
  unsigned getTotalNumSLocs() const {
1760
8.97M
    return TotalNumSLocEntries;
1761
8.97M
  }
1762
1763
  /// Returns the number of identifiers found in the chain.
1764
38.2k
  unsigned getTotalNumIdentifiers() const {
1765
38.2k
    return static_cast<unsigned>(IdentifiersLoaded.size());
1766
38.2k
  }
1767
1768
  /// Returns the number of macros found in the chain.
1769
36.4k
  unsigned getTotalNumMacros() const {
1770
36.4k
    return static_cast<unsigned>(MacrosLoaded.size());
1771
36.4k
  }
1772
1773
  /// Returns the number of types found in the chain.
1774
39.0k
  unsigned getTotalNumTypes() const {
1775
39.0k
    return static_cast<unsigned>(TypesLoaded.size());
1776
39.0k
  }
1777
1778
  /// Returns the number of declarations found in the chain.
1779
38.9k
  unsigned getTotalNumDecls() const {
1780
38.9k
    return static_cast<unsigned>(DeclsLoaded.size());
1781
38.9k
  }
1782
1783
  /// Returns the number of submodules known.
1784
31.4k
  unsigned getTotalNumSubmodules() const {
1785
31.4k
    return static_cast<unsigned>(SubmodulesLoaded.size());
1786
31.4k
  }
1787
1788
  /// Returns the number of selectors found in the chain.
1789
5.40k
  unsigned getTotalNumSelectors() const {
1790
5.40k
    return static_cast<unsigned>(SelectorsLoaded.size());
1791
5.40k
  }
1792
1793
  /// Returns the number of preprocessed entities known to the AST
1794
  /// reader.
1795
457
  unsigned getTotalNumPreprocessedEntities() const {
1796
457
    unsigned Result = 0;
1797
457
    for (const auto &M : ModuleMgr)
1798
470
      Result += M.NumPreprocessedEntities;
1799
457
    return Result;
1800
457
  }
1801
1802
  /// Resolve a type ID into a type, potentially building a new
1803
  /// type.
1804
  QualType GetType(serialization::TypeID ID);
1805
1806
  /// Resolve a local type ID within a given AST file into a type.
1807
  QualType getLocalType(ModuleFile &F, unsigned LocalID);
1808
1809
  /// Map a local type ID within a given AST file into a global type ID.
1810
  serialization::TypeID getGlobalTypeID(ModuleFile &F, unsigned LocalID) const;
1811
1812
  /// Read a type from the current position in the given record, which
1813
  /// was read from the given AST file.
1814
26.5M
  QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx) {
1815
26.5M
    if (Idx >= Record.size())
1816
0
      return {};
1817
1818
26.5M
    return getLocalType(F, Record[Idx++]);
1819
26.5M
  }
1820
1821
  /// Map from a local declaration ID within a given module to a
1822
  /// global declaration ID.
1823
  serialization::DeclID getGlobalDeclID(ModuleFile &F,
1824
                                      serialization::LocalDeclID LocalID) const;
1825
1826
  /// Returns true if global DeclID \p ID originated from module \p M.
1827
  bool isDeclIDFromModule(serialization::GlobalDeclID ID, ModuleFile &M) const;
1828
1829
  /// Retrieve the module file that owns the given declaration, or NULL
1830
  /// if the declaration is not from a module file.
1831
  ModuleFile *getOwningModuleFile(const Decl *D);
1832
1833
  /// Get the best name we know for the module that owns the given
1834
  /// declaration, or an empty string if the declaration is not from a module.
1835
  std::string getOwningModuleNameForDiagnostic(const Decl *D);
1836
1837
  /// Returns the source location for the decl \p ID.
1838
  SourceLocation getSourceLocationForDeclID(serialization::GlobalDeclID ID);
1839
1840
  /// Resolve a declaration ID into a declaration, potentially
1841
  /// building a new declaration.
1842
  Decl *GetDecl(serialization::DeclID ID);
1843
  Decl *GetExternalDecl(uint32_t ID) override;
1844
1845
  /// Resolve a declaration ID into a declaration. Return 0 if it's not
1846
  /// been loaded yet.
1847
  Decl *GetExistingDecl(serialization::DeclID ID);
1848
1849
  /// Reads a declaration with the given local ID in the given module.
1850
2.73M
  Decl *GetLocalDecl(ModuleFile &F, uint32_t LocalID) {
1851
2.73M
    return GetDecl(getGlobalDeclID(F, LocalID));
1852
2.73M
  }
1853
1854
  /// Reads a declaration with the given local ID in the given module.
1855
  ///
1856
  /// \returns The requested declaration, casted to the given return type.
1857
  template<typename T>
1858
7.03k
  T *GetLocalDeclAs(ModuleFile &F, uint32_t LocalID) {
1859
7.03k
    return cast_or_null<T>(GetLocalDecl(F, LocalID));
1860
7.03k
  }
1861
1862
  /// Map a global declaration ID into the declaration ID used to
1863
  /// refer to this declaration within the given module fule.
1864
  ///
1865
  /// \returns the global ID of the given declaration as known in the given
1866
  /// module file.
1867
  serialization::DeclID
1868
  mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
1869
                                  serialization::DeclID GlobalID);
1870
1871
  /// Reads a declaration ID from the given position in a record in the
1872
  /// given module.
1873
  ///
1874
  /// \returns The declaration ID read from the record, adjusted to a global ID.
1875
  serialization::DeclID ReadDeclID(ModuleFile &F, const RecordData &Record,
1876
                                   unsigned &Idx);
1877
1878
  /// Reads a declaration from the given position in a record in the
1879
  /// given module.
1880
8.56M
  Decl *ReadDecl(ModuleFile &F, const RecordData &R, unsigned &I) {
1881
8.56M
    return GetDecl(ReadDeclID(F, R, I));
1882
8.56M
  }
1883
1884
  /// Reads a declaration from the given position in a record in the
1885
  /// given module.
1886
  ///
1887
  /// \returns The declaration read from this location, casted to the given
1888
  /// result type.
1889
  template<typename T>
1890
21.6M
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
21.6M
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
21.6M
  }
clang::ParmVarDecl* clang::ASTReader::ReadDeclAs<clang::ParmVarDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
2.25M
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
2.25M
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
2.25M
  }
clang::NamedDecl* clang::ASTReader::ReadDeclAs<clang::NamedDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
4.05M
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
4.05M
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
4.05M
  }
clang::FieldDecl* clang::ASTReader::ReadDeclAs<clang::FieldDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
45.0k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
45.0k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
45.0k
  }
clang::IndirectFieldDecl* clang::ASTReader::ReadDeclAs<clang::IndirectFieldDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
6
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
6
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
6
  }
clang::NamespaceDecl* clang::ASTReader::ReadDeclAs<clang::NamespaceDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
153k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
153k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
153k
  }
clang::NamespaceAliasDecl* clang::ASTReader::ReadDeclAs<clang::NamespaceAliasDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
5
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
5
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
5
  }
clang::CXXRecordDecl* clang::ASTReader::ReadDeclAs<clang::CXXRecordDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
284k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
284k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
284k
  }
clang::CXXDestructorDecl* clang::ASTReader::ReadDeclAs<clang::CXXDestructorDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
2.29k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
2.29k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
2.29k
  }
clang::ValueDecl* clang::ASTReader::ReadDeclAs<clang::ValueDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
1.60M
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
1.60M
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
1.60M
  }
clang::DeclContext* clang::ASTReader::ReadDeclAs<clang::DeclContext>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
10.5M
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
10.5M
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
10.5M
  }
clang::TypeAliasTemplateDecl* clang::ASTReader::ReadDeclAs<clang::TypeAliasTemplateDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
38.4k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
38.4k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
38.4k
  }
clang::EnumDecl* clang::ASTReader::ReadDeclAs<clang::EnumDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
4.63k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
4.63k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
4.63k
  }
clang::FunctionTemplateDecl* clang::ASTReader::ReadDeclAs<clang::FunctionTemplateDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
492k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
492k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
492k
  }
clang::FunctionDecl* clang::ASTReader::ReadDeclAs<clang::FunctionDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
95.6k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
95.6k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
95.6k
  }
clang::ImplicitParamDecl* clang::ASTReader::ReadDeclAs<clang::ImplicitParamDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
162k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
162k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
162k
  }
clang::ObjCMethodDecl* clang::ASTReader::ReadDeclAs<clang::ObjCMethodDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
6.86k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
6.86k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
6.86k
  }
clang::ObjCTypeParamDecl* clang::ASTReader::ReadDeclAs<clang::ObjCTypeParamDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
21.3k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
21.3k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
21.3k
  }
clang::ObjCProtocolDecl* clang::ASTReader::ReadDeclAs<clang::ObjCProtocolDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
7.35k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
7.35k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
7.35k
  }
clang::ObjCInterfaceDecl* clang::ASTReader::ReadDeclAs<clang::ObjCInterfaceDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
13.8k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
13.8k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
13.8k
  }
clang::ObjCIvarDecl* clang::ASTReader::ReadDeclAs<clang::ObjCIvarDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
3.38k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
3.38k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
3.38k
  }
clang::ObjCPropertyDecl* clang::ASTReader::ReadDeclAs<clang::ObjCPropertyDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
16
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
16
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
16
  }
Unexecuted instantiation: clang::Decl* clang::ASTReader::ReadDeclAs<clang::Decl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
clang::VarTemplateDecl* clang::ASTReader::ReadDeclAs<clang::VarTemplateDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
399
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
399
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
399
  }
clang::VarDecl* clang::ASTReader::ReadDeclAs<clang::VarDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
93.9k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
93.9k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
93.9k
  }
clang::BindingDecl* clang::ASTReader::ReadDeclAs<clang::BindingDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
12
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
12
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
12
  }
clang::UsingShadowDecl* clang::ASTReader::ReadDeclAs<clang::UsingShadowDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
12.7k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
12.7k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
12.7k
  }
clang::UsingEnumDecl* clang::ASTReader::ReadDeclAs<clang::UsingEnumDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
1
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
1
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
1
  }
clang::ConstructorUsingShadowDecl* clang::ASTReader::ReadDeclAs<clang::ConstructorUsingShadowDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
152
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
152
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
152
  }
clang::ClassTemplateDecl* clang::ASTReader::ReadDeclAs<clang::ClassTemplateDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
1.24M
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
1.24M
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
1.24M
  }
clang::CXXConstructorDecl* clang::ASTReader::ReadDeclAs<clang::CXXConstructorDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
20.2k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
20.2k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
20.2k
  }
clang::CXXMethodDecl* clang::ASTReader::ReadDeclAs<clang::CXXMethodDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
1.22k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
1.22k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
1.22k
  }
clang::RedeclarableTemplateDecl* clang::ASTReader::ReadDeclAs<clang::RedeclarableTemplateDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
366k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
366k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
366k
  }
clang::ClassTemplatePartialSpecializationDecl* clang::ASTReader::ReadDeclAs<clang::ClassTemplatePartialSpecializationDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
29.0k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
29.0k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
29.0k
  }
clang::VarTemplatePartialSpecializationDecl* clang::ASTReader::ReadDeclAs<clang::VarTemplatePartialSpecializationDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
25
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
25
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
25
  }
clang::ConceptDecl* clang::ASTReader::ReadDeclAs<clang::ConceptDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
52
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
52
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
52
  }
clang::LabelDecl* clang::ASTReader::ReadDeclAs<clang::LabelDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
157
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
157
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
157
  }
clang::CapturedDecl* clang::ASTReader::ReadDeclAs<clang::CapturedDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
31.5k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
31.5k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
31.5k
  }
clang::RecordDecl* clang::ASTReader::ReadDeclAs<clang::RecordDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
31.5k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
31.5k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
31.5k
  }
clang::RequiresExprBodyDecl* clang::ASTReader::ReadDeclAs<clang::RequiresExprBodyDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
2
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
2
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
2
  }
clang::BlockDecl* clang::ASTReader::ReadDeclAs<clang::BlockDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
26
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
26
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
26
  }
clang::NonTypeTemplateParmDecl* clang::ASTReader::ReadDeclAs<clang::NonTypeTemplateParmDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
99.7k
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
99.7k
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
99.7k
  }
clang::MSPropertyDecl* clang::ASTReader::ReadDeclAs<clang::MSPropertyDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
22
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
22
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
22
  }
clang::MSGuidDecl* clang::ASTReader::ReadDeclAs<clang::MSGuidDecl>(clang::serialization::ModuleFile&, llvm::SmallVector<unsigned long long, 64u> const&, unsigned int&)
Line
Count
Source
1890
1
  T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
1891
1
    return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
1892
1
  }
1893
1894
  /// If any redeclarations of \p D have been imported since it was
1895
  /// last checked, this digs out those redeclarations and adds them to the
1896
  /// redeclaration chain for \p D.
1897
  void CompleteRedeclChain(const Decl *D) override;
1898
1899
  CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override;
1900
1901
  /// Resolve the offset of a statement into a statement.
1902
  ///
1903
  /// This operation will read a new statement from the external
1904
  /// source each time it is called, and is meant to be used via a
1905
  /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
1906
  Stmt *GetExternalDeclStmt(uint64_t Offset) override;
1907
1908
  /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1909
  /// specified cursor.  Read the abbreviations that are at the top of the block
1910
  /// and then leave the cursor pointing into the block.
1911
  static llvm::Error ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
1912
                                      unsigned BlockID,
1913
                                      uint64_t *StartOfBlockOffset = nullptr);
1914
1915
  /// Finds all the visible declarations with a given name.
1916
  /// The current implementation of this method just loads the entire
1917
  /// lookup table as unmaterialized references.
1918
  bool FindExternalVisibleDeclsByName(const DeclContext *DC,
1919
                                      DeclarationName Name) override;
1920
1921
  /// Read all of the declarations lexically stored in a
1922
  /// declaration context.
1923
  ///
1924
  /// \param DC The declaration context whose declarations will be
1925
  /// read.
1926
  ///
1927
  /// \param IsKindWeWant A predicate indicating which declaration kinds
1928
  /// we are interested in.
1929
  ///
1930
  /// \param Decls Vector that will contain the declarations loaded
1931
  /// from the external source. The caller is responsible for merging
1932
  /// these declarations with any declarations already stored in the
1933
  /// declaration context.
1934
  void
1935
  FindExternalLexicalDecls(const DeclContext *DC,
1936
                           llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
1937
                           SmallVectorImpl<Decl *> &Decls) override;
1938
1939
  /// Get the decls that are contained in a file in the Offset/Length
1940
  /// range. \p Length can be 0 to indicate a point at \p Offset instead of
1941
  /// a range.
1942
  void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length,
1943
                           SmallVectorImpl<Decl *> &Decls) override;
1944
1945
  /// Notify ASTReader that we started deserialization of
1946
  /// a decl or type so until FinishedDeserializing is called there may be
1947
  /// decls that are initializing. Must be paired with FinishedDeserializing.
1948
  void StartedDeserializing() override;
1949
1950
  /// Notify ASTReader that we finished the deserialization of
1951
  /// a decl or type. Must be paired with StartedDeserializing.
1952
  void FinishedDeserializing() override;
1953
1954
  /// Function that will be invoked when we begin parsing a new
1955
  /// translation unit involving this external AST source.
1956
  ///
1957
  /// This function will provide all of the external definitions to
1958
  /// the ASTConsumer.
1959
  void StartTranslationUnit(ASTConsumer *Consumer) override;
1960
1961
  /// Print some statistics about AST usage.
1962
  void PrintStats() override;
1963
1964
  /// Dump information about the AST reader to standard error.
1965
  void dump();
1966
1967
  /// Return the amount of memory used by memory buffers, breaking down
1968
  /// by heap-backed versus mmap'ed memory.
1969
  void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override;
1970
1971
  /// Initialize the semantic source with the Sema instance
1972
  /// being used to perform semantic analysis on the abstract syntax
1973
  /// tree.
1974
  void InitializeSema(Sema &S) override;
1975
1976
  /// Inform the semantic consumer that Sema is no longer available.
1977
11.4k
  void ForgetSema() override { SemaObj = nullptr; }
1978
1979
  /// Retrieve the IdentifierInfo for the named identifier.
1980
  ///
1981
  /// This routine builds a new IdentifierInfo for the given identifier. If any
1982
  /// declarations with this name are visible from translation unit scope, their
1983
  /// declarations will be deserialized and introduced into the declaration
1984
  /// chain of the identifier.
1985
  IdentifierInfo *get(StringRef Name) override;
1986
1987
  /// Retrieve an iterator into the set of all identifiers
1988
  /// in all loaded AST files.
1989
  IdentifierIterator *getIdentifiers() override;
1990
1991
  /// Load the contents of the global method pool for a given
1992
  /// selector.
1993
  void ReadMethodPool(Selector Sel) override;
1994
1995
  /// Load the contents of the global method pool for a given
1996
  /// selector if necessary.
1997
  void updateOutOfDateSelector(Selector Sel) override;
1998
1999
  /// Load the set of namespaces that are known to the external source,
2000
  /// which will be used during typo correction.
2001
  void ReadKnownNamespaces(
2002
                         SmallVectorImpl<NamespaceDecl *> &Namespaces) override;
2003
2004
  void ReadUndefinedButUsed(
2005
      llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) override;
2006
2007
  void ReadMismatchingDeleteExpressions(llvm::MapVector<
2008
      FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
2009
                                            Exprs) override;
2010
2011
  void ReadTentativeDefinitions(
2012
                            SmallVectorImpl<VarDecl *> &TentativeDefs) override;
2013
2014
  void ReadUnusedFileScopedDecls(
2015
                       SmallVectorImpl<const DeclaratorDecl *> &Decls) override;
2016
2017
  void ReadDelegatingConstructors(
2018
                         SmallVectorImpl<CXXConstructorDecl *> &Decls) override;
2019
2020
  void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) override;
2021
2022
  void ReadUnusedLocalTypedefNameCandidates(
2023
      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override;
2024
2025
  void ReadDeclsToCheckForDeferredDiags(
2026
      llvm::SmallSetVector<Decl *, 4> &Decls) override;
2027
2028
  void ReadReferencedSelectors(
2029
           SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) override;
2030
2031
  void ReadWeakUndeclaredIdentifiers(
2032
           SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WI) override;
2033
2034
  void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override;
2035
2036
  void ReadPendingInstantiations(
2037
                  SmallVectorImpl<std::pair<ValueDecl *,
2038
                                            SourceLocation>> &Pending) override;
2039
2040
  void ReadLateParsedTemplates(
2041
      llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
2042
          &LPTMap) override;
2043
2044
  /// Load a selector from disk, registering its ID if it exists.
2045
  void LoadSelector(Selector Sel);
2046
2047
  void SetIdentifierInfo(unsigned ID, IdentifierInfo *II);
2048
  void SetGloballyVisibleDecls(IdentifierInfo *II,
2049
                               const SmallVectorImpl<uint32_t> &DeclIDs,
2050
                               SmallVectorImpl<Decl *> *Decls = nullptr);
2051
2052
  /// Report a diagnostic.
2053
  DiagnosticBuilder Diag(unsigned DiagID) const;
2054
2055
  /// Report a diagnostic.
2056
  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const;
2057
2058
  IdentifierInfo *DecodeIdentifierInfo(serialization::IdentifierID ID);
2059
2060
  IdentifierInfo *readIdentifier(ModuleFile &M, const RecordData &Record,
2061
11.0M
                                 unsigned &Idx) {
2062
11.0M
    return DecodeIdentifierInfo(getGlobalIdentifierID(M, Record[Idx++]));
2063
11.0M
  }
2064
2065
191
  IdentifierInfo *GetIdentifier(serialization::IdentifierID ID) override {
2066
    // Note that we are loading an identifier.
2067
191
    Deserializing AnIdentifier(this);
2068
2069
191
    return DecodeIdentifierInfo(ID);
2070
191
  }
2071
2072
  IdentifierInfo *getLocalIdentifier(ModuleFile &M, unsigned LocalID);
2073
2074
  serialization::IdentifierID getGlobalIdentifierID(ModuleFile &M,
2075
                                                    unsigned LocalID);
2076
2077
  void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo);
2078
2079
  /// Retrieve the macro with the given ID.
2080
  MacroInfo *getMacro(serialization::MacroID ID);
2081
2082
  /// Retrieve the global macro ID corresponding to the given local
2083
  /// ID within the given module file.
2084
  serialization::MacroID getGlobalMacroID(ModuleFile &M, unsigned LocalID);
2085
2086
  /// Read the source location entry with index ID.
2087
  bool ReadSLocEntry(int ID) override;
2088
2089
  /// Retrieve the module import location and module name for the
2090
  /// given source manager entry ID.
2091
  std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) override;
2092
2093
  /// Retrieve the global submodule ID given a module and its local ID
2094
  /// number.
2095
  serialization::SubmoduleID
2096
  getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID);
2097
2098
  /// Retrieve the submodule that corresponds to a global submodule ID.
2099
  ///
2100
  Module *getSubmodule(serialization::SubmoduleID GlobalID);
2101
2102
  /// Retrieve the module that corresponds to the given module ID.
2103
  ///
2104
  /// Note: overrides method in ExternalASTSource
2105
  Module *getModule(unsigned ID) override;
2106
2107
  /// Retrieve the module file with a given local ID within the specified
2108
  /// ModuleFile.
2109
  ModuleFile *getLocalModuleFile(ModuleFile &M, unsigned ID);
2110
2111
  /// Get an ID for the given module file.
2112
  unsigned getModuleFileID(ModuleFile *M);
2113
2114
  /// Return a descriptor for the corresponding module.
2115
  llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID) override;
2116
2117
  ExtKind hasExternalDefinitions(const Decl *D) override;
2118
2119
  /// Retrieve a selector from the given module with its local ID
2120
  /// number.
2121
  Selector getLocalSelector(ModuleFile &M, unsigned LocalID);
2122
2123
  Selector DecodeSelector(serialization::SelectorID Idx);
2124
2125
  Selector GetExternalSelector(serialization::SelectorID ID) override;
2126
  uint32_t GetNumExternalSelectors() override;
2127
2128
32.6k
  Selector ReadSelector(ModuleFile &M, const RecordData &Record, unsigned &Idx) {
2129
32.6k
    return getLocalSelector(M, Record[Idx++]);
2130
32.6k
  }
2131
2132
  /// Retrieve the global selector ID that corresponds to this
2133
  /// the local selector ID in a given module.
2134
  serialization::SelectorID getGlobalSelectorID(ModuleFile &F,
2135
                                                unsigned LocalID) const;
2136
2137
  /// Read the contents of a CXXCtorInitializer array.
2138
  CXXCtorInitializer **GetExternalCXXCtorInitializers(uint64_t Offset) override;
2139
2140
  /// Read a AlignPackInfo from raw form.
2141
3.93k
  Sema::AlignPackInfo ReadAlignPackInfo(uint32_t Raw) const {
2142
3.93k
    return Sema::AlignPackInfo::getFromRawEncoding(Raw);
2143
3.93k
  }
2144
2145
  /// Read a source location from raw form and return it in its
2146
  /// originating module file's source location space.
2147
  SourceLocation
2148
88.9M
  ReadUntranslatedSourceLocation(SourceLocation::UIntTy Raw) const {
2149
88.9M
    return SourceLocation::getFromRawEncoding((Raw >> 1) |
2150
88.9M
                                              (Raw << (8 * sizeof(Raw) - 1)));
2151
88.9M
  }
2152
2153
  /// Read a source location from raw form.
2154
  SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
2155
88.9M
                                    SourceLocation::UIntTy Raw) const {
2156
88.9M
    SourceLocation Loc = ReadUntranslatedSourceLocation(Raw);
2157
88.9M
    return TranslateSourceLocation(ModuleFile, Loc);
2158
88.9M
  }
2159
2160
  /// Translate a source location from another module file's source
2161
  /// location space into ours.
2162
  SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile,
2163
96.7M
                                         SourceLocation Loc) const {
2164
96.7M
    if (!ModuleFile.ModuleOffsetMap.empty())
2165
0
      ReadModuleOffsetMap(ModuleFile);
2166
96.7M
    assert(ModuleFile.SLocRemap.find(Loc.getOffset()) !=
2167
96.7M
               ModuleFile.SLocRemap.end() &&
2168
96.7M
           "Cannot find offset to remap.");
2169
0
    SourceLocation::IntTy Remap =
2170
96.7M
        ModuleFile.SLocRemap.find(Loc.getOffset())->second;
2171
96.7M
    return Loc.getLocWithOffset(Remap);
2172
96.7M
  }
2173
2174
  /// Read a source location.
2175
  SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
2176
                                    const RecordDataImpl &Record,
2177
62.6M
                                    unsigned &Idx) {
2178
62.6M
    return ReadSourceLocation(ModuleFile, Record[Idx++]);
2179
62.6M
  }
2180
2181
  /// Read a source range.
2182
  SourceRange ReadSourceRange(ModuleFile &F,
2183
                              const RecordData &Record, unsigned &Idx);
2184
2185
  // Read a string
2186
  static std::string ReadString(const RecordData &Record, unsigned &Idx);
2187
2188
  // Skip a string
2189
22
  static void SkipString(const RecordData &Record, unsigned &Idx) {
2190
22
    Idx += Record[Idx] + 1;
2191
22
  }
2192
2193
  // Read a path
2194
  std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx);
2195
2196
  // Read a path
2197
  std::string ReadPath(StringRef BaseDirectory, const RecordData &Record,
2198
                       unsigned &Idx);
2199
2200
  // Skip a path
2201
22
  static void SkipPath(const RecordData &Record, unsigned &Idx) {
2202
22
    SkipString(Record, Idx);
2203
22
  }
2204
2205
  /// Read a version tuple.
2206
  static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx);
2207
2208
  CXXTemporary *ReadCXXTemporary(ModuleFile &F, const RecordData &Record,
2209
                                 unsigned &Idx);
2210
2211
  /// Reads a statement.
2212
  Stmt *ReadStmt(ModuleFile &F);
2213
2214
  /// Reads an expression.
2215
  Expr *ReadExpr(ModuleFile &F);
2216
2217
  /// Reads a sub-statement operand during statement reading.
2218
5.87M
  Stmt *ReadSubStmt() {
2219
5.87M
    assert(ReadingKind == Read_Stmt &&
2220
5.87M
           "Should be called only during statement reading!");
2221
    // Subexpressions are stored from last to first, so the next Stmt we need
2222
    // is at the back of the stack.
2223
0
    assert(!StmtStack.empty() && "Read too many sub-statements!");
2224
0
    return StmtStack.pop_back_val();
2225
5.87M
  }
2226
2227
  /// Reads a sub-expression operand during statement reading.
2228
  Expr *ReadSubExpr();
2229
2230
  /// Reads a token out of a record.
2231
  Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx);
2232
2233
  /// Reads the macro record located at the given offset.
2234
  MacroInfo *ReadMacroRecord(ModuleFile &F, uint64_t Offset);
2235
2236
  /// Determine the global preprocessed entity ID that corresponds to
2237
  /// the given local ID within the given module.
2238
  serialization::PreprocessedEntityID
2239
  getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const;
2240
2241
  /// Add a macro to deserialize its macro directive history.
2242
  ///
2243
  /// \param II The name of the macro.
2244
  /// \param M The module file.
2245
  /// \param MacroDirectivesOffset Offset of the serialized macro directive
2246
  /// history.
2247
  void addPendingMacro(IdentifierInfo *II, ModuleFile *M,
2248
                       uint32_t MacroDirectivesOffset);
2249
2250
  /// Read the set of macros defined by this external macro source.
2251
  void ReadDefinedMacros() override;
2252
2253
  /// Update an out-of-date identifier.
2254
  void updateOutOfDateIdentifier(IdentifierInfo &II) override;
2255
2256
  /// Note that this identifier is up-to-date.
2257
  void markIdentifierUpToDate(IdentifierInfo *II);
2258
2259
  /// Load all external visible decls in the given DeclContext.
2260
  void completeVisibleDeclsMap(const DeclContext *DC) override;
2261
2262
  /// Retrieve the AST context that this AST reader supplements.
2263
96.1M
  ASTContext &getContext() {
2264
96.1M
    assert(ContextObj && "requested AST context when not loading AST");
2265
0
    return *ContextObj;
2266
96.1M
  }
2267
2268
  // Contains the IDs for declarations that were requested before we have
2269
  // access to a Sema object.
2270
  SmallVector<uint64_t, 16> PreloadedDeclIDs;
2271
2272
  /// Retrieve the semantic analysis object used to analyze the
2273
  /// translation unit in which the precompiled header is being
2274
  /// imported.
2275
2.82k
  Sema *getSema() { return SemaObj; }
2276
2277
  /// Get the identifier resolver used for name lookup / updates
2278
  /// in the translation unit scope. We have one of these even if we don't
2279
  /// have a Sema object.
2280
  IdentifierResolver &getIdResolver();
2281
2282
  /// Retrieve the identifier table associated with the
2283
  /// preprocessor.
2284
  IdentifierTable &getIdentifierTable();
2285
2286
  /// Record that the given ID maps to the given switch-case
2287
  /// statement.
2288
  void RecordSwitchCaseID(SwitchCase *SC, unsigned ID);
2289
2290
  /// Retrieve the switch-case statement with the given ID.
2291
  SwitchCase *getSwitchCaseWithID(unsigned ID);
2292
2293
  void ClearSwitchCaseIDs();
2294
2295
  /// Cursors for comments blocks.
2296
  SmallVector<std::pair<llvm::BitstreamCursor,
2297
                        serialization::ModuleFile *>, 8> CommentsCursors;
2298
2299
  /// Loads comments ranges.
2300
  void ReadComments() override;
2301
2302
  /// Visit all the input files of the given module file.
2303
  void visitInputFiles(serialization::ModuleFile &MF,
2304
                       bool IncludeSystem, bool Complain,
2305
          llvm::function_ref<void(const serialization::InputFile &IF,
2306
                                  bool isSystem)> Visitor);
2307
2308
  /// Visit all the top-level module maps loaded when building the given module
2309
  /// file.
2310
  void visitTopLevelModuleMaps(serialization::ModuleFile &MF,
2311
                               llvm::function_ref<
2312
                                   void(const FileEntry *)> Visitor);
2313
2314
1.18M
  bool isProcessingUpdateRecords() { return ProcessingUpdateRecords; }
2315
};
2316
2317
} // namespace clang
2318
2319
#endif // LLVM_CLANG_SERIALIZATION_ASTREADER_H