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