Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- ASTReader.h - AST File Reader ----------------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file defines the ASTReader class, which reads AST files.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_SERIALIZATION_ASTREADER_H

#define LLVM_CLANG_SERIALIZATION_ASTREADER_H

#include "clang/AST/Type.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/DiagnosticOptions.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/OpenCLOptions.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Version.h"

#include "clang/Lex/ExternalPreprocessorSource.h"

#include "clang/Lex/HeaderSearch.h"

#include "clang/Lex/PreprocessingRecord.h"

#include "clang/Lex/PreprocessorOptions.h"

#include "clang/Sema/ExternalSemaSource.h"

#include "clang/Sema/IdentifierResolver.h"

#include "clang/Sema/Sema.h"

#include "clang/Serialization/ASTBitCodes.h"

#include "clang/Serialization/ContinuousRangeMap.h"

#include "clang/Serialization/ModuleFile.h"

#include "clang/Serialization/ModuleFileExtension.h"

#include "clang/Serialization/ModuleManager.h"

#include "clang/Serialization/SourceLocationEncoding.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Bitstream/BitstreamReader.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/Timer.h"

#include "llvm/Support/VersionTuple.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <ctime>

#include <deque>

#include <memory>

#include <optional>

#include <set>

#include <string>

#include <utility>

#include <vector>

namespace clang {

class ASTConsumer;

class ASTContext;

class ASTDeserializationListener;

class ASTReader;

class ASTRecordReader;

class CXXTemporary;

class Decl;

class DeclarationName;

class DeclaratorDecl;

class DeclContext;

class EnumDecl;

class Expr;

class FieldDecl;

class FileEntry;

class FileManager;

class FileSystemOptions;

class FunctionDecl;

class GlobalModuleIndex;

struct HeaderFileInfo;

class HeaderSearchOptions;

class LangOptions;

class MacroInfo;

class InMemoryModuleCache;

class NamedDecl;

class NamespaceDecl;

class ObjCCategoryDecl;

class ObjCInterfaceDecl;

class PCHContainerReader;

class Preprocessor;

class PreprocessorOptions;

class Sema;

class SourceManager;

class Stmt;

class SwitchCase;

class TargetOptions;

class Token;

class TypedefNameDecl;

class ValueDecl;

class VarDecl;

/// Abstract interface for callback invocations by the ASTReader.

///

/// While reading an AST file, the ASTReader will call the methods of the

/// listener to pass on specific information. Some of the listener methods can

/// return true to indicate to the ASTReader that the information (and

/// consequently the AST file) is invalid.

class ASTReaderListener {

public:

  virtual ~ASTReaderListener();

  /// Receives the full Clang version information.

  ///

  /// \returns true to indicate that the version is invalid. Subclasses should

  /// generally defer to this implementation.

  virtual bool ReadFullVersionInformation(StringRef FullVersion) {

    return FullVersion != getClangFullRepositoryVersion();

  }

  virtual void ReadModuleName(StringRef ModuleName) {}

  virtual void ReadModuleMapFile(StringRef ModuleMapPath) {}

  /// Receives the language options.

  ///

  /// \returns true to indicate the options are invalid or false otherwise.

  virtual bool ReadLanguageOptions(const LangOptions &LangOpts,

                                   bool Complain,

                                   bool AllowCompatibleDifferences) {

    return false;

  }

  /// Receives the target options.

  ///

  /// \returns true to indicate the target options are invalid, or false

  /// otherwise.

  virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,

                                 bool AllowCompatibleDifferences) {

    return false;

  }

  /// Receives the diagnostic options.

  ///

  /// \returns true to indicate the diagnostic options are invalid, or false

  /// otherwise.

  virtual bool

  ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,

                        bool Complain) {

    return false;

  }

  /// Receives the file system options.

  ///

  /// \returns true to indicate the file system options are invalid, or false

  /// otherwise.

  virtual bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,

                                     bool Complain) {

    return false;

  }

  /// Receives the header search options.

  ///

  /// \param HSOpts The read header search options. The following fields are

  ///               missing and are reported in ReadHeaderSearchPaths():

  ///               UserEntries, SystemHeaderPrefixes, VFSOverlayFiles.

  ///

  /// \returns true to indicate the header search options are invalid, or false

  /// otherwise.

  virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,

                                       StringRef SpecificModuleCachePath,

                                       bool Complain) {

    return false;

  }

  /// Receives the header search paths.

  ///

  /// \param HSOpts The read header search paths. Only the following fields are

  ///               initialized: UserEntries, SystemHeaderPrefixes,

  ///               VFSOverlayFiles. The rest is reported in

  ///               ReadHeaderSearchOptions().

  ///

  /// \returns true to indicate the header search paths are invalid, or false

  /// otherwise.

  virtual bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,

                                     bool Complain) {

    return false;

  }

  /// Receives the preprocessor options.

  ///

  /// \param SuggestedPredefines Can be filled in with the set of predefines

  /// that are suggested by the preprocessor options. Typically only used when

  /// loading a precompiled header.

  ///

  /// \returns true to indicate the preprocessor options are invalid, or false

  /// otherwise.

  virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,

                                       bool Complain,

                                       std::string &SuggestedPredefines) {

    return false;

  }

  /// Receives __COUNTER__ value.

  virtual void ReadCounter(const serialization::ModuleFile &M,

                           unsigned Value) {}

  /// This is called for each AST file loaded.

  virtual void visitModuleFile(StringRef Filename,

                               serialization::ModuleKind Kind) {}

  /// Returns true if this \c ASTReaderListener wants to receive the

  /// input files of the AST file via \c visitInputFile, false otherwise.

  virtual bool needsInputFileVisitation() { return false; }

  /// Returns true if this \c ASTReaderListener wants to receive the

  /// system input files of the AST file via \c visitInputFile, false otherwise.

  virtual bool needsSystemInputFileVisitation() { return false; }

  /// if \c needsInputFileVisitation returns true, this is called for

  /// each non-system input file of the AST File. If

  /// \c needsSystemInputFileVisitation is true, then it is called for all

  /// system input files as well.

  ///

  /// \returns true to continue receiving the next input file, false to stop.

  virtual bool visitInputFile(StringRef Filename, bool isSystem,

                              bool isOverridden, bool isExplicitModule) {

    return true;

  }

  /// Returns true if this \c ASTReaderListener wants to receive the

  /// imports of the AST file via \c visitImport, false otherwise.

  virtual bool needsImportVisitation() const { return false; }

  /// If needsImportVisitation returns \c true, this is called for each

  /// AST file imported by this AST file.

  virtual void visitImport(StringRef ModuleName, StringRef Filename) {}

  /// Indicates that a particular module file extension has been read.

  virtual void readModuleFileExtension(

                 const ModuleFileExtensionMetadata &Metadata) {}

};

/// Simple wrapper class for chaining listeners.

class ChainedASTReaderListener : public ASTReaderListener {

  std::unique_ptr<ASTReaderListener> First;

  std::unique_ptr<ASTReaderListener> Second;

public:

  /// Takes ownership of \p First and \p Second.

  ChainedASTReaderListener(std::unique_ptr<ASTReaderListener> First,

                           std::unique_ptr<ASTReaderListener> Second)

      : First(std::move(First)), Second(std::move(Second)) {}

  std::unique_ptr<ASTReaderListener> takeFirst() { return std::move(First); }

  std::unique_ptr<ASTReaderListener> takeSecond() { return std::move(Second); }

  bool ReadFullVersionInformation(StringRef FullVersion) override;

  void ReadModuleName(StringRef ModuleName) override;

  void ReadModuleMapFile(StringRef ModuleMapPath) override;

  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,

                           bool AllowCompatibleDifferences) override;

  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,

                         bool AllowCompatibleDifferences) override;

  bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,

                             bool Complain) override;

  bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,

                             bool Complain) override;

  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,

                               StringRef SpecificModuleCachePath,

                               bool Complain) override;

  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,

                               bool Complain,

                               std::string &SuggestedPredefines) override;

  void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override;

  bool needsInputFileVisitation() override;

  bool needsSystemInputFileVisitation() override;

  void visitModuleFile(StringRef Filename,

                       serialization::ModuleKind Kind) override;

  bool visitInputFile(StringRef Filename, bool isSystem,

                      bool isOverridden, bool isExplicitModule) override;

  void readModuleFileExtension(

         const ModuleFileExtensionMetadata &Metadata) override;

};

/// ASTReaderListener implementation to validate the information of

/// the PCH file against an initialized Preprocessor.

class PCHValidator : public ASTReaderListener {

  Preprocessor &PP;

  ASTReader &Reader;

public:

  PCHValidator(Preprocessor &PP, ASTReader &Reader)

      : PP(PP), Reader(Reader) {}

  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,

                           bool AllowCompatibleDifferences) override;

  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,

                         bool AllowCompatibleDifferences) override;

  bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,

                             bool Complain) override;

  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,

                               std::string &SuggestedPredefines) override;

  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,

                               StringRef SpecificModuleCachePath,

                               bool Complain) override;

  void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override;

private:

  void Error(const char *Msg);

};

/// ASTReaderListenter implementation to set SuggestedPredefines of

/// ASTReader which is required to use a pch file. This is the replacement

/// of PCHValidator or SimplePCHValidator when using a pch file without

/// validating it.

class SimpleASTReaderListener : public ASTReaderListener {

  Preprocessor &PP;

public:

  SimpleASTReaderListener(Preprocessor &PP) : PP(PP) {}

  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,

                               std::string &SuggestedPredefines) override;

};

namespace serialization {

class ReadMethodPoolVisitor;

namespace reader {

class ASTIdentifierLookupTrait;

/// The on-disk hash table(s) used for DeclContext name lookup.

struct DeclContextLookupTable;

} // namespace reader

} // namespace serialization

/// Reads an AST files chain containing the contents of a translation

/// unit.

///

/// The ASTReader class reads bitstreams (produced by the ASTWriter

/// class) containing the serialized representation of a given

/// abstract syntax tree and its supporting data structures. An

/// instance of the ASTReader can be attached to an ASTContext object,

/// which will provide access to the contents of the AST files.

///

/// The AST reader provides lazy de-serialization of declarations, as

/// required when traversing the AST. Only those AST nodes that are

/// actually required will be de-serialized.

class ASTReader

  : public ExternalPreprocessorSource,

    public ExternalPreprocessingRecordSource,

    public ExternalHeaderFileInfoSource,

    public ExternalSemaSource,

    public IdentifierInfoLookup,

    public ExternalSLocEntrySource

{

public:

  /// Types of AST files.

  friend class ASTDeclReader;

  friend class ASTIdentifierIterator;

  friend class ASTRecordReader;

  friend class ASTUnit; // ASTUnit needs to remap source locations.

  friend class ASTWriter;

  friend class PCHValidator;

  friend class serialization::reader::ASTIdentifierLookupTrait;

  friend class serialization::ReadMethodPoolVisitor;

  friend class TypeLocReader;

  using RecordData = SmallVector<uint64_t, 64>;

  using RecordDataImpl = SmallVectorImpl<uint64_t>;

  /// The result of reading the control block of an AST file, which

  /// can fail for various reasons.

  enum ASTReadResult {

    /// The control block was read successfully. Aside from failures,

    /// the AST file is safe to read into the current context.

    Success,

    /// The AST file itself appears corrupted.

    Failure,

    /// The AST file was missing.

    Missing,

    /// The AST file is out-of-date relative to its input files,

    /// and needs to be regenerated.

    OutOfDate,

    /// The AST file was written by a different version of Clang.

    VersionMismatch,

    /// The AST file was written with a different language/target

    /// configuration.

    ConfigurationMismatch,

    /// The AST file has errors.

    HadErrors

  };

  using ModuleFile = serialization::ModuleFile;

  using ModuleKind = serialization::ModuleKind;

  using ModuleManager = serialization::ModuleManager;

  using ModuleIterator = ModuleManager::ModuleIterator;

  using ModuleConstIterator = ModuleManager::ModuleConstIterator;

  using ModuleReverseIterator = ModuleManager::ModuleReverseIterator;

private:

  using LocSeq = SourceLocationSequence;

  /// The receiver of some callbacks invoked by ASTReader.

  std::unique_ptr<ASTReaderListener> Listener;

  /// The receiver of deserialization events.

  ASTDeserializationListener *DeserializationListener = nullptr;

  bool OwnsDeserializationListener = false;

  SourceManager &SourceMgr;

  FileManager &FileMgr;

  const PCHContainerReader &PCHContainerRdr;

  DiagnosticsEngine &Diags;

  /// The semantic analysis object that will be processing the

  /// AST files and the translation unit that uses it.

  Sema *SemaObj = nullptr;

  /// The preprocessor that will be loading the source file.

  Preprocessor &PP;

  /// The AST context into which we'll read the AST files.

  ASTContext *ContextObj = nullptr;

  /// The AST consumer.

  ASTConsumer *Consumer = nullptr;

  /// The module manager which manages modules and their dependencies

  ModuleManager ModuleMgr;

  /// A dummy identifier resolver used to merge TU-scope declarations in

  /// C, for the cases where we don't have a Sema object to provide a real

  /// identifier resolver.

  IdentifierResolver DummyIdResolver;

  /// A mapping from extension block names to module file extensions.

  llvm::StringMap<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions;

  /// A timer used to track the time spent deserializing.

  std::unique_ptr<llvm::Timer> ReadTimer;

  /// The location where the module file will be considered as

  /// imported from. For non-module AST types it should be invalid.

  SourceLocation CurrentImportLoc;

  /// The module kind that is currently deserializing.

  std::optional<ModuleKind> CurrentDeserializingModuleKind;

  /// The global module index, if loaded.

  std::unique_ptr<GlobalModuleIndex> GlobalIndex;

  /// A map of global bit offsets to the module that stores entities

  /// at those bit offsets.

  ContinuousRangeMap<uint64_t, ModuleFile*, 4> GlobalBitOffsetsMap;

  /// A map of negated SLocEntryIDs to the modules containing them.

  ContinuousRangeMap<unsigned, ModuleFile*, 64> GlobalSLocEntryMap;

  using GlobalSLocOffsetMapType =

      ContinuousRangeMap<unsigned, ModuleFile *, 64>;

  /// A map of reversed (SourceManager::MaxLoadedOffset - SLocOffset)

  /// SourceLocation offsets to the modules containing them.

  GlobalSLocOffsetMapType GlobalSLocOffsetMap;

  /// Types that have already been loaded from the chain.

  ///

  /// When the pointer at index I is non-NULL, the type with

  /// ID = (I + 1) << FastQual::Width has already been loaded

  std::vector<QualType> TypesLoaded;

  using GlobalTypeMapType =

      ContinuousRangeMap<serialization::TypeID, ModuleFile *, 4>;

  /// Mapping from global type IDs to the module in which the

  /// type resides along with the offset that should be added to the

  /// global type ID to produce a local ID.

  GlobalTypeMapType GlobalTypeMap;

  /// Declarations that have already been loaded from the chain.

  ///

  /// When the pointer at index I is non-NULL, the declaration with ID

  /// = I + 1 has already been loaded.

  std::vector<Decl *> DeclsLoaded;

  using GlobalDeclMapType =

      ContinuousRangeMap<serialization::DeclID, ModuleFile *, 4>;

  /// Mapping from global declaration IDs to the module in which the

  /// declaration resides.

  GlobalDeclMapType GlobalDeclMap;

  using FileOffset = std::pair<ModuleFile *, uint64_t>;

  using FileOffsetsTy = SmallVector<FileOffset, 2>;

  using DeclUpdateOffsetsMap =

      llvm::DenseMap<serialization::DeclID, FileOffsetsTy>;

  /// Declarations that have modifications residing in a later file

  /// in the chain.

  DeclUpdateOffsetsMap DeclUpdateOffsets;

  struct PendingUpdateRecord {

    Decl *D;

    serialization::GlobalDeclID ID;

    // Whether the declaration was just deserialized.

    bool JustLoaded;

    PendingUpdateRecord(serialization::GlobalDeclID ID, Decl *D,

                        bool JustLoaded)

        : D(D), ID(ID), JustLoaded(JustLoaded) {}

  };

  /// Declaration updates for already-loaded declarations that we need

  /// to apply once we finish processing an import.

  llvm::SmallVector<PendingUpdateRecord, 16> PendingUpdateRecords;

  enum class PendingFakeDefinitionKind { NotFake, Fake, FakeLoaded };

  /// The DefinitionData pointers that we faked up for class definitions

  /// that we needed but hadn't loaded yet.

  llvm::DenseMap<void *, PendingFakeDefinitionKind> PendingFakeDefinitionData;

  /// Exception specification updates that have been loaded but not yet

  /// propagated across the relevant redeclaration chain. The map key is the

  /// canonical declaration (used only for deduplication) and the value is a

  /// declaration that has an exception specification.

  llvm::SmallMapVector<Decl *, FunctionDecl *, 4> PendingExceptionSpecUpdates;

  /// Deduced return type updates that have been loaded but not yet propagated

  /// across the relevant redeclaration chain. The map key is the canonical

  /// declaration and the value is the deduced return type.

  llvm::SmallMapVector<FunctionDecl *, QualType, 4> PendingDeducedTypeUpdates;

  /// Declarations that have been imported and have typedef names for

  /// linkage purposes.

  llvm::DenseMap<std::pair<DeclContext *, IdentifierInfo *>, NamedDecl *>

      ImportedTypedefNamesForLinkage;

  /// Mergeable declaration contexts that have anonymous declarations

  /// within them, and those anonymous declarations.

  llvm::DenseMap<Decl*, llvm::SmallVector<NamedDecl*, 2>>

    AnonymousDeclarationsForMerging;

  /// Key used to identify LifetimeExtendedTemporaryDecl for merging,

  /// containing the lifetime-extending declaration and the mangling number.

  using LETemporaryKey = std::pair<Decl *, unsigned>;

  /// Map of already deserialiazed temporaries.

  llvm::DenseMap<LETemporaryKey, LifetimeExtendedTemporaryDecl *>

      LETemporaryForMerging;

  struct FileDeclsInfo {

    ModuleFile *Mod = nullptr;

    ArrayRef<serialization::LocalDeclID> Decls;

    FileDeclsInfo() = default;

    FileDeclsInfo(ModuleFile *Mod, ArrayRef<serialization::LocalDeclID> Decls)

        : Mod(Mod), Decls(Decls) {}

  };

  /// Map from a FileID to the file-level declarations that it contains.

  llvm::DenseMap<FileID, FileDeclsInfo> FileDeclIDs;

  /// An array of lexical contents of a declaration context, as a sequence of

  /// Decl::Kind, DeclID pairs.

  using LexicalContents = ArrayRef<llvm::support::unaligned_uint32_t>;

  /// Map from a DeclContext to its lexical contents.

  llvm::DenseMap<const DeclContext*, std::pair<ModuleFile*, LexicalContents>>

      LexicalDecls;

  /// Map from the TU to its lexical contents from each module file.

  std::vector<std::pair<ModuleFile*, LexicalContents>> TULexicalDecls;

  /// Map from a DeclContext to its lookup tables.

  llvm::DenseMap<const DeclContext *,

                 serialization::reader::DeclContextLookupTable> Lookups;

  // Updates for visible decls can occur for other contexts than just the

  // TU, and when we read those update records, the actual context may not

  // be available yet, so have this pending map using the ID as a key. It

  // will be realized when the context is actually loaded.

  struct PendingVisibleUpdate {

    ModuleFile *Mod;

    const unsigned char *Data;

  };

  using DeclContextVisibleUpdates = SmallVector<PendingVisibleUpdate, 1>;

  /// Updates to the visible declarations of declaration contexts that

  /// haven't been loaded yet.

  llvm::DenseMap<serialization::DeclID, DeclContextVisibleUpdates>

      PendingVisibleUpdates;

  /// The set of C++ or Objective-C classes that have forward

  /// declarations that have not yet been linked to their definitions.

  llvm::SmallPtrSet<Decl *, 4> PendingDefinitions;

  using PendingBodiesMap =

      llvm::MapVector<Decl *, uint64_t,

                      llvm::SmallDenseMap<Decl *, unsigned, 4>,

                      SmallVector<std::pair<Decl *, uint64_t>, 4>>;

  /// Functions or methods that have bodies that will be attached.

  PendingBodiesMap PendingBodies;

  /// Definitions for which we have added merged definitions but not yet

  /// performed deduplication.

  llvm::SetVector<NamedDecl *> PendingMergedDefinitionsToDeduplicate;

  /// Read the record that describes the lexical contents of a DC.

  bool ReadLexicalDeclContextStorage(ModuleFile &M,

                                     llvm::BitstreamCursor &Cursor,

                                     uint64_t Offset, DeclContext *DC);

  /// Read the record that describes the visible contents of a DC.

  bool ReadVisibleDeclContextStorage(ModuleFile &M,

                                     llvm::BitstreamCursor &Cursor,

                                     uint64_t Offset, serialization::DeclID ID);

  /// A vector containing identifiers that have already been

  /// loaded.

  ///

  /// If the pointer at index I is non-NULL, then it refers to the

  /// IdentifierInfo for the identifier with ID=I+1 that has already

  /// been loaded.

  std::vector<IdentifierInfo *> IdentifiersLoaded;

  using GlobalIdentifierMapType =

      ContinuousRangeMap<serialization::IdentID, ModuleFile *, 4>;

  /// Mapping from global identifier IDs to the module in which the

  /// identifier resides along with the offset that should be added to the

  /// global identifier ID to produce a local ID.

  GlobalIdentifierMapType GlobalIdentifierMap;

  /// A vector containing macros that have already been

  /// loaded.

  ///

  /// If the pointer at index I is non-NULL, then it refers to the

  /// MacroInfo for the identifier with ID=I+1 that has already

  /// been loaded.

  std::vector<MacroInfo *> MacrosLoaded;

  using LoadedMacroInfo =

      std::pair<IdentifierInfo *, serialization::SubmoduleID>;

  /// A set of #undef directives that we have loaded; used to

  /// deduplicate the same #undef information coming from multiple module

  /// files.

  llvm::DenseSet<LoadedMacroInfo> LoadedUndefs;

  using GlobalMacroMapType =

      ContinuousRangeMap<serialization::MacroID, ModuleFile *, 4>;

  /// Mapping from global macro IDs to the module in which the

  /// macro resides along with the offset that should be added to the

  /// global macro ID to produce a local ID.

  GlobalMacroMapType GlobalMacroMap;

  /// A vector containing submodules that have already been loaded.

  ///

  /// This vector is indexed by the Submodule ID (-1). NULL submodule entries

  /// indicate that the particular submodule ID has not yet been loaded.

  SmallVector<Module *, 2> SubmodulesLoaded;

  using GlobalSubmoduleMapType =

      ContinuousRangeMap<serialization::SubmoduleID, ModuleFile *, 4>;

  /// Mapping from global submodule IDs to the module file in which the

  /// submodule resides along with the offset that should be added to the

  /// global submodule ID to produce a local ID.

  GlobalSubmoduleMapType GlobalSubmoduleMap;

  /// A set of hidden declarations.

  using HiddenNames = SmallVector<Decl *, 2>;

  using HiddenNamesMapType = llvm::DenseMap<Module *, HiddenNames>;

  /// A mapping from each of the hidden submodules to the deserialized

  /// declarations in that submodule that could be made visible.

  HiddenNamesMapType HiddenNamesMap;

  /// A module import, export, or conflict that hasn't yet been resolved.

  struct UnresolvedModuleRef {

    /// The file in which this module resides.

    ModuleFile *File;

    /// The module that is importing or exporting.

    Module *Mod;

    /// The kind of module reference.

    enum { Import, Export, Conflict, Affecting } Kind;

    /// The local ID of the module that is being exported.

    unsigned ID;

    /// Whether this is a wildcard export.

    unsigned IsWildcard : 1;

    /// String data.

    StringRef String;

  };

  /// The set of module imports and exports that still need to be

  /// resolved.

  SmallVector<UnresolvedModuleRef, 2> UnresolvedModuleRefs;

  /// A vector containing selectors that have already been loaded.

  ///

  /// This vector is indexed by the Selector ID (-1). NULL selector

  /// entries indicate that the particular selector ID has not yet

  /// been loaded.

  SmallVector<Selector, 16> SelectorsLoaded;

  using GlobalSelectorMapType =

      ContinuousRangeMap<serialization::SelectorID, ModuleFile *, 4>;

  /// Mapping from global selector IDs to the module in which the

  /// global selector ID to produce a local ID.

  GlobalSelectorMapType GlobalSelectorMap;

  /// The generation number of the last time we loaded data from the

  /// global method pool for this selector.

  llvm::DenseMap<Selector, unsigned> SelectorGeneration;

  /// Whether a selector is out of date. We mark a selector as out of date

  /// if we load another module after the method pool entry was pulled in.

  llvm::DenseMap<Selector, bool> SelectorOutOfDate;

  struct PendingMacroInfo {

    ModuleFile *M;

    /// Offset relative to ModuleFile::MacroOffsetsBase.

    uint32_t MacroDirectivesOffset;

    PendingMacroInfo(ModuleFile *M, uint32_t MacroDirectivesOffset)

        : M(M), MacroDirectivesOffset(MacroDirectivesOffset) {}

  };

  using PendingMacroIDsMap =

      llvm::MapVector<IdentifierInfo *, SmallVector<PendingMacroInfo, 2>>;

  /// Mapping from identifiers that have a macro history to the global

  /// IDs have not yet been deserialized to the global IDs of those macros.

  PendingMacroIDsMap PendingMacroIDs;

  using GlobalPreprocessedEntityMapType =

      ContinuousRangeMap<unsigned, ModuleFile *, 4>;

  /// Mapping from global preprocessing entity IDs to the module in

  /// which the preprocessed entity resides along with the offset that should be

  /// added to the global preprocessing entity ID to produce a local ID.

  GlobalPreprocessedEntityMapType GlobalPreprocessedEntityMap;

  using GlobalSkippedRangeMapType =

      ContinuousRangeMap<unsigned, ModuleFile *, 4>;

  /// Mapping from global skipped range base IDs to the module in which

  /// the skipped ranges reside.

  GlobalSkippedRangeMapType GlobalSkippedRangeMap;

  /// \name CodeGen-relevant special data

  /// Fields containing data that is relevant to CodeGen.

  //@{

  /// The IDs of all declarations that fulfill the criteria of

  /// "interesting" decls.

  ///

  /// This contains the data loaded from all EAGERLY_DESERIALIZED_DECLS blocks

  /// in the chain. The referenced declarations are deserialized and passed to

  /// the consumer eagerly.

  SmallVector<serialization::DeclID, 16> EagerlyDeserializedDecls;

  /// The IDs of all tentative definitions stored in the chain.

  ///

  /// Sema keeps track of all tentative definitions in a TU because it has to

  /// complete them and pass them on to CodeGen. Thus, tentative definitions in

  /// the PCH chain must be eagerly deserialized.

  SmallVector<serialization::DeclID, 16> TentativeDefinitions;

  /// The IDs of all CXXRecordDecls stored in the chain whose VTables are

  /// used.

  ///

  /// CodeGen has to emit VTables for these records, so they have to be eagerly

  /// deserialized.

  SmallVector<serialization::DeclID, 64> VTableUses;

  /// A snapshot of the pending instantiations in the chain.

  ///

  /// This record tracks the instantiations that Sema has to perform at the

  /// end of the TU. It consists of a pair of values for every pending

  /// instantiation where the first value is the ID of the decl and the second

  /// is the instantiation location.

  SmallVector<serialization::DeclID, 64> PendingInstantiations;

  //@}

  /// \name DiagnosticsEngine-relevant special data

  /// Fields containing data that is used for generating diagnostics

  //@{

  /// A snapshot of Sema's unused file-scoped variable tracking, for

  /// generating warnings.

  SmallVector<serialization::DeclID, 16> UnusedFileScopedDecls;

  /// A list of all the delegating constructors we've seen, to diagnose

  /// cycles.

  SmallVector<serialization::DeclID, 4> DelegatingCtorDecls;

  /// Method selectors used in a @selector expression. Used for

  /// implementation of -Wselector.

  SmallVector<serialization::SelectorID, 64> ReferencedSelectorsData;

  /// A snapshot of Sema's weak undeclared identifier tracking, for

  /// generating warnings.

  SmallVector<serialization::IdentifierID, 64> WeakUndeclaredIdentifiers;

  /// The IDs of type aliases for ext_vectors that exist in the chain.

  ///

  /// Used by Sema for finding sugared names for ext_vectors in diagnostics.

  SmallVector<serialization::DeclID, 4> ExtVectorDecls;

  //@}

  /// \name Sema-relevant special data

  /// Fields containing data that is used for semantic analysis

  //@{

  /// The IDs of all potentially unused typedef names in the chain.

  ///

  /// Sema tracks these to emit warnings.

  SmallVector<serialization::DeclID, 16> UnusedLocalTypedefNameCandidates;

  /// Our current depth in #pragma cuda force_host_device begin/end

  /// macros.

  unsigned ForceCUDAHostDeviceDepth = 0;

  /// The IDs of the declarations Sema stores directly.

  ///

  /// Sema tracks a few important decls, such as namespace std, directly.

  SmallVector<serialization::DeclID, 4> SemaDeclRefs;

  /// The IDs of the types ASTContext stores directly.

  ///

  /// The AST context tracks a few important types, such as va_list, directly.

  SmallVector<serialization::TypeID, 16> SpecialTypes;

  /// The IDs of CUDA-specific declarations ASTContext stores directly.

  ///

  /// The AST context tracks a few important decls, currently cudaConfigureCall,

  /// directly.

  SmallVector<serialization::DeclID, 2> CUDASpecialDeclRefs;

  /// The floating point pragma option settings.

  SmallVector<uint64_t, 1> FPPragmaOptions;

  /// The pragma clang optimize location (if the pragma state is "off").

  SourceLocation OptimizeOffPragmaLocation;

  /// The PragmaMSStructKind pragma ms_struct state if set, or -1.

  int PragmaMSStructState = -1;

  /// The PragmaMSPointersToMembersKind pragma pointers_to_members state.

  int PragmaMSPointersToMembersState = -1;

  SourceLocation PointersToMembersPragmaLocation;

  /// The pragma float_control state.

  std::optional<FPOptionsOverride> FpPragmaCurrentValue;