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 = 27; 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 /// ID 66 used to be the list of included files. 700 701 /// Record code for an unterminated \#pragma clang assume_nonnull begin 702 /// recorded in a preamble. 703 PP_ASSUME_NONNULL_LOC = 67, 704 }; 705 706 /// Record types used within a source manager block. 707 enum SourceManagerRecordTypes { 708 /// Describes a source location entry (SLocEntry) for a 709 /// file. 710 SM_SLOC_FILE_ENTRY = 1, 711 712 /// Describes a source location entry (SLocEntry) for a 713 /// buffer. 714 SM_SLOC_BUFFER_ENTRY = 2, 715 716 /// Describes a blob that contains the data for a buffer 717 /// entry. This kind of record always directly follows a 718 /// SM_SLOC_BUFFER_ENTRY record or a SM_SLOC_FILE_ENTRY with an 719 /// overridden buffer. 720 SM_SLOC_BUFFER_BLOB = 3, 721 722 /// Describes a zlib-compressed blob that contains the data for 723 /// a buffer entry. 724 SM_SLOC_BUFFER_BLOB_COMPRESSED = 4, 725 726 /// Describes a source location entry (SLocEntry) for a 727 /// macro expansion. 728 SM_SLOC_EXPANSION_ENTRY = 5 729 }; 730 731 /// Record types used within a preprocessor block. 732 enum PreprocessorRecordTypes { 733 // The macros in the PP section are a PP_MACRO_* instance followed by a 734 // list of PP_TOKEN instances for each token in the definition. 735 736 /// An object-like macro definition. 737 /// [PP_MACRO_OBJECT_LIKE, IdentInfoID, SLoc, IsUsed] 738 PP_MACRO_OBJECT_LIKE = 1, 739 740 /// A function-like macro definition. 741 /// [PP_MACRO_FUNCTION_LIKE, \<ObjectLikeStuff>, IsC99Varargs, 742 /// IsGNUVarars, NumArgs, ArgIdentInfoID* ] 743 PP_MACRO_FUNCTION_LIKE = 2, 744 745 /// Describes one token. 746 /// [PP_TOKEN, SLoc, Length, IdentInfoID, Kind, Flags] 747 PP_TOKEN = 3, 748 749 /// The macro directives history for a particular identifier. 750 PP_MACRO_DIRECTIVE_HISTORY = 4, 751 752 /// A macro directive exported by a module. 753 /// [PP_MODULE_MACRO, SubmoduleID, MacroID, (Overridden SubmoduleID)*] 754 PP_MODULE_MACRO = 5, 755 }; 756 757 /// Record types used within a preprocessor detail block. 758 enum PreprocessorDetailRecordTypes { 759 /// Describes a macro expansion within the preprocessing record. 760 PPD_MACRO_EXPANSION = 0, 761 762 /// Describes a macro definition within the preprocessing record. 763 PPD_MACRO_DEFINITION = 1, 764 765 /// Describes an inclusion directive within the preprocessing 766 /// record. 767 PPD_INCLUSION_DIRECTIVE = 2 768 }; 769 770 /// Record types used within a submodule description block. 771 enum SubmoduleRecordTypes { 772 /// Metadata for submodules as a whole. 773 SUBMODULE_METADATA = 0, 774 775 /// Defines the major attributes of a submodule, including its 776 /// name and parent. 777 SUBMODULE_DEFINITION = 1, 778 779 /// Specifies the umbrella header used to create this module, 780 /// if any. 781 SUBMODULE_UMBRELLA_HEADER = 2, 782 783 /// Specifies a header that falls into this (sub)module. 784 SUBMODULE_HEADER = 3, 785 786 /// Specifies a top-level header that falls into this (sub)module. 787 SUBMODULE_TOPHEADER = 4, 788 789 /// Specifies an umbrella directory. 790 SUBMODULE_UMBRELLA_DIR = 5, 791 792 /// Specifies the submodules that are imported by this 793 /// submodule. 794 SUBMODULE_IMPORTS = 6, 795 796 /// Specifies the submodules that are re-exported from this 797 /// submodule. 798 SUBMODULE_EXPORTS = 7, 799 800 /// Specifies a required feature. 801 SUBMODULE_REQUIRES = 8, 802 803 /// Specifies a header that has been explicitly excluded 804 /// from this submodule. 805 SUBMODULE_EXCLUDED_HEADER = 9, 806 807 /// Specifies a library or framework to link against. 808 SUBMODULE_LINK_LIBRARY = 10, 809 810 /// Specifies a configuration macro for this module. 811 SUBMODULE_CONFIG_MACRO = 11, 812 813 /// Specifies a conflict with another module. 814 SUBMODULE_CONFLICT = 12, 815 816 /// Specifies a header that is private to this submodule. 817 SUBMODULE_PRIVATE_HEADER = 13, 818 819 /// Specifies a header that is part of the module but must be 820 /// textually included. 821 SUBMODULE_TEXTUAL_HEADER = 14, 822 823 /// Specifies a header that is private to this submodule but 824 /// must be textually included. 825 SUBMODULE_PRIVATE_TEXTUAL_HEADER = 15, 826 827 /// Specifies some declarations with initializers that must be 828 /// emitted to initialize the module. 829 SUBMODULE_INITIALIZERS = 16, 830 831 /// Specifies the name of the module that will eventually 832 /// re-export the entities in this module. 833 SUBMODULE_EXPORT_AS = 17, 834 835 /// Specifies affecting modules that were not imported. 836 SUBMODULE_AFFECTING_MODULES = 18, 837 }; 838 839 /// Record types used within a comments block. 840 enum CommentRecordTypes { COMMENTS_RAW_COMMENT = 0 }; 841 842 /// \defgroup ASTAST AST file AST constants 843 /// 844 /// The constants in this group describe various components of the 845 /// abstract syntax tree within an AST file. 846 /// 847 /// @{ 848 849 /// Predefined type IDs. 850 /// 851 /// These type IDs correspond to predefined types in the AST 852 /// context, such as built-in types (int) and special place-holder 853 /// types (the \<overload> and \<dependent> type markers). Such 854 /// types are never actually serialized, since they will be built 855 /// by the AST context when it is created. 856 enum PredefinedTypeIDs { 857 /// The NULL type. 858 PREDEF_TYPE_NULL_ID = 0, 859 860 /// The void type. 861 PREDEF_TYPE_VOID_ID = 1, 862 863 /// The 'bool' or '_Bool' type. 864 PREDEF_TYPE_BOOL_ID = 2, 865 866 /// The 'char' type, when it is unsigned. 867 PREDEF_TYPE_CHAR_U_ID = 3, 868 869 /// The 'unsigned char' type. 870 PREDEF_TYPE_UCHAR_ID = 4, 871 872 /// The 'unsigned short' type. 873 PREDEF_TYPE_USHORT_ID = 5, 874 875 /// The 'unsigned int' type. 876 PREDEF_TYPE_UINT_ID = 6, 877 878 /// The 'unsigned long' type. 879 PREDEF_TYPE_ULONG_ID = 7, 880 881 /// The 'unsigned long long' type. 882 PREDEF_TYPE_ULONGLONG_ID = 8, 883 884 /// The 'char' type, when it is signed. 885 PREDEF_TYPE_CHAR_S_ID = 9, 886 887 /// The 'signed char' type. 888 PREDEF_TYPE_SCHAR_ID = 10, 889 890 /// The C++ 'wchar_t' type. 891 PREDEF_TYPE_WCHAR_ID = 11, 892 893 /// The (signed) 'short' type. 894 PREDEF_TYPE_SHORT_ID = 12, 895 896 /// The (signed) 'int' type. 897 PREDEF_TYPE_INT_ID = 13, 898 899 /// The (signed) 'long' type. 900 PREDEF_TYPE_LONG_ID = 14, 901 902 /// The (signed) 'long long' type. 903 PREDEF_TYPE_LONGLONG_ID = 15, 904 905 /// The 'float' type. 906 PREDEF_TYPE_FLOAT_ID = 16, 907 908 /// The 'double' type. 909 PREDEF_TYPE_DOUBLE_ID = 17, 910 911 /// The 'long double' type. 912 PREDEF_TYPE_LONGDOUBLE_ID = 18, 913 914 /// The placeholder type for overloaded function sets. 915 PREDEF_TYPE_OVERLOAD_ID = 19, 916 917 /// The placeholder type for dependent types. 918 PREDEF_TYPE_DEPENDENT_ID = 20, 919 920 /// The '__uint128_t' type. 921 PREDEF_TYPE_UINT128_ID = 21, 922 923 /// The '__int128_t' type. 924 PREDEF_TYPE_INT128_ID = 22, 925 926 /// The type of 'nullptr'. 927 PREDEF_TYPE_NULLPTR_ID = 23, 928 929 /// The C++ 'char16_t' type. 930 PREDEF_TYPE_CHAR16_ID = 24, 931 932 /// The C++ 'char32_t' type. 933 PREDEF_TYPE_CHAR32_ID = 25, 934 935 /// The ObjC 'id' type. 936 PREDEF_TYPE_OBJC_ID = 26, 937 938 /// The ObjC 'Class' type. 939 PREDEF_TYPE_OBJC_CLASS = 27, 940 941 /// The ObjC 'SEL' type. 942 PREDEF_TYPE_OBJC_SEL = 28, 943 944 /// The 'unknown any' placeholder type. 945 PREDEF_TYPE_UNKNOWN_ANY = 29, 946 947 /// The placeholder type for bound member functions. 948 PREDEF_TYPE_BOUND_MEMBER = 30, 949 950 /// The "auto" deduction type. 951 PREDEF_TYPE_AUTO_DEDUCT = 31, 952 953 /// The "auto &&" deduction type. 954 PREDEF_TYPE_AUTO_RREF_DEDUCT = 32, 955 956 /// The OpenCL 'half' / ARM NEON __fp16 type. 957 PREDEF_TYPE_HALF_ID = 33, 958 959 /// ARC's unbridged-cast placeholder type. 960 PREDEF_TYPE_ARC_UNBRIDGED_CAST = 34, 961 962 /// The pseudo-object placeholder type. 963 PREDEF_TYPE_PSEUDO_OBJECT = 35, 964 965 /// The placeholder type for builtin functions. 966 PREDEF_TYPE_BUILTIN_FN = 36, 967 968 /// OpenCL event type. 969 PREDEF_TYPE_EVENT_ID = 37, 970 971 /// OpenCL clk event type. 972 PREDEF_TYPE_CLK_EVENT_ID = 38, 973 974 /// OpenCL sampler type. 975 PREDEF_TYPE_SAMPLER_ID = 39, 976 977 /// OpenCL queue type. 978 PREDEF_TYPE_QUEUE_ID = 40, 979 980 /// OpenCL reserve_id type. 981 PREDEF_TYPE_RESERVE_ID_ID = 41, 982 983 /// The placeholder type for OpenMP array section. 984 PREDEF_TYPE_OMP_ARRAY_SECTION = 42, 985 986 /// The '__float128' type 987 PREDEF_TYPE_FLOAT128_ID = 43, 988 989 /// The '_Float16' type 990 PREDEF_TYPE_FLOAT16_ID = 44, 991 992 /// The C++ 'char8_t' type. 993 PREDEF_TYPE_CHAR8_ID = 45, 994 995 /// \brief The 'short _Accum' type 996 PREDEF_TYPE_SHORT_ACCUM_ID = 46, 997 998 /// \brief The '_Accum' type 999 PREDEF_TYPE_ACCUM_ID = 47, 1000 1001 /// \brief The 'long _Accum' type 1002 PREDEF_TYPE_LONG_ACCUM_ID = 48, 1003 1004 /// \brief The 'unsigned short _Accum' type 1005 PREDEF_TYPE_USHORT_ACCUM_ID = 49, 1006 1007 /// \brief The 'unsigned _Accum' type 1008 PREDEF_TYPE_UACCUM_ID = 50, 1009 1010 /// \brief The 'unsigned long _Accum' type 1011 PREDEF_TYPE_ULONG_ACCUM_ID = 51, 1012 1013 /// \brief The 'short _Fract' type 1014 PREDEF_TYPE_SHORT_FRACT_ID = 52, 1015 1016 /// \brief The '_Fract' type 1017 PREDEF_TYPE_FRACT_ID = 53, 1018 1019 /// \brief The 'long _Fract' type 1020 PREDEF_TYPE_LONG_FRACT_ID = 54, 1021 1022 /// \brief The 'unsigned short _Fract' type 1023 PREDEF_TYPE_USHORT_FRACT_ID = 55, 1024 1025 /// \brief The 'unsigned _Fract' type 1026 PREDEF_TYPE_UFRACT_ID = 56, 1027 1028 /// \brief The 'unsigned long _Fract' type 1029 PREDEF_TYPE_ULONG_FRACT_ID = 57, 1030 1031 /// \brief The '_Sat short _Accum' type 1032 PREDEF_TYPE_SAT_SHORT_ACCUM_ID = 58, 1033 1034 /// \brief The '_Sat _Accum' type 1035 PREDEF_TYPE_SAT_ACCUM_ID = 59, 1036 1037 /// \brief The '_Sat long _Accum' type 1038 PREDEF_TYPE_SAT_LONG_ACCUM_ID = 60, 1039 1040 /// \brief The '_Sat unsigned short _Accum' type 1041 PREDEF_TYPE_SAT_USHORT_ACCUM_ID = 61, 1042 1043 /// \brief The '_Sat unsigned _Accum' type 1044 PREDEF_TYPE_SAT_UACCUM_ID = 62, 1045 1046 /// \brief The '_Sat unsigned long _Accum' type 1047 PREDEF_TYPE_SAT_ULONG_ACCUM_ID = 63, 1048 1049 /// \brief The '_Sat short _Fract' type 1050 PREDEF_TYPE_SAT_SHORT_FRACT_ID = 64, 1051 1052 /// \brief The '_Sat _Fract' type 1053 PREDEF_TYPE_SAT_FRACT_ID = 65, 1054 1055 /// \brief The '_Sat long _Fract' type 1056 PREDEF_TYPE_SAT_LONG_FRACT_ID = 66, 1057 1058 /// \brief The '_Sat unsigned short _Fract' type 1059 PREDEF_TYPE_SAT_USHORT_FRACT_ID = 67, 1060 1061 /// \brief The '_Sat unsigned _Fract' type 1062 PREDEF_TYPE_SAT_UFRACT_ID = 68, 1063 1064 /// \brief The '_Sat unsigned long _Fract' type 1065 PREDEF_TYPE_SAT_ULONG_FRACT_ID = 69, 1066 1067 /// The placeholder type for OpenMP array shaping operation. 1068 PREDEF_TYPE_OMP_ARRAY_SHAPING = 70, 1069 1070 /// The placeholder type for OpenMP iterator expression. 1071 PREDEF_TYPE_OMP_ITERATOR = 71, 1072 1073 /// A placeholder type for incomplete matrix index operations. 1074 PREDEF_TYPE_INCOMPLETE_MATRIX_IDX = 72, 1075 1076 /// \brief The '__bf16' type 1077 PREDEF_TYPE_BFLOAT16_ID = 73, 1078 1079 /// \brief The '__ibm128' type 1080 PREDEF_TYPE_IBM128_ID = 74, 1081 1082 /// OpenCL image types with auto numeration 1083 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 1084 PREDEF_TYPE_##Id##_ID, 1085 #include "clang/Basic/OpenCLImageTypes.def" 1086 /// \brief OpenCL extension types with auto numeration 1087 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) PREDEF_TYPE_##Id##_ID, 1088 #include "clang/Basic/OpenCLExtensionTypes.def" 1089 // \brief SVE types with auto numeration 1090 #define SVE_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID, 1091 #include "clang/Basic/AArch64SVEACLETypes.def" 1092 // \brief PowerPC MMA types with auto numeration 1093 #define PPC_VECTOR_TYPE(Name, Id, Size) PREDEF_TYPE_##Id##_ID, 1094 #include "clang/Basic/PPCTypes.def" 1095 // \brief RISC-V V types with auto numeration 1096 #define RVV_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID, 1097 #include "clang/Basic/RISCVVTypes.def" 1098 // \brief WebAssembly reference types with auto numeration 1099 #define WASM_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID, 1100 #include "clang/Basic/WebAssemblyReferenceTypes.def" 1101 // Sentinel value. Considered a predefined type but not useable as one. 1102 PREDEF_TYPE_LAST_ID 1103 }; 1104 1105 /// The number of predefined type IDs that are reserved for 1106 /// the PREDEF_TYPE_* constants. 1107 /// 1108 /// Type IDs for non-predefined types will start at 1109 /// NUM_PREDEF_TYPE_IDs. 1110 const unsigned NUM_PREDEF_TYPE_IDS = 500; 1111 1112 // Ensure we do not overrun the predefined types we reserved 1113 // in the enum PredefinedTypeIDs above. 1114 static_assert(PREDEF_TYPE_LAST_ID < NUM_PREDEF_TYPE_IDS, 1115 "Too many enumerators in PredefinedTypeIDs. Review the value of " 1116 "NUM_PREDEF_TYPE_IDS"); 1117 1118 /// Record codes for each kind of type. 1119 /// 1120 /// These constants describe the type records that can occur within a 1121 /// block identified by DECLTYPES_BLOCK_ID in the AST file. Each 1122 /// constant describes a record for a specific type class in the 1123 /// AST. Note that DeclCode values share this code space. 1124 enum TypeCode { 1125 #define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \ 1126 TYPE_##CODE_ID = CODE_VALUE, 1127 #include "clang/Serialization/TypeBitCodes.def" 1128 1129 /// An ExtQualType record. 1130 TYPE_EXT_QUAL = 1 1131 }; 1132 1133 /// The type IDs for special types constructed by semantic 1134 /// analysis. 1135 /// 1136 /// The constants in this enumeration are indices into the 1137 /// SPECIAL_TYPES record. 1138 enum SpecialTypeIDs { 1139 /// CFConstantString type 1140 SPECIAL_TYPE_CF_CONSTANT_STRING = 0, 1141 1142 /// C FILE typedef type 1143 SPECIAL_TYPE_FILE = 1, 1144 1145 /// C jmp_buf typedef type 1146 SPECIAL_TYPE_JMP_BUF = 2, 1147 1148 /// C sigjmp_buf typedef type 1149 SPECIAL_TYPE_SIGJMP_BUF = 3, 1150 1151 /// Objective-C "id" redefinition type 1152 SPECIAL_TYPE_OBJC_ID_REDEFINITION = 4, 1153 1154 /// Objective-C "Class" redefinition type 1155 SPECIAL_TYPE_OBJC_CLASS_REDEFINITION = 5, 1156 1157 /// Objective-C "SEL" redefinition type 1158 SPECIAL_TYPE_OBJC_SEL_REDEFINITION = 6, 1159 1160 /// C ucontext_t typedef type 1161 SPECIAL_TYPE_UCONTEXT_T = 7 1162 }; 1163 1164 /// The number of special type IDs. 1165 const unsigned NumSpecialTypeIDs = 8; 1166 1167 /// Predefined declaration IDs. 1168 /// 1169 /// These declaration IDs correspond to predefined declarations in the AST 1170 /// context, such as the NULL declaration ID. Such declarations are never 1171 /// actually serialized, since they will be built by the AST context when 1172 /// it is created. 1173 enum PredefinedDeclIDs { 1174 /// The NULL declaration. 1175 PREDEF_DECL_NULL_ID = 0, 1176 1177 /// The translation unit. 1178 PREDEF_DECL_TRANSLATION_UNIT_ID = 1, 1179 1180 /// The Objective-C 'id' type. 1181 PREDEF_DECL_OBJC_ID_ID = 2, 1182 1183 /// The Objective-C 'SEL' type. 1184 PREDEF_DECL_OBJC_SEL_ID = 3, 1185 1186 /// The Objective-C 'Class' type. 1187 PREDEF_DECL_OBJC_CLASS_ID = 4, 1188 1189 /// The Objective-C 'Protocol' type. 1190 PREDEF_DECL_OBJC_PROTOCOL_ID = 5, 1191 1192 /// The signed 128-bit integer type. 1193 PREDEF_DECL_INT_128_ID = 6, 1194 1195 /// The unsigned 128-bit integer type. 1196 PREDEF_DECL_UNSIGNED_INT_128_ID = 7, 1197 1198 /// The internal 'instancetype' typedef. 1199 PREDEF_DECL_OBJC_INSTANCETYPE_ID = 8, 1200 1201 /// The internal '__builtin_va_list' typedef. 1202 PREDEF_DECL_BUILTIN_VA_LIST_ID = 9, 1203 1204 /// The internal '__va_list_tag' struct, if any. 1205 PREDEF_DECL_VA_LIST_TAG = 10, 1206 1207 /// The internal '__builtin_ms_va_list' typedef. 1208 PREDEF_DECL_BUILTIN_MS_VA_LIST_ID = 11, 1209 1210 /// The predeclared '_GUID' struct. 1211 PREDEF_DECL_BUILTIN_MS_GUID_ID = 12, 1212 1213 /// The extern "C" context. 1214 PREDEF_DECL_EXTERN_C_CONTEXT_ID = 13, 1215 1216 /// The internal '__make_integer_seq' template. 1217 PREDEF_DECL_MAKE_INTEGER_SEQ_ID = 14, 1218 1219 /// The internal '__NSConstantString' typedef. 1220 PREDEF_DECL_CF_CONSTANT_STRING_ID = 15, 1221 1222 /// The internal '__NSConstantString' tag type. 1223 PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID = 16, 1224 1225 /// The internal '__type_pack_element' template. 1226 PREDEF_DECL_TYPE_PACK_ELEMENT_ID = 17, 1227 }; 1228 1229 /// The number of declaration IDs that are predefined. 1230 /// 1231 /// For more information about predefined declarations, see the 1232 /// \c PredefinedDeclIDs type and the PREDEF_DECL_*_ID constants. 1233 const unsigned int NUM_PREDEF_DECL_IDS = 18; 1234 1235 /// Record of updates for a declaration that was modified after 1236 /// being deserialized. This can occur within DECLTYPES_BLOCK_ID. 1237 const unsigned int DECL_UPDATES = 49; 1238 1239 /// Record code for a list of local redeclarations of a declaration. 1240 /// This can occur within DECLTYPES_BLOCK_ID. 1241 const unsigned int LOCAL_REDECLARATIONS = 50; 1242 1243 /// Record codes for each kind of declaration. 1244 /// 1245 /// These constants describe the declaration records that can occur within 1246 /// a declarations block (identified by DECLTYPES_BLOCK_ID). Each 1247 /// constant describes a record for a specific declaration class 1248 /// in the AST. Note that TypeCode values share this code space. 1249 enum DeclCode { 1250 /// A TypedefDecl record. 1251 DECL_TYPEDEF = 51, 1252 /// A TypeAliasDecl record. 1253 1254 DECL_TYPEALIAS, 1255 1256 /// An EnumDecl record. 1257 DECL_ENUM, 1258 1259 /// A RecordDecl record. 1260 DECL_RECORD, 1261 1262 /// An EnumConstantDecl record. 1263 DECL_ENUM_CONSTANT, 1264 1265 /// A FunctionDecl record. 1266 DECL_FUNCTION, 1267 1268 /// A ObjCMethodDecl record. 1269 DECL_OBJC_METHOD, 1270 1271 /// A ObjCInterfaceDecl record. 1272 DECL_OBJC_INTERFACE, 1273 1274 /// A ObjCProtocolDecl record. 1275 DECL_OBJC_PROTOCOL, 1276 1277 /// A ObjCIvarDecl record. 1278 DECL_OBJC_IVAR, 1279 1280 /// A ObjCAtDefsFieldDecl record. 1281 DECL_OBJC_AT_DEFS_FIELD, 1282 1283 /// A ObjCCategoryDecl record. 1284 DECL_OBJC_CATEGORY, 1285 1286 /// A ObjCCategoryImplDecl record. 1287 DECL_OBJC_CATEGORY_IMPL, 1288 1289 /// A ObjCImplementationDecl record. 1290 DECL_OBJC_IMPLEMENTATION, 1291 1292 /// A ObjCCompatibleAliasDecl record. 1293 DECL_OBJC_COMPATIBLE_ALIAS, 1294 1295 /// A ObjCPropertyDecl record. 1296 DECL_OBJC_PROPERTY, 1297 1298 /// A ObjCPropertyImplDecl record. 1299 DECL_OBJC_PROPERTY_IMPL, 1300 1301 /// A FieldDecl record. 1302 DECL_FIELD, 1303 1304 /// A MSPropertyDecl record. 1305 DECL_MS_PROPERTY, 1306 1307 /// A MSGuidDecl record. 1308 DECL_MS_GUID, 1309 1310 /// A TemplateParamObjectDecl record. 1311 DECL_TEMPLATE_PARAM_OBJECT, 1312 1313 /// A VarDecl record. 1314 DECL_VAR, 1315 1316 /// An ImplicitParamDecl record. 1317 DECL_IMPLICIT_PARAM, 1318 1319 /// A ParmVarDecl record. 1320 DECL_PARM_VAR, 1321 1322 /// A DecompositionDecl record. 1323 DECL_DECOMPOSITION, 1324 1325 /// A BindingDecl record. 1326 DECL_BINDING, 1327 1328 /// A FileScopeAsmDecl record. 1329 DECL_FILE_SCOPE_ASM, 1330 1331 /// A TopLevelStmtDecl record. 1332 DECL_TOP_LEVEL_STMT_DECL, 1333 1334 /// A BlockDecl record. 1335 DECL_BLOCK, 1336 1337 /// A CapturedDecl record. 1338 DECL_CAPTURED, 1339 1340 /// A record that stores the set of declarations that are 1341 /// lexically stored within a given DeclContext. 1342 /// 1343 /// The record itself is a blob that is an array of declaration IDs, 1344 /// in the order in which those declarations were added to the 1345 /// declaration context. This data is used when iterating over 1346 /// the contents of a DeclContext, e.g., via 1347 /// DeclContext::decls_begin() and DeclContext::decls_end(). 1348 DECL_CONTEXT_LEXICAL, 1349 1350 /// A record that stores the set of declarations that are 1351 /// visible from a given DeclContext. 1352 /// 1353 /// The record itself stores a set of mappings, each of which 1354 /// associates a declaration name with one or more declaration 1355 /// IDs. This data is used when performing qualified name lookup 1356 /// into a DeclContext via DeclContext::lookup. 1357 DECL_CONTEXT_VISIBLE, 1358 1359 /// A LabelDecl record. 1360 DECL_LABEL, 1361 1362 /// A NamespaceDecl record. 1363 DECL_NAMESPACE, 1364 1365 /// A NamespaceAliasDecl record. 1366 DECL_NAMESPACE_ALIAS, 1367 1368 /// A UsingDecl record. 1369 DECL_USING, 1370 1371 /// A UsingEnumDecl record. 1372 DECL_USING_ENUM, 1373 1374 /// A UsingPackDecl record. 1375 DECL_USING_PACK, 1376 1377 /// A UsingShadowDecl record. 1378 DECL_USING_SHADOW, 1379 1380 /// A ConstructorUsingShadowDecl record. 1381 DECL_CONSTRUCTOR_USING_SHADOW, 1382 1383 /// A UsingDirecitveDecl record. 1384 DECL_USING_DIRECTIVE, 1385 1386 /// An UnresolvedUsingValueDecl record. 1387 DECL_UNRESOLVED_USING_VALUE, 1388 1389 /// An UnresolvedUsingTypenameDecl record. 1390 DECL_UNRESOLVED_USING_TYPENAME, 1391 1392 /// A LinkageSpecDecl record. 1393 DECL_LINKAGE_SPEC, 1394 1395 /// An ExportDecl record. 1396 DECL_EXPORT, 1397 1398 /// A CXXRecordDecl record. 1399 DECL_CXX_RECORD, 1400 1401 /// A CXXDeductionGuideDecl record. 1402 DECL_CXX_DEDUCTION_GUIDE, 1403 1404 /// A CXXMethodDecl record. 1405 DECL_CXX_METHOD, 1406 1407 /// A CXXConstructorDecl record. 1408 DECL_CXX_CONSTRUCTOR, 1409 1410 /// A CXXDestructorDecl record. 1411 DECL_CXX_DESTRUCTOR, 1412 1413 /// A CXXConversionDecl record. 1414 DECL_CXX_CONVERSION, 1415 1416 /// An AccessSpecDecl record. 1417 DECL_ACCESS_SPEC, 1418 1419 /// A FriendDecl record. 1420 DECL_FRIEND, 1421 1422 /// A FriendTemplateDecl record. 1423 DECL_FRIEND_TEMPLATE, 1424 1425 /// A ClassTemplateDecl record. 1426 DECL_CLASS_TEMPLATE, 1427 1428 /// A ClassTemplateSpecializationDecl record. 1429 DECL_CLASS_TEMPLATE_SPECIALIZATION, 1430 1431 /// A ClassTemplatePartialSpecializationDecl record. 1432 DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION, 1433 1434 /// A VarTemplateDecl record. 1435 DECL_VAR_TEMPLATE, 1436 1437 /// A VarTemplateSpecializationDecl record. 1438 DECL_VAR_TEMPLATE_SPECIALIZATION, 1439 1440 /// A VarTemplatePartialSpecializationDecl record. 1441 DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION, 1442 1443 /// A FunctionTemplateDecl record. 1444 DECL_FUNCTION_TEMPLATE, 1445 1446 /// A TemplateTypeParmDecl record. 1447 DECL_TEMPLATE_TYPE_PARM, 1448 1449 /// A NonTypeTemplateParmDecl record. 1450 DECL_NON_TYPE_TEMPLATE_PARM, 1451 1452 /// A TemplateTemplateParmDecl record. 1453 DECL_TEMPLATE_TEMPLATE_PARM, 1454 1455 /// A TypeAliasTemplateDecl record. 1456 DECL_TYPE_ALIAS_TEMPLATE, 1457 1458 /// \brief A ConceptDecl record. 1459 DECL_CONCEPT, 1460 1461 /// An UnresolvedUsingIfExistsDecl record. 1462 DECL_UNRESOLVED_USING_IF_EXISTS, 1463 1464 /// \brief A StaticAssertDecl record. 1465 DECL_STATIC_ASSERT, 1466 1467 /// A record containing CXXBaseSpecifiers. 1468 DECL_CXX_BASE_SPECIFIERS, 1469 1470 /// A record containing CXXCtorInitializers. 1471 DECL_CXX_CTOR_INITIALIZERS, 1472 1473 /// A IndirectFieldDecl record. 1474 DECL_INDIRECTFIELD, 1475 1476 /// A NonTypeTemplateParmDecl record that stores an expanded 1477 /// non-type template parameter pack. 1478 DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK, 1479 1480 /// A TemplateTemplateParmDecl record that stores an expanded 1481 /// template template parameter pack. 1482 DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK, 1483 1484 /// A ClassScopeFunctionSpecializationDecl record a class scope 1485 /// function specialization. (Microsoft extension). 1486 DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION, 1487 1488 /// An ImportDecl recording a module import. 1489 DECL_IMPORT, 1490 1491 /// An OMPThreadPrivateDecl record. 1492 DECL_OMP_THREADPRIVATE, 1493 1494 /// An OMPRequiresDecl record. 1495 DECL_OMP_REQUIRES, 1496 1497 /// An OMPAllocateDcl record. 1498 DECL_OMP_ALLOCATE, 1499 1500 /// An EmptyDecl record. 1501 DECL_EMPTY, 1502 1503 /// An LifetimeExtendedTemporaryDecl record. 1504 DECL_LIFETIME_EXTENDED_TEMPORARY, 1505 1506 /// A RequiresExprBodyDecl record. 1507 DECL_REQUIRES_EXPR_BODY, 1508 1509 /// An ObjCTypeParamDecl record. 1510 DECL_OBJC_TYPE_PARAM, 1511 1512 /// An OMPCapturedExprDecl record. 1513 DECL_OMP_CAPTUREDEXPR, 1514 1515 /// A PragmaCommentDecl record. 1516 DECL_PRAGMA_COMMENT, 1517 1518 /// A PragmaDetectMismatchDecl record. 1519 DECL_PRAGMA_DETECT_MISMATCH, 1520 1521 /// An OMPDeclareMapperDecl record. 1522 DECL_OMP_DECLARE_MAPPER, 1523 1524 /// An OMPDeclareReductionDecl record. 1525 DECL_OMP_DECLARE_REDUCTION, 1526 1527 /// A UnnamedGlobalConstantDecl record. 1528 DECL_UNNAMED_GLOBAL_CONSTANT, 1529 1530 /// A HLSLBufferDecl record. 1531 DECL_HLSL_BUFFER, 1532 1533 /// An ImplicitConceptSpecializationDecl record. 1534 DECL_IMPLICIT_CONCEPT_SPECIALIZATION, 1535 1536 DECL_LAST = DECL_IMPLICIT_CONCEPT_SPECIALIZATION 1537 }; 1538 1539 /// Record codes for each kind of statement or expression. 1540 /// 1541 /// These constants describe the records that describe statements 1542 /// or expressions. These records occur within type and declarations 1543 /// block, so they begin with record values of 128. Each constant 1544 /// describes a record for a specific statement or expression class in the 1545 /// AST. 1546 enum StmtCode { 1547 /// A marker record that indicates that we are at the end 1548 /// of an expression. 1549 STMT_STOP = DECL_LAST + 1, 1550 1551 /// A NULL expression. 1552 STMT_NULL_PTR, 1553 1554 /// A reference to a previously [de]serialized Stmt record. 1555 STMT_REF_PTR, 1556 1557 /// A NullStmt record. 1558 STMT_NULL, 1559 1560 /// A CompoundStmt record. 1561 STMT_COMPOUND, 1562 1563 /// A CaseStmt record. 1564 STMT_CASE, 1565 1566 /// A DefaultStmt record. 1567 STMT_DEFAULT, 1568 1569 /// A LabelStmt record. 1570 STMT_LABEL, 1571 1572 /// An AttributedStmt record. 1573 STMT_ATTRIBUTED, 1574 1575 /// An IfStmt record. 1576 STMT_IF, 1577 1578 /// A SwitchStmt record. 1579 STMT_SWITCH, 1580 1581 /// A WhileStmt record. 1582 STMT_WHILE, 1583 1584 /// A DoStmt record. 1585 STMT_DO, 1586 1587 /// A ForStmt record. 1588 STMT_FOR, 1589 1590 /// A GotoStmt record. 1591 STMT_GOTO, 1592 1593 /// An IndirectGotoStmt record. 1594 STMT_INDIRECT_GOTO, 1595 1596 /// A ContinueStmt record. 1597 STMT_CONTINUE, 1598 1599 /// A BreakStmt record. 1600 STMT_BREAK, 1601 1602 /// A ReturnStmt record. 1603 STMT_RETURN, 1604 1605 /// A DeclStmt record. 1606 STMT_DECL, 1607 1608 /// A CapturedStmt record. 1609 STMT_CAPTURED, 1610 1611 /// A GCC-style AsmStmt record. 1612 STMT_GCCASM, 1613 1614 /// A MS-style AsmStmt record. 1615 STMT_MSASM, 1616 1617 /// A constant expression context. 1618 EXPR_CONSTANT, 1619 1620 /// A PredefinedExpr record. 1621 EXPR_PREDEFINED, 1622 1623 /// A DeclRefExpr record. 1624 EXPR_DECL_REF, 1625 1626 /// An IntegerLiteral record. 1627 EXPR_INTEGER_LITERAL, 1628 1629 /// A FloatingLiteral record. 1630 EXPR_FLOATING_LITERAL, 1631 1632 /// An ImaginaryLiteral record. 1633 EXPR_IMAGINARY_LITERAL, 1634 1635 /// A StringLiteral record. 1636 EXPR_STRING_LITERAL, 1637 1638 /// A CharacterLiteral record. 1639 EXPR_CHARACTER_LITERAL, 1640 1641 /// A ParenExpr record. 1642 EXPR_PAREN, 1643 1644 /// A ParenListExpr record. 1645 EXPR_PAREN_LIST, 1646 1647 /// A UnaryOperator record. 1648 EXPR_UNARY_OPERATOR, 1649 1650 /// An OffsetOfExpr record. 1651 EXPR_OFFSETOF, 1652 1653 /// A SizefAlignOfExpr record. 1654 EXPR_SIZEOF_ALIGN_OF, 1655 1656 /// An ArraySubscriptExpr record. 1657 EXPR_ARRAY_SUBSCRIPT, 1658 1659 /// An MatrixSubscriptExpr record. 1660 EXPR_MATRIX_SUBSCRIPT, 1661 1662 /// A CallExpr record. 1663 EXPR_CALL, 1664 1665 /// A MemberExpr record. 1666 EXPR_MEMBER, 1667 1668 /// A BinaryOperator record. 1669 EXPR_BINARY_OPERATOR, 1670 1671 /// A CompoundAssignOperator record. 1672 EXPR_COMPOUND_ASSIGN_OPERATOR, 1673 1674 /// A ConditionOperator record. 1675 EXPR_CONDITIONAL_OPERATOR, 1676 1677 /// An ImplicitCastExpr record. 1678 EXPR_IMPLICIT_CAST, 1679 1680 /// A CStyleCastExpr record. 1681 EXPR_CSTYLE_CAST, 1682 1683 /// A CompoundLiteralExpr record. 1684 EXPR_COMPOUND_LITERAL, 1685 1686 /// An ExtVectorElementExpr record. 1687 EXPR_EXT_VECTOR_ELEMENT, 1688 1689 /// An InitListExpr record. 1690 EXPR_INIT_LIST, 1691 1692 /// A DesignatedInitExpr record. 1693 EXPR_DESIGNATED_INIT, 1694 1695 /// A DesignatedInitUpdateExpr record. 1696 EXPR_DESIGNATED_INIT_UPDATE, 1697 1698 /// An NoInitExpr record. 1699 EXPR_NO_INIT, 1700 1701 /// An ArrayInitLoopExpr record. 1702 EXPR_ARRAY_INIT_LOOP, 1703 1704 /// An ArrayInitIndexExpr record. 1705 EXPR_ARRAY_INIT_INDEX, 1706 1707 /// An ImplicitValueInitExpr record. 1708 EXPR_IMPLICIT_VALUE_INIT, 1709 1710 /// A VAArgExpr record. 1711 EXPR_VA_ARG, 1712 1713 /// An AddrLabelExpr record. 1714 EXPR_ADDR_LABEL, 1715 1716 /// A StmtExpr record. 1717 EXPR_STMT, 1718 1719 /// A ChooseExpr record. 1720 EXPR_CHOOSE, 1721 1722 /// A GNUNullExpr record. 1723 EXPR_GNU_NULL, 1724 1725 /// A SourceLocExpr record. 1726 EXPR_SOURCE_LOC, 1727 1728 /// A ShuffleVectorExpr record. 1729 EXPR_SHUFFLE_VECTOR, 1730 1731 /// A ConvertVectorExpr record. 1732 EXPR_CONVERT_VECTOR, 1733 1734 /// BlockExpr 1735 EXPR_BLOCK, 1736 1737 /// A GenericSelectionExpr record. 1738 EXPR_GENERIC_SELECTION, 1739 1740 /// A PseudoObjectExpr record. 1741 EXPR_PSEUDO_OBJECT, 1742 1743 /// An AtomicExpr record. 1744 EXPR_ATOMIC, 1745 1746 /// A RecoveryExpr record. 1747 EXPR_RECOVERY, 1748 1749 // Objective-C 1750 1751 /// An ObjCStringLiteral record. 1752 EXPR_OBJC_STRING_LITERAL, 1753 1754 EXPR_OBJC_BOXED_EXPRESSION, 1755 EXPR_OBJC_ARRAY_LITERAL, 1756 EXPR_OBJC_DICTIONARY_LITERAL, 1757 1758 /// An ObjCEncodeExpr record. 1759 EXPR_OBJC_ENCODE, 1760 1761 /// An ObjCSelectorExpr record. 1762 EXPR_OBJC_SELECTOR_EXPR, 1763 1764 /// An ObjCProtocolExpr record. 1765 EXPR_OBJC_PROTOCOL_EXPR, 1766 1767 /// An ObjCIvarRefExpr record. 1768 EXPR_OBJC_IVAR_REF_EXPR, 1769 1770 /// An ObjCPropertyRefExpr record. 1771 EXPR_OBJC_PROPERTY_REF_EXPR, 1772 1773 /// An ObjCSubscriptRefExpr record. 1774 EXPR_OBJC_SUBSCRIPT_REF_EXPR, 1775 1776 /// UNUSED 1777 EXPR_OBJC_KVC_REF_EXPR, 1778 1779 /// An ObjCMessageExpr record. 1780 EXPR_OBJC_MESSAGE_EXPR, 1781 1782 /// An ObjCIsa Expr record. 1783 EXPR_OBJC_ISA, 1784 1785 /// An ObjCIndirectCopyRestoreExpr record. 1786 EXPR_OBJC_INDIRECT_COPY_RESTORE, 1787 1788 /// An ObjCForCollectionStmt record. 1789 STMT_OBJC_FOR_COLLECTION, 1790 1791 /// An ObjCAtCatchStmt record. 1792 STMT_OBJC_CATCH, 1793 1794 /// An ObjCAtFinallyStmt record. 1795 STMT_OBJC_FINALLY, 1796 1797 /// An ObjCAtTryStmt record. 1798 STMT_OBJC_AT_TRY, 1799 1800 /// An ObjCAtSynchronizedStmt record. 1801 STMT_OBJC_AT_SYNCHRONIZED, 1802 1803 /// An ObjCAtThrowStmt record. 1804 STMT_OBJC_AT_THROW, 1805 1806 /// An ObjCAutoreleasePoolStmt record. 1807 STMT_OBJC_AUTORELEASE_POOL, 1808 1809 /// An ObjCBoolLiteralExpr record. 1810 EXPR_OBJC_BOOL_LITERAL, 1811 1812 /// An ObjCAvailabilityCheckExpr record. 1813 EXPR_OBJC_AVAILABILITY_CHECK, 1814 1815 // C++ 1816 1817 /// A CXXCatchStmt record. 1818 STMT_CXX_CATCH, 1819 1820 /// A CXXTryStmt record. 1821 STMT_CXX_TRY, 1822 /// A CXXForRangeStmt record. 1823 1824 STMT_CXX_FOR_RANGE, 1825 1826 /// A CXXOperatorCallExpr record. 1827 EXPR_CXX_OPERATOR_CALL, 1828 1829 /// A CXXMemberCallExpr record. 1830 EXPR_CXX_MEMBER_CALL, 1831 1832 /// A CXXRewrittenBinaryOperator record. 1833 EXPR_CXX_REWRITTEN_BINARY_OPERATOR, 1834 1835 /// A CXXConstructExpr record. 1836 EXPR_CXX_CONSTRUCT, 1837 1838 /// A CXXInheritedCtorInitExpr record. 1839 EXPR_CXX_INHERITED_CTOR_INIT, 1840 1841 /// A CXXTemporaryObjectExpr record. 1842 EXPR_CXX_TEMPORARY_OBJECT, 1843 1844 /// A CXXStaticCastExpr record. 1845 EXPR_CXX_STATIC_CAST, 1846 1847 /// A CXXDynamicCastExpr record. 1848 EXPR_CXX_DYNAMIC_CAST, 1849 1850 /// A CXXReinterpretCastExpr record. 1851 EXPR_CXX_REINTERPRET_CAST, 1852 1853 /// A CXXConstCastExpr record. 1854 EXPR_CXX_CONST_CAST, 1855 1856 /// A CXXAddrspaceCastExpr record. 1857 EXPR_CXX_ADDRSPACE_CAST, 1858 1859 /// A CXXFunctionalCastExpr record. 1860 EXPR_CXX_FUNCTIONAL_CAST, 1861 1862 /// A BuiltinBitCastExpr record. 1863 EXPR_BUILTIN_BIT_CAST, 1864 1865 /// A UserDefinedLiteral record. 1866 EXPR_USER_DEFINED_LITERAL, 1867 1868 /// A CXXStdInitializerListExpr record. 1869 EXPR_CXX_STD_INITIALIZER_LIST, 1870 1871 /// A CXXBoolLiteralExpr record. 1872 EXPR_CXX_BOOL_LITERAL, 1873 1874 /// A CXXParenListInitExpr record. 1875 EXPR_CXX_PAREN_LIST_INIT, 1876 1877 EXPR_CXX_NULL_PTR_LITERAL, // CXXNullPtrLiteralExpr 1878 EXPR_CXX_TYPEID_EXPR, // CXXTypeidExpr (of expr). 1879 EXPR_CXX_TYPEID_TYPE, // CXXTypeidExpr (of type). 1880 EXPR_CXX_THIS, // CXXThisExpr 1881 EXPR_CXX_THROW, // CXXThrowExpr 1882 EXPR_CXX_DEFAULT_ARG, // CXXDefaultArgExpr 1883 EXPR_CXX_DEFAULT_INIT, // CXXDefaultInitExpr 1884 EXPR_CXX_BIND_TEMPORARY, // CXXBindTemporaryExpr 1885 1886 EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr 1887 EXPR_CXX_NEW, // CXXNewExpr 1888 EXPR_CXX_DELETE, // CXXDeleteExpr 1889 EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr 1890 1891 EXPR_EXPR_WITH_CLEANUPS, // ExprWithCleanups 1892 1893 EXPR_CXX_DEPENDENT_SCOPE_MEMBER, // CXXDependentScopeMemberExpr 1894 EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr 1895 EXPR_CXX_UNRESOLVED_CONSTRUCT, // CXXUnresolvedConstructExpr 1896 EXPR_CXX_UNRESOLVED_MEMBER, // UnresolvedMemberExpr 1897 EXPR_CXX_UNRESOLVED_LOOKUP, // UnresolvedLookupExpr 1898 1899 EXPR_CXX_EXPRESSION_TRAIT, // ExpressionTraitExpr 1900 EXPR_CXX_NOEXCEPT, // CXXNoexceptExpr 1901 1902 EXPR_OPAQUE_VALUE, // OpaqueValueExpr 1903 EXPR_BINARY_CONDITIONAL_OPERATOR, // BinaryConditionalOperator 1904 EXPR_TYPE_TRAIT, // TypeTraitExpr 1905 EXPR_ARRAY_TYPE_TRAIT, // ArrayTypeTraitIntExpr 1906 1907 EXPR_PACK_EXPANSION, // PackExpansionExpr 1908 EXPR_SIZEOF_PACK, // SizeOfPackExpr 1909 EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr 1910 EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK, // SubstNonTypeTemplateParmPackExpr 1911 EXPR_FUNCTION_PARM_PACK, // FunctionParmPackExpr 1912 EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr 1913 EXPR_CXX_FOLD, // CXXFoldExpr 1914 EXPR_CONCEPT_SPECIALIZATION, // ConceptSpecializationExpr 1915 EXPR_REQUIRES, // RequiresExpr 1916 1917 // CUDA 1918 EXPR_CUDA_KERNEL_CALL, // CUDAKernelCallExpr 1919 1920 // OpenCL 1921 EXPR_ASTYPE, // AsTypeExpr 1922 1923 // Microsoft 1924 EXPR_CXX_PROPERTY_REF_EXPR, // MSPropertyRefExpr 1925 EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr 1926 EXPR_CXX_UUIDOF_EXPR, // CXXUuidofExpr (of expr). 1927 EXPR_CXX_UUIDOF_TYPE, // CXXUuidofExpr (of type). 1928 STMT_SEH_LEAVE, // SEHLeaveStmt 1929 STMT_SEH_EXCEPT, // SEHExceptStmt 1930 STMT_SEH_FINALLY, // SEHFinallyStmt 1931 STMT_SEH_TRY, // SEHTryStmt 1932 1933 // OpenMP directives 1934 STMT_OMP_META_DIRECTIVE, 1935 STMT_OMP_CANONICAL_LOOP, 1936 STMT_OMP_PARALLEL_DIRECTIVE, 1937 STMT_OMP_SIMD_DIRECTIVE, 1938 STMT_OMP_TILE_DIRECTIVE, 1939 STMT_OMP_UNROLL_DIRECTIVE, 1940 STMT_OMP_FOR_DIRECTIVE, 1941 STMT_OMP_FOR_SIMD_DIRECTIVE, 1942 STMT_OMP_SECTIONS_DIRECTIVE, 1943 STMT_OMP_SECTION_DIRECTIVE, 1944 STMT_OMP_SINGLE_DIRECTIVE, 1945 STMT_OMP_MASTER_DIRECTIVE, 1946 STMT_OMP_CRITICAL_DIRECTIVE, 1947 STMT_OMP_PARALLEL_FOR_DIRECTIVE, 1948 STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE, 1949 STMT_OMP_PARALLEL_MASTER_DIRECTIVE, 1950 STMT_OMP_PARALLEL_MASKED_DIRECTIVE, 1951 STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE, 1952 STMT_OMP_TASK_DIRECTIVE, 1953 STMT_OMP_TASKYIELD_DIRECTIVE, 1954 STMT_OMP_ERROR_DIRECTIVE, 1955 STMT_OMP_BARRIER_DIRECTIVE, 1956 STMT_OMP_TASKWAIT_DIRECTIVE, 1957 STMT_OMP_FLUSH_DIRECTIVE, 1958 STMT_OMP_DEPOBJ_DIRECTIVE, 1959 STMT_OMP_SCAN_DIRECTIVE, 1960 STMT_OMP_ORDERED_DIRECTIVE, 1961 STMT_OMP_ATOMIC_DIRECTIVE, 1962 STMT_OMP_TARGET_DIRECTIVE, 1963 STMT_OMP_TARGET_DATA_DIRECTIVE, 1964 STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE, 1965 STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE, 1966 STMT_OMP_TARGET_PARALLEL_DIRECTIVE, 1967 STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE, 1968 STMT_OMP_TEAMS_DIRECTIVE, 1969 STMT_OMP_TASKGROUP_DIRECTIVE, 1970 STMT_OMP_CANCELLATION_POINT_DIRECTIVE, 1971 STMT_OMP_CANCEL_DIRECTIVE, 1972 STMT_OMP_TASKLOOP_DIRECTIVE, 1973 STMT_OMP_TASKLOOP_SIMD_DIRECTIVE, 1974 STMT_OMP_MASTER_TASKLOOP_DIRECTIVE, 1975 STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE, 1976 STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE, 1977 STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE, 1978 STMT_OMP_MASKED_TASKLOOP_DIRECTIVE, 1979 STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE, 1980 STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE, 1981 STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE, 1982 STMT_OMP_DISTRIBUTE_DIRECTIVE, 1983 STMT_OMP_TARGET_UPDATE_DIRECTIVE, 1984 STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE, 1985 STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE, 1986 STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE, 1987 STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE, 1988 STMT_OMP_TARGET_SIMD_DIRECTIVE, 1989 STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE, 1990 STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE, 1991 STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE, 1992 STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE, 1993 STMT_OMP_TARGET_TEAMS_DIRECTIVE, 1994 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE, 1995 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE, 1996 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE, 1997 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE, 1998 STMT_OMP_INTEROP_DIRECTIVE, 1999 STMT_OMP_DISPATCH_DIRECTIVE, 2000 STMT_OMP_MASKED_DIRECTIVE, 2001 STMT_OMP_GENERIC_LOOP_DIRECTIVE, 2002 STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE, 2003 STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE, 2004 STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE, 2005 STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE, 2006 EXPR_OMP_ARRAY_SECTION, 2007 EXPR_OMP_ARRAY_SHAPING, 2008 EXPR_OMP_ITERATOR, 2009 2010 // ARC 2011 EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr 2012 2013 STMT_MS_DEPENDENT_EXISTS, // MSDependentExistsStmt 2014 EXPR_LAMBDA, // LambdaExpr 2015 STMT_COROUTINE_BODY, 2016 STMT_CORETURN, 2017 EXPR_COAWAIT, 2018 EXPR_COYIELD, 2019 EXPR_DEPENDENT_COAWAIT, 2020 2021 // FixedPointLiteral 2022 EXPR_FIXEDPOINT_LITERAL, 2023 2024 // SYCLUniqueStableNameExpr 2025 EXPR_SYCL_UNIQUE_STABLE_NAME, 2026 }; 2027 2028 /// The kinds of designators that can occur in a 2029 /// DesignatedInitExpr. 2030 enum DesignatorTypes { 2031 /// Field designator where only the field name is known. 2032 DESIG_FIELD_NAME = 0, 2033 2034 /// Field designator where the field has been resolved to 2035 /// a declaration. 2036 DESIG_FIELD_DECL = 1, 2037 2038 /// Array designator. 2039 DESIG_ARRAY = 2, 2040 2041 /// GNU array range designator. 2042 DESIG_ARRAY_RANGE = 3 2043 }; 2044 2045 /// The different kinds of data that can occur in a 2046 /// CtorInitializer. 2047 enum CtorInitializerType { 2048 CTOR_INITIALIZER_BASE, 2049 CTOR_INITIALIZER_DELEGATING, 2050 CTOR_INITIALIZER_MEMBER, 2051 CTOR_INITIALIZER_INDIRECT_MEMBER 2052 }; 2053 2054 /// Kinds of cleanup objects owned by ExprWithCleanups. 2055 enum CleanupObjectKind { COK_Block, COK_CompoundLiteral }; 2056 2057 /// Describes the redeclarations of a declaration. 2058 struct LocalRedeclarationsInfo { 2059 // The ID of the first declaration 2060 DeclID FirstID; 2061 2062 // Offset into the array of redeclaration chains. 2063 unsigned Offset; 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 friend bool operator<=(const LocalRedeclarationsInfo &X, 2076 const LocalRedeclarationsInfo &Y) { 2077 return X.FirstID <= Y.FirstID; 2078 } 2079 2080 friend bool operator>=(const LocalRedeclarationsInfo &X, 2081 const LocalRedeclarationsInfo &Y) { 2082 return X.FirstID >= Y.FirstID; 2083 } 2084 }; 2085 2086 /// Describes the categories of an Objective-C class. 2087 struct ObjCCategoriesInfo { 2088 // The ID of the definition 2089 DeclID DefinitionID; 2090 2091 // Offset into the array of category lists. 2092 unsigned Offset; 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 friend bool operator<=(const ObjCCategoriesInfo &X, 2105 const ObjCCategoriesInfo &Y) { 2106 return X.DefinitionID <= Y.DefinitionID; 2107 } 2108 2109 friend bool operator>=(const ObjCCategoriesInfo &X, 2110 const ObjCCategoriesInfo &Y) { 2111 return X.DefinitionID >= Y.DefinitionID; 2112 } 2113 }; 2114 2115 /// A key used when looking up entities by \ref DeclarationName. 2116 /// 2117 /// Different \ref DeclarationNames are mapped to different keys, but the 2118 /// same key can occasionally represent multiple names (for names that 2119 /// contain types, in particular). 2120 class DeclarationNameKey { 2121 using NameKind = unsigned; 2122 2123 NameKind Kind = 0; 2124 uint64_t Data = 0; 2125 2126 public: 2127 DeclarationNameKey() = default; 2128 DeclarationNameKey(DeclarationName Name); 2129 DeclarationNameKey(NameKind Kind, uint64_t Data) : Kind(Kind), Data(Data) {} 2130 2131 NameKind getKind() const { return Kind; } 2132 2133 IdentifierInfo *getIdentifier() const { 2134 assert(Kind == DeclarationName::Identifier || 2135 Kind == DeclarationName::CXXLiteralOperatorName || 2136 Kind == DeclarationName::CXXDeductionGuideName); 2137 return (IdentifierInfo *)Data; 2138 } 2139 2140 Selector getSelector() const { 2141 assert(Kind == DeclarationName::ObjCZeroArgSelector || 2142 Kind == DeclarationName::ObjCOneArgSelector || 2143 Kind == DeclarationName::ObjCMultiArgSelector); 2144 return Selector(Data); 2145 } 2146 2147 OverloadedOperatorKind getOperatorKind() const { 2148 assert(Kind == DeclarationName::CXXOperatorName); 2149 return (OverloadedOperatorKind)Data; 2150 } 2151 2152 /// Compute a fingerprint of this key for use in on-disk hash table. 2153 unsigned getHash() const; 2154 2155 friend bool operator==(const DeclarationNameKey &A, 2156 const DeclarationNameKey &B) { 2157 return A.Kind == B.Kind && A.Data == B.Data; 2158 } 2159 }; 2160 2161 /// @} 2162 2163 } // namespace serialization 2164 } // namespace clang 2165 2166 namespace llvm { 2167 2168 template <> struct DenseMapInfo<clang::serialization::DeclarationNameKey> { 2169 static clang::serialization::DeclarationNameKey getEmptyKey() { 2170 return clang::serialization::DeclarationNameKey(-1, 1); 2171 } 2172 2173 static clang::serialization::DeclarationNameKey getTombstoneKey() { 2174 return clang::serialization::DeclarationNameKey(-1, 2); 2175 } 2176 2177 static unsigned 2178 getHashValue(const clang::serialization::DeclarationNameKey &Key) { 2179 return Key.getHash(); 2180 } 2181 2182 static bool isEqual(const clang::serialization::DeclarationNameKey &L, 2183 const clang::serialization::DeclarationNameKey &R) { 2184 return L == R; 2185 } 2186 }; 2187 2188 } // namespace llvm 2189 2190 #endif // LLVM_CLANG_SERIALIZATION_ASTBITCODES_H 2191