Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- ASTBitCodes.h - Enum values for the PCH bitcode format ---*- C++ -*-===//

//

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

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

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

//

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

//

// This header defines Bitcode enum values for Clang serialized AST files.

//

// The enum values defined in this file should be considered permanent.  If

// new features are added, they should have values added at the end of the

// respective lists.

//

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

#ifndef LLVM_CLANG_SERIALIZATION_ASTBITCODES_H

#define LLVM_CLANG_SERIALIZATION_ASTBITCODES_H

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Type.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/OperatorKinds.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 = 25;

/// 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);

  }

  static QualType getTombstoneKey() {

    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.

  SourceLocation::UIntTy Begin;

  /// Raw source location of end of range.

  SourceLocation::UIntTy End;

  /// Offset in the AST file relative to ModuleFile::MacroOffsetsBase.

  uint32_t BitOffset;

  PPEntityOffset(SourceRange R, uint32_t 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.

  SourceLocation::UIntTy Begin;

  /// Raw source location of end of range.

  SourceLocation::UIntTy End;

  PPSkippedRange(SourceRange R)

      : Begin(R.getBegin().getRawEncoding()), End(R.getEnd().getRawEncoding()) {

  }

  SourceLocation getBegin() const {

    return SourceLocation::getFromRawEncoding(Begin);

  }

  SourceLocation getEnd() const {

    return SourceLocation::getFromRawEncoding(End);

  }

};

/// Offset in the AST file. Use splitted 64-bit integer into low/high

/// parts to keep structure alignment 32-bit (it is important because

/// blobs in bitstream are 32-bit aligned). This structure is serialized

/// "as is" to the AST file.

struct UnderalignedInt64 {

  uint32_t BitOffsetLow = 0;

  uint32_t BitOffsetHigh = 0;

  UnderalignedInt64() = default;

  UnderalignedInt64(uint64_t BitOffset) { setBitOffset(BitOffset); }

  void setBitOffset(uint64_t Offset) {

    BitOffsetLow = Offset;

    BitOffsetHigh = Offset >> 32;

  }

  uint64_t getBitOffset() const {

    return BitOffsetLow | (uint64_t(BitOffsetHigh) << 32);

  }

};

/// Source location and bit offset of a declaration.

struct DeclOffset {

  /// Raw source location.

  SourceLocation::UIntTy Loc = 0;

  /// Offset relative to the start of the DECLTYPES_BLOCK block. Keep

  /// structure alignment 32-bit and avoid padding gap because undefined

  /// value in the padding affects AST hash.

  UnderalignedInt64 BitOffset;

  DeclOffset() = default;

  DeclOffset(SourceLocation Loc, uint64_t BitOffset,

             uint64_t DeclTypesBlockStartOffset) {

    setLocation(Loc);

    setBitOffset(BitOffset, DeclTypesBlockStartOffset);

  }

  void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }

  SourceLocation getLocation() const {

    return SourceLocation::getFromRawEncoding(Loc);

  }

  void setBitOffset(uint64_t Offset, const uint64_t DeclTypesBlockStartOffset) {

    BitOffset.setBitOffset(Offset - DeclTypesBlockStartOffset);

  }

  uint64_t getBitOffset(const uint64_t DeclTypesBlockStartOffset) const {

    return BitOffset.getBitOffset() + DeclTypesBlockStartOffset;

  }

};

/// 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,

  /// 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 content hash of the AST block.

  AST_BLOCK_HASH,

  /// Record code for the diagnostic options table.

  DIAGNOSTIC_OPTIONS,

  /// Record code for the headers search paths.

  HEADER_SEARCH_PATHS,

  /// Record code for \#pragma diagnostic mappings.

  DIAG_PRAGMA_MAPPINGS,

  /// Record code for the indices of used header search entries.

  HEADER_SEARCH_ENTRY_USAGE,

};

/// 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 align/pack options.

  ALIGN_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 code for the Decls to be checked for deferred diags.

  DECLS_TO_CHECK_FOR_DEFERRED_DIAGS = 64,

  /// Record code for \#pragma float_control options.

  FLOAT_CONTROL_PRAGMA_OPTIONS = 65,

  /// Record code for included files.

  PP_INCLUDED_FILES = 66,

  /// Record code for an unterminated \#pragma clang assume_nonnull begin

  /// recorded in a preamble.

  PP_ASSUME_NONNULL_LOC = 67,

};

/// 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,

  /// Specifies affecting modules that were not imported.

  SUBMODULE_AFFECTING_MODULES = 18,

};

/// Record types used within a comments block.

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,

  /// The void type.

  PREDEF_TYPE_VOID_ID = 1,

  /// The 'bool' or '_Bool' type.

  PREDEF_TYPE_BOOL_ID = 2,

  /// The 'char' type, when it is unsigned.

  PREDEF_TYPE_CHAR_U_ID = 3,

  /// The 'unsigned char' type.

  PREDEF_TYPE_UCHAR_ID = 4,

  /// The 'unsigned short' type.

  PREDEF_TYPE_USHORT_ID = 5,

  /// The 'unsigned int' type.

  PREDEF_TYPE_UINT_ID = 6,

  /// The 'unsigned long' type.

  PREDEF_TYPE_ULONG_ID = 7,

  /// The 'unsigned long long' type.

  PREDEF_TYPE_ULONGLONG_ID = 8,

  /// The 'char' type, when it is signed.

  PREDEF_TYPE_CHAR_S_ID = 9,

  /// The 'signed char' type.

  PREDEF_TYPE_SCHAR_ID = 10,

  /// The C++ 'wchar_t' type.

  PREDEF_TYPE_WCHAR_ID = 11,

  /// The (signed) 'short' type.

  PREDEF_TYPE_SHORT_ID = 12,

  /// The (signed) 'int' type.

  PREDEF_TYPE_INT_ID = 13,

  /// The (signed) 'long' type.

  PREDEF_TYPE_LONG_ID = 14,

  /// The (signed) 'long long' type.

  PREDEF_TYPE_LONGLONG_ID = 15,

  /// The 'float' type.

  PREDEF_TYPE_FLOAT_ID = 16,

  /// The 'double' type.

  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,

  /// The placeholder type for dependent types.

  PREDEF_TYPE_DEPENDENT_ID = 20,

  /// The '__uint128_t' type.

  PREDEF_TYPE_UINT128_ID = 21,

  /// The '__int128_t' type.

  PREDEF_TYPE_INT128_ID = 22,

  /// The type of 'nullptr'.

  PREDEF_TYPE_NULLPTR_ID = 23,

  /// The C++ 'char16_t' type.

  PREDEF_TYPE_CHAR16_ID = 24,

  /// The C++ 'char32_t' type.

  PREDEF_TYPE_CHAR32_ID = 25,

  /// The ObjC 'id' type.

  PREDEF_TYPE_OBJC_ID = 26,

  /// The ObjC 'Class' type.

  PREDEF_TYPE_OBJC_CLASS = 27,

  /// The ObjC 'SEL' type.

  PREDEF_TYPE_OBJC_SEL = 28,

  /// The 'unknown any' placeholder type.

  PREDEF_TYPE_UNKNOWN_ANY = 29,

  /// The placeholder type for bound member functions.

  PREDEF_TYPE_BOUND_MEMBER = 30,