[clang][AST] Support AST files larger than 512M

[DmitryPolukhin]

Summary

Clang uses 32-bit integers for storing bit offsets from the beginning of
the file that results in 512M limit on AST file. This diff replaces
absolute offsets with relative offsets from the beginning of
corresponding data structure when it is possible. And uses 64-bit
offsets for DeclOffests and TypeOffssts because these coder AST
section may easily exceeds 512M alone.

This diff breaks AST file format compatibility so VERSION_MAJOR bumped.

Test Plan:
Existing clang AST serialization tests
Tested on clangd with ~700M and ~900M preamble files

[DmitryPolukhin]

clang-format for ASTBitCodes.h

[sammccall]

This looks reasonable to me, though I'm not familiar enough with the code to do a good review.

Just wanted to confirm my understanding: the problematic offsets that are now section-relative instead of file-relative are only used in two sections of the file (macro directives and sloc entries). These sections seem likely to be small relative to others that hold e.g. the AST. So this should raise the effective size limit by a lot, more likely 100x than 5?

(We've coincidentally started to see large crashing preambles this week, so thanks for this! I think we probably don't need to add any detection/recovery if this limit is high enough)

[DmitryPolukhin]

In D76594#1937289, @sammccall wrote:

This looks reasonable to me, though I'm not familiar enough with the code to do a good review.

Just wanted to confirm my understanding: the problematic offsets that are now section-relative instead of file-relative are only used in two sections of the file (macro directives and sloc entries). These sections seem likely to be small relative to others that hold e.g. the AST. So this should raise the effective size limit by a lot, more likely 100x than 5?

Yes, problematic offsets are now section relative and the sections several times smaller than the whole file. In suspect in some artificial cases these section can be pretty large. For example, you can create source file with only macro and you can exceed limit for on macro size alone. Moreover I'm not sure that files bigger than 4G can be processed correctly. Because there are other places where 32 bit numbers are used for some IDs or byte offsets.

(We've coincidentally started to see large crashing preambles this week, so thanks for this! I think we probably don't need to add any detection/recovery if this limit is high enough)

I added asserts for all new places where overflow can happen but perhaps we also need something for release builds. If you have cases when you reach size limit, it would be very helpful if you can try this patch on these cases. I tested it on couple ~700M files but my examples relatively unified and follow the same pattern.

[DmitryPolukhin]

Use 64-bit offsets for TypesOffsests and DeclOffsests

[xbolva00]

clang/lib/Serialization/ASTReader.cpp

3100

use C++ cast style

[DmitryPolukhin]

Resolve merge conflict, revert clang-format for ASTBitCodes.h to avoid further conflicts, use C++ cast

[DmitryPolukhin]

Rebase, all tests passes locally

[sammccall]

clang/include/clang/Serialization/ASTBitCodes.h

32–33

Is there one of these for every decl in the module? It seems like we're probably giving up a good fraction of the 4% increase for just using absolute 64 bit offsets everywhere :-( Is there still a significant gain from using section-relative elsewhere?

If there are indeed lots of these, giving up 4 bytes to padding (in addition to the wide offset) seems unfortunate and because we memcpy the structs into the AST file seems like a sad reason :-)
Can we align this to 4 bytes instead?
(e.g. by splitting into two fields and encapsulating the few direct accesses, though there's probably a neater way)

[DmitryPolukhin]

clang/include/clang/Serialization/ASTBitCodes.h

32–33

Yes, it seems that all referenced decls should have an entry in this table. 4% increase was counted on previous diff before I discovered DeclOffsets and TypeOffsets. This diff uses relative offsets for previous cases and increase is only 2 additional 64-bit integers per file. DeclOffsets are about 4.7% and TypeOffsets are about 2.5% of the whole file. With this diff both number will be 2x, splitting DeclOffset in two separate arrays could make the increase only 1.5x for DeclOffsets. If approach from this diff looks fine, I can split array of DeclOffset into 2 separate arrays. It could be a bit less efficient because of worse memory locality but will save some space.

[DmitryPolukhin]

@rsmith, @dexonsmith, @jdoerfert could you please take a look to this diff?
If you think that there are other reviewers who might have more context AST persistence, please add them.

[dexonsmith]

In D76594#1957452, @DmitryPolukhin wrote:

@rsmith, @dexonsmith, @jdoerfert could you please take a look to this diff?
If you think that there are other reviewers who might have more context AST persistence, please add them.

@Bigcheese, can you take a look?

[hokein]

I'm not familiar with the code, but this patch does fix the large-preamble crashes we encountered internally.

[sammccall]

We're starting to see quite a lot of production crashes with this and would very much like a fix.
At this point it seems like we're best moving ahead and if someone comes up with a better idea, we can improve it later.

clang/include/clang/Serialization/ASTBitCodes.h

32–33

Or even just 32-bit BitOffsetLow and BitOffsetHigh fields so the overall struct is 32-bit aligned... then you'd still be local?

[DmitryPolukhin]

Split BitOffset in DeclOffset in high/low parts; rebase

[DmitryPolukhin]

Split BitOffset in DeclOffset in high/low parts; rebase

[DmitryPolukhin]

Fix nit

[DmitryPolukhin]

@sammccall thank you for review!
I'll wait for one more day for additional feedback if any, and land this diff.

[martong]

I am not sure, but maybe this patch causes an undefined behavior?
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fast/builds/40472/steps/check-clang%20ubsan/logs/stdio

/b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6327:28: runtime error: load of misaligned address 0x7feac40a55bc for type 'const uint64_t' (aka 'const unsigned long'), which requires 8 byte alignment
0x7feac40a55bc: note: pointer points here
  00 00 00 00 a3 c7 01 00  00 00 00 00 0c c8 01 00  00 00 00 00 29 c8 01 00  00 00 00 00 7a cc 01 00
              ^ 
    #0 0x3be2fe4 in clang::ASTReader::TypeCursorForIndex(unsigned int) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6327:28
    #1 0x3be30a0 in clang::ASTReader::readTypeRecord(unsigned int) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6348:24
    #2 0x3bd3d4a in clang::ASTReader::GetType(unsigned int) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6985:26
    ...

(I am in the blamelist too of that build, so that's why I am sniffing.)

[DmitryPolukhin]

In D76594#1986846, @martong wrote:

I am not sure, but maybe this patch causes an undefined behavior?
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fast/builds/40472/steps/check-clang%20ubsan/logs/stdio

/b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6327:28: runtime error: load of misaligned address 0x7feac40a55bc for type 'const uint64_t' (aka 'const unsigned long'), which requires 8 byte alignment
0x7feac40a55bc: note: pointer points here
  00 00 00 00 a3 c7 01 00  00 00 00 00 0c c8 01 00  00 00 00 00 29 c8 01 00  00 00 00 00 7a cc 01 00
              ^ 
    #0 0x3be2fe4 in clang::ASTReader::TypeCursorForIndex(unsigned int) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6327:28
    #1 0x3be30a0 in clang::ASTReader::readTypeRecord(unsigned int) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6348:24
    #2 0x3bd3d4a in clang::ASTReader::GetType(unsigned int) /b/sanitizer-x86_64-linux-fast/build/llvm-project/clang/lib/Serialization/ASTReader.cpp:6985:26
    ...

(I am in the blamelist too of that build, so that's why I am sniffing.)

Temporary reverted in a8f85da9f538a400dfea00e4954e403bf5f3269c

[DmitryPolukhin]

Split TypeOffsets to low/high parts too

[sammccall]

A little sad it's not possible to just 64-bit align the typeoffsets array, but 32 seems to be the magic number.

clang/include/clang/Serialization/ASTBitCodes.h

33

may be worth mentioning that blobs in bitstream are specifically 32-bit aligned as part of the motivation here.

36

consider making this a class and these members private

45

Alternatively you could factor this as a class UnderalignedInt64, use that for type-offsets, and embed it in DeclOffset...

[DmitryPolukhin]

Comments resolved

clang/include/clang/Serialization/ASTBitCodes.h

36

I kept members public because they public for all other similar struct in the file. I think initial idea to keep them public was to have POD struct but it is actually not the case due to user defined constructor.

[JackKemp99]

clang/lib/Serialization/ASTWriter.cpp

1905

clangd crashes here:

[DmitryPolukhin]

clang/lib/Serialization/ASTWriter.cpp

1905

@JackKemp99 It means that you have a source file that has number of source location that exceeds 32-bit offset. Do you have a reproducer that you can share?

Is it something Boost related? There is a discussion about too many source location with Boost https://lists.llvm.org/pipermail/cfe-dev/2021-February/067599.html Your example may not exceed amount in of SourceLocation IDs but exceeds lower bound on offsets during preamble generation.

clang/include/clang/Serialization/ASTBitCodes.h

 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Bitstream/BitCodes.h"
 #include <cassert>
 #include <cstdint>
 
 namespace clang {
 namespace serialization {
 
-    /// AST file major version number supported by this version of
-    /// Clang.
-    ///
-    /// Whenever the AST file format changes in a way that makes it
-    /// incompatible with previous versions (such that a reader
-    /// designed for the previous version could not support reading
-    /// the new version), this number should be increased.
-    ///
-    /// Version 4 of AST files also requires that the version control branch and
-    /// revision match exactly, since there is no backward compatibility of
-    /// AST files at this time.
-    const unsigned VERSION_MAJOR = 9;
+const unsigned VERSION_MAJOR = 10;
 
-    /// AST file minor version number supported by this version of
-    /// Clang.
-    ///
-    /// Whenever the AST format changes in a way that is still
-    /// compatible with previous versions (such that a reader designed
-    /// for the previous version could still support reading the new
-    /// version by ignoring new kinds of subblocks), this number
-    /// should be increased.
-    const unsigned VERSION_MINOR = 0;
 
-    /// An ID number that refers to an identifier in an AST file.
-    ///
-    /// The ID numbers of identifiers are consecutive (in order of discovery)
-    /// and start at 1. 0 is reserved for NULL.
-    using IdentifierID = uint32_t;
 
-    /// An ID number that refers to a declaration in an AST file.
-    ///
-    /// The ID numbers of declarations are consecutive (in order of
-    /// discovery), with values below NUM_PREDEF_DECL_IDS being reserved.
-    /// At the start of a chain of precompiled headers, declaration ID 1 is
-    /// used for the translation unit declaration.
-    using DeclID = uint32_t;
 
-    // FIXME: Turn these into classes so we can have some type safety when
-    // we go from local ID to global and vice-versa.
-    using LocalDeclID = DeclID;
-    using GlobalDeclID = DeclID;
 
-    /// An ID number that refers to a type in an AST file.
-    ///
-    /// The ID of a type is partitioned into two parts: the lower
-    /// three bits are used to store the const/volatile/restrict
-    /// qualifiers (as with QualType) and the upper bits provide a
-    /// type index. The type index values are partitioned into two
-    /// sets. The values below NUM_PREDEF_TYPE_IDs are predefined type
-    /// IDs (based on the PREDEF_TYPE_*_ID constants), with 0 as a
-    /// placeholder for "no type". Values from NUM_PREDEF_TYPE_IDs are
-    /// other types that have serialized representations.
-    using TypeID = uint32_t;
 
-    /// A type index; the type ID with the qualifier bits removed.
-    class TypeIdx {
-      uint32_t Idx = 0;
 
-    public:
-      TypeIdx() = default;
-      explicit TypeIdx(uint32_t index) : Idx(index) {}
 
-      uint32_t getIndex() const { return Idx; }
 
-      TypeID asTypeID(unsigned FastQuals) const {
-        if (Idx == uint32_t(-1))
-          return TypeID(-1);
 
-        return (Idx << Qualifiers::FastWidth) | FastQuals;
-      }
 
-      static TypeIdx fromTypeID(TypeID ID) {
-        if (ID == TypeID(-1))
-          return TypeIdx(-1);
 
-        return TypeIdx(ID >> Qualifiers::FastWidth);
-      }
-    };
 
-    /// A structure for putting "fast"-unqualified QualTypes into a
-    /// DenseMap.  This uses the standard pointer hash function.
-    struct UnsafeQualTypeDenseMapInfo {
-      static bool isEqual(QualType A, QualType B) { return A == B; }
 
-      static QualType getEmptyKey() {
-        return QualType::getFromOpaquePtr((void*) 1);
-      }
+    return QualType::getFromOpaquePtr((void *)1);
 
-      static QualType getTombstoneKey() {
-        return QualType::getFromOpaquePtr((void*) 2);
-      }
+    return QualType::getFromOpaquePtr((void *)2);
 
-      static unsigned getHashValue(QualType T) {
-        assert(!T.getLocalFastQualifiers() &&
-               "hash invalid for types with fast quals");
-        uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
-        return (unsigned(v) >> 4) ^ (unsigned(v) >> 9);
-      }
-    };
 
-    /// An ID number that refers to an identifier in an AST file.
-    using IdentID = uint32_t;
 
-    /// The number of predefined identifier IDs.
-    const unsigned int NUM_PREDEF_IDENT_IDS = 1;
 
-    /// An ID number that refers to a macro in an AST file.
-    using MacroID = uint32_t;
 
-    /// A global ID number that refers to a macro in an AST file.
-    using GlobalMacroID = uint32_t;
 
-    /// A local to a module ID number that refers to a macro in an
-    /// AST file.
-    using LocalMacroID = uint32_t;
 
-    /// The number of predefined macro IDs.
-    const unsigned int NUM_PREDEF_MACRO_IDS = 1;
 
-    /// An ID number that refers to an ObjC selector in an AST file.
-    using SelectorID = uint32_t;
 
-    /// The number of predefined selector IDs.
-    const unsigned int NUM_PREDEF_SELECTOR_IDS = 1;
 
-    /// An ID number that refers to a set of CXXBaseSpecifiers in an
-    /// AST file.
-    using CXXBaseSpecifiersID = uint32_t;
 
-    /// An ID number that refers to a list of CXXCtorInitializers in an
-    /// AST file.
-    using CXXCtorInitializersID = uint32_t;
 
-    /// An ID number that refers to an entity in the detailed
-    /// preprocessing record.
-    using PreprocessedEntityID = uint32_t;
 
-    /// An ID number that refers to a submodule in a module file.
-    using SubmoduleID = uint32_t;
 
-    /// The number of predefined submodule IDs.
-    const unsigned int NUM_PREDEF_SUBMODULE_IDS = 1;
 
-    /// Source range/offset of a preprocessed entity.
-    struct PPEntityOffset {
-      /// Raw source location of beginning of range.
-      unsigned Begin;
 
-      /// Raw source location of end of range.
-      unsigned End;
 
-      /// Offset in the AST file.
-      uint32_t BitOffset;
+  /// Offset in the AST file relative to ModuleFile::MacroOffsetsBase.
 
-      PPEntityOffset(SourceRange R, uint32_t BitOffset)
-        : Begin(R.getBegin().getRawEncoding()),
-          End(R.getEnd().getRawEncoding()), BitOffset(BitOffset) {}
+      : Begin(R.getBegin().getRawEncoding()), End(R.getEnd().getRawEncoding()),
+        BitOffset(BitOffset) {}
 
-      SourceLocation getBegin() const {
-        return SourceLocation::getFromRawEncoding(Begin);
-      }
 
-      SourceLocation getEnd() const {
-        return SourceLocation::getFromRawEncoding(End);
-      }
-    };
 
-    /// Source range of a skipped preprocessor region
-    struct PPSkippedRange {
-      /// Raw source location of beginning of range.
-      unsigned Begin;
-      /// Raw source location of end of range.
-      unsigned End;
 
-      PPSkippedRange(SourceRange R)
-        : Begin(R.getBegin().getRawEncoding()),
-          End(R.getEnd().getRawEncoding()) { }
+      : Begin(R.getBegin().getRawEncoding()), End(R.getEnd().getRawEncoding()) {
+  }
 
-      SourceLocation getBegin() const {
-        return SourceLocation::getFromRawEncoding(Begin);
-      }
-      SourceLocation getEnd() const {
-        return SourceLocation::getFromRawEncoding(End);
-      }
-    };
 
-    /// Source range/offset of a preprocessed entity.
-    struct DeclOffset {
-      /// Raw source location.
-      unsigned Loc = 0;
 
-      /// Offset in the AST file.
-      uint32_t BitOffset = 0;
 
-      DeclOffset() = default;
-      DeclOffset(SourceLocation Loc, uint32_t BitOffset)
-        : Loc(Loc.getRawEncoding()), BitOffset(BitOffset) {}
 
-      void setLocation(SourceLocation L) {
-        Loc = L.getRawEncoding();
-      }
+  void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
 
-      SourceLocation getLocation() const {
-        return SourceLocation::getFromRawEncoding(Loc);
-      }
-    };
 
-    /// The number of predefined preprocessed entity IDs.
-    const unsigned int NUM_PREDEF_PP_ENTITY_IDS = 1;
 
-    /// Describes the various kinds of blocks that occur within
-    /// an AST file.
-    enum BlockIDs {
-      /// The AST block, which acts as a container around the
-      /// full AST block.
-      AST_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,
 
-      /// The block containing information about the source
-      /// manager.
-      SOURCE_MANAGER_BLOCK_ID,
 
-      /// The block containing information about the
-      /// preprocessor.
-      PREPROCESSOR_BLOCK_ID,
 
-      /// The block containing the definitions of all of the
-      /// types and decls used within the AST file.
-      DECLTYPES_BLOCK_ID,
 
-      /// The block containing the detailed preprocessing record.
-      PREPROCESSOR_DETAIL_BLOCK_ID,
 
-      /// The block containing the submodule structure.
-      SUBMODULE_BLOCK_ID,
 
-      /// The block containing comments.
-      COMMENTS_BLOCK_ID,
 
-      /// The control block, which contains all of the
-      /// information that needs to be validated prior to committing
-      /// to loading the AST file.
-      CONTROL_BLOCK_ID,
 
-      /// The block of input files, which were used as inputs
-      /// to create this AST file.
-      ///
-      /// This block is part of the control block.
-      INPUT_FILES_BLOCK_ID,
 
-      /// The block of configuration options, used to check that
-      /// a module is being used in a configuration compatible with the
-      /// configuration in which it was built.
-      ///
-      /// This block is part of the control block.
-      OPTIONS_BLOCK_ID,
 
-      /// A block containing a module file extension.
-      EXTENSION_BLOCK_ID,
 
-      /// A block with unhashed content.
-      ///
-      /// These records should not change the \a ASTFileSignature.  See \a
-      /// UnhashedControlBlockRecordTypes for the list of records.
-      UNHASHED_CONTROL_BLOCK_ID,
-    };
 
-    /// Record types that occur within the control block.
-    enum ControlRecordTypes {
-      /// AST file metadata, including the AST file version number
-      /// and information about the compiler used to build this AST file.
-      METADATA = 1,
 
-      /// Record code for the list of other AST files imported by
-      /// this AST file.
-      IMPORTS,
 
-      /// Record code for the original file that was used to
-      /// generate the AST file, including both its file ID and its
-      /// name.
-      ORIGINAL_FILE,
 
-      /// The directory that the PCH was originally created in.
-      ORIGINAL_PCH_DIR,
 
-      /// Record code for file ID of the file or buffer that was used to
-      /// generate the AST file.
-      ORIGINAL_FILE_ID,
 
-      /// Offsets into the input-files block where input files
-      /// reside.
-      INPUT_FILE_OFFSETS,
 
-      /// Record code for the module name.
-      MODULE_NAME,
 
-      /// Record code for the module map file that was used to build this
-      /// AST file.
-      MODULE_MAP_FILE,
 
-      /// Record code for the module build directory.
-      MODULE_DIRECTORY,
-    };
 
-    /// Record types that occur within the options block inside
-    /// the control block.
-    enum OptionsRecordTypes {
-      /// Record code for the language options table.
-      ///
-      /// The record with this code contains the contents of the
-      /// LangOptions structure. We serialize the entire contents of
-      /// the structure, and let the reader decide which options are
-      /// actually important to check.
-      LANGUAGE_OPTIONS = 1,
 
-      /// Record code for the target options table.
-      TARGET_OPTIONS,
 
-      /// Record code for the filesystem options table.
-      FILE_SYSTEM_OPTIONS,
 
-      /// Record code for the headers search options table.
-      HEADER_SEARCH_OPTIONS,
 
-      /// Record code for the preprocessor options table.
-      PREPROCESSOR_OPTIONS,
-    };
 
-    /// Record codes for the unhashed control block.
-    enum UnhashedControlBlockRecordTypes {
-      /// Record code for the signature that identifiers this AST file.
-      SIGNATURE = 1,
 
-      /// Record code for the diagnostic options table.
-      DIAGNOSTIC_OPTIONS,
 
-      /// Record code for \#pragma diagnostic mappings.
-      DIAG_PRAGMA_MAPPINGS,
-    };
 
-    /// Record code for extension blocks.
-    enum ExtensionBlockRecordTypes {
-      /// Metadata describing this particular extension.
-      EXTENSION_METADATA = 1,
 
-      /// The first record ID allocated to the extensions themselves.
-      FIRST_EXTENSION_RECORD_ID = 4
-    };
 
-    /// Record types that occur within the input-files block
-    /// inside the control block.
-    enum InputFileRecordTypes {
-      /// An input file.
-      INPUT_FILE = 1,
 
-      /// The input file content hash
-      INPUT_FILE_HASH
-    };
 
-    /// Record types that occur within the AST block itself.
-    enum ASTRecordTypes {
-      /// Record code for the offsets of each type.
-      ///
-      /// The TYPE_OFFSET constant describes the record that occurs
-      /// within the AST block. The record itself is an array of offsets that
-      /// point into the declarations and types block (identified by
-      /// DECLTYPES_BLOCK_ID). The index into the array is based on the ID
-      /// of a type. For a given type ID @c T, the lower three bits of
-      /// @c T are its qualifiers (const, volatile, restrict), as in
-      /// the QualType class. The upper bits, after being shifted and
-      /// subtracting NUM_PREDEF_TYPE_IDS, are used to index into the
-      /// TYPE_OFFSET block to determine the offset of that type's
-      /// corresponding record within the DECLTYPES_BLOCK_ID block.
-      TYPE_OFFSET = 1,
 
-      /// Record code for the offsets of each decl.
-      ///
-      /// The DECL_OFFSET constant describes the record that occurs
-      /// within the block identified by DECL_OFFSETS_BLOCK_ID within
-      /// the AST block. The record itself is an array of offsets that
-      /// point into the declarations and types block (identified by
-      /// DECLTYPES_BLOCK_ID). The declaration ID is an index into this
-      /// record, after subtracting one to account for the use of
-      /// declaration ID 0 for a NULL declaration pointer. Index 0 is
-      /// reserved for the translation unit declaration.
-      DECL_OFFSET = 2,
 
-      /// Record code for the table of offsets of each
-      /// identifier ID.
-      ///
-      /// The offset table contains offsets into the blob stored in
-      /// the IDENTIFIER_TABLE record. Each offset points to the
-      /// NULL-terminated string that corresponds to that identifier.
-      IDENTIFIER_OFFSET = 3,
 
-      /// This is so that older clang versions, before the introduction
-      /// of the control block, can read and reject the newer PCH format.
-      /// *DON'T CHANGE THIS NUMBER*.
-      METADATA_OLD_FORMAT = 4,
 
-      /// Record code for the identifier table.
-      ///
-      /// The identifier table is a simple blob that contains
-      /// NULL-terminated strings for all of the identifiers
-      /// referenced by the AST file. The IDENTIFIER_OFFSET table
-      /// contains the mapping from identifier IDs to the characters
-      /// in this blob. Note that the starting offsets of all of the
-      /// identifiers are odd, so that, when the identifier offset
-      /// table is loaded in, we can use the low bit to distinguish
-      /// between offsets (for unresolved identifier IDs) and
-      /// IdentifierInfo pointers (for already-resolved identifier
-      /// IDs).
-      IDENTIFIER_TABLE = 5,
 
-      /// Record code for the array of eagerly deserialized decls.
-      ///
-      /// The AST file contains a list of all of the declarations that should be
-      /// eagerly deserialized present within the parsed headers, stored as an
-      /// array of declaration IDs. These declarations will be
-      /// reported to the AST consumer after the AST file has been
-      /// read, since their presence can affect the semantics of the
-      /// program (e.g., for code generation).
-      EAGERLY_DESERIALIZED_DECLS = 6,
 
-      /// Record code for the set of non-builtin, special
-      /// types.
-      ///
-      /// This record contains the type IDs for the various type nodes
-      /// that are constructed during semantic analysis (e.g.,
-      /// __builtin_va_list). The SPECIAL_TYPE_* constants provide
-      /// offsets into this record.
-      SPECIAL_TYPES = 7,
 
-      /// Record code for the extra statistics we gather while
-      /// generating an AST file.
-      STATISTICS = 8,
 
-      /// Record code for the array of tentative definitions.
-      TENTATIVE_DEFINITIONS = 9,
 
-      // ID 10 used to be for a list of extern "C" declarations.
 
-      /// Record code for the table of offsets into the
-      /// Objective-C method pool.
-      SELECTOR_OFFSETS = 11,
 
-      /// Record code for the Objective-C method pool,
-      METHOD_POOL = 12,
 
-      /// The value of the next __COUNTER__ to dispense.
-      /// [PP_COUNTER_VALUE, Val]
-      PP_COUNTER_VALUE = 13,
 
-      /// Record code for the table of offsets into the block
-      /// of source-location information.
-      SOURCE_LOCATION_OFFSETS = 14,
 
-      /// Record code for the set of source location entries
-      /// that need to be preloaded by the AST reader.
-      ///
-      /// This set contains the source location entry for the
-      /// predefines buffer and for any file entries that need to be
-      /// preloaded.
-      SOURCE_LOCATION_PRELOADS = 15,
 
-      /// Record code for the set of ext_vector type names.
-      EXT_VECTOR_DECLS = 16,
 
-      /// Record code for the array of unused file scoped decls.
-      UNUSED_FILESCOPED_DECLS = 17,
 
-      /// Record code for the table of offsets to entries in the
-      /// preprocessing record.
-      PPD_ENTITIES_OFFSETS = 18,
 
-      /// Record code for the array of VTable uses.
-      VTABLE_USES = 19,
 
-      // ID 20 used to be for a list of dynamic classes.
 
-      /// Record code for referenced selector pool.
-      REFERENCED_SELECTOR_POOL = 21,
 
-      /// Record code for an update to the TU's lexically contained
-      /// declarations.
-      TU_UPDATE_LEXICAL = 22,
 
-      // ID 23 used to be for a list of local redeclarations.
 
-      /// Record code for declarations that Sema keeps references of.
-      SEMA_DECL_REFS = 24,
 
-      /// Record code for weak undeclared identifiers.
-      WEAK_UNDECLARED_IDENTIFIERS = 25,
 
-      /// Record code for pending implicit instantiations.
-      PENDING_IMPLICIT_INSTANTIATIONS = 26,
 
-      // ID 27 used to be for a list of replacement decls.
 
-      /// Record code for an update to a decl context's lookup table.
-      ///
-      /// In practice, this should only be used for the TU and namespaces.
-      UPDATE_VISIBLE = 28,
 
-      /// Record for offsets of DECL_UPDATES records for declarations
-      /// that were modified after being deserialized and need updates.
-      DECL_UPDATE_OFFSETS = 29,
 
-      // ID 30 used to be a decl update record. These are now in the DECLTYPES
-      // block.
 
-      // ID 31 used to be a list of offsets to DECL_CXX_BASE_SPECIFIERS records.
 
-      // ID 32 used to be the code for \#pragma diagnostic mappings.
 
-      /// Record code for special CUDA declarations.
-      CUDA_SPECIAL_DECL_REFS = 33,
 
-      /// Record code for header search information.
-      HEADER_SEARCH_TABLE = 34,
 
-      /// Record code for floating point \#pragma options.
-      FP_PRAGMA_OPTIONS = 35,
 
-      /// Record code for enabled OpenCL extensions.
-      OPENCL_EXTENSIONS = 36,
 
-      /// The list of delegating constructor declarations.
-      DELEGATING_CTORS = 37,
 
-      /// Record code for the set of known namespaces, which are used
-      /// for typo correction.
-      KNOWN_NAMESPACES = 38,
 
-      /// Record code for the remapping information used to relate
-      /// loaded modules to the various offsets and IDs(e.g., source location
-      /// offests, declaration and type IDs) that are used in that module to
-      /// refer to other modules.
-      MODULE_OFFSET_MAP = 39,
 
-      /// Record code for the source manager line table information,
-      /// which stores information about \#line directives.
-      SOURCE_MANAGER_LINE_TABLE = 40,
 
-      /// Record code for map of Objective-C class definition IDs to the
-      /// ObjC categories in a module that are attached to that class.
-      OBJC_CATEGORIES_MAP = 41,
 
-      /// Record code for a file sorted array of DeclIDs in a module.
-      FILE_SORTED_DECLS = 42,
 
-      /// Record code for an array of all of the (sub)modules that were
-      /// imported by the AST file.
-      IMPORTED_MODULES = 43,
 
-      // ID 44 used to be a table of merged canonical declarations.
-      // ID 45 used to be a list of declaration IDs of local redeclarations.
 
-      /// Record code for the array of Objective-C categories (including
-      /// extensions).
-      ///
-      /// This array can only be interpreted properly using the Objective-C
-      /// categories map.
-      OBJC_CATEGORIES = 46,
 
-      /// Record code for the table of offsets of each macro ID.
-      ///
-      /// The offset table contains offsets into the blob stored in
-      /// the preprocessor block. Each offset points to the corresponding
-      /// macro definition.
-      MACRO_OFFSET = 47,
 
-      /// A list of "interesting" identifiers. Only used in C++ (where we
-      /// don't normally do lookups into the serialized identifier table). These
-      /// are eagerly deserialized.
-      INTERESTING_IDENTIFIERS = 48,
 
-      /// Record code for undefined but used functions and variables that
-      /// need a definition in this TU.
-      UNDEFINED_BUT_USED = 49,
 
-      /// Record code for late parsed template functions.
-      LATE_PARSED_TEMPLATE = 50,
 
-      /// Record code for \#pragma optimize options.
-      OPTIMIZE_PRAGMA_OPTIONS = 51,
 
-      /// Record code for potentially unused local typedef names.
-      UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES = 52,
 
-      // ID 53 used to be a table of constructor initializer records.
 
-      /// Delete expressions that will be analyzed later.
-      DELETE_EXPRS_TO_ANALYZE = 54,
 
-      /// Record code for \#pragma ms_struct options.
-      MSSTRUCT_PRAGMA_OPTIONS = 55,
 
-      /// Record code for \#pragma ms_struct options.
-      POINTERS_TO_MEMBERS_PRAGMA_OPTIONS = 56,
 
-      /// Number of unmatched #pragma clang cuda_force_host_device begin
-      /// directives we've seen.
-      CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH = 57,
 
-      /// Record code for types associated with OpenCL extensions.
-      OPENCL_EXTENSION_TYPES = 58,
 
-      /// Record code for declarations associated with OpenCL extensions.
-      OPENCL_EXTENSION_DECLS = 59,
 
-      MODULAR_CODEGEN_DECLS = 60,
 
-      /// Record code for \#pragma pack options.
-      PACK_PRAGMA_OPTIONS = 61,
 
-      /// The stack of open #ifs/#ifdefs recorded in a preamble.
-      PP_CONDITIONAL_STACK = 62,
 
-      /// A table of skipped ranges within the preprocessing record.
-      PPD_SKIPPED_RANGES = 63
-    };
 
-    /// Record types used within a source manager block.
-    enum SourceManagerRecordTypes {
-      /// Describes a source location entry (SLocEntry) for a
-      /// file.
-      SM_SLOC_FILE_ENTRY = 1,
 
-      /// Describes a source location entry (SLocEntry) for a
-      /// buffer.
-      SM_SLOC_BUFFER_ENTRY = 2,
 
-      /// Describes a blob that contains the data for a buffer
-      /// entry. This kind of record always directly follows a
-      /// SM_SLOC_BUFFER_ENTRY record or a SM_SLOC_FILE_ENTRY with an
-      /// overridden buffer.
-      SM_SLOC_BUFFER_BLOB = 3,
 
-      /// Describes a zlib-compressed blob that contains the data for
-      /// a buffer entry.
-      SM_SLOC_BUFFER_BLOB_COMPRESSED = 4,
 
-      /// Describes a source location entry (SLocEntry) for a
-      /// macro expansion.
-      SM_SLOC_EXPANSION_ENTRY = 5
-    };
 
-    /// Record types used within a preprocessor block.
-    enum PreprocessorRecordTypes {
-      // The macros in the PP section are a PP_MACRO_* instance followed by a
-      // list of PP_TOKEN instances for each token in the definition.
 
-      /// An object-like macro definition.
-      /// [PP_MACRO_OBJECT_LIKE, IdentInfoID, SLoc, IsUsed]
-      PP_MACRO_OBJECT_LIKE = 1,
 
-      /// A function-like macro definition.
-      /// [PP_MACRO_FUNCTION_LIKE, \<ObjectLikeStuff>, IsC99Varargs,
-      /// IsGNUVarars, NumArgs, ArgIdentInfoID* ]
-      PP_MACRO_FUNCTION_LIKE = 2,
 
-      /// Describes one token.
-      /// [PP_TOKEN, SLoc, Length, IdentInfoID, Kind, Flags]
-      PP_TOKEN = 3,
 
-      /// The macro directives history for a particular identifier.
-      PP_MACRO_DIRECTIVE_HISTORY = 4,
 
-      /// A macro directive exported by a module.
-      /// [PP_MODULE_MACRO, SubmoduleID, MacroID, (Overridden SubmoduleID)*]
-      PP_MODULE_MACRO = 5,
-    };
 
-    /// Record types used within a preprocessor detail block.
-    enum PreprocessorDetailRecordTypes {
-      /// Describes a macro expansion within the preprocessing record.
-      PPD_MACRO_EXPANSION = 0,
 
-      /// Describes a macro definition within the preprocessing record.
-      PPD_MACRO_DEFINITION = 1,
 
-      /// Describes an inclusion directive within the preprocessing
-      /// record.
-      PPD_INCLUSION_DIRECTIVE = 2
-    };
 
-    /// Record types used within a submodule description block.
-    enum SubmoduleRecordTypes {
-      /// Metadata for submodules as a whole.
-      SUBMODULE_METADATA = 0,
 
-      /// Defines the major attributes of a submodule, including its
-      /// name and parent.
-      SUBMODULE_DEFINITION = 1,
 
-      /// Specifies the umbrella header used to create this module,
-      /// if any.
-      SUBMODULE_UMBRELLA_HEADER = 2,
 
-      /// Specifies a header that falls into this (sub)module.
-      SUBMODULE_HEADER = 3,
 
-      /// Specifies a top-level header that falls into this (sub)module.
-      SUBMODULE_TOPHEADER = 4,
 
-      /// Specifies an umbrella directory.
-      SUBMODULE_UMBRELLA_DIR = 5,
 
-      /// Specifies the submodules that are imported by this
-      /// submodule.
-      SUBMODULE_IMPORTS = 6,
 
-      /// Specifies the submodules that are re-exported from this
-      /// submodule.
-      SUBMODULE_EXPORTS = 7,
 
-      /// Specifies a required feature.
-      SUBMODULE_REQUIRES = 8,
 
-      /// Specifies a header that has been explicitly excluded
-      /// from this submodule.
-      SUBMODULE_EXCLUDED_HEADER = 9,
 
-      /// Specifies a library or framework to link against.
-      SUBMODULE_LINK_LIBRARY = 10,
 
-      /// Specifies a configuration macro for this module.
-      SUBMODULE_CONFIG_MACRO = 11,
 
-      /// Specifies a conflict with another module.
-      SUBMODULE_CONFLICT = 12,
 
-      /// Specifies a header that is private to this submodule.
-      SUBMODULE_PRIVATE_HEADER = 13,
 
-      /// Specifies a header that is part of the module but must be
-      /// textually included.
-      SUBMODULE_TEXTUAL_HEADER = 14,
 
-      /// Specifies a header that is private to this submodule but
-      /// must be textually included.
-      SUBMODULE_PRIVATE_TEXTUAL_HEADER = 15,
 
-      /// Specifies some declarations with initializers that must be
-      /// emitted to initialize the module.
-      SUBMODULE_INITIALIZERS = 16,
 
-      /// Specifies the name of the module that will eventually
-      /// re-export the entities in this module.
-      SUBMODULE_EXPORT_AS = 17,
-    };
 
-    /// Record types used within a comments block.
-    enum CommentRecordTypes {
-      COMMENTS_RAW_COMMENT = 0
-    };
+enum CommentRecordTypes { COMMENTS_RAW_COMMENT = 0 };
 
-    /// \defgroup ASTAST AST file AST constants
-    ///
-    /// The constants in this group describe various components of the
-    /// abstract syntax tree within an AST file.
-    ///
-    /// @{
 
-    /// Predefined type IDs.
-    ///
-    /// These type IDs correspond to predefined types in the AST
-    /// context, such as built-in types (int) and special place-holder
-    /// types (the \<overload> and \<dependent> type markers). Such
-    /// types are never actually serialized, since they will be built
-    /// by the AST context when it is created.
-    enum PredefinedTypeIDs {
-      /// The NULL type.
-      PREDEF_TYPE_NULL_ID       = 0,
+  PREDEF_TYPE_NULL_ID = 0,
 
-      /// The void type.
-      PREDEF_TYPE_VOID_ID       = 1,
+  PREDEF_TYPE_VOID_ID = 1,
 
-      /// The 'bool' or '_Bool' type.
-      PREDEF_TYPE_BOOL_ID       = 2,
+  PREDEF_TYPE_BOOL_ID = 2,
 
-      /// The 'char' type, when it is unsigned.
-      PREDEF_TYPE_CHAR_U_ID     = 3,
+  PREDEF_TYPE_CHAR_U_ID = 3,
 
-      /// The 'unsigned char' type.
-      PREDEF_TYPE_UCHAR_ID      = 4,
+  PREDEF_TYPE_UCHAR_ID = 4,
 
-      /// The 'unsigned short' type.
-      PREDEF_TYPE_USHORT_ID     = 5,
+  PREDEF_TYPE_USHORT_ID = 5,
 
-      /// The 'unsigned int' type.
-      PREDEF_TYPE_UINT_ID       = 6,
+  PREDEF_TYPE_UINT_ID = 6,
 
-      /// The 'unsigned long' type.
-      PREDEF_TYPE_ULONG_ID      = 7,
+  PREDEF_TYPE_ULONG_ID = 7,
 
-      /// The 'unsigned long long' type.
-      PREDEF_TYPE_ULONGLONG_ID  = 8,
+  PREDEF_TYPE_ULONGLONG_ID = 8,
 
-      /// The 'char' type, when it is signed.
-      PREDEF_TYPE_CHAR_S_ID     = 9,
+  PREDEF_TYPE_CHAR_S_ID = 9,
 
-      /// The 'signed char' type.
-      PREDEF_TYPE_SCHAR_ID      = 10,
+  PREDEF_TYPE_SCHAR_ID = 10,
 
-      /// The C++ 'wchar_t' type.
-      PREDEF_TYPE_WCHAR_ID      = 11,
+  PREDEF_TYPE_WCHAR_ID = 11,
 
-      /// The (signed) 'short' type.
-      PREDEF_TYPE_SHORT_ID      = 12,
+  PREDEF_TYPE_SHORT_ID = 12,
 
-      /// The (signed) 'int' type.
-      PREDEF_TYPE_INT_ID        = 13,
+  PREDEF_TYPE_INT_ID = 13,
 
-      /// The (signed) 'long' type.
-      PREDEF_TYPE_LONG_ID       = 14,
+  PREDEF_TYPE_LONG_ID = 14,
 
-      /// The (signed) 'long long' type.
-      PREDEF_TYPE_LONGLONG_ID   = 15,
+  PREDEF_TYPE_LONGLONG_ID = 15,
 
-      /// The 'float' type.
-      PREDEF_TYPE_FLOAT_ID      = 16,
+  PREDEF_TYPE_FLOAT_ID = 16,
 
-      /// The 'double' type.
-      PREDEF_TYPE_DOUBLE_ID     = 17,
+  PREDEF_TYPE_DOUBLE_ID = 17,
 
-      /// The 'long double' type.
-      PREDEF_TYPE_LONGDOUBLE_ID = 18,
 
-      /// The placeholder type for overloaded function sets.
-      PREDEF_TYPE_OVERLOAD_ID   = 19,
+  PREDEF_TYPE_OVERLOAD_ID = 19,
 
-      /// The placeholder type for dependent types.
-      PREDEF_TYPE_DEPENDENT_ID  = 20,
+  PREDEF_TYPE_DEPENDENT_ID = 20,
 
-      /// The '__uint128_t' type.
-      PREDEF_TYPE_UINT128_ID    = 21,
+  PREDEF_TYPE_UINT128_ID = 21,
 
-      /// The '__int128_t' type.
-      PREDEF_TYPE_INT128_ID     = 22,
+  PREDEF_TYPE_INT128_ID = 22,
 
-      /// The type of 'nullptr'.
-      PREDEF_TYPE_NULLPTR_ID    = 23,
+  PREDEF_TYPE_NULLPTR_ID = 23,
 
-      /// The C++ 'char16_t' type.
-      PREDEF_TYPE_CHAR16_ID     = 24,
+  PREDEF_TYPE_CHAR16_ID = 24,
 
-      /// The C++ 'char32_t' type.
-      PREDEF_TYPE_CHAR32_ID     = 25,
+  PREDEF_TYPE_CHAR32_ID = 25,
 
-      /// The ObjC 'id' type.
-      PREDEF_TYPE_OBJC_ID       = 26,
+  PREDEF_TYPE_OBJC_ID = 26,
 
-      /// The ObjC 'Class' type.
-      PREDEF_TYPE_OBJC_CLASS    = 27,
+  PREDEF_TYPE_OBJC_CLASS = 27,
 
-      /// The ObjC 'SEL' type.
-      PREDEF_TYPE_OBJC_SEL      = 28,
+  PREDEF_TYPE_OBJC_SEL = 28,
 
-      /// The 'unknown any' placeholder type.
-      PREDEF_TYPE_UNKNOWN_ANY   = 29,
+  PREDEF_TYPE_UNKNOWN_ANY = 29,
 
-      /// The placeholder type for bound member functions.
-      PREDEF_TYPE_BOUND_MEMBER  = 30,
+  PREDEF_TYPE_BOUND_MEMBER = 30,
 
-      /// The "auto" deduction type.
-      PREDEF_TYPE_AUTO_DEDUCT   = 31,
+  PREDEF_TYPE_AUTO_DEDUCT = 31,
 
-      /// The "auto &&" deduction type.
-      PREDEF_TYPE_AUTO_RREF_DEDUCT = 32,
 
-      /// The OpenCL 'half' / ARM NEON __fp16 type.
-      PREDEF_TYPE_HALF_ID       = 33,
+  PREDEF_TYPE_HALF_ID = 33,
 
-      /// ARC's unbridged-cast placeholder type.
-      PREDEF_TYPE_ARC_UNBRIDGED_CAST = 34,
 
-      /// The pseudo-object placeholder type.
-      PREDEF_TYPE_PSEUDO_OBJECT = 35,
 
-      /// The placeholder type for builtin functions.
-      PREDEF_TYPE_BUILTIN_FN = 36,
 
-      /// OpenCL event type.
-      PREDEF_TYPE_EVENT_ID      = 37,
+  PREDEF_TYPE_EVENT_ID = 37,
 
-      /// OpenCL clk event type.
-      PREDEF_TYPE_CLK_EVENT_ID  = 38,
+  PREDEF_TYPE_CLK_EVENT_ID = 38,
 
-      /// OpenCL sampler type.
-      PREDEF_TYPE_SAMPLER_ID    = 39,
+  PREDEF_TYPE_SAMPLER_ID = 39,
 
-      /// OpenCL queue type.
-      PREDEF_TYPE_QUEUE_ID      = 40,
+  PREDEF_TYPE_QUEUE_ID = 40,
 
-      /// OpenCL reserve_id type.
-      PREDEF_TYPE_RESERVE_ID_ID = 41,
 
-      /// The placeholder type for OpenMP array section.
-      PREDEF_TYPE_OMP_ARRAY_SECTION = 42,
 
-      /// The '__float128' type
-      PREDEF_TYPE_FLOAT128_ID = 43,
 
-      /// The '_Float16' type
-      PREDEF_TYPE_FLOAT16_ID = 44,
 
-      /// The C++ 'char8_t' type.
-      PREDEF_TYPE_CHAR8_ID = 45,
 
-      /// \brief The 'short _Accum' type
-      PREDEF_TYPE_SHORT_ACCUM_ID    = 46,
+  PREDEF_TYPE_SHORT_ACCUM_ID = 46,
 
-      /// \brief The '_Accum' type
-      PREDEF_TYPE_ACCUM_ID      = 47,
+  PREDEF_TYPE_ACCUM_ID = 47,
 
-      /// \brief The 'long _Accum' type
-      PREDEF_TYPE_LONG_ACCUM_ID = 48,
 
-      /// \brief The 'unsigned short _Accum' type
-      PREDEF_TYPE_USHORT_ACCUM_ID   = 49,
+  PREDEF_TYPE_USHORT_ACCUM_ID = 49,
 
-      /// \brief The 'unsigned _Accum' type
-      PREDEF_TYPE_UACCUM_ID     = 50,
+  PREDEF_TYPE_UACCUM_ID = 50,
 
-      /// \brief The 'unsigned long _Accum' type
-      PREDEF_TYPE_ULONG_ACCUM_ID    = 51,
+  PREDEF_TYPE_ULONG_ACCUM_ID = 51,
 
-      /// \brief The 'short _Fract' type
-      PREDEF_TYPE_SHORT_FRACT_ID = 52,
 
-      /// \brief The '_Fract' type
-      PREDEF_TYPE_FRACT_ID = 53,
 
-      /// \brief The 'long _Fract' type
-      PREDEF_TYPE_LONG_FRACT_ID = 54,
 
-      /// \brief The 'unsigned short _Fract' type
-      PREDEF_TYPE_USHORT_FRACT_ID = 55,
 
-      /// \brief The 'unsigned _Fract' type
-      PREDEF_TYPE_UFRACT_ID = 56,
 
-      /// \brief The 'unsigned long _Fract' type
-      PREDEF_TYPE_ULONG_FRACT_ID = 57,
 
-      /// \brief The '_Sat short _Accum' type
-      PREDEF_TYPE_SAT_SHORT_ACCUM_ID = 58,
 
-      /// \brief The '_Sat _Accum' type
-      PREDEF_TYPE_SAT_ACCUM_ID = 59,
 
-      /// \brief The '_Sat long _Accum' type
-      PREDEF_TYPE_SAT_LONG_ACCUM_ID = 60,
 
-      /// \brief The '_Sat unsigned short _Accum' type
-      PREDEF_TYPE_SAT_USHORT_ACCUM_ID = 61,
 
-      /// \brief The '_Sat unsigned _Accum' type
-      PREDEF_TYPE_SAT_UACCUM_ID = 62,
 
-      /// \brief The '_Sat unsigned long _Accum' type
-      PREDEF_TYPE_SAT_ULONG_ACCUM_ID = 63,
 
-      /// \brief The '_Sat short _Fract' type
-      PREDEF_TYPE_SAT_SHORT_FRACT_ID = 64,
 
-      /// \brief The '_Sat _Fract' type
-      PREDEF_TYPE_SAT_FRACT_ID = 65,
 
-      /// \brief The '_Sat long _Fract' type
-      PREDEF_TYPE_SAT_LONG_FRACT_ID = 66,
 
-      /// \brief The '_Sat unsigned short _Fract' type
-      PREDEF_TYPE_SAT_USHORT_FRACT_ID = 67,
 
-      /// \brief The '_Sat unsigned _Fract' type
-      PREDEF_TYPE_SAT_UFRACT_ID = 68,
 
-      /// \brief The '_Sat unsigned long _Fract' type
-      PREDEF_TYPE_SAT_ULONG_FRACT_ID = 69,
 
-      /// OpenCL image types with auto numeration
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-      PREDEF_TYPE_##Id##_ID,
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
 #include "clang/Basic/OpenCLImageTypes.def"
-      /// \brief OpenCL extension types with auto numeration
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-      PREDEF_TYPE_##Id##_ID,
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLExtensionTypes.def"
-      // \brief SVE types with auto numeration
 #define SVE_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/AArch64SVEACLETypes.def"
-    };
 
-    /// The number of predefined type IDs that are reserved for
-    /// the PREDEF_TYPE_* constants.
-    ///
-    /// Type IDs for non-predefined types will start at
-    /// NUM_PREDEF_TYPE_IDs.
-    const unsigned NUM_PREDEF_TYPE_IDS = 200;
 
-    /// Record codes for each kind of type.
-    ///
-    /// These constants describe the type records that can occur within a
-    /// block identified by DECLTYPES_BLOCK_ID in the AST file. Each
-    /// constant describes a record for a specific type class in the
-    /// AST. Note that DeclCode values share this code space.
-    enum TypeCode {
-#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
-      TYPE_##CODE_ID = CODE_VALUE,
+#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE)                           \
 #include "clang/Serialization/TypeBitCodes.def"
 
-      /// An ExtQualType record.
-      TYPE_EXT_QUAL = 1
-    };
 
-    /// The type IDs for special types constructed by semantic
-    /// analysis.
-    ///
-    /// The constants in this enumeration are indices into the
-    /// SPECIAL_TYPES record.
-    enum SpecialTypeIDs {
-      /// CFConstantString type
-      SPECIAL_TYPE_CF_CONSTANT_STRING          = 0,
+  SPECIAL_TYPE_CF_CONSTANT_STRING = 0,
 
-      /// C FILE typedef type
-      SPECIAL_TYPE_FILE                        = 1,
+  SPECIAL_TYPE_FILE = 1,
 
-      /// C jmp_buf typedef type
-      SPECIAL_TYPE_JMP_BUF                     = 2,
+  SPECIAL_TYPE_JMP_BUF = 2,
 
-      /// C sigjmp_buf typedef type
-      SPECIAL_TYPE_SIGJMP_BUF                  = 3,
+  SPECIAL_TYPE_SIGJMP_BUF = 3,
 
-      /// Objective-C "id" redefinition type
-      SPECIAL_TYPE_OBJC_ID_REDEFINITION        = 4,
+  SPECIAL_TYPE_OBJC_ID_REDEFINITION = 4,
 
-      /// Objective-C "Class" redefinition type
-      SPECIAL_TYPE_OBJC_CLASS_REDEFINITION     = 5,
+  SPECIAL_TYPE_OBJC_CLASS_REDEFINITION = 5,
 
-      /// Objective-C "SEL" redefinition type
-      SPECIAL_TYPE_OBJC_SEL_REDEFINITION       = 6,
+  SPECIAL_TYPE_OBJC_SEL_REDEFINITION = 6,
 
-      /// C ucontext_t typedef type
-      SPECIAL_TYPE_UCONTEXT_T                  = 7
-    };
+  SPECIAL_TYPE_UCONTEXT_T = 7
 
-    /// The number of special type IDs.
-    const unsigned NumSpecialTypeIDs = 8;
 
-    /// Predefined declaration IDs.
-    ///
-    /// These declaration IDs correspond to predefined declarations in the AST
-    /// context, such as the NULL declaration ID. Such declarations are never
-    /// actually serialized, since they will be built by the AST context when
-    /// it is created.
-    enum PredefinedDeclIDs {
-      /// The NULL declaration.
-      PREDEF_DECL_NULL_ID = 0,
 
-      /// The translation unit.
-      PREDEF_DECL_TRANSLATION_UNIT_ID = 1,
 
-      /// The Objective-C 'id' type.
-      PREDEF_DECL_OBJC_ID_ID = 2,
 
-      /// The Objective-C 'SEL' type.
-      PREDEF_DECL_OBJC_SEL_ID = 3,
 
-      /// The Objective-C 'Class' type.
-      PREDEF_DECL_OBJC_CLASS_ID = 4,
 
-      /// The Objective-C 'Protocol' type.
-      PREDEF_DECL_OBJC_PROTOCOL_ID = 5,
 
-      /// The signed 128-bit integer type.
-      PREDEF_DECL_INT_128_ID = 6,
 
-      /// The unsigned 128-bit integer type.
-      PREDEF_DECL_UNSIGNED_INT_128_ID = 7,
 
-      /// The internal 'instancetype' typedef.
-      PREDEF_DECL_OBJC_INSTANCETYPE_ID = 8,
 
-      /// The internal '__builtin_va_list' typedef.
-      PREDEF_DECL_BUILTIN_VA_LIST_ID = 9,
 
-      /// The internal '__va_list_tag' struct, if any.
-      PREDEF_DECL_VA_LIST_TAG = 10,
 
-      /// The internal '__builtin_ms_va_list' typedef.
-      PREDEF_DECL_BUILTIN_MS_VA_LIST_ID = 11,
 
-      /// The extern "C" context.
-      PREDEF_DECL_EXTERN_C_CONTEXT_ID = 12,
 
-      /// The internal '__make_integer_seq' template.
-      PREDEF_DECL_MAKE_INTEGER_SEQ_ID = 13,
 
-      /// The internal '__NSConstantString' typedef.
-      PREDEF_DECL_CF_CONSTANT_STRING_ID = 14,
 
-      /// The internal '__NSConstantString' tag type.
-      PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID = 15,
 
-      /// The internal '__type_pack_element' template.
-      PREDEF_DECL_TYPE_PACK_ELEMENT_ID = 16,
-    };
 
-    /// The number of declaration IDs that are predefined.
-    ///
-    /// For more information about predefined declarations, see the
-    /// \c PredefinedDeclIDs type and the PREDEF_DECL_*_ID constants.
-    const unsigned int NUM_PREDEF_DECL_IDS = 17;
 
-    /// Record of updates for a declaration that was modified after
-    /// being deserialized. This can occur within DECLTYPES_BLOCK_ID.
-    const unsigned int DECL_UPDATES = 49;
 
-    /// Record code for a list of local redeclarations of a declaration.
-    /// This can occur within DECLTYPES_BLOCK_ID.
-    const unsigned int LOCAL_REDECLARATIONS = 50;
 
-    /// Record codes for each kind of declaration.
-    ///
-    /// These constants describe the declaration records that can occur within
-    /// a declarations block (identified by DECLTYPES_BLOCK_ID). Each
-    /// constant describes a record for a specific declaration class
-    /// in the AST. Note that TypeCode values share this code space.
-    enum DeclCode {
-      /// A TypedefDecl record.
-      DECL_TYPEDEF = 51,
-      /// A TypeAliasDecl record.
 
-      DECL_TYPEALIAS,
 
-      /// An EnumDecl record.
-      DECL_ENUM,
 
-      /// A RecordDecl record.
-      DECL_RECORD,
 
-      /// An EnumConstantDecl record.
-      DECL_ENUM_CONSTANT,
 
-      /// A FunctionDecl record.
-      DECL_FUNCTION,
 
-      /// A ObjCMethodDecl record.
-      DECL_OBJC_METHOD,
 
-      /// A ObjCInterfaceDecl record.
-      DECL_OBJC_INTERFACE,
 
-      /// A ObjCProtocolDecl record.
-      DECL_OBJC_PROTOCOL,
 
-      /// A ObjCIvarDecl record.
-      DECL_OBJC_IVAR,
 
-      /// A ObjCAtDefsFieldDecl record.
-      DECL_OBJC_AT_DEFS_FIELD,
 
-      /// A ObjCCategoryDecl record.
-      DECL_OBJC_CATEGORY,
 
-      /// A ObjCCategoryImplDecl record.
-      DECL_OBJC_CATEGORY_IMPL,
 
-      /// A ObjCImplementationDecl record.
-      DECL_OBJC_IMPLEMENTATION,
 
-      /// A ObjCCompatibleAliasDecl record.
-      DECL_OBJC_COMPATIBLE_ALIAS,
 
-      /// A ObjCPropertyDecl record.
-      DECL_OBJC_PROPERTY,
 
-      /// A ObjCPropertyImplDecl record.
-      DECL_OBJC_PROPERTY_IMPL,
 
-      /// A FieldDecl record.
-      DECL_FIELD,
 
-      /// A MSPropertyDecl record.
-      DECL_MS_PROPERTY,
 
-      /// A VarDecl record.
-      DECL_VAR,
 
-      /// An ImplicitParamDecl record.
-      DECL_IMPLICIT_PARAM,
 
-      /// A ParmVarDecl record.
-      DECL_PARM_VAR,
 
-      /// A DecompositionDecl record.
-      DECL_DECOMPOSITION,
 
-      /// A BindingDecl record.
-      DECL_BINDING,
 
-      /// A FileScopeAsmDecl record.
-      DECL_FILE_SCOPE_ASM,
 
-      /// A BlockDecl record.
-      DECL_BLOCK,
 
-      /// A CapturedDecl record.
-      DECL_CAPTURED,
 
-      /// A record that stores the set of declarations that are
-      /// lexically stored within a given DeclContext.
-      ///
-      /// The record itself is a blob that is an array of declaration IDs,
-      /// in the order in which those declarations were added to the
-      /// declaration context. This data is used when iterating over
-      /// the contents of a DeclContext, e.g., via
-      /// DeclContext::decls_begin() and DeclContext::decls_end().
-      DECL_CONTEXT_LEXICAL,
 
-      /// A record that stores the set of declarations that are
-      /// visible from a given DeclContext.
-      ///
-      /// The record itself stores a set of mappings, each of which
-      /// associates a declaration name with one or more declaration
-      /// IDs. This data is used when performing qualified name lookup
-      /// into a DeclContext via DeclContext::lookup.
-      DECL_CONTEXT_VISIBLE,
 
-      /// A LabelDecl record.
-      DECL_LABEL,
 
-      /// A NamespaceDecl record.
-      DECL_NAMESPACE,
 
-      /// A NamespaceAliasDecl record.
-      DECL_NAMESPACE_ALIAS,
 
-      /// A UsingDecl record.
-      DECL_USING,
 
-      /// A UsingPackDecl record.
-      DECL_USING_PACK,
 
-      /// A UsingShadowDecl record.
-      DECL_USING_SHADOW,
 
-      /// A ConstructorUsingShadowDecl record.
-      DECL_CONSTRUCTOR_USING_SHADOW,
 
-      /// A UsingDirecitveDecl record.
-      DECL_USING_DIRECTIVE,
 
-      /// An UnresolvedUsingValueDecl record.
-      DECL_UNRESOLVED_USING_VALUE,
 
-      /// An UnresolvedUsingTypenameDecl record.
-      DECL_UNRESOLVED_USING_TYPENAME,
 
-      /// A LinkageSpecDecl record.
-      DECL_LINKAGE_SPEC,
 
-      /// An ExportDecl record.
-      DECL_EXPORT,
 
-      /// A CXXRecordDecl record.
-      DECL_CXX_RECORD,
 
-      /// A CXXDeductionGuideDecl record.
-      DECL_CXX_DEDUCTION_GUIDE,
 
-      /// A CXXMethodDecl record.
-      DECL_CXX_METHOD,
 
-      /// A CXXConstructorDecl record.
-      DECL_CXX_CONSTRUCTOR,
 
-      /// A CXXDestructorDecl record.
-      DECL_CXX_DESTRUCTOR,
 
-      /// A CXXConversionDecl record.
-      DECL_CXX_CONVERSION,
 
-      /// An AccessSpecDecl record.
-      DECL_ACCESS_SPEC,
 
-      /// A FriendDecl record.
-      DECL_FRIEND,
 
-      /// A FriendTemplateDecl record.
-      DECL_FRIEND_TEMPLATE,
 
-      /// A ClassTemplateDecl record.
-      DECL_CLASS_TEMPLATE,
 
-      /// A ClassTemplateSpecializationDecl record.
-      DECL_CLASS_TEMPLATE_SPECIALIZATION,
 
-      /// A ClassTemplatePartialSpecializationDecl record.
-      DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION,
 
-      /// A VarTemplateDecl record.
-      DECL_VAR_TEMPLATE,
 
-      /// A VarTemplateSpecializationDecl record.
-      DECL_VAR_TEMPLATE_SPECIALIZATION,
 
-      /// A VarTemplatePartialSpecializationDecl record.
-      DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION,
 
-      /// A FunctionTemplateDecl record.
-      DECL_FUNCTION_TEMPLATE,
 
-      /// A TemplateTypeParmDecl record.
-      DECL_TEMPLATE_TYPE_PARM,
 
-      /// A NonTypeTemplateParmDecl record.
-      DECL_NON_TYPE_TEMPLATE_PARM,
 
-      /// A TemplateTemplateParmDecl record.
-      DECL_TEMPLATE_TEMPLATE_PARM,
 
-      /// A TypeAliasTemplateDecl record.
-      DECL_TYPE_ALIAS_TEMPLATE,
 
-      /// \brief A ConceptDecl record.
-      DECL_CONCEPT,
 
-      /// \brief A StaticAssertDecl record.
-      DECL_STATIC_ASSERT,
 
-      /// A record containing CXXBaseSpecifiers.
-      DECL_CXX_BASE_SPECIFIERS,
 
-      /// A record containing CXXCtorInitializers.
-      DECL_CXX_CTOR_INITIALIZERS,
 
-      /// A IndirectFieldDecl record.
-      DECL_INDIRECTFIELD,
 
-      /// A NonTypeTemplateParmDecl record that stores an expanded
-      /// non-type template parameter pack.
-      DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK,
 
-      /// A TemplateTemplateParmDecl record that stores an expanded
-      /// template template parameter pack.
-      DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK,
 
-      /// A ClassScopeFunctionSpecializationDecl record a class scope
-      /// function specialization. (Microsoft extension).
-      DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION,
 
-      /// An ImportDecl recording a module import.
-      DECL_IMPORT,
 
-      /// An OMPThreadPrivateDecl record.
-      DECL_OMP_THREADPRIVATE,
 
-      /// An OMPRequiresDecl record.
-      DECL_OMP_REQUIRES,
 
-      /// An OMPAllocateDcl record.
-      DECL_OMP_ALLOCATE,
 
-      /// An EmptyDecl record.
-      DECL_EMPTY,
 
-      /// An LifetimeExtendedTemporaryDecl record.
-      DECL_LIFETIME_EXTENDED_TEMPORARY,
 
-      /// A RequiresExprBodyDecl record.
-      DECL_REQUIRES_EXPR_BODY,
 
-      /// An ObjCTypeParamDecl record.
-      DECL_OBJC_TYPE_PARAM,
 
-      /// An OMPCapturedExprDecl record.
-      DECL_OMP_CAPTUREDEXPR,
 
-      /// A PragmaCommentDecl record.
-      DECL_PRAGMA_COMMENT,
 
-      /// A PragmaDetectMismatchDecl record.
-      DECL_PRAGMA_DETECT_MISMATCH,
 
-      /// An OMPDeclareMapperDecl record.
-      DECL_OMP_DECLARE_MAPPER,
 
-      /// An OMPDeclareReductionDecl record.
-      DECL_OMP_DECLARE_REDUCTION,
 
-      DECL_LAST = DECL_OMP_DECLARE_REDUCTION
-    };
 
-    /// Record codes for each kind of statement or expression.
-    ///
-    /// These constants describe the records that describe statements
-    /// or expressions. These records  occur within type and declarations
-    /// block, so they begin with record values of 128.  Each constant
-    /// describes a record for a specific statement or expression class in the
-    /// AST.
-    enum StmtCode {
-      /// A marker record that indicates that we are at the end
-      /// of an expression.
-      STMT_STOP = DECL_LAST + 1,
 
-      /// A NULL expression.
-      STMT_NULL_PTR,
 
-      /// A reference to a previously [de]serialized Stmt record.
-      STMT_REF_PTR,
 
-      /// A NullStmt record.
-      STMT_NULL,
 
-      /// A CompoundStmt record.
-      STMT_COMPOUND,
 
-      /// A CaseStmt record.
-      STMT_CASE,
 
-      /// A DefaultStmt record.
-      STMT_DEFAULT,
 
-      /// A LabelStmt record.
-      STMT_LABEL,
 
-      /// An AttributedStmt record.
-      STMT_ATTRIBUTED,
 
-      /// An IfStmt record.
-      STMT_IF,
 
-      /// A SwitchStmt record.
-      STMT_SWITCH,
 
-      /// A WhileStmt record.
-      STMT_WHILE,
 
-      /// A DoStmt record.
-      STMT_DO,
 
-      /// A ForStmt record.
-      STMT_FOR,
 
-      /// A GotoStmt record.
-      STMT_GOTO,
 
-      /// An IndirectGotoStmt record.
-      STMT_INDIRECT_GOTO,
 
-      /// A ContinueStmt record.
-      STMT_CONTINUE,
 
-      /// A BreakStmt record.
-      STMT_BREAK,
 
-      /// A ReturnStmt record.
-      STMT_RETURN,
 
-      /// A DeclStmt record.
-      STMT_DECL,
 
-      /// A CapturedStmt record.
-      STMT_CAPTURED,
 
-      /// A GCC-style AsmStmt record.
-      STMT_GCCASM,
 
-      /// A MS-style AsmStmt record.
-      STMT_MSASM,
 
-      /// A constant expression context.
-      EXPR_CONSTANT,
 
-      /// A PredefinedExpr record.
-      EXPR_PREDEFINED,
 
-      /// A DeclRefExpr record.
-      EXPR_DECL_REF,
 
-      /// An IntegerLiteral record.
-      EXPR_INTEGER_LITERAL,
 
-      /// A FloatingLiteral record.
-      EXPR_FLOATING_LITERAL,
 
-      /// An ImaginaryLiteral record.
-      EXPR_IMAGINARY_LITERAL,
 
-      /// A StringLiteral record.
-      EXPR_STRING_LITERAL,
 
-      /// A CharacterLiteral record.
-      EXPR_CHARACTER_LITERAL,
 
-      /// A ParenExpr record.
-      EXPR_PAREN,
 
-      /// A ParenListExpr record.
-      EXPR_PAREN_LIST,
 
-      /// A UnaryOperator record.
-      EXPR_UNARY_OPERATOR,
 
-      /// An OffsetOfExpr record.
-      EXPR_OFFSETOF,
 
-      /// A SizefAlignOfExpr record.
-      EXPR_SIZEOF_ALIGN_OF,
 
-      /// An ArraySubscriptExpr record.
-      EXPR_ARRAY_SUBSCRIPT,
 
-      /// A CallExpr record.
-      EXPR_CALL,
 
-      /// A MemberExpr record.
-      EXPR_MEMBER,
 
-      /// A BinaryOperator record.
-      EXPR_BINARY_OPERATOR,
 
-      /// A CompoundAssignOperator record.
-      EXPR_COMPOUND_ASSIGN_OPERATOR,
 
-      /// A ConditionOperator record.
-      EXPR_CONDITIONAL_OPERATOR,
 
-      /// An ImplicitCastExpr record.
-      EXPR_IMPLICIT_CAST,
 
-      /// A CStyleCastExpr record.
-      EXPR_CSTYLE_CAST,
 
-      /// A CompoundLiteralExpr record.
-      EXPR_COMPOUND_LITERAL,
 
-      /// An ExtVectorElementExpr record.
-      EXPR_EXT_VECTOR_ELEMENT,
 
-      /// An InitListExpr record.
-      EXPR_INIT_LIST,
 
-      /// A DesignatedInitExpr record.
-      EXPR_DESIGNATED_INIT,
 
-      /// A DesignatedInitUpdateExpr record.
-      EXPR_DESIGNATED_INIT_UPDATE,
 
-      /// An NoInitExpr record.
-      EXPR_NO_INIT,
 
-      /// An ArrayInitLoopExpr record.
-      EXPR_ARRAY_INIT_LOOP,
 
-      /// An ArrayInitIndexExpr record.
-      EXPR_ARRAY_INIT_INDEX,
 
-      /// An ImplicitValueInitExpr record.
-      EXPR_IMPLICIT_VALUE_INIT,
 
-      /// A VAArgExpr record.
-      EXPR_VA_ARG,
 
-      /// An AddrLabelExpr record.
-      EXPR_ADDR_LABEL,
 
-      /// A StmtExpr record.
-      EXPR_STMT,
 
-      /// A ChooseExpr record.
-      EXPR_CHOOSE,
 
-      /// A GNUNullExpr record.
-      EXPR_GNU_NULL,
 
-      /// A SourceLocExpr record.
-      EXPR_SOURCE_LOC,
 
-      /// A ShuffleVectorExpr record.
-      EXPR_SHUFFLE_VECTOR,
 
-      /// A ConvertVectorExpr record.
-      EXPR_CONVERT_VECTOR,
 
-      /// BlockExpr
-      EXPR_BLOCK,
 
-      /// A GenericSelectionExpr record.
-      EXPR_GENERIC_SELECTION,
 
-      /// A PseudoObjectExpr record.
-      EXPR_PSEUDO_OBJECT,
 
-      /// An AtomicExpr record.
-      EXPR_ATOMIC,
 
-      // Objective-C
 
-      /// An ObjCStringLiteral record.
-      EXPR_OBJC_STRING_LITERAL,
 
-      EXPR_OBJC_BOXED_EXPRESSION,
-      EXPR_OBJC_ARRAY_LITERAL,
-      EXPR_OBJC_DICTIONARY_LITERAL,
 
-      /// An ObjCEncodeExpr record.
-      EXPR_OBJC_ENCODE,
 
-      /// An ObjCSelectorExpr record.
-      EXPR_OBJC_SELECTOR_EXPR,
 
-      /// An ObjCProtocolExpr record.
-      EXPR_OBJC_PROTOCOL_EXPR,
 
-      /// An ObjCIvarRefExpr record.
-      EXPR_OBJC_IVAR_REF_EXPR,
 
-      /// An ObjCPropertyRefExpr record.
-      EXPR_OBJC_PROPERTY_REF_EXPR,
 
-      /// An ObjCSubscriptRefExpr record.
-      EXPR_OBJC_SUBSCRIPT_REF_EXPR,
 
-      /// UNUSED
-      EXPR_OBJC_KVC_REF_EXPR,
 
-      /// An ObjCMessageExpr record.
-      EXPR_OBJC_MESSAGE_EXPR,
 
-      /// An ObjCIsa Expr record.
-      EXPR_OBJC_ISA,
 
-      /// An ObjCIndirectCopyRestoreExpr record.
-      EXPR_OBJC_INDIRECT_COPY_RESTORE,
 
-      /// An ObjCForCollectionStmt record.
-      STMT_OBJC_FOR_COLLECTION,
 
-      /// An ObjCAtCatchStmt record.
-      STMT_OBJC_CATCH,
 
-      /// An ObjCAtFinallyStmt record.
-      STMT_OBJC_FINALLY,
 
-      /// An ObjCAtTryStmt record.
-      STMT_OBJC_AT_TRY,
 
-      /// An ObjCAtSynchronizedStmt record.
-      STMT_OBJC_AT_SYNCHRONIZED,
 
-      /// An ObjCAtThrowStmt record.
-      STMT_OBJC_AT_THROW,
 
-      /// An ObjCAutoreleasePoolStmt record.
-      STMT_OBJC_AUTORELEASE_POOL,
 
-      /// An ObjCBoolLiteralExpr record.
-      EXPR_OBJC_BOOL_LITERAL,
 
-      /// An ObjCAvailabilityCheckExpr record.
-      EXPR_OBJC_AVAILABILITY_CHECK,
 
-      // C++
 
-      /// A CXXCatchStmt record.
-      STMT_CXX_CATCH,
 
-      /// A CXXTryStmt record.
-      STMT_CXX_TRY,
-      /// A CXXForRangeStmt record.
 
-      STMT_CXX_FOR_RANGE,
 
-      /// A CXXOperatorCallExpr record.
-      EXPR_CXX_OPERATOR_CALL,
 
-      /// A CXXMemberCallExpr record.
-      EXPR_CXX_MEMBER_CALL,
 
-      /// A CXXRewrittenBinaryOperator record.
-      EXPR_CXX_REWRITTEN_BINARY_OPERATOR,
 
-      /// A CXXConstructExpr record.
-      EXPR_CXX_CONSTRUCT,
 
-      /// A CXXInheritedCtorInitExpr record.
-      EXPR_CXX_INHERITED_CTOR_INIT,
 
-      /// A CXXTemporaryObjectExpr record.
-      EXPR_CXX_TEMPORARY_OBJECT,
 
-      /// A CXXStaticCastExpr record.
-      EXPR_CXX_STATIC_CAST,
 
-      /// A CXXDynamicCastExpr record.
-      EXPR_CXX_DYNAMIC_CAST,
 
-      /// A CXXReinterpretCastExpr record.
-      EXPR_CXX_REINTERPRET_CAST,
 
-      /// A CXXConstCastExpr record.
-      EXPR_CXX_CONST_CAST,
 
-      /// A CXXFunctionalCastExpr record.
-      EXPR_CXX_FUNCTIONAL_CAST,
 
-      /// A UserDefinedLiteral record.
-      EXPR_USER_DEFINED_LITERAL,
 
-      /// A CXXStdInitializerListExpr record.
-      EXPR_CXX_STD_INITIALIZER_LIST,
 
-      /// A CXXBoolLiteralExpr record.
-      EXPR_CXX_BOOL_LITERAL,
 
-      EXPR_CXX_NULL_PTR_LITERAL,  // CXXNullPtrLiteralExpr
-      EXPR_CXX_TYPEID_EXPR,       // CXXTypeidExpr (of expr).
-      EXPR_CXX_TYPEID_TYPE,       // CXXTypeidExpr (of type).
-      EXPR_CXX_THIS,              // CXXThisExpr
-      EXPR_CXX_THROW,             // CXXThrowExpr
-      EXPR_CXX_DEFAULT_ARG,       // CXXDefaultArgExpr
-      EXPR_CXX_DEFAULT_INIT,      // CXXDefaultInitExpr
-      EXPR_CXX_BIND_TEMPORARY,    // CXXBindTemporaryExpr
+  EXPR_CXX_NULL_PTR_LITERAL, // CXXNullPtrLiteralExpr
+  EXPR_CXX_TYPEID_EXPR,      // CXXTypeidExpr (of expr).
+  EXPR_CXX_TYPEID_TYPE,      // CXXTypeidExpr (of type).
+  EXPR_CXX_THIS,             // CXXThisExpr
+  EXPR_CXX_THROW,            // CXXThrowExpr
+  EXPR_CXX_DEFAULT_ARG,      // CXXDefaultArgExpr
+  EXPR_CXX_DEFAULT_INIT,     // CXXDefaultInitExpr
+  EXPR_CXX_BIND_TEMPORARY,   // CXXBindTemporaryExpr
 
-      EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr
-      EXPR_CXX_NEW,               // CXXNewExpr
-      EXPR_CXX_DELETE,            // CXXDeleteExpr
-      EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr
 
-      EXPR_EXPR_WITH_CLEANUPS,    // ExprWithCleanups
+  EXPR_EXPR_WITH_CLEANUPS, // ExprWithCleanups
 
-      EXPR_CXX_DEPENDENT_SCOPE_MEMBER,   // CXXDependentScopeMemberExpr
-      EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr
-      EXPR_CXX_UNRESOLVED_CONSTRUCT,     // CXXUnresolvedConstructExpr
-      EXPR_CXX_UNRESOLVED_MEMBER,        // UnresolvedMemberExpr
-      EXPR_CXX_UNRESOLVED_LOOKUP,        // UnresolvedLookupExpr
 
-      EXPR_CXX_EXPRESSION_TRAIT,  // ExpressionTraitExpr
-      EXPR_CXX_NOEXCEPT,          // CXXNoexceptExpr
+  EXPR_CXX_EXPRESSION_TRAIT, // ExpressionTraitExpr
+  EXPR_CXX_NOEXCEPT,         // CXXNoexceptExpr
 
-      EXPR_OPAQUE_VALUE,          // OpaqueValueExpr
-      EXPR_BINARY_CONDITIONAL_OPERATOR,  // BinaryConditionalOperator
-      EXPR_TYPE_TRAIT,            // TypeTraitExpr
-      EXPR_ARRAY_TYPE_TRAIT,      // ArrayTypeTraitIntExpr
+  EXPR_OPAQUE_VALUE,                // OpaqueValueExpr
+  EXPR_BINARY_CONDITIONAL_OPERATOR, // BinaryConditionalOperator
+  EXPR_TYPE_TRAIT,                  // TypeTraitExpr
+  EXPR_ARRAY_TYPE_TRAIT,            // ArrayTypeTraitIntExpr
 
-      EXPR_PACK_EXPANSION,        // PackExpansionExpr
-      EXPR_SIZEOF_PACK,           // SizeOfPackExpr
-      EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr
-      EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,// SubstNonTypeTemplateParmPackExpr
-      EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
-      EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
-      EXPR_CXX_FOLD,              // CXXFoldExpr
-      EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
-      EXPR_REQUIRES,              // RequiresExpr
+  EXPR_PACK_EXPANSION,                    // PackExpansionExpr
+  EXPR_SIZEOF_PACK,                       // SizeOfPackExpr
+  EXPR_SUBST_NON_TYPE_TEMPLATE_PARM,      // SubstNonTypeTemplateParmExpr
+  EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK, // SubstNonTypeTemplateParmPackExpr
+  EXPR_FUNCTION_PARM_PACK,                // FunctionParmPackExpr
+  EXPR_MATERIALIZE_TEMPORARY,             // MaterializeTemporaryExpr
+  EXPR_CXX_FOLD,                          // CXXFoldExpr
+  EXPR_CONCEPT_SPECIALIZATION,            // ConceptSpecializationExpr
+  EXPR_REQUIRES,                          // RequiresExpr
 
-      // CUDA
-      EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr
+  EXPR_CUDA_KERNEL_CALL, // CUDAKernelCallExpr
 
-      // OpenCL
-      EXPR_ASTYPE,                 // AsTypeExpr
+  EXPR_ASTYPE, // AsTypeExpr
 
-      // Microsoft
-      EXPR_CXX_PROPERTY_REF_EXPR, // MSPropertyRefExpr
-      EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr
-      EXPR_CXX_UUIDOF_EXPR,       // CXXUuidofExpr (of expr).
-      EXPR_CXX_UUIDOF_TYPE,       // CXXUuidofExpr (of type).
-      STMT_SEH_LEAVE,             // SEHLeaveStmt
-      STMT_SEH_EXCEPT,            // SEHExceptStmt
-      STMT_SEH_FINALLY,           // SEHFinallyStmt
-      STMT_SEH_TRY,               // SEHTryStmt
+  EXPR_CXX_PROPERTY_REF_EXPR,       // MSPropertyRefExpr
+  EXPR_CXX_UUIDOF_EXPR,             // CXXUuidofExpr (of expr).
+  EXPR_CXX_UUIDOF_TYPE,             // CXXUuidofExpr (of type).
+  STMT_SEH_LEAVE,                   // SEHLeaveStmt
+  STMT_SEH_EXCEPT,                  // SEHExceptStmt
+  STMT_SEH_FINALLY,                 // SEHFinallyStmt
+  STMT_SEH_TRY,                     // SEHTryStmt
 
-      // OpenMP directives
-      STMT_OMP_PARALLEL_DIRECTIVE,
-      STMT_OMP_SIMD_DIRECTIVE,
-      STMT_OMP_FOR_DIRECTIVE,
-      STMT_OMP_FOR_SIMD_DIRECTIVE,
-      STMT_OMP_SECTIONS_DIRECTIVE,
-      STMT_OMP_SECTION_DIRECTIVE,
-      STMT_OMP_SINGLE_DIRECTIVE,
-      STMT_OMP_MASTER_DIRECTIVE,
-      STMT_OMP_CRITICAL_DIRECTIVE,
-      STMT_OMP_PARALLEL_FOR_DIRECTIVE,
-      STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE,
-      STMT_OMP_PARALLEL_MASTER_DIRECTIVE,
-      STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE,
-      STMT_OMP_TASK_DIRECTIVE,
-      STMT_OMP_TASKYIELD_DIRECTIVE,
-      STMT_OMP_BARRIER_DIRECTIVE,
-      STMT_OMP_TASKWAIT_DIRECTIVE,
-      STMT_OMP_FLUSH_DIRECTIVE,
-      STMT_OMP_DEPOBJ_DIRECTIVE,
-      STMT_OMP_ORDERED_DIRECTIVE,
-      STMT_OMP_ATOMIC_DIRECTIVE,
-      STMT_OMP_TARGET_DIRECTIVE,
-      STMT_OMP_TARGET_DATA_DIRECTIVE,
-      STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE,
-      STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE,
-      STMT_OMP_TARGET_PARALLEL_DIRECTIVE,
-      STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE,
-      STMT_OMP_TEAMS_DIRECTIVE,
-      STMT_OMP_TASKGROUP_DIRECTIVE,
-      STMT_OMP_CANCELLATION_POINT_DIRECTIVE,
-      STMT_OMP_CANCEL_DIRECTIVE,
-      STMT_OMP_TASKLOOP_DIRECTIVE,
-      STMT_OMP_TASKLOOP_SIMD_DIRECTIVE,
-      STMT_OMP_MASTER_TASKLOOP_DIRECTIVE,
-      STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE,
-      STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE,
-      STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE,
-      STMT_OMP_DISTRIBUTE_DIRECTIVE,
-      STMT_OMP_TARGET_UPDATE_DIRECTIVE,
-      STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
-      STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
-      STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE,
-      STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE,
-      STMT_OMP_TARGET_SIMD_DIRECTIVE,
-      STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE,
-      STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
-      STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
-      STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
-      STMT_OMP_TARGET_TEAMS_DIRECTIVE,
-      STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
-      STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
-      STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
-      STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
-      EXPR_OMP_ARRAY_SECTION,
 
-      // ARC
-      EXPR_OBJC_BRIDGED_CAST,     // ObjCBridgedCastExpr
+  EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr
 
-      STMT_MS_DEPENDENT_EXISTS,   // MSDependentExistsStmt
-      EXPR_LAMBDA,                // LambdaExpr
-      STMT_COROUTINE_BODY,
-      STMT_CORETURN,
-      EXPR_COAWAIT,
-      EXPR_COYIELD,
-      EXPR_DEPENDENT_COAWAIT,
-    };
+  STMT_MS_DEPENDENT_EXISTS, // MSDependentExistsStmt
+  EXPR_LAMBDA,              // LambdaExpr
 
-    /// The kinds of designators that can occur in a
-    /// DesignatedInitExpr.
-    enum DesignatorTypes {
-      /// Field designator where only the field name is known.
-      DESIG_FIELD_NAME  = 0,
+  DESIG_FIELD_NAME = 0,
 
-      /// Field designator where the field has been resolved to
-      /// a declaration.
-      DESIG_FIELD_DECL  = 1,
+  DESIG_FIELD_DECL = 1,
 
-      /// Array designator.
-      DESIG_ARRAY       = 2,
+  DESIG_ARRAY = 2,
 
-      /// GNU array range designator.
-      DESIG_ARRAY_RANGE = 3
-    };
 
-    /// The different kinds of data that can occur in a
-    /// CtorInitializer.
-    enum CtorInitializerType {
-      CTOR_INITIALIZER_BASE,
-      CTOR_INITIALIZER_DELEGATING,
-      CTOR_INITIALIZER_MEMBER,
-      CTOR_INITIALIZER_INDIRECT_MEMBER
-    };
 
-    /// Kinds of cleanup objects owned by ExprWithCleanups.
-    enum CleanupObjectKind { COK_Block, COK_CompoundLiteral };
 
-    /// Describes the redeclarations of a declaration.
-    struct LocalRedeclarationsInfo {
-      // The ID of the first declaration
-      DeclID FirstID;
 
-      // Offset into the array of redeclaration chains.
-      unsigned Offset;
 
-      friend bool operator<(const LocalRedeclarationsInfo &X,
-                            const LocalRedeclarationsInfo &Y) {
-        return X.FirstID < Y.FirstID;
-      }
 
-      friend bool operator>(const LocalRedeclarationsInfo &X,
-                            const LocalRedeclarationsInfo &Y) {
-        return X.FirstID > Y.FirstID;
-      }
 
-      friend bool operator<=(const LocalRedeclarationsInfo &X,
-                             const LocalRedeclarationsInfo &Y) {
-        return X.FirstID <= Y.FirstID;
-      }
 
-      friend bool operator>=(const LocalRedeclarationsInfo &X,
-                             const LocalRedeclarationsInfo &Y) {
-        return X.FirstID >= Y.FirstID;
-      }
-    };
 
-    /// Describes the categories of an Objective-C class.
-    struct ObjCCategoriesInfo {
-      // The ID of the definition
-      DeclID DefinitionID;
 
-      // Offset into the array of category lists.
-      unsigned Offset;
 
-      friend bool operator<(const ObjCCategoriesInfo &X,
-                            const ObjCCategoriesInfo &Y) {
-        return X.DefinitionID < Y.DefinitionID;
-      }
 
-      friend bool operator>(const ObjCCategoriesInfo &X,
-                            const ObjCCategoriesInfo &Y) {
-        return X.DefinitionID > Y.DefinitionID;
-      }
 
-      friend bool operator<=(const ObjCCategoriesInfo &X,
-                             const ObjCCategoriesInfo &Y) {
-        return X.DefinitionID <= Y.DefinitionID;
-      }
 
-      friend bool operator>=(const ObjCCategoriesInfo &X,
-                             const ObjCCategoriesInfo &Y) {
-        return X.DefinitionID >= Y.DefinitionID;
-      }
-    };
 
-    /// A key used when looking up entities by \ref DeclarationName.
-    ///
-    /// Different \ref DeclarationNames are mapped to different keys, but the
-    /// same key can occasionally represent multiple names (for names that
-    /// contain types, in particular).
-    class DeclarationNameKey {
-      using NameKind = unsigned;
 
-      NameKind Kind = 0;
-      uint64_t Data = 0;
 
-    public:
-      DeclarationNameKey() = default;
-      DeclarationNameKey(DeclarationName Name);
-      DeclarationNameKey(NameKind Kind, uint64_t Data)
-          : Kind(Kind), Data(Data) {}
+  DeclarationNameKey(NameKind Kind, uint64_t Data) : Kind(Kind), Data(Data) {}
 
-      NameKind getKind() const { return Kind; }
 
-      IdentifierInfo *getIdentifier() const {
-        assert(Kind == DeclarationName::Identifier ||
-               Kind == DeclarationName::CXXLiteralOperatorName ||
-               Kind == DeclarationName::CXXDeductionGuideName);
-        return (IdentifierInfo *)Data;
-      }
 
-      Selector getSelector() const {
-        assert(Kind == DeclarationName::ObjCZeroArgSelector ||
-               Kind == DeclarationName::ObjCOneArgSelector ||
-               Kind == DeclarationName::ObjCMultiArgSelector);
-        return Selector(Data);
-      }
 
-      OverloadedOperatorKind getOperatorKind() const {
-        assert(Kind == DeclarationName::CXXOperatorName);
-        return (OverloadedOperatorKind)Data;
-      }
 
-      /// Compute a fingerprint of this key for use in on-disk hash table.
-      unsigned getHash() const;
 
-      friend bool operator==(const DeclarationNameKey &A,
-                             const DeclarationNameKey &B) {
-        return A.Kind == B.Kind && A.Data == B.Data;
-      }
-    };
 
-    /// @}
 
 } // namespace serialization
 } // namespace clang
 
 namespace llvm {
 
-  template <> struct DenseMapInfo<clang::serialization::DeclarationNameKey> {
-    static clang::serialization::DeclarationNameKey getEmptyKey() {
-      return clang::serialization::DeclarationNameKey(-1, 1);
-    }
 
-    static clang::serialization::DeclarationNameKey getTombstoneKey() {
-      return clang::serialization::DeclarationNameKey(-1, 2);
-    }
 
-    static unsigned
-    getHashValue(const clang::serialization::DeclarationNameKey &Key) {
-      return Key.getHash();
-    }
 
-    static bool isEqual(const clang::serialization::DeclarationNameKey &L,
-                        const clang::serialization::DeclarationNameKey &R) {
-      return L == R;
-    }
-  };
 
 } // namespace llvm
 
 #endif // LLVM_CLANG_SERIALIZATION_ASTBITCODES_H

clang/include/clang/Serialization/ASTReader.h

private:
   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;
-    uint64_t MacroDirectivesOffset;
+    /// Offset relative to ModuleFile::MacroOffsetsBase.
+    uint32_t MacroDirectivesOffset;
 
-    PendingMacroInfo(ModuleFile *M, uint64_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.
public:
 
   /// Add a macro to deserialize its macro directive history.
   ///
   /// \param II The name of the macro.
   /// \param M The module file.
   /// \param MacroDirectivesOffset Offset of the serialized macro directive
   /// history.
   void addPendingMacro(IdentifierInfo *II, ModuleFile *M,
-                       uint64_t MacroDirectivesOffset);
+                       uint32_t MacroDirectivesOffset);
 
   /// Read the set of macros defined by this external macro source.
   void ReadDefinedMacros() override;
 
   /// Update an out-of-date identifier.
   void updateOutOfDateIdentifier(IdentifierInfo &II) override;
 
   /// Note that this identifier is up-to-date.

clang/include/clang/Serialization/ASTWriter.h

struct MacroInfoToEmitData {
     const IdentifierInfo *Name;
     MacroInfo *MI;
     serialization::MacroID ID;
   };
 
   /// The macro infos to emit.
   std::vector<MacroInfoToEmitData> MacroInfosToEmit;
 
-  llvm::DenseMap<const IdentifierInfo *, uint64_t> IdentMacroDirectivesOffsetMap;
+  llvm::DenseMap<const IdentifierInfo *, uint32_t>
+      IdentMacroDirectivesOffsetMap;
 
   /// @name FlushStmt Caches
   /// @{
 
   /// Set of parent Stmts for the currently serializing sub-stmt.
   llvm::DenseSet<Stmt *> ParentStmts;
 
   /// Offsets of sub-stmts already serialized. The offset points
private:
   static ASTFileSignature createSignature(StringRef Bytes);
 
   void WriteInputFiles(SourceManager &SourceMgr, HeaderSearchOptions &HSOpts,
                        bool Modules);
   void WriteSourceManagerBlock(SourceManager &SourceMgr,
                                const Preprocessor &PP);
   void WritePreprocessor(const Preprocessor &PP, bool IsModule);
   void WriteHeaderSearch(const HeaderSearch &HS);
-  void WritePreprocessorDetail(PreprocessingRecord &PPRec);
+  void WritePreprocessorDetail(PreprocessingRecord &PPRec,
+                               uint64_t MacroOffsetsBase);
   void WriteSubmodules(Module *WritingModule);
 
   void WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag,
                                      bool isModule);
 
   unsigned TypeExtQualAbbrev = 0;
   unsigned TypeFunctionProtoAbbrev = 0;
   void WriteTypeAbbrevs();
public:
   serialization::IdentID getIdentifierRef(const IdentifierInfo *II);
 
   /// Get the unique number used to refer to the given macro.
   serialization::MacroID getMacroRef(MacroInfo *MI, const IdentifierInfo *Name);
 
   /// Determine the ID of an already-emitted macro.
   serialization::MacroID getMacroID(MacroInfo *MI);
 
-  uint64_t getMacroDirectivesOffset(const IdentifierInfo *Name);
+  uint32_t getMacroDirectivesOffset(const IdentifierInfo *Name);
 
   /// Emit a reference to a type.
   void AddTypeRef(QualType T, RecordDataImpl &Record);
 
   /// Force a type to be emitted and get its ID.
   serialization::TypeID GetOrCreateTypeID(QualType T);
 
   /// Determine the type ID of an already-emitted type.

clang/include/clang/Serialization/ModuleFile.h

public:
   unsigned LocalNumSLocEntries = 0;
 
   /// The base ID in the source manager's view of this module.
   int SLocEntryBaseID = 0;
 
   /// The base offset in the source manager's view of this module.
   unsigned SLocEntryBaseOffset = 0;
 
+  /// Base file offset for the offsets in SLocEntryOffsets. Real file offset
+  /// for the entry is SLocEntryOffsetsBase + SLocEntryOffsets[i].
+  uint64_t SLocEntryOffsetsBase = 0;
+
   /// Offsets for all of the source location entries in the
   /// AST file.
   const uint32_t *SLocEntryOffsets = nullptr;
 
   /// SLocEntries that we're going to preload.
   SmallVector<uint64_t, 4> PreloadSLocEntries;
 
   /// Remapping table for source locations in this module.
public:
 
   /// The cursor to the start of the preprocessor block, which stores
   /// all of the macro definitions.
   llvm::BitstreamCursor MacroCursor;
 
   /// The number of macros in this AST file.
   unsigned LocalNumMacros = 0;
 
+  /// Base file offset for the offsets in MacroOffsets. Real file offset for
+  /// the entry is MacroOffsetsBase + MacroOffsets[i].
+  uint64_t MacroOffsetsBase = 0;
+
   /// Offsets of macros in the preprocessor block.
   ///
   /// This array is indexed by the macro ID (-1), and provides
   /// the offset into the preprocessor block where macro definitions are
   /// stored.
   const uint32_t *MacroOffsets = nullptr;
 
   /// Base macro ID for macros local to this module.

clang/lib/Serialization/ASTReader.cpp

auto ReadBuffer = [this](
     } else {
       Error("AST record has invalid code");
       return nullptr;
     }
   };
 
   ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
   if (llvm::Error Err = F->SLocEntryCursor.JumpToBit(
+          F->SLocEntryOffsetsBase +
           F->SLocEntryOffsets[ID - F->SLocEntryBaseID])) {
     Error(std::move(Err));
     return true;
   }
 
   BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
   unsigned BaseOffset = F->SLocEntryBaseOffset;
 
HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
   }
 
   // This HeaderFileInfo was externally loaded.
   HFI.External = true;
   HFI.IsValid = true;
   return HFI;
 }
 
-void ASTReader::addPendingMacro(IdentifierInfo *II,
-                                ModuleFile *M,
-                                uint64_t MacroDirectivesOffset) {
+void ASTReader::addPendingMacro(IdentifierInfo *II, ModuleFile *M,
+                                uint32_t MacroDirectivesOffset) {
   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
   PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
 }
 
 void ASTReader::ReadDefinedMacros() {
   // Note that we are loading defined macros.
   Deserializing Macros(this);
 

 }
 
 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
                                     const PendingMacroInfo &PMInfo) {
   ModuleFile &M = *PMInfo.M;
 
   BitstreamCursor &Cursor = M.MacroCursor;
   SavedStreamPosition SavedPosition(Cursor);
-  if (llvm::Error Err = Cursor.JumpToBit(PMInfo.MacroDirectivesOffset)) {
+  if (llvm::Error Err =
+          Cursor.JumpToBit(M.MacroOffsetsBase + PMInfo.MacroDirectivesOffset)) {
     Error(std::move(Err));
     return;
   }
 
   struct ModuleMacroRecord {
     SubmoduleID SubModID;
     MacroInfo *MI;
     SmallVector<SubmoduleID, 8> Overrides;
while (true) {
     default:  // Default behavior: ignore.
       break;
 
     case TYPE_OFFSET: {
       if (F.LocalNumTypes != 0) {
         Error("duplicate TYPE_OFFSET record in AST file");
         return Failure;
       }
       F.TypeOffsets = (const uint32_t *)Blob.data();
       F.LocalNumTypes = Record[0];
       unsigned LocalBaseTypeIndex = Record[1];
       F.BaseTypeIndex = getTotalNumTypes();
 
       if (F.LocalNumTypes > 0) {
         // Introduce the global -> local mapping for types within this module.
         GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
 
case FILE_SORTED_DECLS:
       F.FileSortedDecls = (const DeclID *)Blob.data();
       F.NumFileSortedDecls = Record[0];
       break;
 
     case SOURCE_LOCATION_OFFSETS: {
       F.SLocEntryOffsets = (const uint32_t *)Blob.data();
       F.LocalNumSLocEntries = Record[0];
       unsigned SLocSpaceSize = Record[1];
+      F.SLocEntryOffsetsBase = Record[2];
       std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
           SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
                                               SLocSpaceSize);
       if (!F.SLocEntryBaseID) {
         Error("ran out of source locations");
         break;
       }
       // Make our entry in the range map. BaseID is negative and growing, so
while (true) {
     case MACRO_OFFSET: {
       if (F.LocalNumMacros != 0) {
         Error("duplicate MACRO_OFFSET record in AST file");
         return Failure;
       }
       F.MacroOffsets = (const uint32_t *)Blob.data();
       F.LocalNumMacros = Record[0];
       unsigned LocalBaseMacroID = Record[1];
+      F.MacroOffsetsBase = Record[2];
       F.BaseMacroID = getTotalNumMacros();
 
       if (F.LocalNumMacros > 0) {
         // Introduce the global -> local mapping for macros within this module.
         GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
 
         // Introduce the local -> global mapping for macros within this module.
         F.MacroRemap.insertOrReplace(
PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
 
   if (!PP.getPreprocessingRecord()) {
     Error("no preprocessing record");
     return nullptr;
   }
 
   SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
-  if (llvm::Error Err =
-          M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset)) {
+  if (llvm::Error Err = M.PreprocessorDetailCursor.JumpToBit(
+          M.MacroOffsetsBase + PPOffs.BitOffset)) {
     Error(std::move(Err));
     return nullptr;
   }
 
   Expected<llvm::BitstreamEntry> MaybeEntry =
       M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
   if (!MaybeEntry) {
     Error(MaybeEntry.takeError());
MacroInfo *ASTReader::getMacro(MacroID ID) {
 
   ID -= NUM_PREDEF_MACRO_IDS;
   if (!MacrosLoaded[ID]) {
     GlobalMacroMapType::iterator I
       = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
     assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
     ModuleFile *M = I->second;
     unsigned Index = ID - M->BaseMacroID;
-    MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
+    MacrosLoaded[ID] =
+        ReadMacroRecord(*M, M->MacroOffsetsBase + M->MacroOffsets[Index]);
 
     if (DeserializationListener)
       DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
                                          MacrosLoaded[ID]);
   }
 
   return MacrosLoaded[ID];
 }

clang/lib/Serialization/ASTWriter.cpp

void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
   unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false);
   unsigned SLocBufferBlobCompressedAbbrv =
       CreateSLocBufferBlobAbbrev(Stream, true);
   unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
 
   // Write out the source location entry table. We skip the first
   // entry, which is always the same dummy entry.
   std::vector<uint32_t> SLocEntryOffsets;
+  uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
   RecordData PreloadSLocs;
   SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
   for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
        I != N; ++I) {
     // Get this source location entry.
     const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
     FileID FID = FileID::get(I);
     assert(&SourceMgr.getSLocEntry(FID) == SLoc);
 
     // Record the offset of this source-location entry.
-    SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
+    uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
+    assert((Offset >> 32) == 0 && "SLocEntry offset too large");
+    SLocEntryOffsets.push_back(Offset);
 
     // Figure out which record code to use.
     unsigned Code;
     if (SLoc->isFile()) {
       const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
       if (Cache->OrigEntry) {
         Code = SM_SLOC_FILE_ENTRY;
       } else
void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
   // Write the source-location offsets table into the AST block. This
   // table is used for lazily loading source-location information.
   using namespace llvm;
 
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // base offset
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
   unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
   {
     RecordData::value_type Record[] = {
         SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(),
-        SourceMgr.getNextLocalOffset() - 1 /* skip dummy */};
+        SourceMgr.getNextLocalOffset() - 1 /* skip dummy */,
+        SLocEntryOffsetsBase};
     Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record,
                               bytes(SLocEntryOffsets));
   }
   // Write the source location entry preloads array, telling the AST
   // reader which source locations entries it should load eagerly.
   Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
 
   // Write the line table. It depends on remapping working, so it must come
static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule,
   }
 
   return false;
 }
 
 /// Writes the block containing the serialized form of the
 /// preprocessor.
 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
+  uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
+
   PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
   if (PPRec)
-    WritePreprocessorDetail(*PPRec);
+    WritePreprocessorDetail(*PPRec, MacroOffsetsBase);
 
   RecordData Record;
   RecordData ModuleMacroRecord;
 
   // If the preprocessor __COUNTER__ value has been bumped, remember it.
   if (PP.getCounterValue() != 0) {
     RecordData::value_type Record[] = {PP.getCounterValue()};
     Stream.EmitRecord(PP_COUNTER_VALUE, Record);
void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
   // Sort the set of macro definitions that need to be serialized by the
   // name of the macro, to provide a stable ordering.
   llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>());
 
   // Emit the macro directives as a list and associate the offset with the
   // identifier they belong to.
   for (const IdentifierInfo *Name : MacroIdentifiers) {
     MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name);
-    auto StartOffset = Stream.GetCurrentBitNo();
+    uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
+    assert((StartOffset >> 32) == 0 && "Macro identifiers offset too large");
 
     // Emit the macro directives in reverse source order.
     for (; MD; MD = MD->getPrevious()) {
       // Once we hit an ignored macro, we're done: the rest of the chain
       // will all be ignored macros.
       if (shouldIgnoreMacro(MD, IsModule, PP))
         break;
 
for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
 
     if (ID < FirstMacroID) {
       assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?");
       continue;
     }
 
     // Record the local offset of this macro.
     unsigned Index = ID - FirstMacroID;
-    if (Index == MacroOffsets.size())
-      MacroOffsets.push_back(Stream.GetCurrentBitNo());
-    else {
-      if (Index > MacroOffsets.size())
-        MacroOffsets.resize(Index + 1);
+    if (Index >= MacroOffsets.size())
 
-      MacroOffsets[Index] = Stream.GetCurrentBitNo();
-    }
+    uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
+    assert((Offset >> 32) == 0 && "Macro offset too large");
+    MacroOffsets[Index] = Offset;
 
     AddIdentifierRef(Name, Record);
     AddSourceLocation(MI->getDefinitionLoc(), Record);
     AddSourceLocation(MI->getDefinitionEndLoc(), Record);
     Record.push_back(MI->isUsed());
     Record.push_back(MI->isUsedForHeaderGuard());
     unsigned Code;
     if (MI->isObjectLike()) {
void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
 
   // Write the offsets table for macro IDs.
   using namespace llvm;
 
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));   // base offset
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 
   unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
   {
     RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(),
-                                       FirstMacroID - NUM_PREDEF_MACRO_IDS};
+                                       FirstMacroID - NUM_PREDEF_MACRO_IDS,
+                                       MacroOffsetsBase};
     Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, bytes(MacroOffsets));
   }
 }
 
-void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
+void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec,
+                                        uint64_t MacroOffsetsBase) {
   if (PPRec.local_begin() == PPRec.local_end())
     return;
 
   SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
 
   // Enter the preprocessor block.
   Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
 
void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec,
   unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
   RecordData Record;
   for (PreprocessingRecord::iterator E = PPRec.local_begin(),
                                   EEnd = PPRec.local_end();
        E != EEnd;
        (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
     Record.clear();
 
+    uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
+    assert((Offset >> 32) == 0 && "Preprocessed entity offset too large");
     PreprocessedEntityOffsets.push_back(
-        PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo()));
+        PPEntityOffset((*E)->getSourceRange(), Offset));
 
     if (auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
       // Record this macro definition's ID.
       MacroDefinitions[MD] = NextPreprocessorEntityID;
 
       AddIdentifierRef(MD->getName(), Record);
       Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
       continue;

 MacroID ASTWriter::getMacroID(MacroInfo *MI) {
   if (!MI || MI->isBuiltinMacro())
     return 0;
 
   assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!");
   return MacroIDs[MI];
 }
 
-uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) {
+uint32_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) {
   return IdentMacroDirectivesOffsetMap.lookup(Name);
 }
 
 void ASTRecordWriter::AddSelectorRef(const Selector SelRef) {
   Record->push_back(Writer->getSelectorRef(SelRef));
 }
 
 SelectorID ASTWriter::getSelectorRef(Selector Sel) {