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