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

Generated by: LCOV version 1.13