Coverage Report

Created: 2020-02-18 08:44

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