1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ 2|* *| 3|* Attribute dumper *| 4|* *| 5|* Automatically generated file, do not edit! *| 6|* *| 7\*===----------------------------------------------------------------------===*/ 8 9 switch (A->getKind()) { 10 case attr::AMDGPUFlatWorkGroupSize: { 11 const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A); 12 OS << " " << SA->getMin(); 13 OS << " " << SA->getMax(); 14 break; 15 } 16 case attr::AMDGPUNumSGPR: { 17 const auto *SA = cast<AMDGPUNumSGPRAttr>(A); 18 OS << " " << SA->getNumSGPR(); 19 break; 20 } 21 case attr::AMDGPUNumVGPR: { 22 const auto *SA = cast<AMDGPUNumVGPRAttr>(A); 23 OS << " " << SA->getNumVGPR(); 24 break; 25 } 26 case attr::AMDGPUWavesPerEU: { 27 const auto *SA = cast<AMDGPUWavesPerEUAttr>(A); 28 OS << " " << SA->getMin(); 29 OS << " " << SA->getMax(); 30 break; 31 } 32 case attr::ARMInterrupt: { 33 const auto *SA = cast<ARMInterruptAttr>(A); 34 switch(SA->getInterrupt()) { 35 case ARMInterruptAttr::IRQ: 36 OS << " IRQ"; 37 break; 38 case ARMInterruptAttr::FIQ: 39 OS << " FIQ"; 40 break; 41 case ARMInterruptAttr::SWI: 42 OS << " SWI"; 43 break; 44 case ARMInterruptAttr::ABORT: 45 OS << " ABORT"; 46 break; 47 case ARMInterruptAttr::UNDEF: 48 OS << " UNDEF"; 49 break; 50 case ARMInterruptAttr::Generic: 51 OS << " Generic"; 52 break; 53 } 54 break; 55 } 56 case attr::AVRInterrupt: { 57 break; 58 } 59 case attr::AVRSignal: { 60 break; 61 } 62 case attr::AbiTag: { 63 const auto *SA = cast<AbiTagAttr>(A); 64 for (const auto &Val : SA->tags()) 65 OS << " " << Val; 66 break; 67 } 68 case attr::AcquireCapability: { 69 OS << " " << A->getSpelling(); 70 const auto *SA = cast<AcquireCapabilityAttr>(A); 71 for (AcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 72 dumpStmt(*I); 73 break; 74 } 75 case attr::AcquiredAfter: { 76 const auto *SA = cast<AcquiredAfterAttr>(A); 77 for (AcquiredAfterAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 78 dumpStmt(*I); 79 break; 80 } 81 case attr::AcquiredBefore: { 82 const auto *SA = cast<AcquiredBeforeAttr>(A); 83 for (AcquiredBeforeAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 84 dumpStmt(*I); 85 break; 86 } 87 case attr::Alias: { 88 const auto *SA = cast<AliasAttr>(A); 89 OS << " \"" << SA->getAliasee() << "\""; 90 break; 91 } 92 case attr::AlignMac68k: { 93 break; 94 } 95 case attr::AlignValue: { 96 const auto *SA = cast<AlignValueAttr>(A); 97 dumpStmt(SA->getAlignment()); 98 break; 99 } 100 case attr::Aligned: { 101 OS << " " << A->getSpelling(); 102 const auto *SA = cast<AlignedAttr>(A); 103 if (SA->isAlignmentExpr()) 104 dumpStmt(SA->getAlignmentExpr()); 105 else 106 dumpType(SA->getAlignmentType()->getType()); 107 break; 108 } 109 case attr::AllocAlign: { 110 const auto *SA = cast<AllocAlignAttr>(A); 111 OS << " " << SA->getParamIndex(); 112 break; 113 } 114 case attr::AllocSize: { 115 const auto *SA = cast<AllocSizeAttr>(A); 116 OS << " " << SA->getElemSizeParam(); 117 OS << " " << SA->getNumElemsParam(); 118 break; 119 } 120 case attr::AlwaysInline: { 121 OS << " " << A->getSpelling(); 122 break; 123 } 124 case attr::AnalyzerNoReturn: { 125 break; 126 } 127 case attr::Annotate: { 128 const auto *SA = cast<AnnotateAttr>(A); 129 OS << " \"" << SA->getAnnotation() << "\""; 130 break; 131 } 132 case attr::AnyX86Interrupt: { 133 break; 134 } 135 case attr::AnyX86NoCallerSavedRegisters: { 136 break; 137 } 138 case attr::ArcWeakrefUnavailable: { 139 break; 140 } 141 case attr::ArgumentWithTypeTag: { 142 OS << " " << A->getSpelling(); 143 const auto *SA = cast<ArgumentWithTypeTagAttr>(A); 144 OS << " " << SA->getArgumentKind()->getName(); 145 OS << " " << SA->getArgumentIdx(); 146 OS << " " << SA->getTypeTagIdx(); 147 if (SA->getIsPointer()) OS << " IsPointer"; 148 break; 149 } 150 case attr::AsmLabel: { 151 const auto *SA = cast<AsmLabelAttr>(A); 152 OS << " \"" << SA->getLabel() << "\""; 153 break; 154 } 155 case attr::AssertCapability: { 156 OS << " " << A->getSpelling(); 157 const auto *SA = cast<AssertCapabilityAttr>(A); 158 dumpStmt(SA->getExpr()); 159 break; 160 } 161 case attr::AssertExclusiveLock: { 162 const auto *SA = cast<AssertExclusiveLockAttr>(A); 163 for (AssertExclusiveLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 164 dumpStmt(*I); 165 break; 166 } 167 case attr::AssertSharedLock: { 168 const auto *SA = cast<AssertSharedLockAttr>(A); 169 for (AssertSharedLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 170 dumpStmt(*I); 171 break; 172 } 173 case attr::AssumeAligned: { 174 const auto *SA = cast<AssumeAlignedAttr>(A); 175 dumpStmt(SA->getAlignment()); 176 dumpStmt(SA->getOffset()); 177 break; 178 } 179 case attr::Availability: { 180 const auto *SA = cast<AvailabilityAttr>(A); 181 OS << " " << SA->getPlatform()->getName(); 182 OS << " " << SA->getIntroduced(); 183 OS << " " << SA->getDeprecated(); 184 OS << " " << SA->getObsoleted(); 185 if (SA->getUnavailable()) OS << " Unavailable"; 186 OS << " \"" << SA->getMessage() << "\""; 187 if (SA->getStrict()) OS << " Strict"; 188 OS << " \"" << SA->getReplacement() << "\""; 189 break; 190 } 191 case attr::Blocks: { 192 const auto *SA = cast<BlocksAttr>(A); 193 switch(SA->getType()) { 194 case BlocksAttr::ByRef: 195 OS << " ByRef"; 196 break; 197 } 198 break; 199 } 200 case attr::C11NoReturn: { 201 break; 202 } 203 case attr::CDecl: { 204 break; 205 } 206 case attr::CFAuditedTransfer: { 207 break; 208 } 209 case attr::CFConsumed: { 210 break; 211 } 212 case attr::CFReturnsNotRetained: { 213 break; 214 } 215 case attr::CFReturnsRetained: { 216 break; 217 } 218 case attr::CFUnknownTransfer: { 219 break; 220 } 221 case attr::CUDAConstant: { 222 break; 223 } 224 case attr::CUDADevice: { 225 break; 226 } 227 case attr::CUDAGlobal: { 228 break; 229 } 230 case attr::CUDAHost: { 231 break; 232 } 233 case attr::CUDAInvalidTarget: { 234 break; 235 } 236 case attr::CUDALaunchBounds: { 237 const auto *SA = cast<CUDALaunchBoundsAttr>(A); 238 dumpStmt(SA->getMaxThreads()); 239 dumpStmt(SA->getMinBlocks()); 240 break; 241 } 242 case attr::CUDAShared: { 243 break; 244 } 245 case attr::CXX11NoReturn: { 246 break; 247 } 248 case attr::CallableWhen: { 249 const auto *SA = cast<CallableWhenAttr>(A); 250 for (CallableWhenAttr::callableStates_iterator I = SA->callableStates_begin(), E = SA->callableStates_end(); I != E; ++I) { 251 switch(*I) { 252 case CallableWhenAttr::Unknown: 253 OS << " Unknown"; 254 break; 255 case CallableWhenAttr::Consumed: 256 OS << " Consumed"; 257 break; 258 case CallableWhenAttr::Unconsumed: 259 OS << " Unconsumed"; 260 break; 261 } 262 } 263 break; 264 } 265 case attr::Capability: { 266 OS << " " << A->getSpelling(); 267 const auto *SA = cast<CapabilityAttr>(A); 268 OS << " \"" << SA->getName() << "\""; 269 break; 270 } 271 case attr::CapturedRecord: { 272 break; 273 } 274 case attr::CarriesDependency: { 275 break; 276 } 277 case attr::Cleanup: { 278 const auto *SA = cast<CleanupAttr>(A); 279 OS << " "; 280 dumpBareDeclRef(SA->getFunctionDecl()); 281 break; 282 } 283 case attr::Cold: { 284 break; 285 } 286 case attr::Common: { 287 break; 288 } 289 case attr::Const: { 290 break; 291 } 292 case attr::Constructor: { 293 const auto *SA = cast<ConstructorAttr>(A); 294 OS << " " << SA->getPriority(); 295 break; 296 } 297 case attr::Consumable: { 298 const auto *SA = cast<ConsumableAttr>(A); 299 switch(SA->getDefaultState()) { 300 case ConsumableAttr::Unknown: 301 OS << " Unknown"; 302 break; 303 case ConsumableAttr::Consumed: 304 OS << " Consumed"; 305 break; 306 case ConsumableAttr::Unconsumed: 307 OS << " Unconsumed"; 308 break; 309 } 310 break; 311 } 312 case attr::ConsumableAutoCast: { 313 break; 314 } 315 case attr::ConsumableSetOnRead: { 316 break; 317 } 318 case attr::Convergent: { 319 break; 320 } 321 case attr::DLLExport: { 322 break; 323 } 324 case attr::DLLImport: { 325 break; 326 } 327 case attr::Deprecated: { 328 const auto *SA = cast<DeprecatedAttr>(A); 329 OS << " \"" << SA->getMessage() << "\""; 330 OS << " \"" << SA->getReplacement() << "\""; 331 break; 332 } 333 case attr::Destructor: { 334 const auto *SA = cast<DestructorAttr>(A); 335 OS << " " << SA->getPriority(); 336 break; 337 } 338 case attr::DiagnoseIf: { 339 const auto *SA = cast<DiagnoseIfAttr>(A); 340 OS << " \"" << SA->getMessage() << "\""; 341 switch(SA->getDiagnosticType()) { 342 case DiagnoseIfAttr::DT_Error: 343 OS << " DT_Error"; 344 break; 345 case DiagnoseIfAttr::DT_Warning: 346 OS << " DT_Warning"; 347 break; 348 } 349 if (SA->getArgDependent()) OS << " ArgDependent"; 350 OS << " "; 351 dumpBareDeclRef(SA->getParent()); 352 dumpStmt(SA->getCond()); 353 break; 354 } 355 case attr::DisableTailCalls: { 356 break; 357 } 358 case attr::EmptyBases: { 359 break; 360 } 361 case attr::EnableIf: { 362 const auto *SA = cast<EnableIfAttr>(A); 363 OS << " \"" << SA->getMessage() << "\""; 364 dumpStmt(SA->getCond()); 365 break; 366 } 367 case attr::EnumExtensibility: { 368 const auto *SA = cast<EnumExtensibilityAttr>(A); 369 switch(SA->getExtensibility()) { 370 case EnumExtensibilityAttr::Closed: 371 OS << " Closed"; 372 break; 373 case EnumExtensibilityAttr::Open: 374 OS << " Open"; 375 break; 376 } 377 break; 378 } 379 case attr::ExclusiveTrylockFunction: { 380 const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A); 381 dumpStmt(SA->getSuccessValue()); 382 for (ExclusiveTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 383 dumpStmt(*I); 384 break; 385 } 386 case attr::ExternalSourceSymbol: { 387 const auto *SA = cast<ExternalSourceSymbolAttr>(A); 388 OS << " \"" << SA->getLanguage() << "\""; 389 OS << " \"" << SA->getDefinedIn() << "\""; 390 if (SA->getGeneratedDeclaration()) OS << " GeneratedDeclaration"; 391 break; 392 } 393 case attr::FallThrough: { 394 break; 395 } 396 case attr::FastCall: { 397 break; 398 } 399 case attr::Final: { 400 OS << " " << A->getSpelling(); 401 break; 402 } 403 case attr::FlagEnum: { 404 break; 405 } 406 case attr::Flatten: { 407 break; 408 } 409 case attr::Format: { 410 const auto *SA = cast<FormatAttr>(A); 411 OS << " " << SA->getType()->getName(); 412 OS << " " << SA->getFormatIdx(); 413 OS << " " << SA->getFirstArg(); 414 break; 415 } 416 case attr::FormatArg: { 417 const auto *SA = cast<FormatArgAttr>(A); 418 OS << " " << SA->getFormatIdx(); 419 break; 420 } 421 case attr::GNUInline: { 422 break; 423 } 424 case attr::GuardedBy: { 425 const auto *SA = cast<GuardedByAttr>(A); 426 dumpStmt(SA->getArg()); 427 break; 428 } 429 case attr::GuardedVar: { 430 break; 431 } 432 case attr::Hot: { 433 break; 434 } 435 case attr::IBAction: { 436 break; 437 } 438 case attr::IBOutlet: { 439 break; 440 } 441 case attr::IBOutletCollection: { 442 const auto *SA = cast<IBOutletCollectionAttr>(A); 443 OS << " " << SA->getInterface().getAsString(); 444 break; 445 } 446 case attr::IFunc: { 447 const auto *SA = cast<IFuncAttr>(A); 448 OS << " \"" << SA->getResolver() << "\""; 449 break; 450 } 451 case attr::InitPriority: { 452 const auto *SA = cast<InitPriorityAttr>(A); 453 OS << " " << SA->getPriority(); 454 break; 455 } 456 case attr::InitSeg: { 457 const auto *SA = cast<InitSegAttr>(A); 458 OS << " \"" << SA->getSection() << "\""; 459 break; 460 } 461 case attr::IntelOclBicc: { 462 break; 463 } 464 case attr::InternalLinkage: { 465 break; 466 } 467 case attr::LTOVisibilityPublic: { 468 break; 469 } 470 case attr::LayoutVersion: { 471 const auto *SA = cast<LayoutVersionAttr>(A); 472 OS << " " << SA->getVersion(); 473 break; 474 } 475 case attr::LockReturned: { 476 const auto *SA = cast<LockReturnedAttr>(A); 477 dumpStmt(SA->getArg()); 478 break; 479 } 480 case attr::LocksExcluded: { 481 const auto *SA = cast<LocksExcludedAttr>(A); 482 for (LocksExcludedAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 483 dumpStmt(*I); 484 break; 485 } 486 case attr::LoopHint: { 487 OS << " " << A->getSpelling(); 488 const auto *SA = cast<LoopHintAttr>(A); 489 switch(SA->getOption()) { 490 case LoopHintAttr::Vectorize: 491 OS << " Vectorize"; 492 break; 493 case LoopHintAttr::VectorizeWidth: 494 OS << " VectorizeWidth"; 495 break; 496 case LoopHintAttr::Interleave: 497 OS << " Interleave"; 498 break; 499 case LoopHintAttr::InterleaveCount: 500 OS << " InterleaveCount"; 501 break; 502 case LoopHintAttr::Unroll: 503 OS << " Unroll"; 504 break; 505 case LoopHintAttr::UnrollCount: 506 OS << " UnrollCount"; 507 break; 508 case LoopHintAttr::Distribute: 509 OS << " Distribute"; 510 break; 511 } 512 switch(SA->getState()) { 513 case LoopHintAttr::Enable: 514 OS << " Enable"; 515 break; 516 case LoopHintAttr::Disable: 517 OS << " Disable"; 518 break; 519 case LoopHintAttr::Numeric: 520 OS << " Numeric"; 521 break; 522 case LoopHintAttr::AssumeSafety: 523 OS << " AssumeSafety"; 524 break; 525 case LoopHintAttr::Full: 526 OS << " Full"; 527 break; 528 } 529 dumpStmt(SA->getValue()); 530 break; 531 } 532 case attr::MSABI: { 533 break; 534 } 535 case attr::MSInheritance: { 536 OS << " " << A->getSpelling(); 537 const auto *SA = cast<MSInheritanceAttr>(A); 538 if (SA->getBestCase()) OS << " BestCase"; 539 break; 540 } 541 case attr::MSNoVTable: { 542 break; 543 } 544 case attr::MSP430Interrupt: { 545 const auto *SA = cast<MSP430InterruptAttr>(A); 546 OS << " " << SA->getNumber(); 547 break; 548 } 549 case attr::MSStruct: { 550 break; 551 } 552 case attr::MSVtorDisp: { 553 const auto *SA = cast<MSVtorDispAttr>(A); 554 OS << " " << SA->getVdm(); 555 break; 556 } 557 case attr::MaxFieldAlignment: { 558 const auto *SA = cast<MaxFieldAlignmentAttr>(A); 559 OS << " " << SA->getAlignment(); 560 break; 561 } 562 case attr::MayAlias: { 563 break; 564 } 565 case attr::MicroMips: { 566 break; 567 } 568 case attr::MinSize: { 569 break; 570 } 571 case attr::Mips16: { 572 break; 573 } 574 case attr::MipsInterrupt: { 575 const auto *SA = cast<MipsInterruptAttr>(A); 576 switch(SA->getInterrupt()) { 577 case MipsInterruptAttr::sw0: 578 OS << " sw0"; 579 break; 580 case MipsInterruptAttr::sw1: 581 OS << " sw1"; 582 break; 583 case MipsInterruptAttr::hw0: 584 OS << " hw0"; 585 break; 586 case MipsInterruptAttr::hw1: 587 OS << " hw1"; 588 break; 589 case MipsInterruptAttr::hw2: 590 OS << " hw2"; 591 break; 592 case MipsInterruptAttr::hw3: 593 OS << " hw3"; 594 break; 595 case MipsInterruptAttr::hw4: 596 OS << " hw4"; 597 break; 598 case MipsInterruptAttr::hw5: 599 OS << " hw5"; 600 break; 601 case MipsInterruptAttr::eic: 602 OS << " eic"; 603 break; 604 } 605 break; 606 } 607 case attr::Mode: { 608 const auto *SA = cast<ModeAttr>(A); 609 OS << " " << SA->getMode()->getName(); 610 break; 611 } 612 case attr::NSConsumed: { 613 break; 614 } 615 case attr::NSConsumesSelf: { 616 break; 617 } 618 case attr::NSReturnsAutoreleased: { 619 break; 620 } 621 case attr::NSReturnsNotRetained: { 622 break; 623 } 624 case attr::NSReturnsRetained: { 625 break; 626 } 627 case attr::Naked: { 628 break; 629 } 630 case attr::NoAlias: { 631 break; 632 } 633 case attr::NoCommon: { 634 break; 635 } 636 case attr::NoDebug: { 637 break; 638 } 639 case attr::NoDuplicate: { 640 break; 641 } 642 case attr::NoInline: { 643 break; 644 } 645 case attr::NoInstrumentFunction: { 646 break; 647 } 648 case attr::NoMicroMips: { 649 break; 650 } 651 case attr::NoMips16: { 652 break; 653 } 654 case attr::NoReturn: { 655 break; 656 } 657 case attr::NoSanitize: { 658 const auto *SA = cast<NoSanitizeAttr>(A); 659 for (const auto &Val : SA->sanitizers()) 660 OS << " " << Val; 661 break; 662 } 663 case attr::NoSplitStack: { 664 break; 665 } 666 case attr::NoThreadSafetyAnalysis: { 667 break; 668 } 669 case attr::NoThrow: { 670 break; 671 } 672 case attr::NonNull: { 673 const auto *SA = cast<NonNullAttr>(A); 674 for (const auto &Val : SA->args()) 675 OS << " " << Val; 676 break; 677 } 678 case attr::NotTailCalled: { 679 break; 680 } 681 case attr::OMPCaptureNoInit: { 682 break; 683 } 684 case attr::OMPDeclareSimdDecl: { 685 const auto *SA = cast<OMPDeclareSimdDeclAttr>(A); 686 switch(SA->getBranchState()) { 687 case OMPDeclareSimdDeclAttr::BS_Undefined: 688 OS << " BS_Undefined"; 689 break; 690 case OMPDeclareSimdDeclAttr::BS_Inbranch: 691 OS << " BS_Inbranch"; 692 break; 693 case OMPDeclareSimdDeclAttr::BS_Notinbranch: 694 OS << " BS_Notinbranch"; 695 break; 696 } 697 for (const auto &Val : SA->modifiers()) 698 OS << " " << Val; 699 dumpStmt(SA->getSimdlen()); 700 for (OMPDeclareSimdDeclAttr::uniforms_iterator I = SA->uniforms_begin(), E = SA->uniforms_end(); I != E; ++I) 701 dumpStmt(*I); 702 for (OMPDeclareSimdDeclAttr::aligneds_iterator I = SA->aligneds_begin(), E = SA->aligneds_end(); I != E; ++I) 703 dumpStmt(*I); 704 for (OMPDeclareSimdDeclAttr::alignments_iterator I = SA->alignments_begin(), E = SA->alignments_end(); I != E; ++I) 705 dumpStmt(*I); 706 for (OMPDeclareSimdDeclAttr::linears_iterator I = SA->linears_begin(), E = SA->linears_end(); I != E; ++I) 707 dumpStmt(*I); 708 for (OMPDeclareSimdDeclAttr::steps_iterator I = SA->steps_begin(), E = SA->steps_end(); I != E; ++I) 709 dumpStmt(*I); 710 break; 711 } 712 case attr::OMPDeclareTargetDecl: { 713 const auto *SA = cast<OMPDeclareTargetDeclAttr>(A); 714 switch(SA->getMapType()) { 715 case OMPDeclareTargetDeclAttr::MT_To: 716 OS << " MT_To"; 717 break; 718 case OMPDeclareTargetDeclAttr::MT_Link: 719 OS << " MT_Link"; 720 break; 721 } 722 break; 723 } 724 case attr::OMPThreadPrivateDecl: { 725 break; 726 } 727 case attr::ObjCBoxable: { 728 break; 729 } 730 case attr::ObjCBridge: { 731 const auto *SA = cast<ObjCBridgeAttr>(A); 732 OS << " " << SA->getBridgedType()->getName(); 733 break; 734 } 735 case attr::ObjCBridgeMutable: { 736 const auto *SA = cast<ObjCBridgeMutableAttr>(A); 737 OS << " " << SA->getBridgedType()->getName(); 738 break; 739 } 740 case attr::ObjCBridgeRelated: { 741 const auto *SA = cast<ObjCBridgeRelatedAttr>(A); 742 OS << " " << SA->getRelatedClass()->getName(); 743 if (SA->getClassMethod()) 744 OS << " " << SA->getClassMethod()->getName(); 745 if (SA->getInstanceMethod()) 746 OS << " " << SA->getInstanceMethod()->getName(); 747 break; 748 } 749 case attr::ObjCDesignatedInitializer: { 750 break; 751 } 752 case attr::ObjCException: { 753 break; 754 } 755 case attr::ObjCExplicitProtocolImpl: { 756 break; 757 } 758 case attr::ObjCIndependentClass: { 759 break; 760 } 761 case attr::ObjCMethodFamily: { 762 const auto *SA = cast<ObjCMethodFamilyAttr>(A); 763 switch(SA->getFamily()) { 764 case ObjCMethodFamilyAttr::OMF_None: 765 OS << " OMF_None"; 766 break; 767 case ObjCMethodFamilyAttr::OMF_alloc: 768 OS << " OMF_alloc"; 769 break; 770 case ObjCMethodFamilyAttr::OMF_copy: 771 OS << " OMF_copy"; 772 break; 773 case ObjCMethodFamilyAttr::OMF_init: 774 OS << " OMF_init"; 775 break; 776 case ObjCMethodFamilyAttr::OMF_mutableCopy: 777 OS << " OMF_mutableCopy"; 778 break; 779 case ObjCMethodFamilyAttr::OMF_new: 780 OS << " OMF_new"; 781 break; 782 } 783 break; 784 } 785 case attr::ObjCNSObject: { 786 break; 787 } 788 case attr::ObjCPreciseLifetime: { 789 break; 790 } 791 case attr::ObjCRequiresPropertyDefs: { 792 break; 793 } 794 case attr::ObjCRequiresSuper: { 795 break; 796 } 797 case attr::ObjCReturnsInnerPointer: { 798 break; 799 } 800 case attr::ObjCRootClass: { 801 break; 802 } 803 case attr::ObjCRuntimeName: { 804 const auto *SA = cast<ObjCRuntimeNameAttr>(A); 805 OS << " \"" << SA->getMetadataName() << "\""; 806 break; 807 } 808 case attr::ObjCRuntimeVisible: { 809 break; 810 } 811 case attr::ObjCSubclassingRestricted: { 812 break; 813 } 814 case attr::OpenCLAccess: { 815 OS << " " << A->getSpelling(); 816 break; 817 } 818 case attr::OpenCLIntelReqdSubGroupSize: { 819 const auto *SA = cast<OpenCLIntelReqdSubGroupSizeAttr>(A); 820 OS << " " << SA->getSubGroupSize(); 821 break; 822 } 823 case attr::OpenCLKernel: { 824 break; 825 } 826 case attr::OpenCLUnrollHint: { 827 const auto *SA = cast<OpenCLUnrollHintAttr>(A); 828 OS << " " << SA->getUnrollHint(); 829 break; 830 } 831 case attr::OptimizeNone: { 832 break; 833 } 834 case attr::Overloadable: { 835 break; 836 } 837 case attr::Override: { 838 break; 839 } 840 case attr::Ownership: { 841 OS << " " << A->getSpelling(); 842 const auto *SA = cast<OwnershipAttr>(A); 843 OS << " " << SA->getModule()->getName(); 844 for (const auto &Val : SA->args()) 845 OS << " " << Val; 846 break; 847 } 848 case attr::Packed: { 849 break; 850 } 851 case attr::ParamTypestate: { 852 const auto *SA = cast<ParamTypestateAttr>(A); 853 switch(SA->getParamState()) { 854 case ParamTypestateAttr::Unknown: 855 OS << " Unknown"; 856 break; 857 case ParamTypestateAttr::Consumed: 858 OS << " Consumed"; 859 break; 860 case ParamTypestateAttr::Unconsumed: 861 OS << " Unconsumed"; 862 break; 863 } 864 break; 865 } 866 case attr::Pascal: { 867 break; 868 } 869 case attr::PassObjectSize: { 870 const auto *SA = cast<PassObjectSizeAttr>(A); 871 OS << " " << SA->getType(); 872 break; 873 } 874 case attr::Pcs: { 875 const auto *SA = cast<PcsAttr>(A); 876 switch(SA->getPCS()) { 877 case PcsAttr::AAPCS: 878 OS << " AAPCS"; 879 break; 880 case PcsAttr::AAPCS_VFP: 881 OS << " AAPCS_VFP"; 882 break; 883 } 884 break; 885 } 886 case attr::PragmaClangBSSSection: { 887 const auto *SA = cast<PragmaClangBSSSectionAttr>(A); 888 OS << " \"" << SA->getName() << "\""; 889 break; 890 } 891 case attr::PragmaClangDataSection: { 892 const auto *SA = cast<PragmaClangDataSectionAttr>(A); 893 OS << " \"" << SA->getName() << "\""; 894 break; 895 } 896 case attr::PragmaClangRodataSection: { 897 const auto *SA = cast<PragmaClangRodataSectionAttr>(A); 898 OS << " \"" << SA->getName() << "\""; 899 break; 900 } 901 case attr::PragmaClangTextSection: { 902 const auto *SA = cast<PragmaClangTextSectionAttr>(A); 903 OS << " \"" << SA->getName() << "\""; 904 break; 905 } 906 case attr::PreserveAll: { 907 break; 908 } 909 case attr::PreserveMost: { 910 break; 911 } 912 case attr::PtGuardedBy: { 913 const auto *SA = cast<PtGuardedByAttr>(A); 914 dumpStmt(SA->getArg()); 915 break; 916 } 917 case attr::PtGuardedVar: { 918 break; 919 } 920 case attr::Pure: { 921 break; 922 } 923 case attr::RegCall: { 924 break; 925 } 926 case attr::ReleaseCapability: { 927 OS << " " << A->getSpelling(); 928 const auto *SA = cast<ReleaseCapabilityAttr>(A); 929 for (ReleaseCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 930 dumpStmt(*I); 931 break; 932 } 933 case attr::RenderScriptKernel: { 934 break; 935 } 936 case attr::ReqdWorkGroupSize: { 937 const auto *SA = cast<ReqdWorkGroupSizeAttr>(A); 938 OS << " " << SA->getXDim(); 939 OS << " " << SA->getYDim(); 940 OS << " " << SA->getZDim(); 941 break; 942 } 943 case attr::RequireConstantInit: { 944 break; 945 } 946 case attr::RequiresCapability: { 947 OS << " " << A->getSpelling(); 948 const auto *SA = cast<RequiresCapabilityAttr>(A); 949 for (RequiresCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 950 dumpStmt(*I); 951 break; 952 } 953 case attr::Restrict: { 954 OS << " " << A->getSpelling(); 955 break; 956 } 957 case attr::ReturnTypestate: { 958 const auto *SA = cast<ReturnTypestateAttr>(A); 959 switch(SA->getState()) { 960 case ReturnTypestateAttr::Unknown: 961 OS << " Unknown"; 962 break; 963 case ReturnTypestateAttr::Consumed: 964 OS << " Consumed"; 965 break; 966 case ReturnTypestateAttr::Unconsumed: 967 OS << " Unconsumed"; 968 break; 969 } 970 break; 971 } 972 case attr::ReturnsNonNull: { 973 break; 974 } 975 case attr::ReturnsTwice: { 976 break; 977 } 978 case attr::ScopedLockable: { 979 break; 980 } 981 case attr::Section: { 982 OS << " " << A->getSpelling(); 983 const auto *SA = cast<SectionAttr>(A); 984 OS << " \"" << SA->getName() << "\""; 985 break; 986 } 987 case attr::SelectAny: { 988 break; 989 } 990 case attr::Sentinel: { 991 const auto *SA = cast<SentinelAttr>(A); 992 OS << " " << SA->getSentinel(); 993 OS << " " << SA->getNullPos(); 994 break; 995 } 996 case attr::SetTypestate: { 997 const auto *SA = cast<SetTypestateAttr>(A); 998 switch(SA->getNewState()) { 999 case SetTypestateAttr::Unknown: 1000 OS << " Unknown"; 1001 break; 1002 case SetTypestateAttr::Consumed: 1003 OS << " Consumed"; 1004 break; 1005 case SetTypestateAttr::Unconsumed: 1006 OS << " Unconsumed"; 1007 break; 1008 } 1009 break; 1010 } 1011 case attr::SharedTrylockFunction: { 1012 const auto *SA = cast<SharedTrylockFunctionAttr>(A); 1013 dumpStmt(SA->getSuccessValue()); 1014 for (SharedTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 1015 dumpStmt(*I); 1016 break; 1017 } 1018 case attr::StdCall: { 1019 break; 1020 } 1021 case attr::Suppress: { 1022 const auto *SA = cast<SuppressAttr>(A); 1023 for (const auto &Val : SA->diagnosticIdentifiers()) 1024 OS << " " << Val; 1025 break; 1026 } 1027 case attr::SwiftCall: { 1028 break; 1029 } 1030 case attr::SwiftContext: { 1031 break; 1032 } 1033 case attr::SwiftErrorResult: { 1034 break; 1035 } 1036 case attr::SwiftIndirectResult: { 1037 break; 1038 } 1039 case attr::SysVABI: { 1040 break; 1041 } 1042 case attr::TLSModel: { 1043 const auto *SA = cast<TLSModelAttr>(A); 1044 OS << " \"" << SA->getModel() << "\""; 1045 break; 1046 } 1047 case attr::Target: { 1048 const auto *SA = cast<TargetAttr>(A); 1049 OS << " \"" << SA->getFeaturesStr() << "\""; 1050 break; 1051 } 1052 case attr::TestTypestate: { 1053 const auto *SA = cast<TestTypestateAttr>(A); 1054 switch(SA->getTestState()) { 1055 case TestTypestateAttr::Consumed: 1056 OS << " Consumed"; 1057 break; 1058 case TestTypestateAttr::Unconsumed: 1059 OS << " Unconsumed"; 1060 break; 1061 } 1062 break; 1063 } 1064 case attr::ThisCall: { 1065 break; 1066 } 1067 case attr::Thread: { 1068 break; 1069 } 1070 case attr::TransparentUnion: { 1071 break; 1072 } 1073 case attr::TryAcquireCapability: { 1074 OS << " " << A->getSpelling(); 1075 const auto *SA = cast<TryAcquireCapabilityAttr>(A); 1076 dumpStmt(SA->getSuccessValue()); 1077 for (TryAcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) 1078 dumpStmt(*I); 1079 break; 1080 } 1081 case attr::TypeTagForDatatype: { 1082 const auto *SA = cast<TypeTagForDatatypeAttr>(A); 1083 OS << " " << SA->getArgumentKind()->getName(); 1084 OS << " " << SA->getMatchingCType().getAsString(); 1085 if (SA->getLayoutCompatible()) OS << " LayoutCompatible"; 1086 if (SA->getMustBeNull()) OS << " MustBeNull"; 1087 break; 1088 } 1089 case attr::TypeVisibility: { 1090 const auto *SA = cast<TypeVisibilityAttr>(A); 1091 switch(SA->getVisibility()) { 1092 case TypeVisibilityAttr::Default: 1093 OS << " Default"; 1094 break; 1095 case TypeVisibilityAttr::Hidden: 1096 OS << " Hidden"; 1097 break; 1098 case TypeVisibilityAttr::Protected: 1099 OS << " Protected"; 1100 break; 1101 } 1102 break; 1103 } 1104 case attr::Unavailable: { 1105 const auto *SA = cast<UnavailableAttr>(A); 1106 OS << " \"" << SA->getMessage() << "\""; 1107 switch(SA->getImplicitReason()) { 1108 case UnavailableAttr::IR_None: 1109 OS << " IR_None"; 1110 break; 1111 case UnavailableAttr::IR_ARCForbiddenType: 1112 OS << " IR_ARCForbiddenType"; 1113 break; 1114 case UnavailableAttr::IR_ForbiddenWeak: 1115 OS << " IR_ForbiddenWeak"; 1116 break; 1117 case UnavailableAttr::IR_ARCForbiddenConversion: 1118 OS << " IR_ARCForbiddenConversion"; 1119 break; 1120 case UnavailableAttr::IR_ARCInitReturnsUnrelated: 1121 OS << " IR_ARCInitReturnsUnrelated"; 1122 break; 1123 case UnavailableAttr::IR_ARCFieldWithOwnership: 1124 OS << " IR_ARCFieldWithOwnership"; 1125 break; 1126 } 1127 break; 1128 } 1129 case attr::Unused: { 1130 OS << " " << A->getSpelling(); 1131 break; 1132 } 1133 case attr::Used: { 1134 break; 1135 } 1136 case attr::Uuid: { 1137 const auto *SA = cast<UuidAttr>(A); 1138 OS << " \"" << SA->getGuid() << "\""; 1139 break; 1140 } 1141 case attr::VecReturn: { 1142 break; 1143 } 1144 case attr::VecTypeHint: { 1145 const auto *SA = cast<VecTypeHintAttr>(A); 1146 OS << " " << SA->getTypeHint().getAsString(); 1147 break; 1148 } 1149 case attr::VectorCall: { 1150 break; 1151 } 1152 case attr::Visibility: { 1153 const auto *SA = cast<VisibilityAttr>(A); 1154 switch(SA->getVisibility()) { 1155 case VisibilityAttr::Default: 1156 OS << " Default"; 1157 break; 1158 case VisibilityAttr::Hidden: 1159 OS << " Hidden"; 1160 break; 1161 case VisibilityAttr::Protected: 1162 OS << " Protected"; 1163 break; 1164 } 1165 break; 1166 } 1167 case attr::WarnUnused: { 1168 break; 1169 } 1170 case attr::WarnUnusedResult: { 1171 OS << " " << A->getSpelling(); 1172 break; 1173 } 1174 case attr::Weak: { 1175 break; 1176 } 1177 case attr::WeakImport: { 1178 break; 1179 } 1180 case attr::WeakRef: { 1181 const auto *SA = cast<WeakRefAttr>(A); 1182 OS << " \"" << SA->getAliasee() << "\""; 1183 break; 1184 } 1185 case attr::WorkGroupSizeHint: { 1186 const auto *SA = cast<WorkGroupSizeHintAttr>(A); 1187 OS << " " << SA->getXDim(); 1188 OS << " " << SA->getYDim(); 1189 OS << " " << SA->getZDim(); 1190 break; 1191 } 1192 case attr::X86ForceAlignArgPointer: { 1193 break; 1194 } 1195 case attr::XRayInstrument: { 1196 OS << " " << A->getSpelling(); 1197 break; 1198 } 1199 case attr::XRayLogArgs: { 1200 const auto *SA = cast<XRayLogArgsAttr>(A); 1201 OS << " " << SA->getArgumentCount(); 1202 break; 1203 } 1204 } 1205