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

Generated by: LCOV version 1.13