Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- ASTBitCodes.h - Enum values for the PCH bitcode format ---*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This header defines Bitcode enum values for Clang serialized AST files.
  10. //
  11. // The enum values defined in this file should be considered permanent.  If
  12. // new features are added, they should have values added at the end of the
  13. // respective lists.
  14. //
  15. //===----------------------------------------------------------------------===//
  16.  
  17. #ifndef LLVM_CLANG_SERIALIZATION_ASTBITCODES_H
  18. #define LLVM_CLANG_SERIALIZATION_ASTBITCODES_H
  19.  
  20. #include "clang/AST/DeclarationName.h"
  21. #include "clang/AST/Type.h"
  22. #include "clang/Basic/IdentifierTable.h"
  23. #include "clang/Basic/OperatorKinds.h"
  24. #include "clang/Basic/SourceLocation.h"
  25. #include "llvm/ADT/DenseMapInfo.h"
  26. #include "llvm/Bitstream/BitCodes.h"
  27. #include <cassert>
  28. #include <cstdint>
  29.  
  30. namespace clang {
  31. namespace serialization {
  32.  
  33. /// AST file major version number supported by this version of
  34. /// Clang.
  35. ///
  36. /// Whenever the AST file format changes in a way that makes it
  37. /// incompatible with previous versions (such that a reader
  38. /// designed for the previous version could not support reading
  39. /// the new version), this number should be increased.
  40. ///
  41. /// Version 4 of AST files also requires that the version control branch and
  42. /// revision match exactly, since there is no backward compatibility of
  43. /// AST files at this time.
  44. const unsigned VERSION_MAJOR = 25;
  45.  
  46. /// AST file minor version number supported by this version of
  47. /// Clang.
  48. ///
  49. /// Whenever the AST format changes in a way that is still
  50. /// compatible with previous versions (such that a reader designed
  51. /// for the previous version could still support reading the new
  52. /// version by ignoring new kinds of subblocks), this number
  53. /// should be increased.
  54. const unsigned VERSION_MINOR = 0;
  55.  
  56. /// An ID number that refers to an identifier in an AST file.
  57. ///
  58. /// The ID numbers of identifiers are consecutive (in order of discovery)
  59. /// and start at 1. 0 is reserved for NULL.
  60. using IdentifierID = uint32_t;
  61.  
  62. /// An ID number that refers to a declaration in an AST file.
  63. ///
  64. /// The ID numbers of declarations are consecutive (in order of
  65. /// discovery), with values below NUM_PREDEF_DECL_IDS being reserved.
  66. /// At the start of a chain of precompiled headers, declaration ID 1 is
  67. /// used for the translation unit declaration.
  68. using DeclID = uint32_t;
  69.  
  70. // FIXME: Turn these into classes so we can have some type safety when
  71. // we go from local ID to global and vice-versa.
  72. using LocalDeclID = DeclID;
  73. using GlobalDeclID = DeclID;
  74.  
  75. /// An ID number that refers to a type in an AST file.
  76. ///
  77. /// The ID of a type is partitioned into two parts: the lower
  78. /// three bits are used to store the const/volatile/restrict
  79. /// qualifiers (as with QualType) and the upper bits provide a
  80. /// type index. The type index values are partitioned into two
  81. /// sets. The values below NUM_PREDEF_TYPE_IDs are predefined type
  82. /// IDs (based on the PREDEF_TYPE_*_ID constants), with 0 as a
  83. /// placeholder for "no type". Values from NUM_PREDEF_TYPE_IDs are
  84. /// other types that have serialized representations.
  85. using TypeID = uint32_t;
  86.  
  87. /// A type index; the type ID with the qualifier bits removed.
  88. class TypeIdx {
  89.   uint32_t Idx = 0;
  90.  
  91. public:
  92.   TypeIdx() = default;
  93.   explicit TypeIdx(uint32_t index) : Idx(index) {}
  94.  
  95.   uint32_t getIndex() const { return Idx; }
  96.  
  97.   TypeID asTypeID(unsigned FastQuals) const {
  98.     if (Idx == uint32_t(-1))
  99.       return TypeID(-1);
  100.  
  101.     return (Idx << Qualifiers::FastWidth) | FastQuals;
  102.   }
  103.  
  104.   static TypeIdx fromTypeID(TypeID ID) {
  105.     if (ID == TypeID(-1))
  106.       return TypeIdx(-1);
  107.  
  108.     return TypeIdx(ID >> Qualifiers::FastWidth);
  109.   }
  110. };
  111.  
  112. /// A structure for putting "fast"-unqualified QualTypes into a
  113. /// DenseMap.  This uses the standard pointer hash function.
  114. struct UnsafeQualTypeDenseMapInfo {
  115.   static bool isEqual(QualType A, QualType B) { return A == B; }
  116.  
  117.   static QualType getEmptyKey() {
  118.     return QualType::getFromOpaquePtr((void *)1);
  119.   }
  120.  
  121.   static QualType getTombstoneKey() {
  122.     return QualType::getFromOpaquePtr((void *)2);
  123.   }
  124.  
  125.   static unsigned getHashValue(QualType T) {
  126.     assert(!T.getLocalFastQualifiers() &&
  127.            "hash invalid for types with fast quals");
  128.     uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
  129.     return (unsigned(v) >> 4) ^ (unsigned(v) >> 9);
  130.   }
  131. };
  132.  
  133. /// An ID number that refers to an identifier in an AST file.
  134. using IdentID = uint32_t;
  135.  
  136. /// The number of predefined identifier IDs.
  137. const unsigned int NUM_PREDEF_IDENT_IDS = 1;
  138.  
  139. /// An ID number that refers to a macro in an AST file.
  140. using MacroID = uint32_t;
  141.  
  142. /// A global ID number that refers to a macro in an AST file.
  143. using GlobalMacroID = uint32_t;
  144.  
  145. /// A local to a module ID number that refers to a macro in an
  146. /// AST file.
  147. using LocalMacroID = uint32_t;
  148.  
  149. /// The number of predefined macro IDs.
  150. const unsigned int NUM_PREDEF_MACRO_IDS = 1;
  151.  
  152. /// An ID number that refers to an ObjC selector in an AST file.
  153. using SelectorID = uint32_t;
  154.  
  155. /// The number of predefined selector IDs.
  156. const unsigned int NUM_PREDEF_SELECTOR_IDS = 1;
  157.  
  158. /// An ID number that refers to a set of CXXBaseSpecifiers in an
  159. /// AST file.
  160. using CXXBaseSpecifiersID = uint32_t;
  161.  
  162. /// An ID number that refers to a list of CXXCtorInitializers in an
  163. /// AST file.
  164. using CXXCtorInitializersID = uint32_t;
  165.  
  166. /// An ID number that refers to an entity in the detailed
  167. /// preprocessing record.
  168. using PreprocessedEntityID = uint32_t;
  169.  
  170. /// An ID number that refers to a submodule in a module file.
  171. using SubmoduleID = uint32_t;
  172.  
  173. /// The number of predefined submodule IDs.
  174. const unsigned int NUM_PREDEF_SUBMODULE_IDS = 1;
  175.  
  176. /// Source range/offset of a preprocessed entity.
  177. struct PPEntityOffset {
  178.   /// Raw source location of beginning of range.
  179.   SourceLocation::UIntTy Begin;
  180.  
  181.   /// Raw source location of end of range.
  182.   SourceLocation::UIntTy End;
  183.  
  184.   /// Offset in the AST file relative to ModuleFile::MacroOffsetsBase.
  185.   uint32_t BitOffset;
  186.  
  187.   PPEntityOffset(SourceRange R, uint32_t BitOffset)
  188.       : Begin(R.getBegin().getRawEncoding()), End(R.getEnd().getRawEncoding()),
  189.         BitOffset(BitOffset) {}
  190.  
  191.   SourceLocation getBegin() const {
  192.     return SourceLocation::getFromRawEncoding(Begin);
  193.   }
  194.  
  195.   SourceLocation getEnd() const {
  196.     return SourceLocation::getFromRawEncoding(End);
  197.   }
  198. };
  199.  
  200. /// Source range of a skipped preprocessor region
  201. struct PPSkippedRange {
  202.   /// Raw source location of beginning of range.
  203.   SourceLocation::UIntTy Begin;
  204.   /// Raw source location of end of range.
  205.   SourceLocation::UIntTy End;
  206.  
  207.   PPSkippedRange(SourceRange R)
  208.       : Begin(R.getBegin().getRawEncoding()), End(R.getEnd().getRawEncoding()) {
  209.   }
  210.  
  211.   SourceLocation getBegin() const {
  212.     return SourceLocation::getFromRawEncoding(Begin);
  213.   }
  214.   SourceLocation getEnd() const {
  215.     return SourceLocation::getFromRawEncoding(End);
  216.   }
  217. };
  218.  
  219. /// Offset in the AST file. Use splitted 64-bit integer into low/high
  220. /// parts to keep structure alignment 32-bit (it is important because
  221. /// blobs in bitstream are 32-bit aligned). This structure is serialized
  222. /// "as is" to the AST file.
  223. struct UnderalignedInt64 {
  224.   uint32_t BitOffsetLow = 0;
  225.   uint32_t BitOffsetHigh = 0;
  226.  
  227.   UnderalignedInt64() = default;
  228.   UnderalignedInt64(uint64_t BitOffset) { setBitOffset(BitOffset); }
  229.  
  230.   void setBitOffset(uint64_t Offset) {
  231.     BitOffsetLow = Offset;
  232.     BitOffsetHigh = Offset >> 32;
  233.   }
  234.  
  235.   uint64_t getBitOffset() const {
  236.     return BitOffsetLow | (uint64_t(BitOffsetHigh) << 32);
  237.   }
  238. };
  239.  
  240. /// Source location and bit offset of a declaration.
  241. struct DeclOffset {
  242.   /// Raw source location.
  243.   SourceLocation::UIntTy Loc = 0;
  244.  
  245.   /// Offset relative to the start of the DECLTYPES_BLOCK block. Keep
  246.   /// structure alignment 32-bit and avoid padding gap because undefined
  247.   /// value in the padding affects AST hash.
  248.   UnderalignedInt64 BitOffset;
  249.  
  250.   DeclOffset() = default;
  251.   DeclOffset(SourceLocation Loc, uint64_t BitOffset,
  252.              uint64_t DeclTypesBlockStartOffset) {
  253.     setLocation(Loc);
  254.     setBitOffset(BitOffset, DeclTypesBlockStartOffset);
  255.   }
  256.  
  257.   void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
  258.  
  259.   SourceLocation getLocation() const {
  260.     return SourceLocation::getFromRawEncoding(Loc);
  261.   }
  262.  
  263.   void setBitOffset(uint64_t Offset, const uint64_t DeclTypesBlockStartOffset) {
  264.     BitOffset.setBitOffset(Offset - DeclTypesBlockStartOffset);
  265.   }
  266.  
  267.   uint64_t getBitOffset(const uint64_t DeclTypesBlockStartOffset) const {
  268.     return BitOffset.getBitOffset() + DeclTypesBlockStartOffset;
  269.   }
  270. };
  271.  
  272. /// The number of predefined preprocessed entity IDs.
  273. const unsigned int NUM_PREDEF_PP_ENTITY_IDS = 1;
  274.  
  275. /// Describes the various kinds of blocks that occur within
  276. /// an AST file.
  277. enum BlockIDs {
  278.   /// The AST block, which acts as a container around the
  279.   /// full AST block.
  280.   AST_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,
  281.  
  282.   /// The block containing information about the source
  283.   /// manager.
  284.   SOURCE_MANAGER_BLOCK_ID,
  285.  
  286.   /// The block containing information about the
  287.   /// preprocessor.
  288.   PREPROCESSOR_BLOCK_ID,
  289.  
  290.   /// The block containing the definitions of all of the
  291.   /// types and decls used within the AST file.
  292.   DECLTYPES_BLOCK_ID,
  293.  
  294.   /// The block containing the detailed preprocessing record.
  295.   PREPROCESSOR_DETAIL_BLOCK_ID,
  296.  
  297.   /// The block containing the submodule structure.
  298.   SUBMODULE_BLOCK_ID,
  299.  
  300.   /// The block containing comments.
  301.   COMMENTS_BLOCK_ID,
  302.  
  303.   /// The control block, which contains all of the
  304.   /// information that needs to be validated prior to committing
  305.   /// to loading the AST file.
  306.   CONTROL_BLOCK_ID,
  307.  
  308.   /// The block of input files, which were used as inputs
  309.   /// to create this AST file.
  310.   ///
  311.   /// This block is part of the control block.
  312.   INPUT_FILES_BLOCK_ID,
  313.  
  314.   /// The block of configuration options, used to check that
  315.   /// a module is being used in a configuration compatible with the
  316.   /// configuration in which it was built.
  317.   ///
  318.   /// This block is part of the control block.
  319.   OPTIONS_BLOCK_ID,
  320.  
  321.   /// A block containing a module file extension.
  322.   EXTENSION_BLOCK_ID,
  323.  
  324.   /// A block with unhashed content.
  325.   ///
  326.   /// These records should not change the \a ASTFileSignature.  See \a
  327.   /// UnhashedControlBlockRecordTypes for the list of records.
  328.   UNHASHED_CONTROL_BLOCK_ID,
  329. };
  330.  
  331. /// Record types that occur within the control block.
  332. enum ControlRecordTypes {
  333.   /// AST file metadata, including the AST file version number
  334.   /// and information about the compiler used to build this AST file.
  335.   METADATA = 1,
  336.  
  337.   /// Record code for the list of other AST files imported by
  338.   /// this AST file.
  339.   IMPORTS,
  340.  
  341.   /// Record code for the original file that was used to
  342.   /// generate the AST file, including both its file ID and its
  343.   /// name.
  344.   ORIGINAL_FILE,
  345.  
  346.   /// Record code for file ID of the file or buffer that was used to
  347.   /// generate the AST file.
  348.   ORIGINAL_FILE_ID,
  349.  
  350.   /// Offsets into the input-files block where input files
  351.   /// reside.
  352.   INPUT_FILE_OFFSETS,
  353.  
  354.   /// Record code for the module name.
  355.   MODULE_NAME,
  356.  
  357.   /// Record code for the module map file that was used to build this
  358.   /// AST file.
  359.   MODULE_MAP_FILE,
  360.  
  361.   /// Record code for the module build directory.
  362.   MODULE_DIRECTORY,
  363. };
  364.  
  365. /// Record types that occur within the options block inside
  366. /// the control block.
  367. enum OptionsRecordTypes {
  368.   /// Record code for the language options table.
  369.   ///
  370.   /// The record with this code contains the contents of the
  371.   /// LangOptions structure. We serialize the entire contents of
  372.   /// the structure, and let the reader decide which options are
  373.   /// actually important to check.
  374.   LANGUAGE_OPTIONS = 1,
  375.  
  376.   /// Record code for the target options table.
  377.   TARGET_OPTIONS,
  378.  
  379.   /// Record code for the filesystem options table.
  380.   FILE_SYSTEM_OPTIONS,
  381.  
  382.   /// Record code for the headers search options table.
  383.   HEADER_SEARCH_OPTIONS,
  384.  
  385.   /// Record code for the preprocessor options table.
  386.   PREPROCESSOR_OPTIONS,
  387. };
  388.  
  389. /// Record codes for the unhashed control block.
  390. enum UnhashedControlBlockRecordTypes {
  391.   /// Record code for the signature that identifiers this AST file.
  392.   SIGNATURE = 1,
  393.  
  394.   /// Record code for the content hash of the AST block.
  395.   AST_BLOCK_HASH,
  396.  
  397.   /// Record code for the diagnostic options table.
  398.   DIAGNOSTIC_OPTIONS,
  399.  
  400.   /// Record code for the headers search paths.
  401.   HEADER_SEARCH_PATHS,
  402.  
  403.   /// Record code for \#pragma diagnostic mappings.
  404.   DIAG_PRAGMA_MAPPINGS,
  405.  
  406.   /// Record code for the indices of used header search entries.
  407.   HEADER_SEARCH_ENTRY_USAGE,
  408. };
  409.  
  410. /// Record code for extension blocks.
  411. enum ExtensionBlockRecordTypes {
  412.   /// Metadata describing this particular extension.
  413.   EXTENSION_METADATA = 1,
  414.  
  415.   /// The first record ID allocated to the extensions themselves.
  416.   FIRST_EXTENSION_RECORD_ID = 4
  417. };
  418.  
  419. /// Record types that occur within the input-files block
  420. /// inside the control block.
  421. enum InputFileRecordTypes {
  422.   /// An input file.
  423.   INPUT_FILE = 1,
  424.  
  425.   /// The input file content hash
  426.   INPUT_FILE_HASH
  427. };
  428.  
  429. /// Record types that occur within the AST block itself.
  430. enum ASTRecordTypes {
  431.   /// Record code for the offsets of each type.
  432.   ///
  433.   /// The TYPE_OFFSET constant describes the record that occurs
  434.   /// within the AST block. The record itself is an array of offsets that
  435.   /// point into the declarations and types block (identified by
  436.   /// DECLTYPES_BLOCK_ID). The index into the array is based on the ID
  437.   /// of a type. For a given type ID @c T, the lower three bits of
  438.   /// @c T are its qualifiers (const, volatile, restrict), as in
  439.   /// the QualType class. The upper bits, after being shifted and
  440.   /// subtracting NUM_PREDEF_TYPE_IDS, are used to index into the
  441.   /// TYPE_OFFSET block to determine the offset of that type's
  442.   /// corresponding record within the DECLTYPES_BLOCK_ID block.
  443.   TYPE_OFFSET = 1,
  444.  
  445.   /// Record code for the offsets of each decl.
  446.   ///
  447.   /// The DECL_OFFSET constant describes the record that occurs
  448.   /// within the block identified by DECL_OFFSETS_BLOCK_ID within
  449.   /// the AST block. The record itself is an array of offsets that
  450.   /// point into the declarations and types block (identified by
  451.   /// DECLTYPES_BLOCK_ID). The declaration ID is an index into this
  452.   /// record, after subtracting one to account for the use of
  453.   /// declaration ID 0 for a NULL declaration pointer. Index 0 is
  454.   /// reserved for the translation unit declaration.
  455.   DECL_OFFSET = 2,
  456.  
  457.   /// Record code for the table of offsets of each
  458.   /// identifier ID.
  459.   ///
  460.   /// The offset table contains offsets into the blob stored in
  461.   /// the IDENTIFIER_TABLE record. Each offset points to the
  462.   /// NULL-terminated string that corresponds to that identifier.
  463.   IDENTIFIER_OFFSET = 3,
  464.  
  465.   /// This is so that older clang versions, before the introduction
  466.   /// of the control block, can read and reject the newer PCH format.
  467.   /// *DON'T CHANGE THIS NUMBER*.
  468.   METADATA_OLD_FORMAT = 4,
  469.  
  470.   /// Record code for the identifier table.
  471.   ///
  472.   /// The identifier table is a simple blob that contains
  473.   /// NULL-terminated strings for all of the identifiers
  474.   /// referenced by the AST file. The IDENTIFIER_OFFSET table
  475.   /// contains the mapping from identifier IDs to the characters
  476.   /// in this blob. Note that the starting offsets of all of the
  477.   /// identifiers are odd, so that, when the identifier offset
  478.   /// table is loaded in, we can use the low bit to distinguish
  479.   /// between offsets (for unresolved identifier IDs) and
  480.   /// IdentifierInfo pointers (for already-resolved identifier
  481.   /// IDs).
  482.   IDENTIFIER_TABLE = 5,
  483.  
  484.   /// Record code for the array of eagerly deserialized decls.
  485.   ///
  486.   /// The AST file contains a list of all of the declarations that should be
  487.   /// eagerly deserialized present within the parsed headers, stored as an
  488.   /// array of declaration IDs. These declarations will be
  489.   /// reported to the AST consumer after the AST file has been
  490.   /// read, since their presence can affect the semantics of the
  491.   /// program (e.g., for code generation).
  492.   EAGERLY_DESERIALIZED_DECLS = 6,
  493.  
  494.   /// Record code for the set of non-builtin, special
  495.   /// types.
  496.   ///
  497.   /// This record contains the type IDs for the various type nodes
  498.   /// that are constructed during semantic analysis (e.g.,
  499.   /// __builtin_va_list). The SPECIAL_TYPE_* constants provide
  500.   /// offsets into this record.
  501.   SPECIAL_TYPES = 7,
  502.  
  503.   /// Record code for the extra statistics we gather while
  504.   /// generating an AST file.
  505.   STATISTICS = 8,
  506.  
  507.   /// Record code for the array of tentative definitions.
  508.   TENTATIVE_DEFINITIONS = 9,
  509.  
  510.   // ID 10 used to be for a list of extern "C" declarations.
  511.  
  512.   /// Record code for the table of offsets into the
  513.   /// Objective-C method pool.
  514.   SELECTOR_OFFSETS = 11,
  515.  
  516.   /// Record code for the Objective-C method pool,
  517.   METHOD_POOL = 12,
  518.  
  519.   /// The value of the next __COUNTER__ to dispense.
  520.   /// [PP_COUNTER_VALUE, Val]
  521.   PP_COUNTER_VALUE = 13,
  522.  
  523.   /// Record code for the table of offsets into the block
  524.   /// of source-location information.
  525.   SOURCE_LOCATION_OFFSETS = 14,
  526.  
  527.   /// Record code for the set of source location entries
  528.   /// that need to be preloaded by the AST reader.
  529.   ///
  530.   /// This set contains the source location entry for the
  531.   /// predefines buffer and for any file entries that need to be
  532.   /// preloaded.
  533.   SOURCE_LOCATION_PRELOADS = 15,
  534.  
  535.   /// Record code for the set of ext_vector type names.
  536.   EXT_VECTOR_DECLS = 16,
  537.  
  538.   /// Record code for the array of unused file scoped decls.
  539.   UNUSED_FILESCOPED_DECLS = 17,
  540.  
  541.   /// Record code for the table of offsets to entries in the
  542.   /// preprocessing record.
  543.   PPD_ENTITIES_OFFSETS = 18,
  544.  
  545.   /// Record code for the array of VTable uses.
  546.   VTABLE_USES = 19,
  547.  
  548.   // ID 20 used to be for a list of dynamic classes.
  549.  
  550.   /// Record code for referenced selector pool.
  551.   REFERENCED_SELECTOR_POOL = 21,
  552.  
  553.   /// Record code for an update to the TU's lexically contained
  554.   /// declarations.
  555.   TU_UPDATE_LEXICAL = 22,
  556.  
  557.   // ID 23 used to be for a list of local redeclarations.
  558.  
  559.   /// Record code for declarations that Sema keeps references of.
  560.   SEMA_DECL_REFS = 24,
  561.  
  562.   /// Record code for weak undeclared identifiers.
  563.   WEAK_UNDECLARED_IDENTIFIERS = 25,
  564.  
  565.   /// Record code for pending implicit instantiations.
  566.   PENDING_IMPLICIT_INSTANTIATIONS = 26,
  567.  
  568.   // ID 27 used to be for a list of replacement decls.
  569.  
  570.   /// Record code for an update to a decl context's lookup table.
  571.   ///
  572.   /// In practice, this should only be used for the TU and namespaces.
  573.   UPDATE_VISIBLE = 28,
  574.  
  575.   /// Record for offsets of DECL_UPDATES records for declarations
  576.   /// that were modified after being deserialized and need updates.
  577.   DECL_UPDATE_OFFSETS = 29,
  578.  
  579.   // ID 30 used to be a decl update record. These are now in the DECLTYPES
  580.   // block.
  581.  
  582.   // ID 31 used to be a list of offsets to DECL_CXX_BASE_SPECIFIERS records.
  583.  
  584.   // ID 32 used to be the code for \#pragma diagnostic mappings.
  585.  
  586.   /// Record code for special CUDA declarations.
  587.   CUDA_SPECIAL_DECL_REFS = 33,
  588.  
  589.   /// Record code for header search information.
  590.   HEADER_SEARCH_TABLE = 34,
  591.  
  592.   /// Record code for floating point \#pragma options.
  593.   FP_PRAGMA_OPTIONS = 35,
  594.  
  595.   /// Record code for enabled OpenCL extensions.
  596.   OPENCL_EXTENSIONS = 36,
  597.  
  598.   /// The list of delegating constructor declarations.
  599.   DELEGATING_CTORS = 37,
  600.  
  601.   /// Record code for the set of known namespaces, which are used
  602.   /// for typo correction.
  603.   KNOWN_NAMESPACES = 38,
  604.  
  605.   /// Record code for the remapping information used to relate
  606.   /// loaded modules to the various offsets and IDs(e.g., source location
  607.   /// offests, declaration and type IDs) that are used in that module to
  608.   /// refer to other modules.
  609.   MODULE_OFFSET_MAP = 39,
  610.  
  611.   /// Record code for the source manager line table information,
  612.   /// which stores information about \#line directives.
  613.   SOURCE_MANAGER_LINE_TABLE = 40,
  614.  
  615.   /// Record code for map of Objective-C class definition IDs to the
  616.   /// ObjC categories in a module that are attached to that class.
  617.   OBJC_CATEGORIES_MAP = 41,
  618.  
  619.   /// Record code for a file sorted array of DeclIDs in a module.
  620.   FILE_SORTED_DECLS = 42,
  621.  
  622.   /// Record code for an array of all of the (sub)modules that were
  623.   /// imported by the AST file.
  624.   IMPORTED_MODULES = 43,
  625.  
  626.   // ID 44 used to be a table of merged canonical declarations.
  627.   // ID 45 used to be a list of declaration IDs of local redeclarations.
  628.  
  629.   /// Record code for the array of Objective-C categories (including
  630.   /// extensions).
  631.   ///
  632.   /// This array can only be interpreted properly using the Objective-C
  633.   /// categories map.
  634.   OBJC_CATEGORIES = 46,
  635.  
  636.   /// Record code for the table of offsets of each macro ID.
  637.   ///
  638.   /// The offset table contains offsets into the blob stored in
  639.   /// the preprocessor block. Each offset points to the corresponding
  640.   /// macro definition.
  641.   MACRO_OFFSET = 47,
  642.  
  643.   /// A list of "interesting" identifiers. Only used in C++ (where we
  644.   /// don't normally do lookups into the serialized identifier table). These
  645.   /// are eagerly deserialized.
  646.   INTERESTING_IDENTIFIERS = 48,
  647.  
  648.   /// Record code for undefined but used functions and variables that
  649.   /// need a definition in this TU.
  650.   UNDEFINED_BUT_USED = 49,
  651.  
  652.   /// Record code for late parsed template functions.
  653.   LATE_PARSED_TEMPLATE = 50,
  654.  
  655.   /// Record code for \#pragma optimize options.
  656.   OPTIMIZE_PRAGMA_OPTIONS = 51,
  657.  
  658.   /// Record code for potentially unused local typedef names.
  659.   UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES = 52,
  660.  
  661.   // ID 53 used to be a table of constructor initializer records.
  662.  
  663.   /// Delete expressions that will be analyzed later.
  664.   DELETE_EXPRS_TO_ANALYZE = 54,
  665.  
  666.   /// Record code for \#pragma ms_struct options.
  667.   MSSTRUCT_PRAGMA_OPTIONS = 55,
  668.  
  669.   /// Record code for \#pragma ms_struct options.
  670.   POINTERS_TO_MEMBERS_PRAGMA_OPTIONS = 56,
  671.  
  672.   /// Number of unmatched #pragma clang cuda_force_host_device begin
  673.   /// directives we've seen.
  674.   CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH = 57,
  675.  
  676.   /// Record code for types associated with OpenCL extensions.
  677.   OPENCL_EXTENSION_TYPES = 58,
  678.  
  679.   /// Record code for declarations associated with OpenCL extensions.
  680.   OPENCL_EXTENSION_DECLS = 59,
  681.  
  682.   MODULAR_CODEGEN_DECLS = 60,
  683.  
  684.   /// Record code for \#pragma align/pack options.
  685.   ALIGN_PACK_PRAGMA_OPTIONS = 61,
  686.  
  687.   /// The stack of open #ifs/#ifdefs recorded in a preamble.
  688.   PP_CONDITIONAL_STACK = 62,
  689.  
  690.   /// A table of skipped ranges within the preprocessing record.
  691.   PPD_SKIPPED_RANGES = 63,
  692.  
  693.   /// Record code for the Decls to be checked for deferred diags.
  694.   DECLS_TO_CHECK_FOR_DEFERRED_DIAGS = 64,
  695.  
  696.   /// Record code for \#pragma float_control options.
  697.   FLOAT_CONTROL_PRAGMA_OPTIONS = 65,
  698.  
  699.   /// Record code for included files.
  700.   PP_INCLUDED_FILES = 66,
  701.  
  702.   /// Record code for an unterminated \#pragma clang assume_nonnull begin
  703.   /// recorded in a preamble.
  704.   PP_ASSUME_NONNULL_LOC = 67,
  705. };
  706.  
  707. /// Record types used within a source manager block.
  708. enum SourceManagerRecordTypes {
  709.   /// Describes a source location entry (SLocEntry) for a
  710.   /// file.
  711.   SM_SLOC_FILE_ENTRY = 1,
  712.  
  713.   /// Describes a source location entry (SLocEntry) for a
  714.   /// buffer.
  715.   SM_SLOC_BUFFER_ENTRY = 2,
  716.  
  717.   /// Describes a blob that contains the data for a buffer
  718.   /// entry. This kind of record always directly follows a
  719.   /// SM_SLOC_BUFFER_ENTRY record or a SM_SLOC_FILE_ENTRY with an
  720.   /// overridden buffer.
  721.   SM_SLOC_BUFFER_BLOB = 3,
  722.  
  723.   /// Describes a zlib-compressed blob that contains the data for
  724.   /// a buffer entry.
  725.   SM_SLOC_BUFFER_BLOB_COMPRESSED = 4,
  726.  
  727.   /// Describes a source location entry (SLocEntry) for a
  728.   /// macro expansion.
  729.   SM_SLOC_EXPANSION_ENTRY = 5
  730. };
  731.  
  732. /// Record types used within a preprocessor block.
  733. enum PreprocessorRecordTypes {
  734.   // The macros in the PP section are a PP_MACRO_* instance followed by a
  735.   // list of PP_TOKEN instances for each token in the definition.
  736.  
  737.   /// An object-like macro definition.
  738.   /// [PP_MACRO_OBJECT_LIKE, IdentInfoID, SLoc, IsUsed]
  739.   PP_MACRO_OBJECT_LIKE = 1,
  740.  
  741.   /// A function-like macro definition.
  742.   /// [PP_MACRO_FUNCTION_LIKE, \<ObjectLikeStuff>, IsC99Varargs,
  743.   /// IsGNUVarars, NumArgs, ArgIdentInfoID* ]
  744.   PP_MACRO_FUNCTION_LIKE = 2,
  745.  
  746.   /// Describes one token.
  747.   /// [PP_TOKEN, SLoc, Length, IdentInfoID, Kind, Flags]
  748.   PP_TOKEN = 3,
  749.  
  750.   /// The macro directives history for a particular identifier.
  751.   PP_MACRO_DIRECTIVE_HISTORY = 4,
  752.  
  753.   /// A macro directive exported by a module.
  754.   /// [PP_MODULE_MACRO, SubmoduleID, MacroID, (Overridden SubmoduleID)*]
  755.   PP_MODULE_MACRO = 5,
  756. };
  757.  
  758. /// Record types used within a preprocessor detail block.
  759. enum PreprocessorDetailRecordTypes {
  760.   /// Describes a macro expansion within the preprocessing record.
  761.   PPD_MACRO_EXPANSION = 0,
  762.  
  763.   /// Describes a macro definition within the preprocessing record.
  764.   PPD_MACRO_DEFINITION = 1,
  765.  
  766.   /// Describes an inclusion directive within the preprocessing
  767.   /// record.
  768.   PPD_INCLUSION_DIRECTIVE = 2
  769. };
  770.  
  771. /// Record types used within a submodule description block.
  772. enum SubmoduleRecordTypes {
  773.   /// Metadata for submodules as a whole.
  774.   SUBMODULE_METADATA = 0,
  775.  
  776.   /// Defines the major attributes of a submodule, including its
  777.   /// name and parent.
  778.   SUBMODULE_DEFINITION = 1,
  779.  
  780.   /// Specifies the umbrella header used to create this module,
  781.   /// if any.
  782.   SUBMODULE_UMBRELLA_HEADER = 2,
  783.  
  784.   /// Specifies a header that falls into this (sub)module.
  785.   SUBMODULE_HEADER = 3,
  786.  
  787.   /// Specifies a top-level header that falls into this (sub)module.
  788.   SUBMODULE_TOPHEADER = 4,
  789.  
  790.   /// Specifies an umbrella directory.
  791.   SUBMODULE_UMBRELLA_DIR = 5,
  792.  
  793.   /// Specifies the submodules that are imported by this
  794.   /// submodule.
  795.   SUBMODULE_IMPORTS = 6,
  796.  
  797.   /// Specifies the submodules that are re-exported from this
  798.   /// submodule.
  799.   SUBMODULE_EXPORTS = 7,
  800.  
  801.   /// Specifies a required feature.
  802.   SUBMODULE_REQUIRES = 8,
  803.  
  804.   /// Specifies a header that has been explicitly excluded
  805.   /// from this submodule.
  806.   SUBMODULE_EXCLUDED_HEADER = 9,
  807.  
  808.   /// Specifies a library or framework to link against.
  809.   SUBMODULE_LINK_LIBRARY = 10,
  810.  
  811.   /// Specifies a configuration macro for this module.
  812.   SUBMODULE_CONFIG_MACRO = 11,
  813.  
  814.   /// Specifies a conflict with another module.
  815.   SUBMODULE_CONFLICT = 12,
  816.  
  817.   /// Specifies a header that is private to this submodule.
  818.   SUBMODULE_PRIVATE_HEADER = 13,
  819.  
  820.   /// Specifies a header that is part of the module but must be
  821.   /// textually included.
  822.   SUBMODULE_TEXTUAL_HEADER = 14,
  823.  
  824.   /// Specifies a header that is private to this submodule but
  825.   /// must be textually included.
  826.   SUBMODULE_PRIVATE_TEXTUAL_HEADER = 15,
  827.  
  828.   /// Specifies some declarations with initializers that must be
  829.   /// emitted to initialize the module.
  830.   SUBMODULE_INITIALIZERS = 16,
  831.  
  832.   /// Specifies the name of the module that will eventually
  833.   /// re-export the entities in this module.
  834.   SUBMODULE_EXPORT_AS = 17,
  835.  
  836.   /// Specifies affecting modules that were not imported.
  837.   SUBMODULE_AFFECTING_MODULES = 18,
  838. };
  839.  
  840. /// Record types used within a comments block.
  841. enum CommentRecordTypes { COMMENTS_RAW_COMMENT = 0 };
  842.  
  843. /// \defgroup ASTAST AST file AST constants
  844. ///
  845. /// The constants in this group describe various components of the
  846. /// abstract syntax tree within an AST file.
  847. ///
  848. /// @{
  849.  
  850. /// Predefined type IDs.
  851. ///
  852. /// These type IDs correspond to predefined types in the AST
  853. /// context, such as built-in types (int) and special place-holder
  854. /// types (the \<overload> and \<dependent> type markers). Such
  855. /// types are never actually serialized, since they will be built
  856. /// by the AST context when it is created.
  857. enum PredefinedTypeIDs {
  858.   /// The NULL type.
  859.   PREDEF_TYPE_NULL_ID = 0,
  860.  
  861.   /// The void type.
  862.   PREDEF_TYPE_VOID_ID = 1,
  863.  
  864.   /// The 'bool' or '_Bool' type.
  865.   PREDEF_TYPE_BOOL_ID = 2,
  866.  
  867.   /// The 'char' type, when it is unsigned.
  868.   PREDEF_TYPE_CHAR_U_ID = 3,
  869.  
  870.   /// The 'unsigned char' type.
  871.   PREDEF_TYPE_UCHAR_ID = 4,
  872.  
  873.   /// The 'unsigned short' type.
  874.   PREDEF_TYPE_USHORT_ID = 5,
  875.  
  876.   /// The 'unsigned int' type.
  877.   PREDEF_TYPE_UINT_ID = 6,
  878.  
  879.   /// The 'unsigned long' type.
  880.   PREDEF_TYPE_ULONG_ID = 7,
  881.  
  882.   /// The 'unsigned long long' type.
  883.   PREDEF_TYPE_ULONGLONG_ID = 8,
  884.  
  885.   /// The 'char' type, when it is signed.
  886.   PREDEF_TYPE_CHAR_S_ID = 9,
  887.  
  888.   /// The 'signed char' type.
  889.   PREDEF_TYPE_SCHAR_ID = 10,
  890.  
  891.   /// The C++ 'wchar_t' type.
  892.   PREDEF_TYPE_WCHAR_ID = 11,
  893.  
  894.   /// The (signed) 'short' type.
  895.   PREDEF_TYPE_SHORT_ID = 12,
  896.  
  897.   /// The (signed) 'int' type.
  898.   PREDEF_TYPE_INT_ID = 13,
  899.  
  900.   /// The (signed) 'long' type.
  901.   PREDEF_TYPE_LONG_ID = 14,
  902.  
  903.   /// The (signed) 'long long' type.
  904.   PREDEF_TYPE_LONGLONG_ID = 15,
  905.  
  906.   /// The 'float' type.
  907.   PREDEF_TYPE_FLOAT_ID = 16,
  908.  
  909.   /// The 'double' type.
  910.   PREDEF_TYPE_DOUBLE_ID = 17,
  911.  
  912.   /// The 'long double' type.
  913.   PREDEF_TYPE_LONGDOUBLE_ID = 18,
  914.  
  915.   /// The placeholder type for overloaded function sets.
  916.   PREDEF_TYPE_OVERLOAD_ID = 19,
  917.  
  918.   /// The placeholder type for dependent types.
  919.   PREDEF_TYPE_DEPENDENT_ID = 20,
  920.  
  921.   /// The '__uint128_t' type.
  922.   PREDEF_TYPE_UINT128_ID = 21,
  923.  
  924.   /// The '__int128_t' type.
  925.   PREDEF_TYPE_INT128_ID = 22,
  926.  
  927.   /// The type of 'nullptr'.
  928.   PREDEF_TYPE_NULLPTR_ID = 23,
  929.  
  930.   /// The C++ 'char16_t' type.
  931.   PREDEF_TYPE_CHAR16_ID = 24,
  932.  
  933.   /// The C++ 'char32_t' type.
  934.   PREDEF_TYPE_CHAR32_ID = 25,
  935.  
  936.   /// The ObjC 'id' type.
  937.   PREDEF_TYPE_OBJC_ID = 26,
  938.  
  939.   /// The ObjC 'Class' type.
  940.   PREDEF_TYPE_OBJC_CLASS = 27,
  941.  
  942.   /// The ObjC 'SEL' type.
  943.   PREDEF_TYPE_OBJC_SEL = 28,
  944.  
  945.   /// The 'unknown any' placeholder type.
  946.   PREDEF_TYPE_UNKNOWN_ANY = 29,
  947.  
  948.   /// The placeholder type for bound member functions.
  949.   PREDEF_TYPE_BOUND_MEMBER = 30,
  950.  
  951.   /// The "auto" deduction type.
  952.   PREDEF_TYPE_AUTO_DEDUCT = 31,
  953.  
  954.   /// The "auto &&" deduction type.
  955.   PREDEF_TYPE_AUTO_RREF_DEDUCT = 32,
  956.  
  957.   /// The OpenCL 'half' / ARM NEON __fp16 type.
  958.   PREDEF_TYPE_HALF_ID = 33,
  959.  
  960.   /// ARC's unbridged-cast placeholder type.
  961.   PREDEF_TYPE_ARC_UNBRIDGED_CAST = 34,
  962.  
  963.   /// The pseudo-object placeholder type.
  964.   PREDEF_TYPE_PSEUDO_OBJECT = 35,
  965.  
  966.   /// The placeholder type for builtin functions.
  967.   PREDEF_TYPE_BUILTIN_FN = 36,
  968.  
  969.   /// OpenCL event type.
  970.   PREDEF_TYPE_EVENT_ID = 37,
  971.  
  972.   /// OpenCL clk event type.
  973.   PREDEF_TYPE_CLK_EVENT_ID = 38,
  974.  
  975.   /// OpenCL sampler type.
  976.   PREDEF_TYPE_SAMPLER_ID = 39,
  977.  
  978.   /// OpenCL queue type.
  979.   PREDEF_TYPE_QUEUE_ID = 40,
  980.  
  981.   /// OpenCL reserve_id type.
  982.   PREDEF_TYPE_RESERVE_ID_ID = 41,
  983.  
  984.   /// The placeholder type for OpenMP array section.
  985.   PREDEF_TYPE_OMP_ARRAY_SECTION = 42,
  986.  
  987.   /// The '__float128' type
  988.   PREDEF_TYPE_FLOAT128_ID = 43,
  989.  
  990.   /// The '_Float16' type
  991.   PREDEF_TYPE_FLOAT16_ID = 44,
  992.  
  993.   /// The C++ 'char8_t' type.
  994.   PREDEF_TYPE_CHAR8_ID = 45,
  995.  
  996.   /// \brief The 'short _Accum' type
  997.   PREDEF_TYPE_SHORT_ACCUM_ID = 46,
  998.  
  999.   /// \brief The '_Accum' type
  1000.   PREDEF_TYPE_ACCUM_ID = 47,
  1001.  
  1002.   /// \brief The 'long _Accum' type
  1003.   PREDEF_TYPE_LONG_ACCUM_ID = 48,
  1004.  
  1005.   /// \brief The 'unsigned short _Accum' type
  1006.   PREDEF_TYPE_USHORT_ACCUM_ID = 49,
  1007.  
  1008.   /// \brief The 'unsigned _Accum' type
  1009.   PREDEF_TYPE_UACCUM_ID = 50,
  1010.  
  1011.   /// \brief The 'unsigned long _Accum' type
  1012.   PREDEF_TYPE_ULONG_ACCUM_ID = 51,
  1013.  
  1014.   /// \brief The 'short _Fract' type
  1015.   PREDEF_TYPE_SHORT_FRACT_ID = 52,
  1016.  
  1017.   /// \brief The '_Fract' type
  1018.   PREDEF_TYPE_FRACT_ID = 53,
  1019.  
  1020.   /// \brief The 'long _Fract' type
  1021.   PREDEF_TYPE_LONG_FRACT_ID = 54,
  1022.  
  1023.   /// \brief The 'unsigned short _Fract' type
  1024.   PREDEF_TYPE_USHORT_FRACT_ID = 55,
  1025.  
  1026.   /// \brief The 'unsigned _Fract' type
  1027.   PREDEF_TYPE_UFRACT_ID = 56,
  1028.  
  1029.   /// \brief The 'unsigned long _Fract' type
  1030.   PREDEF_TYPE_ULONG_FRACT_ID = 57,
  1031.  
  1032.   /// \brief The '_Sat short _Accum' type
  1033.   PREDEF_TYPE_SAT_SHORT_ACCUM_ID = 58,
  1034.  
  1035.   /// \brief The '_Sat _Accum' type
  1036.   PREDEF_TYPE_SAT_ACCUM_ID = 59,
  1037.  
  1038.   /// \brief The '_Sat long _Accum' type
  1039.   PREDEF_TYPE_SAT_LONG_ACCUM_ID = 60,
  1040.  
  1041.   /// \brief The '_Sat unsigned short _Accum' type
  1042.   PREDEF_TYPE_SAT_USHORT_ACCUM_ID = 61,
  1043.  
  1044.   /// \brief The '_Sat unsigned _Accum' type
  1045.   PREDEF_TYPE_SAT_UACCUM_ID = 62,
  1046.  
  1047.   /// \brief The '_Sat unsigned long _Accum' type
  1048.   PREDEF_TYPE_SAT_ULONG_ACCUM_ID = 63,
  1049.  
  1050.   /// \brief The '_Sat short _Fract' type
  1051.   PREDEF_TYPE_SAT_SHORT_FRACT_ID = 64,
  1052.  
  1053.   /// \brief The '_Sat _Fract' type
  1054.   PREDEF_TYPE_SAT_FRACT_ID = 65,
  1055.  
  1056.   /// \brief The '_Sat long _Fract' type
  1057.   PREDEF_TYPE_SAT_LONG_FRACT_ID = 66,
  1058.  
  1059.   /// \brief The '_Sat unsigned short _Fract' type
  1060.   PREDEF_TYPE_SAT_USHORT_FRACT_ID = 67,
  1061.  
  1062.   /// \brief The '_Sat unsigned _Fract' type
  1063.   PREDEF_TYPE_SAT_UFRACT_ID = 68,
  1064.  
  1065.   /// \brief The '_Sat unsigned long _Fract' type
  1066.   PREDEF_TYPE_SAT_ULONG_FRACT_ID = 69,
  1067.  
  1068.   /// The placeholder type for OpenMP array shaping operation.
  1069.   PREDEF_TYPE_OMP_ARRAY_SHAPING = 70,
  1070.  
  1071.   /// The placeholder type for OpenMP iterator expression.
  1072.   PREDEF_TYPE_OMP_ITERATOR = 71,
  1073.  
  1074.   /// A placeholder type for incomplete matrix index operations.
  1075.   PREDEF_TYPE_INCOMPLETE_MATRIX_IDX = 72,
  1076.  
  1077.   /// \brief The '__bf16' type
  1078.   PREDEF_TYPE_BFLOAT16_ID = 73,
  1079.  
  1080.   /// \brief The '__ibm128' type
  1081.   PREDEF_TYPE_IBM128_ID = 74,
  1082.  
  1083. /// OpenCL image types with auto numeration
  1084. #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
  1085.   PREDEF_TYPE_##Id##_ID,
  1086. #include "clang/Basic/OpenCLImageTypes.def"
  1087. /// \brief OpenCL extension types with auto numeration
  1088. #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) PREDEF_TYPE_##Id##_ID,
  1089. #include "clang/Basic/OpenCLExtensionTypes.def"
  1090. // \brief SVE types with auto numeration
  1091. #define SVE_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
  1092. #include "clang/Basic/AArch64SVEACLETypes.def"
  1093. // \brief  PowerPC MMA types with auto numeration
  1094. #define PPC_VECTOR_TYPE(Name, Id, Size) PREDEF_TYPE_##Id##_ID,
  1095. #include "clang/Basic/PPCTypes.def"
  1096. // \brief RISC-V V types with auto numeration
  1097. #define RVV_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID,
  1098. #include "clang/Basic/RISCVVTypes.def"
  1099. };
  1100.  
  1101. /// The number of predefined type IDs that are reserved for
  1102. /// the PREDEF_TYPE_* constants.
  1103. ///
  1104. /// Type IDs for non-predefined types will start at
  1105. /// NUM_PREDEF_TYPE_IDs.
  1106. const unsigned NUM_PREDEF_TYPE_IDS = 300;
  1107.  
  1108. /// Record codes for each kind of type.
  1109. ///
  1110. /// These constants describe the type records that can occur within a
  1111. /// block identified by DECLTYPES_BLOCK_ID in the AST file. Each
  1112. /// constant describes a record for a specific type class in the
  1113. /// AST. Note that DeclCode values share this code space.
  1114. enum TypeCode {
  1115. #define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE)                           \
  1116.   TYPE_##CODE_ID = CODE_VALUE,
  1117. #include "clang/Serialization/TypeBitCodes.def"
  1118.  
  1119.   /// An ExtQualType record.
  1120.   TYPE_EXT_QUAL = 1
  1121. };
  1122.  
  1123. /// The type IDs for special types constructed by semantic
  1124. /// analysis.
  1125. ///
  1126. /// The constants in this enumeration are indices into the
  1127. /// SPECIAL_TYPES record.
  1128. enum SpecialTypeIDs {
  1129.   /// CFConstantString type
  1130.   SPECIAL_TYPE_CF_CONSTANT_STRING = 0,
  1131.  
  1132.   /// C FILE typedef type
  1133.   SPECIAL_TYPE_FILE = 1,
  1134.  
  1135.   /// C jmp_buf typedef type
  1136.   SPECIAL_TYPE_JMP_BUF = 2,
  1137.  
  1138.   /// C sigjmp_buf typedef type
  1139.   SPECIAL_TYPE_SIGJMP_BUF = 3,
  1140.  
  1141.   /// Objective-C "id" redefinition type
  1142.   SPECIAL_TYPE_OBJC_ID_REDEFINITION = 4,
  1143.  
  1144.   /// Objective-C "Class" redefinition type
  1145.   SPECIAL_TYPE_OBJC_CLASS_REDEFINITION = 5,
  1146.  
  1147.   /// Objective-C "SEL" redefinition type
  1148.   SPECIAL_TYPE_OBJC_SEL_REDEFINITION = 6,
  1149.  
  1150.   /// C ucontext_t typedef type
  1151.   SPECIAL_TYPE_UCONTEXT_T = 7
  1152. };
  1153.  
  1154. /// The number of special type IDs.
  1155. const unsigned NumSpecialTypeIDs = 8;
  1156.  
  1157. /// Predefined declaration IDs.
  1158. ///
  1159. /// These declaration IDs correspond to predefined declarations in the AST
  1160. /// context, such as the NULL declaration ID. Such declarations are never
  1161. /// actually serialized, since they will be built by the AST context when
  1162. /// it is created.
  1163. enum PredefinedDeclIDs {
  1164.   /// The NULL declaration.
  1165.   PREDEF_DECL_NULL_ID = 0,
  1166.  
  1167.   /// The translation unit.
  1168.   PREDEF_DECL_TRANSLATION_UNIT_ID = 1,
  1169.  
  1170.   /// The Objective-C 'id' type.
  1171.   PREDEF_DECL_OBJC_ID_ID = 2,
  1172.  
  1173.   /// The Objective-C 'SEL' type.
  1174.   PREDEF_DECL_OBJC_SEL_ID = 3,
  1175.  
  1176.   /// The Objective-C 'Class' type.
  1177.   PREDEF_DECL_OBJC_CLASS_ID = 4,
  1178.  
  1179.   /// The Objective-C 'Protocol' type.
  1180.   PREDEF_DECL_OBJC_PROTOCOL_ID = 5,
  1181.  
  1182.   /// The signed 128-bit integer type.
  1183.   PREDEF_DECL_INT_128_ID = 6,
  1184.  
  1185.   /// The unsigned 128-bit integer type.
  1186.   PREDEF_DECL_UNSIGNED_INT_128_ID = 7,
  1187.  
  1188.   /// The internal 'instancetype' typedef.
  1189.   PREDEF_DECL_OBJC_INSTANCETYPE_ID = 8,
  1190.  
  1191.   /// The internal '__builtin_va_list' typedef.
  1192.   PREDEF_DECL_BUILTIN_VA_LIST_ID = 9,
  1193.  
  1194.   /// The internal '__va_list_tag' struct, if any.
  1195.   PREDEF_DECL_VA_LIST_TAG = 10,
  1196.  
  1197.   /// The internal '__builtin_ms_va_list' typedef.
  1198.   PREDEF_DECL_BUILTIN_MS_VA_LIST_ID = 11,
  1199.  
  1200.   /// The predeclared '_GUID' struct.
  1201.   PREDEF_DECL_BUILTIN_MS_GUID_ID = 12,
  1202.  
  1203.   /// The extern "C" context.
  1204.   PREDEF_DECL_EXTERN_C_CONTEXT_ID = 13,
  1205.  
  1206.   /// The internal '__make_integer_seq' template.
  1207.   PREDEF_DECL_MAKE_INTEGER_SEQ_ID = 14,
  1208.  
  1209.   /// The internal '__NSConstantString' typedef.
  1210.   PREDEF_DECL_CF_CONSTANT_STRING_ID = 15,
  1211.  
  1212.   /// The internal '__NSConstantString' tag type.
  1213.   PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID = 16,
  1214.  
  1215.   /// The internal '__type_pack_element' template.
  1216.   PREDEF_DECL_TYPE_PACK_ELEMENT_ID = 17,
  1217. };
  1218.  
  1219. /// The number of declaration IDs that are predefined.
  1220. ///
  1221. /// For more information about predefined declarations, see the
  1222. /// \c PredefinedDeclIDs type and the PREDEF_DECL_*_ID constants.
  1223. const unsigned int NUM_PREDEF_DECL_IDS = 18;
  1224.  
  1225. /// Record of updates for a declaration that was modified after
  1226. /// being deserialized. This can occur within DECLTYPES_BLOCK_ID.
  1227. const unsigned int DECL_UPDATES = 49;
  1228.  
  1229. /// Record code for a list of local redeclarations of a declaration.
  1230. /// This can occur within DECLTYPES_BLOCK_ID.
  1231. const unsigned int LOCAL_REDECLARATIONS = 50;
  1232.  
  1233. /// Record codes for each kind of declaration.
  1234. ///
  1235. /// These constants describe the declaration records that can occur within
  1236. /// a declarations block (identified by DECLTYPES_BLOCK_ID). Each
  1237. /// constant describes a record for a specific declaration class
  1238. /// in the AST. Note that TypeCode values share this code space.
  1239. enum DeclCode {
  1240.   /// A TypedefDecl record.
  1241.   DECL_TYPEDEF = 51,
  1242.   /// A TypeAliasDecl record.
  1243.  
  1244.   DECL_TYPEALIAS,
  1245.  
  1246.   /// An EnumDecl record.
  1247.   DECL_ENUM,
  1248.  
  1249.   /// A RecordDecl record.
  1250.   DECL_RECORD,
  1251.  
  1252.   /// An EnumConstantDecl record.
  1253.   DECL_ENUM_CONSTANT,
  1254.  
  1255.   /// A FunctionDecl record.
  1256.   DECL_FUNCTION,
  1257.  
  1258.   /// A ObjCMethodDecl record.
  1259.   DECL_OBJC_METHOD,
  1260.  
  1261.   /// A ObjCInterfaceDecl record.
  1262.   DECL_OBJC_INTERFACE,
  1263.  
  1264.   /// A ObjCProtocolDecl record.
  1265.   DECL_OBJC_PROTOCOL,
  1266.  
  1267.   /// A ObjCIvarDecl record.
  1268.   DECL_OBJC_IVAR,
  1269.  
  1270.   /// A ObjCAtDefsFieldDecl record.
  1271.   DECL_OBJC_AT_DEFS_FIELD,
  1272.  
  1273.   /// A ObjCCategoryDecl record.
  1274.   DECL_OBJC_CATEGORY,
  1275.  
  1276.   /// A ObjCCategoryImplDecl record.
  1277.   DECL_OBJC_CATEGORY_IMPL,
  1278.  
  1279.   /// A ObjCImplementationDecl record.
  1280.   DECL_OBJC_IMPLEMENTATION,
  1281.  
  1282.   /// A ObjCCompatibleAliasDecl record.
  1283.   DECL_OBJC_COMPATIBLE_ALIAS,
  1284.  
  1285.   /// A ObjCPropertyDecl record.
  1286.   DECL_OBJC_PROPERTY,
  1287.  
  1288.   /// A ObjCPropertyImplDecl record.
  1289.   DECL_OBJC_PROPERTY_IMPL,
  1290.  
  1291.   /// A FieldDecl record.
  1292.   DECL_FIELD,
  1293.  
  1294.   /// A MSPropertyDecl record.
  1295.   DECL_MS_PROPERTY,
  1296.  
  1297.   /// A MSGuidDecl record.
  1298.   DECL_MS_GUID,
  1299.  
  1300.   /// A TemplateParamObjectDecl record.
  1301.   DECL_TEMPLATE_PARAM_OBJECT,
  1302.  
  1303.   /// A VarDecl record.
  1304.   DECL_VAR,
  1305.  
  1306.   /// An ImplicitParamDecl record.
  1307.   DECL_IMPLICIT_PARAM,
  1308.  
  1309.   /// A ParmVarDecl record.
  1310.   DECL_PARM_VAR,
  1311.  
  1312.   /// A DecompositionDecl record.
  1313.   DECL_DECOMPOSITION,
  1314.  
  1315.   /// A BindingDecl record.
  1316.   DECL_BINDING,
  1317.  
  1318.   /// A FileScopeAsmDecl record.
  1319.   DECL_FILE_SCOPE_ASM,
  1320.  
  1321.   /// A TopLevelStmtDecl record.
  1322.   DECL_TOP_LEVEL_STMT_DECL,
  1323.  
  1324.   /// A BlockDecl record.
  1325.   DECL_BLOCK,
  1326.  
  1327.   /// A CapturedDecl record.
  1328.   DECL_CAPTURED,
  1329.  
  1330.   /// A record that stores the set of declarations that are
  1331.   /// lexically stored within a given DeclContext.
  1332.   ///
  1333.   /// The record itself is a blob that is an array of declaration IDs,
  1334.   /// in the order in which those declarations were added to the
  1335.   /// declaration context. This data is used when iterating over
  1336.   /// the contents of a DeclContext, e.g., via
  1337.   /// DeclContext::decls_begin() and DeclContext::decls_end().
  1338.   DECL_CONTEXT_LEXICAL,
  1339.  
  1340.   /// A record that stores the set of declarations that are
  1341.   /// visible from a given DeclContext.
  1342.   ///
  1343.   /// The record itself stores a set of mappings, each of which
  1344.   /// associates a declaration name with one or more declaration
  1345.   /// IDs. This data is used when performing qualified name lookup
  1346.   /// into a DeclContext via DeclContext::lookup.
  1347.   DECL_CONTEXT_VISIBLE,
  1348.  
  1349.   /// A LabelDecl record.
  1350.   DECL_LABEL,
  1351.  
  1352.   /// A NamespaceDecl record.
  1353.   DECL_NAMESPACE,
  1354.  
  1355.   /// A NamespaceAliasDecl record.
  1356.   DECL_NAMESPACE_ALIAS,
  1357.  
  1358.   /// A UsingDecl record.
  1359.   DECL_USING,
  1360.  
  1361.   /// A UsingEnumDecl record.
  1362.   DECL_USING_ENUM,
  1363.  
  1364.   /// A UsingPackDecl record.
  1365.   DECL_USING_PACK,
  1366.  
  1367.   /// A UsingShadowDecl record.
  1368.   DECL_USING_SHADOW,
  1369.  
  1370.   /// A ConstructorUsingShadowDecl record.
  1371.   DECL_CONSTRUCTOR_USING_SHADOW,
  1372.  
  1373.   /// A UsingDirecitveDecl record.
  1374.   DECL_USING_DIRECTIVE,
  1375.  
  1376.   /// An UnresolvedUsingValueDecl record.
  1377.   DECL_UNRESOLVED_USING_VALUE,
  1378.  
  1379.   /// An UnresolvedUsingTypenameDecl record.
  1380.   DECL_UNRESOLVED_USING_TYPENAME,
  1381.  
  1382.   /// A LinkageSpecDecl record.
  1383.   DECL_LINKAGE_SPEC,
  1384.  
  1385.   /// An ExportDecl record.
  1386.   DECL_EXPORT,
  1387.  
  1388.   /// A CXXRecordDecl record.
  1389.   DECL_CXX_RECORD,
  1390.  
  1391.   /// A CXXDeductionGuideDecl record.
  1392.   DECL_CXX_DEDUCTION_GUIDE,
  1393.  
  1394.   /// A CXXMethodDecl record.
  1395.   DECL_CXX_METHOD,
  1396.  
  1397.   /// A CXXConstructorDecl record.
  1398.   DECL_CXX_CONSTRUCTOR,
  1399.  
  1400.   /// A CXXDestructorDecl record.
  1401.   DECL_CXX_DESTRUCTOR,
  1402.  
  1403.   /// A CXXConversionDecl record.
  1404.   DECL_CXX_CONVERSION,
  1405.  
  1406.   /// An AccessSpecDecl record.
  1407.   DECL_ACCESS_SPEC,
  1408.  
  1409.   /// A FriendDecl record.
  1410.   DECL_FRIEND,
  1411.  
  1412.   /// A FriendTemplateDecl record.
  1413.   DECL_FRIEND_TEMPLATE,
  1414.  
  1415.   /// A ClassTemplateDecl record.
  1416.   DECL_CLASS_TEMPLATE,
  1417.  
  1418.   /// A ClassTemplateSpecializationDecl record.
  1419.   DECL_CLASS_TEMPLATE_SPECIALIZATION,
  1420.  
  1421.   /// A ClassTemplatePartialSpecializationDecl record.
  1422.   DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION,
  1423.  
  1424.   /// A VarTemplateDecl record.
  1425.   DECL_VAR_TEMPLATE,
  1426.  
  1427.   /// A VarTemplateSpecializationDecl record.
  1428.   DECL_VAR_TEMPLATE_SPECIALIZATION,
  1429.  
  1430.   /// A VarTemplatePartialSpecializationDecl record.
  1431.   DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION,
  1432.  
  1433.   /// A FunctionTemplateDecl record.
  1434.   DECL_FUNCTION_TEMPLATE,
  1435.  
  1436.   /// A TemplateTypeParmDecl record.
  1437.   DECL_TEMPLATE_TYPE_PARM,
  1438.  
  1439.   /// A NonTypeTemplateParmDecl record.
  1440.   DECL_NON_TYPE_TEMPLATE_PARM,
  1441.  
  1442.   /// A TemplateTemplateParmDecl record.
  1443.   DECL_TEMPLATE_TEMPLATE_PARM,
  1444.  
  1445.   /// A TypeAliasTemplateDecl record.
  1446.   DECL_TYPE_ALIAS_TEMPLATE,
  1447.  
  1448.   /// \brief A ConceptDecl record.
  1449.   DECL_CONCEPT,
  1450.  
  1451.   /// An UnresolvedUsingIfExistsDecl record.
  1452.   DECL_UNRESOLVED_USING_IF_EXISTS,
  1453.  
  1454.   /// \brief A StaticAssertDecl record.
  1455.   DECL_STATIC_ASSERT,
  1456.  
  1457.   /// A record containing CXXBaseSpecifiers.
  1458.   DECL_CXX_BASE_SPECIFIERS,
  1459.  
  1460.   /// A record containing CXXCtorInitializers.
  1461.   DECL_CXX_CTOR_INITIALIZERS,
  1462.  
  1463.   /// A IndirectFieldDecl record.
  1464.   DECL_INDIRECTFIELD,
  1465.  
  1466.   /// A NonTypeTemplateParmDecl record that stores an expanded
  1467.   /// non-type template parameter pack.
  1468.   DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK,
  1469.  
  1470.   /// A TemplateTemplateParmDecl record that stores an expanded
  1471.   /// template template parameter pack.
  1472.   DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK,
  1473.  
  1474.   /// A ClassScopeFunctionSpecializationDecl record a class scope
  1475.   /// function specialization. (Microsoft extension).
  1476.   DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION,
  1477.  
  1478.   /// An ImportDecl recording a module import.
  1479.   DECL_IMPORT,
  1480.  
  1481.   /// An OMPThreadPrivateDecl record.
  1482.   DECL_OMP_THREADPRIVATE,
  1483.  
  1484.   /// An OMPRequiresDecl record.
  1485.   DECL_OMP_REQUIRES,
  1486.  
  1487.   /// An OMPAllocateDcl record.
  1488.   DECL_OMP_ALLOCATE,
  1489.  
  1490.   /// An EmptyDecl record.
  1491.   DECL_EMPTY,
  1492.  
  1493.   /// An LifetimeExtendedTemporaryDecl record.
  1494.   DECL_LIFETIME_EXTENDED_TEMPORARY,
  1495.  
  1496.   /// A RequiresExprBodyDecl record.
  1497.   DECL_REQUIRES_EXPR_BODY,
  1498.  
  1499.   /// An ObjCTypeParamDecl record.
  1500.   DECL_OBJC_TYPE_PARAM,
  1501.  
  1502.   /// An OMPCapturedExprDecl record.
  1503.   DECL_OMP_CAPTUREDEXPR,
  1504.  
  1505.   /// A PragmaCommentDecl record.
  1506.   DECL_PRAGMA_COMMENT,
  1507.  
  1508.   /// A PragmaDetectMismatchDecl record.
  1509.   DECL_PRAGMA_DETECT_MISMATCH,
  1510.  
  1511.   /// An OMPDeclareMapperDecl record.
  1512.   DECL_OMP_DECLARE_MAPPER,
  1513.  
  1514.   /// An OMPDeclareReductionDecl record.
  1515.   DECL_OMP_DECLARE_REDUCTION,
  1516.  
  1517.   /// A UnnamedGlobalConstantDecl record.
  1518.   DECL_UNNAMED_GLOBAL_CONSTANT,
  1519.  
  1520.   /// A HLSLBufferDecl record.
  1521.   DECL_HLSL_BUFFER,
  1522.  
  1523.   /// An ImplicitConceptSpecializationDecl record.
  1524.   DECL_IMPLICIT_CONCEPT_SPECIALIZATION,
  1525.  
  1526.   DECL_LAST = DECL_IMPLICIT_CONCEPT_SPECIALIZATION
  1527. };
  1528.  
  1529. /// Record codes for each kind of statement or expression.
  1530. ///
  1531. /// These constants describe the records that describe statements
  1532. /// or expressions. These records  occur within type and declarations
  1533. /// block, so they begin with record values of 128.  Each constant
  1534. /// describes a record for a specific statement or expression class in the
  1535. /// AST.
  1536. enum StmtCode {
  1537.   /// A marker record that indicates that we are at the end
  1538.   /// of an expression.
  1539.   STMT_STOP = DECL_LAST + 1,
  1540.  
  1541.   /// A NULL expression.
  1542.   STMT_NULL_PTR,
  1543.  
  1544.   /// A reference to a previously [de]serialized Stmt record.
  1545.   STMT_REF_PTR,
  1546.  
  1547.   /// A NullStmt record.
  1548.   STMT_NULL,
  1549.  
  1550.   /// A CompoundStmt record.
  1551.   STMT_COMPOUND,
  1552.  
  1553.   /// A CaseStmt record.
  1554.   STMT_CASE,
  1555.  
  1556.   /// A DefaultStmt record.
  1557.   STMT_DEFAULT,
  1558.  
  1559.   /// A LabelStmt record.
  1560.   STMT_LABEL,
  1561.  
  1562.   /// An AttributedStmt record.
  1563.   STMT_ATTRIBUTED,
  1564.  
  1565.   /// An IfStmt record.
  1566.   STMT_IF,
  1567.  
  1568.   /// A SwitchStmt record.
  1569.   STMT_SWITCH,
  1570.  
  1571.   /// A WhileStmt record.
  1572.   STMT_WHILE,
  1573.  
  1574.   /// A DoStmt record.
  1575.   STMT_DO,
  1576.  
  1577.   /// A ForStmt record.
  1578.   STMT_FOR,
  1579.  
  1580.   /// A GotoStmt record.
  1581.   STMT_GOTO,
  1582.  
  1583.   /// An IndirectGotoStmt record.
  1584.   STMT_INDIRECT_GOTO,
  1585.  
  1586.   /// A ContinueStmt record.
  1587.   STMT_CONTINUE,
  1588.  
  1589.   /// A BreakStmt record.
  1590.   STMT_BREAK,
  1591.  
  1592.   /// A ReturnStmt record.
  1593.   STMT_RETURN,
  1594.  
  1595.   /// A DeclStmt record.
  1596.   STMT_DECL,
  1597.  
  1598.   /// A CapturedStmt record.
  1599.   STMT_CAPTURED,
  1600.  
  1601.   /// A GCC-style AsmStmt record.
  1602.   STMT_GCCASM,
  1603.  
  1604.   /// A MS-style AsmStmt record.
  1605.   STMT_MSASM,
  1606.  
  1607.   /// A constant expression context.
  1608.   EXPR_CONSTANT,
  1609.  
  1610.   /// A PredefinedExpr record.
  1611.   EXPR_PREDEFINED,
  1612.  
  1613.   /// A DeclRefExpr record.
  1614.   EXPR_DECL_REF,
  1615.  
  1616.   /// An IntegerLiteral record.
  1617.   EXPR_INTEGER_LITERAL,
  1618.  
  1619.   /// A FloatingLiteral record.
  1620.   EXPR_FLOATING_LITERAL,
  1621.  
  1622.   /// An ImaginaryLiteral record.
  1623.   EXPR_IMAGINARY_LITERAL,
  1624.  
  1625.   /// A StringLiteral record.
  1626.   EXPR_STRING_LITERAL,
  1627.  
  1628.   /// A CharacterLiteral record.
  1629.   EXPR_CHARACTER_LITERAL,
  1630.  
  1631.   /// A ParenExpr record.
  1632.   EXPR_PAREN,
  1633.  
  1634.   /// A ParenListExpr record.
  1635.   EXPR_PAREN_LIST,
  1636.  
  1637.   /// A UnaryOperator record.
  1638.   EXPR_UNARY_OPERATOR,
  1639.  
  1640.   /// An OffsetOfExpr record.
  1641.   EXPR_OFFSETOF,
  1642.  
  1643.   /// A SizefAlignOfExpr record.
  1644.   EXPR_SIZEOF_ALIGN_OF,
  1645.  
  1646.   /// An ArraySubscriptExpr record.
  1647.   EXPR_ARRAY_SUBSCRIPT,
  1648.  
  1649.   /// An MatrixSubscriptExpr record.
  1650.   EXPR_MATRIX_SUBSCRIPT,
  1651.  
  1652.   /// A CallExpr record.
  1653.   EXPR_CALL,
  1654.  
  1655.   /// A MemberExpr record.
  1656.   EXPR_MEMBER,
  1657.  
  1658.   /// A BinaryOperator record.
  1659.   EXPR_BINARY_OPERATOR,
  1660.  
  1661.   /// A CompoundAssignOperator record.
  1662.   EXPR_COMPOUND_ASSIGN_OPERATOR,
  1663.  
  1664.   /// A ConditionOperator record.
  1665.   EXPR_CONDITIONAL_OPERATOR,
  1666.  
  1667.   /// An ImplicitCastExpr record.
  1668.   EXPR_IMPLICIT_CAST,
  1669.  
  1670.   /// A CStyleCastExpr record.
  1671.   EXPR_CSTYLE_CAST,
  1672.  
  1673.   /// A CompoundLiteralExpr record.
  1674.   EXPR_COMPOUND_LITERAL,
  1675.  
  1676.   /// An ExtVectorElementExpr record.
  1677.   EXPR_EXT_VECTOR_ELEMENT,
  1678.  
  1679.   /// An InitListExpr record.
  1680.   EXPR_INIT_LIST,
  1681.  
  1682.   /// A DesignatedInitExpr record.
  1683.   EXPR_DESIGNATED_INIT,
  1684.  
  1685.   /// A DesignatedInitUpdateExpr record.
  1686.   EXPR_DESIGNATED_INIT_UPDATE,
  1687.  
  1688.   /// An NoInitExpr record.
  1689.   EXPR_NO_INIT,
  1690.  
  1691.   /// An ArrayInitLoopExpr record.
  1692.   EXPR_ARRAY_INIT_LOOP,
  1693.  
  1694.   /// An ArrayInitIndexExpr record.
  1695.   EXPR_ARRAY_INIT_INDEX,
  1696.  
  1697.   /// An ImplicitValueInitExpr record.
  1698.   EXPR_IMPLICIT_VALUE_INIT,
  1699.  
  1700.   /// A VAArgExpr record.
  1701.   EXPR_VA_ARG,
  1702.  
  1703.   /// An AddrLabelExpr record.
  1704.   EXPR_ADDR_LABEL,
  1705.  
  1706.   /// A StmtExpr record.
  1707.   EXPR_STMT,
  1708.  
  1709.   /// A ChooseExpr record.
  1710.   EXPR_CHOOSE,
  1711.  
  1712.   /// A GNUNullExpr record.
  1713.   EXPR_GNU_NULL,
  1714.  
  1715.   /// A SourceLocExpr record.
  1716.   EXPR_SOURCE_LOC,
  1717.  
  1718.   /// A ShuffleVectorExpr record.
  1719.   EXPR_SHUFFLE_VECTOR,
  1720.  
  1721.   /// A ConvertVectorExpr record.
  1722.   EXPR_CONVERT_VECTOR,
  1723.  
  1724.   /// BlockExpr
  1725.   EXPR_BLOCK,
  1726.  
  1727.   /// A GenericSelectionExpr record.
  1728.   EXPR_GENERIC_SELECTION,
  1729.  
  1730.   /// A PseudoObjectExpr record.
  1731.   EXPR_PSEUDO_OBJECT,
  1732.  
  1733.   /// An AtomicExpr record.
  1734.   EXPR_ATOMIC,
  1735.  
  1736.   /// A RecoveryExpr record.
  1737.   EXPR_RECOVERY,
  1738.  
  1739.   // Objective-C
  1740.  
  1741.   /// An ObjCStringLiteral record.
  1742.   EXPR_OBJC_STRING_LITERAL,
  1743.  
  1744.   EXPR_OBJC_BOXED_EXPRESSION,
  1745.   EXPR_OBJC_ARRAY_LITERAL,
  1746.   EXPR_OBJC_DICTIONARY_LITERAL,
  1747.  
  1748.   /// An ObjCEncodeExpr record.
  1749.   EXPR_OBJC_ENCODE,
  1750.  
  1751.   /// An ObjCSelectorExpr record.
  1752.   EXPR_OBJC_SELECTOR_EXPR,
  1753.  
  1754.   /// An ObjCProtocolExpr record.
  1755.   EXPR_OBJC_PROTOCOL_EXPR,
  1756.  
  1757.   /// An ObjCIvarRefExpr record.
  1758.   EXPR_OBJC_IVAR_REF_EXPR,
  1759.  
  1760.   /// An ObjCPropertyRefExpr record.
  1761.   EXPR_OBJC_PROPERTY_REF_EXPR,
  1762.  
  1763.   /// An ObjCSubscriptRefExpr record.
  1764.   EXPR_OBJC_SUBSCRIPT_REF_EXPR,
  1765.  
  1766.   /// UNUSED
  1767.   EXPR_OBJC_KVC_REF_EXPR,
  1768.  
  1769.   /// An ObjCMessageExpr record.
  1770.   EXPR_OBJC_MESSAGE_EXPR,
  1771.  
  1772.   /// An ObjCIsa Expr record.
  1773.   EXPR_OBJC_ISA,
  1774.  
  1775.   /// An ObjCIndirectCopyRestoreExpr record.
  1776.   EXPR_OBJC_INDIRECT_COPY_RESTORE,
  1777.  
  1778.   /// An ObjCForCollectionStmt record.
  1779.   STMT_OBJC_FOR_COLLECTION,
  1780.  
  1781.   /// An ObjCAtCatchStmt record.
  1782.   STMT_OBJC_CATCH,
  1783.  
  1784.   /// An ObjCAtFinallyStmt record.
  1785.   STMT_OBJC_FINALLY,
  1786.  
  1787.   /// An ObjCAtTryStmt record.
  1788.   STMT_OBJC_AT_TRY,
  1789.  
  1790.   /// An ObjCAtSynchronizedStmt record.
  1791.   STMT_OBJC_AT_SYNCHRONIZED,
  1792.  
  1793.   /// An ObjCAtThrowStmt record.
  1794.   STMT_OBJC_AT_THROW,
  1795.  
  1796.   /// An ObjCAutoreleasePoolStmt record.
  1797.   STMT_OBJC_AUTORELEASE_POOL,
  1798.  
  1799.   /// An ObjCBoolLiteralExpr record.
  1800.   EXPR_OBJC_BOOL_LITERAL,
  1801.  
  1802.   /// An ObjCAvailabilityCheckExpr record.
  1803.   EXPR_OBJC_AVAILABILITY_CHECK,
  1804.  
  1805.   // C++
  1806.  
  1807.   /// A CXXCatchStmt record.
  1808.   STMT_CXX_CATCH,
  1809.  
  1810.   /// A CXXTryStmt record.
  1811.   STMT_CXX_TRY,
  1812.   /// A CXXForRangeStmt record.
  1813.  
  1814.   STMT_CXX_FOR_RANGE,
  1815.  
  1816.   /// A CXXOperatorCallExpr record.
  1817.   EXPR_CXX_OPERATOR_CALL,
  1818.  
  1819.   /// A CXXMemberCallExpr record.
  1820.   EXPR_CXX_MEMBER_CALL,
  1821.  
  1822.   /// A CXXRewrittenBinaryOperator record.
  1823.   EXPR_CXX_REWRITTEN_BINARY_OPERATOR,
  1824.  
  1825.   /// A CXXConstructExpr record.
  1826.   EXPR_CXX_CONSTRUCT,
  1827.  
  1828.   /// A CXXInheritedCtorInitExpr record.
  1829.   EXPR_CXX_INHERITED_CTOR_INIT,
  1830.  
  1831.   /// A CXXTemporaryObjectExpr record.
  1832.   EXPR_CXX_TEMPORARY_OBJECT,
  1833.  
  1834.   /// A CXXStaticCastExpr record.
  1835.   EXPR_CXX_STATIC_CAST,
  1836.  
  1837.   /// A CXXDynamicCastExpr record.
  1838.   EXPR_CXX_DYNAMIC_CAST,
  1839.  
  1840.   /// A CXXReinterpretCastExpr record.
  1841.   EXPR_CXX_REINTERPRET_CAST,
  1842.  
  1843.   /// A CXXConstCastExpr record.
  1844.   EXPR_CXX_CONST_CAST,
  1845.  
  1846.   /// A CXXAddrspaceCastExpr record.
  1847.   EXPR_CXX_ADDRSPACE_CAST,
  1848.  
  1849.   /// A CXXFunctionalCastExpr record.
  1850.   EXPR_CXX_FUNCTIONAL_CAST,
  1851.  
  1852.   /// A BuiltinBitCastExpr record.
  1853.   EXPR_BUILTIN_BIT_CAST,
  1854.  
  1855.   /// A UserDefinedLiteral record.
  1856.   EXPR_USER_DEFINED_LITERAL,
  1857.  
  1858.   /// A CXXStdInitializerListExpr record.
  1859.   EXPR_CXX_STD_INITIALIZER_LIST,
  1860.  
  1861.   /// A CXXBoolLiteralExpr record.
  1862.   EXPR_CXX_BOOL_LITERAL,
  1863.  
  1864.   /// A CXXParenListInitExpr record.
  1865.   EXPR_CXX_PAREN_LIST_INIT,
  1866.  
  1867.   EXPR_CXX_NULL_PTR_LITERAL, // CXXNullPtrLiteralExpr
  1868.   EXPR_CXX_TYPEID_EXPR,      // CXXTypeidExpr (of expr).
  1869.   EXPR_CXX_TYPEID_TYPE,      // CXXTypeidExpr (of type).
  1870.   EXPR_CXX_THIS,             // CXXThisExpr
  1871.   EXPR_CXX_THROW,            // CXXThrowExpr
  1872.   EXPR_CXX_DEFAULT_ARG,      // CXXDefaultArgExpr
  1873.   EXPR_CXX_DEFAULT_INIT,     // CXXDefaultInitExpr
  1874.   EXPR_CXX_BIND_TEMPORARY,   // CXXBindTemporaryExpr
  1875.  
  1876.   EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr
  1877.   EXPR_CXX_NEW,               // CXXNewExpr
  1878.   EXPR_CXX_DELETE,            // CXXDeleteExpr
  1879.   EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr
  1880.  
  1881.   EXPR_EXPR_WITH_CLEANUPS, // ExprWithCleanups
  1882.  
  1883.   EXPR_CXX_DEPENDENT_SCOPE_MEMBER,   // CXXDependentScopeMemberExpr
  1884.   EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr
  1885.   EXPR_CXX_UNRESOLVED_CONSTRUCT,     // CXXUnresolvedConstructExpr
  1886.   EXPR_CXX_UNRESOLVED_MEMBER,        // UnresolvedMemberExpr
  1887.   EXPR_CXX_UNRESOLVED_LOOKUP,        // UnresolvedLookupExpr
  1888.  
  1889.   EXPR_CXX_EXPRESSION_TRAIT, // ExpressionTraitExpr
  1890.   EXPR_CXX_NOEXCEPT,         // CXXNoexceptExpr
  1891.  
  1892.   EXPR_OPAQUE_VALUE,                // OpaqueValueExpr
  1893.   EXPR_BINARY_CONDITIONAL_OPERATOR, // BinaryConditionalOperator
  1894.   EXPR_TYPE_TRAIT,                  // TypeTraitExpr
  1895.   EXPR_ARRAY_TYPE_TRAIT,            // ArrayTypeTraitIntExpr
  1896.  
  1897.   EXPR_PACK_EXPANSION,                    // PackExpansionExpr
  1898.   EXPR_SIZEOF_PACK,                       // SizeOfPackExpr
  1899.   EXPR_SUBST_NON_TYPE_TEMPLATE_PARM,      // SubstNonTypeTemplateParmExpr
  1900.   EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK, // SubstNonTypeTemplateParmPackExpr
  1901.   EXPR_FUNCTION_PARM_PACK,                // FunctionParmPackExpr
  1902.   EXPR_MATERIALIZE_TEMPORARY,             // MaterializeTemporaryExpr
  1903.   EXPR_CXX_FOLD,                          // CXXFoldExpr
  1904.   EXPR_CONCEPT_SPECIALIZATION,            // ConceptSpecializationExpr
  1905.   EXPR_REQUIRES,                          // RequiresExpr
  1906.  
  1907.   // CUDA
  1908.   EXPR_CUDA_KERNEL_CALL, // CUDAKernelCallExpr
  1909.  
  1910.   // OpenCL
  1911.   EXPR_ASTYPE, // AsTypeExpr
  1912.  
  1913.   // Microsoft
  1914.   EXPR_CXX_PROPERTY_REF_EXPR,       // MSPropertyRefExpr
  1915.   EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr
  1916.   EXPR_CXX_UUIDOF_EXPR,             // CXXUuidofExpr (of expr).
  1917.   EXPR_CXX_UUIDOF_TYPE,             // CXXUuidofExpr (of type).
  1918.   STMT_SEH_LEAVE,                   // SEHLeaveStmt
  1919.   STMT_SEH_EXCEPT,                  // SEHExceptStmt
  1920.   STMT_SEH_FINALLY,                 // SEHFinallyStmt
  1921.   STMT_SEH_TRY,                     // SEHTryStmt
  1922.  
  1923.   // OpenMP directives
  1924.   STMT_OMP_META_DIRECTIVE,
  1925.   STMT_OMP_CANONICAL_LOOP,
  1926.   STMT_OMP_PARALLEL_DIRECTIVE,
  1927.   STMT_OMP_SIMD_DIRECTIVE,
  1928.   STMT_OMP_TILE_DIRECTIVE,
  1929.   STMT_OMP_UNROLL_DIRECTIVE,
  1930.   STMT_OMP_FOR_DIRECTIVE,
  1931.   STMT_OMP_FOR_SIMD_DIRECTIVE,
  1932.   STMT_OMP_SECTIONS_DIRECTIVE,
  1933.   STMT_OMP_SECTION_DIRECTIVE,
  1934.   STMT_OMP_SINGLE_DIRECTIVE,
  1935.   STMT_OMP_MASTER_DIRECTIVE,
  1936.   STMT_OMP_CRITICAL_DIRECTIVE,
  1937.   STMT_OMP_PARALLEL_FOR_DIRECTIVE,
  1938.   STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE,
  1939.   STMT_OMP_PARALLEL_MASTER_DIRECTIVE,
  1940.   STMT_OMP_PARALLEL_MASKED_DIRECTIVE,
  1941.   STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE,
  1942.   STMT_OMP_TASK_DIRECTIVE,
  1943.   STMT_OMP_TASKYIELD_DIRECTIVE,
  1944.   STMT_OMP_ERROR_DIRECTIVE,
  1945.   STMT_OMP_BARRIER_DIRECTIVE,
  1946.   STMT_OMP_TASKWAIT_DIRECTIVE,
  1947.   STMT_OMP_FLUSH_DIRECTIVE,
  1948.   STMT_OMP_DEPOBJ_DIRECTIVE,
  1949.   STMT_OMP_SCAN_DIRECTIVE,
  1950.   STMT_OMP_ORDERED_DIRECTIVE,
  1951.   STMT_OMP_ATOMIC_DIRECTIVE,
  1952.   STMT_OMP_TARGET_DIRECTIVE,
  1953.   STMT_OMP_TARGET_DATA_DIRECTIVE,
  1954.   STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE,
  1955.   STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE,
  1956.   STMT_OMP_TARGET_PARALLEL_DIRECTIVE,
  1957.   STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE,
  1958.   STMT_OMP_TEAMS_DIRECTIVE,
  1959.   STMT_OMP_TASKGROUP_DIRECTIVE,
  1960.   STMT_OMP_CANCELLATION_POINT_DIRECTIVE,
  1961.   STMT_OMP_CANCEL_DIRECTIVE,
  1962.   STMT_OMP_TASKLOOP_DIRECTIVE,
  1963.   STMT_OMP_TASKLOOP_SIMD_DIRECTIVE,
  1964.   STMT_OMP_MASTER_TASKLOOP_DIRECTIVE,
  1965.   STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE,
  1966.   STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE,
  1967.   STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE,
  1968.   STMT_OMP_MASKED_TASKLOOP_DIRECTIVE,
  1969.   STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE,
  1970.   STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE,
  1971.   STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE,
  1972.   STMT_OMP_DISTRIBUTE_DIRECTIVE,
  1973.   STMT_OMP_TARGET_UPDATE_DIRECTIVE,
  1974.   STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
  1975.   STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
  1976.   STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE,
  1977.   STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE,
  1978.   STMT_OMP_TARGET_SIMD_DIRECTIVE,
  1979.   STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE,
  1980.   STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
  1981.   STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
  1982.   STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
  1983.   STMT_OMP_TARGET_TEAMS_DIRECTIVE,
  1984.   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
  1985.   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
  1986.   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
  1987.   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
  1988.   STMT_OMP_INTEROP_DIRECTIVE,
  1989.   STMT_OMP_DISPATCH_DIRECTIVE,
  1990.   STMT_OMP_MASKED_DIRECTIVE,
  1991.   STMT_OMP_GENERIC_LOOP_DIRECTIVE,
  1992.   STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE,
  1993.   STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE,
  1994.   STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE,
  1995.   STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE,
  1996.   EXPR_OMP_ARRAY_SECTION,
  1997.   EXPR_OMP_ARRAY_SHAPING,
  1998.   EXPR_OMP_ITERATOR,
  1999.  
  2000.   // ARC
  2001.   EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr
  2002.  
  2003.   STMT_MS_DEPENDENT_EXISTS, // MSDependentExistsStmt
  2004.   EXPR_LAMBDA,              // LambdaExpr
  2005.   STMT_COROUTINE_BODY,
  2006.   STMT_CORETURN,
  2007.   EXPR_COAWAIT,
  2008.   EXPR_COYIELD,
  2009.   EXPR_DEPENDENT_COAWAIT,
  2010.  
  2011.   // FixedPointLiteral
  2012.   EXPR_FIXEDPOINT_LITERAL,
  2013.  
  2014.   // SYCLUniqueStableNameExpr
  2015.   EXPR_SYCL_UNIQUE_STABLE_NAME,
  2016. };
  2017.  
  2018. /// The kinds of designators that can occur in a
  2019. /// DesignatedInitExpr.
  2020. enum DesignatorTypes {
  2021.   /// Field designator where only the field name is known.
  2022.   DESIG_FIELD_NAME = 0,
  2023.  
  2024.   /// Field designator where the field has been resolved to
  2025.   /// a declaration.
  2026.   DESIG_FIELD_DECL = 1,
  2027.  
  2028.   /// Array designator.
  2029.   DESIG_ARRAY = 2,
  2030.  
  2031.   /// GNU array range designator.
  2032.   DESIG_ARRAY_RANGE = 3
  2033. };
  2034.  
  2035. /// The different kinds of data that can occur in a
  2036. /// CtorInitializer.
  2037. enum CtorInitializerType {
  2038.   CTOR_INITIALIZER_BASE,
  2039.   CTOR_INITIALIZER_DELEGATING,
  2040.   CTOR_INITIALIZER_MEMBER,
  2041.   CTOR_INITIALIZER_INDIRECT_MEMBER
  2042. };
  2043.  
  2044. /// Kinds of cleanup objects owned by ExprWithCleanups.
  2045. enum CleanupObjectKind { COK_Block, COK_CompoundLiteral };
  2046.  
  2047. /// Describes the redeclarations of a declaration.
  2048. struct LocalRedeclarationsInfo {
  2049.   // The ID of the first declaration
  2050.   DeclID FirstID;
  2051.  
  2052.   // Offset into the array of redeclaration chains.
  2053.   unsigned Offset;
  2054.  
  2055.   friend bool operator<(const LocalRedeclarationsInfo &X,
  2056.                         const LocalRedeclarationsInfo &Y) {
  2057.     return X.FirstID < Y.FirstID;
  2058.   }
  2059.  
  2060.   friend bool operator>(const LocalRedeclarationsInfo &X,
  2061.                         const LocalRedeclarationsInfo &Y) {
  2062.     return X.FirstID > Y.FirstID;
  2063.   }
  2064.  
  2065.   friend bool operator<=(const LocalRedeclarationsInfo &X,
  2066.                          const LocalRedeclarationsInfo &Y) {
  2067.     return X.FirstID <= Y.FirstID;
  2068.   }
  2069.  
  2070.   friend bool operator>=(const LocalRedeclarationsInfo &X,
  2071.                          const LocalRedeclarationsInfo &Y) {
  2072.     return X.FirstID >= Y.FirstID;
  2073.   }
  2074. };
  2075.  
  2076. /// Describes the categories of an Objective-C class.
  2077. struct ObjCCategoriesInfo {
  2078.   // The ID of the definition
  2079.   DeclID DefinitionID;
  2080.  
  2081.   // Offset into the array of category lists.
  2082.   unsigned Offset;
  2083.  
  2084.   friend bool operator<(const ObjCCategoriesInfo &X,
  2085.                         const ObjCCategoriesInfo &Y) {
  2086.     return X.DefinitionID < Y.DefinitionID;
  2087.   }
  2088.  
  2089.   friend bool operator>(const ObjCCategoriesInfo &X,
  2090.                         const ObjCCategoriesInfo &Y) {
  2091.     return X.DefinitionID > Y.DefinitionID;
  2092.   }
  2093.  
  2094.   friend bool operator<=(const ObjCCategoriesInfo &X,
  2095.                          const ObjCCategoriesInfo &Y) {
  2096.     return X.DefinitionID <= Y.DefinitionID;
  2097.   }
  2098.  
  2099.   friend bool operator>=(const ObjCCategoriesInfo &X,
  2100.                          const ObjCCategoriesInfo &Y) {
  2101.     return X.DefinitionID >= Y.DefinitionID;
  2102.   }
  2103. };
  2104.  
  2105. /// A key used when looking up entities by \ref DeclarationName.
  2106. ///
  2107. /// Different \ref DeclarationNames are mapped to different keys, but the
  2108. /// same key can occasionally represent multiple names (for names that
  2109. /// contain types, in particular).
  2110. class DeclarationNameKey {
  2111.   using NameKind = unsigned;
  2112.  
  2113.   NameKind Kind = 0;
  2114.   uint64_t Data = 0;
  2115.  
  2116. public:
  2117.   DeclarationNameKey() = default;
  2118.   DeclarationNameKey(DeclarationName Name);
  2119.   DeclarationNameKey(NameKind Kind, uint64_t Data) : Kind(Kind), Data(Data) {}
  2120.  
  2121.   NameKind getKind() const { return Kind; }
  2122.  
  2123.   IdentifierInfo *getIdentifier() const {
  2124.     assert(Kind == DeclarationName::Identifier ||
  2125.            Kind == DeclarationName::CXXLiteralOperatorName ||
  2126.            Kind == DeclarationName::CXXDeductionGuideName);
  2127.     return (IdentifierInfo *)Data;
  2128.   }
  2129.  
  2130.   Selector getSelector() const {
  2131.     assert(Kind == DeclarationName::ObjCZeroArgSelector ||
  2132.            Kind == DeclarationName::ObjCOneArgSelector ||
  2133.            Kind == DeclarationName::ObjCMultiArgSelector);
  2134.     return Selector(Data);
  2135.   }
  2136.  
  2137.   OverloadedOperatorKind getOperatorKind() const {
  2138.     assert(Kind == DeclarationName::CXXOperatorName);
  2139.     return (OverloadedOperatorKind)Data;
  2140.   }
  2141.  
  2142.   /// Compute a fingerprint of this key for use in on-disk hash table.
  2143.   unsigned getHash() const;
  2144.  
  2145.   friend bool operator==(const DeclarationNameKey &A,
  2146.                          const DeclarationNameKey &B) {
  2147.     return A.Kind == B.Kind && A.Data == B.Data;
  2148.   }
  2149. };
  2150.  
  2151. /// @}
  2152.  
  2153. } // namespace serialization
  2154. } // namespace clang
  2155.  
  2156. namespace llvm {
  2157.  
  2158. template <> struct DenseMapInfo<clang::serialization::DeclarationNameKey> {
  2159.   static clang::serialization::DeclarationNameKey getEmptyKey() {
  2160.     return clang::serialization::DeclarationNameKey(-1, 1);
  2161.   }
  2162.  
  2163.   static clang::serialization::DeclarationNameKey getTombstoneKey() {
  2164.     return clang::serialization::DeclarationNameKey(-1, 2);
  2165.   }
  2166.  
  2167.   static unsigned
  2168.   getHashValue(const clang::serialization::DeclarationNameKey &Key) {
  2169.     return Key.getHash();
  2170.   }
  2171.  
  2172.   static bool isEqual(const clang::serialization::DeclarationNameKey &L,
  2173.                       const clang::serialization::DeclarationNameKey &R) {
  2174.     return L == R;
  2175.   }
  2176. };
  2177.  
  2178. } // namespace llvm
  2179.  
  2180. #endif // LLVM_CLANG_SERIALIZATION_ASTBITCODES_H
  2181.