LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/AST - AttrDump.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 103 557 18.5 %
Date: 2018-02-23 15:42:53 Functions: 0 0 -
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13