LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/Serialization - AttrPCHWrite.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 258 858 30.1 %
Date: 2018-02-21 17:27:13 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Attribute serialization code                                               *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9      187819 :   switch (A->getKind()) {
      10             :   case attr::AMDGPUFlatWorkGroupSize: {
      11             :     const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A);
      12           0 :     Record.push_back(SA->isInherited());
      13           0 :     Record.push_back(A->isImplicit());
      14           0 :     Record.push_back(A->getSpellingListIndex());
      15           0 :     Record.push_back(SA->getMin());
      16           0 :     Record.push_back(SA->getMax());
      17             :     break;
      18             :   }
      19             :   case attr::AMDGPUNumSGPR: {
      20             :     const auto *SA = cast<AMDGPUNumSGPRAttr>(A);
      21           0 :     Record.push_back(SA->isInherited());
      22           0 :     Record.push_back(A->isImplicit());
      23           0 :     Record.push_back(A->getSpellingListIndex());
      24           0 :     Record.push_back(SA->getNumSGPR());
      25             :     break;
      26             :   }
      27             :   case attr::AMDGPUNumVGPR: {
      28             :     const auto *SA = cast<AMDGPUNumVGPRAttr>(A);
      29           0 :     Record.push_back(SA->isInherited());
      30           0 :     Record.push_back(A->isImplicit());
      31           0 :     Record.push_back(A->getSpellingListIndex());
      32           0 :     Record.push_back(SA->getNumVGPR());
      33             :     break;
      34             :   }
      35             :   case attr::AMDGPUWavesPerEU: {
      36             :     const auto *SA = cast<AMDGPUWavesPerEUAttr>(A);
      37           0 :     Record.push_back(SA->isInherited());
      38           0 :     Record.push_back(A->isImplicit());
      39           0 :     Record.push_back(A->getSpellingListIndex());
      40           0 :     Record.push_back(SA->getMin());
      41           0 :     Record.push_back(SA->getMax());
      42             :     break;
      43             :   }
      44             :   case attr::ARMInterrupt: {
      45             :     const auto *SA = cast<ARMInterruptAttr>(A);
      46           0 :     Record.push_back(SA->isInherited());
      47           0 :     Record.push_back(A->isImplicit());
      48           0 :     Record.push_back(A->getSpellingListIndex());
      49           0 : Record.push_back(SA->getInterrupt());
      50             :     break;
      51             :   }
      52             :   case attr::AVRInterrupt: {
      53             :     const auto *SA = cast<AVRInterruptAttr>(A);
      54           0 :     Record.push_back(SA->isInherited());
      55           0 :     Record.push_back(A->isImplicit());
      56           0 :     Record.push_back(A->getSpellingListIndex());
      57             :     break;
      58             :   }
      59             :   case attr::AVRSignal: {
      60             :     const auto *SA = cast<AVRSignalAttr>(A);
      61           0 :     Record.push_back(SA->isInherited());
      62           0 :     Record.push_back(A->isImplicit());
      63           0 :     Record.push_back(A->getSpellingListIndex());
      64             :     break;
      65             :   }
      66             :   case attr::AbiTag: {
      67             :     const auto *SA = cast<AbiTagAttr>(A);
      68           1 :     Record.push_back(A->isImplicit());
      69           1 :     Record.push_back(A->getSpellingListIndex());
      70           1 :     Record.push_back(SA->tags_size());
      71           7 :     for (auto &Val : SA->tags())
      72           3 :       Record.AddString(Val);
      73             :     break;
      74             :   }
      75             :   case attr::AcquireCapability: {
      76             :     const auto *SA = cast<AcquireCapabilityAttr>(A);
      77          10 :     Record.push_back(SA->isInherited());
      78          10 :     Record.push_back(A->isImplicit());
      79          10 :     Record.push_back(A->getSpellingListIndex());
      80          10 :     Record.push_back(SA->args_size());
      81          22 :     for (auto &Val : SA->args())
      82           6 :       Record.AddStmt(Val);
      83             :     break;
      84             :   }
      85             :   case attr::AcquiredAfter: {
      86             :     const auto *SA = cast<AcquiredAfterAttr>(A);
      87           1 :     Record.push_back(SA->isInherited());
      88           1 :     Record.push_back(A->isImplicit());
      89           1 :     Record.push_back(A->getSpellingListIndex());
      90           1 :     Record.push_back(SA->args_size());
      91           3 :     for (auto &Val : SA->args())
      92           1 :       Record.AddStmt(Val);
      93             :     break;
      94             :   }
      95             :   case attr::AcquiredBefore: {
      96             :     const auto *SA = cast<AcquiredBeforeAttr>(A);
      97             :     Record.push_back(SA->isInherited());
      98           0 :     Record.push_back(A->isImplicit());
      99           0 :     Record.push_back(A->getSpellingListIndex());
     100           0 :     Record.push_back(SA->args_size());
     101           0 :     for (auto &Val : SA->args())
     102           0 :       Record.AddStmt(Val);
     103             :     break;
     104             :   }
     105             :   case attr::Alias: {
     106             :     const auto *SA = cast<AliasAttr>(A);
     107           0 :     Record.push_back(A->isImplicit());
     108           0 :     Record.push_back(A->getSpellingListIndex());
     109           0 :     Record.AddString(SA->getAliasee());
     110             :     break;
     111             :   }
     112             :   case attr::AlignMac68k: {
     113             :     const auto *SA = cast<AlignMac68kAttr>(A);
     114           0 :     Record.push_back(SA->isInherited());
     115           0 :     Record.push_back(A->isImplicit());
     116           0 :     Record.push_back(A->getSpellingListIndex());
     117             :     break;
     118             :   }
     119             :   case attr::AlignValue: {
     120             :     const auto *SA = cast<AlignValueAttr>(A);
     121           0 :     Record.push_back(A->isImplicit());
     122           0 :     Record.push_back(A->getSpellingListIndex());
     123           0 :     Record.AddStmt(SA->getAlignment());
     124             :     break;
     125             :   }
     126             :   case attr::Aligned: {
     127             :     const auto *SA = cast<AlignedAttr>(A);
     128         436 :     Record.push_back(SA->isInherited());
     129         436 :     Record.push_back(A->isImplicit());
     130         436 :     Record.push_back(A->getSpellingListIndex());
     131         436 :     Record.push_back(SA->isAlignmentExpr());
     132         436 :     if (SA->isAlignmentExpr())
     133         436 :       Record.AddStmt(SA->getAlignmentExpr());
     134             :     else
     135           0 :       Record.AddTypeSourceInfo(SA->getAlignmentType());
     136             :     break;
     137             :   }
     138             :   case attr::AllocAlign: {
     139             :     const auto *SA = cast<AllocAlignAttr>(A);
     140           0 :     Record.push_back(SA->isInherited());
     141           0 :     Record.push_back(A->isImplicit());
     142           0 :     Record.push_back(A->getSpellingListIndex());
     143           0 :     Record.push_back(SA->getParamIndex());
     144             :     break;
     145             :   }
     146             :   case attr::AllocSize: {
     147             :     const auto *SA = cast<AllocSizeAttr>(A);
     148           0 :     Record.push_back(SA->isInherited());
     149           0 :     Record.push_back(A->isImplicit());
     150           0 :     Record.push_back(A->getSpellingListIndex());
     151           0 :     Record.push_back(SA->getElemSizeParam());
     152           0 :     Record.push_back(SA->getNumElemsParam());
     153             :     break;
     154             :   }
     155             :   case attr::AlwaysInline: {
     156             :     const auto *SA = cast<AlwaysInlineAttr>(A);
     157       25010 :     Record.push_back(SA->isInherited());
     158       25010 :     Record.push_back(A->isImplicit());
     159       25010 :     Record.push_back(A->getSpellingListIndex());
     160             :     break;
     161             :   }
     162             :   case attr::AnalyzerNoReturn: {
     163             :     const auto *SA = cast<AnalyzerNoReturnAttr>(A);
     164           0 :     Record.push_back(SA->isInherited());
     165           0 :     Record.push_back(A->isImplicit());
     166           0 :     Record.push_back(A->getSpellingListIndex());
     167             :     break;
     168             :   }
     169             :   case attr::Annotate: {
     170             :     const auto *SA = cast<AnnotateAttr>(A);
     171           0 :     Record.push_back(SA->isInherited());
     172           0 :     Record.push_back(A->isImplicit());
     173           0 :     Record.push_back(A->getSpellingListIndex());
     174           0 :     Record.AddString(SA->getAnnotation());
     175             :     break;
     176             :   }
     177             :   case attr::AnyX86Interrupt: {
     178             :     const auto *SA = cast<AnyX86InterruptAttr>(A);
     179           0 :     Record.push_back(SA->isInherited());
     180           0 :     Record.push_back(A->isImplicit());
     181           0 :     Record.push_back(A->getSpellingListIndex());
     182             :     break;
     183             :   }
     184             :   case attr::AnyX86NoCallerSavedRegisters: {
     185             :     const auto *SA = cast<AnyX86NoCallerSavedRegistersAttr>(A);
     186           0 :     Record.push_back(SA->isInherited());
     187           0 :     Record.push_back(A->isImplicit());
     188           0 :     Record.push_back(A->getSpellingListIndex());
     189             :     break;
     190             :   }
     191             :   case attr::ArcWeakrefUnavailable: {
     192             :     const auto *SA = cast<ArcWeakrefUnavailableAttr>(A);
     193           0 :     Record.push_back(SA->isInherited());
     194           0 :     Record.push_back(A->isImplicit());
     195           0 :     Record.push_back(A->getSpellingListIndex());
     196             :     break;
     197             :   }
     198             :   case attr::ArgumentWithTypeTag: {
     199             :     const auto *SA = cast<ArgumentWithTypeTagAttr>(A);
     200           0 :     Record.push_back(SA->isInherited());
     201           0 :     Record.push_back(A->isImplicit());
     202           0 :     Record.push_back(A->getSpellingListIndex());
     203           0 :     Record.AddIdentifierRef(SA->getArgumentKind());
     204           0 :     Record.push_back(SA->getArgumentIdx());
     205           0 :     Record.push_back(SA->getTypeTagIdx());
     206           0 :     Record.push_back(SA->getIsPointer());
     207             :     break;
     208             :   }
     209             :   case attr::Artificial: {
     210             :     const auto *SA = cast<ArtificialAttr>(A);
     211           0 :     Record.push_back(SA->isInherited());
     212           0 :     Record.push_back(A->isImplicit());
     213           0 :     Record.push_back(A->getSpellingListIndex());
     214             :     break;
     215             :   }
     216             :   case attr::AsmLabel: {
     217             :     const auto *SA = cast<AsmLabelAttr>(A);
     218           8 :     Record.push_back(SA->isInherited());
     219           8 :     Record.push_back(A->isImplicit());
     220           8 :     Record.push_back(A->getSpellingListIndex());
     221          16 :     Record.AddString(SA->getLabel());
     222             :     break;
     223             :   }
     224             :   case attr::AssertCapability: {
     225             :     const auto *SA = cast<AssertCapabilityAttr>(A);
     226           0 :     Record.push_back(SA->isInherited());
     227           0 :     Record.push_back(A->isImplicit());
     228           0 :     Record.push_back(A->getSpellingListIndex());
     229           0 :     Record.push_back(SA->args_size());
     230           0 :     for (auto &Val : SA->args())
     231           0 :       Record.AddStmt(Val);
     232             :     break;
     233             :   }
     234             :   case attr::AssertExclusiveLock: {
     235             :     const auto *SA = cast<AssertExclusiveLockAttr>(A);
     236           0 :     Record.push_back(SA->isInherited());
     237           0 :     Record.push_back(A->isImplicit());
     238           0 :     Record.push_back(A->getSpellingListIndex());
     239           0 :     Record.push_back(SA->args_size());
     240           0 :     for (auto &Val : SA->args())
     241           0 :       Record.AddStmt(Val);
     242             :     break;
     243             :   }
     244             :   case attr::AssertSharedLock: {
     245             :     const auto *SA = cast<AssertSharedLockAttr>(A);
     246           0 :     Record.push_back(SA->isInherited());
     247           0 :     Record.push_back(A->isImplicit());
     248           0 :     Record.push_back(A->getSpellingListIndex());
     249           0 :     Record.push_back(SA->args_size());
     250           0 :     for (auto &Val : SA->args())
     251           0 :       Record.AddStmt(Val);
     252             :     break;
     253             :   }
     254             :   case attr::AssumeAligned: {
     255             :     const auto *SA = cast<AssumeAlignedAttr>(A);
     256           0 :     Record.push_back(SA->isInherited());
     257           0 :     Record.push_back(A->isImplicit());
     258           0 :     Record.push_back(A->getSpellingListIndex());
     259           0 :     Record.AddStmt(SA->getAlignment());
     260           0 :     Record.AddStmt(SA->getOffset());
     261             :     break;
     262             :   }
     263             :   case attr::Availability: {
     264             :     const auto *SA = cast<AvailabilityAttr>(A);
     265           2 :     Record.push_back(SA->isInherited());
     266           2 :     Record.push_back(A->isImplicit());
     267           2 :     Record.push_back(A->getSpellingListIndex());
     268           2 :     Record.AddIdentifierRef(SA->getPlatform());
     269           4 :     Record.AddVersionTuple(SA->getIntroduced());
     270           4 :     Record.AddVersionTuple(SA->getDeprecated());
     271           4 :     Record.AddVersionTuple(SA->getObsoleted());
     272           2 :     Record.push_back(SA->getUnavailable());
     273           4 :     Record.AddString(SA->getMessage());
     274           2 :     Record.push_back(SA->getStrict());
     275           4 :     Record.AddString(SA->getReplacement());
     276             :     break;
     277             :   }
     278             :   case attr::Blocks: {
     279             :     const auto *SA = cast<BlocksAttr>(A);
     280           2 :     Record.push_back(SA->isInherited());
     281           2 :     Record.push_back(A->isImplicit());
     282           2 :     Record.push_back(A->getSpellingListIndex());
     283           2 : Record.push_back(SA->getType());
     284             :     break;
     285             :   }
     286             :   case attr::C11NoReturn: {
     287             :     const auto *SA = cast<C11NoReturnAttr>(A);
     288           0 :     Record.push_back(SA->isInherited());
     289           0 :     Record.push_back(A->isImplicit());
     290           0 :     Record.push_back(A->getSpellingListIndex());
     291             :     break;
     292             :   }
     293             :   case attr::CDecl: {
     294             :     const auto *SA = cast<CDeclAttr>(A);
     295           0 :     Record.push_back(SA->isInherited());
     296           0 :     Record.push_back(A->isImplicit());
     297           0 :     Record.push_back(A->getSpellingListIndex());
     298             :     break;
     299             :   }
     300             :   case attr::CFAuditedTransfer: {
     301             :     const auto *SA = cast<CFAuditedTransferAttr>(A);
     302           0 :     Record.push_back(SA->isInherited());
     303           0 :     Record.push_back(A->isImplicit());
     304           0 :     Record.push_back(A->getSpellingListIndex());
     305             :     break;
     306             :   }
     307             :   case attr::CFConsumed: {
     308             :     const auto *SA = cast<CFConsumedAttr>(A);
     309           9 :     Record.push_back(SA->isInherited());
     310           9 :     Record.push_back(A->isImplicit());
     311           9 :     Record.push_back(A->getSpellingListIndex());
     312             :     break;
     313             :   }
     314             :   case attr::CFReturnsNotRetained: {
     315             :     const auto *SA = cast<CFReturnsNotRetainedAttr>(A);
     316           0 :     Record.push_back(SA->isInherited());
     317           0 :     Record.push_back(A->isImplicit());
     318           0 :     Record.push_back(A->getSpellingListIndex());
     319             :     break;
     320             :   }
     321             :   case attr::CFReturnsRetained: {
     322             :     const auto *SA = cast<CFReturnsRetainedAttr>(A);
     323           3 :     Record.push_back(SA->isInherited());
     324           3 :     Record.push_back(A->isImplicit());
     325           3 :     Record.push_back(A->getSpellingListIndex());
     326             :     break;
     327             :   }
     328             :   case attr::CFUnknownTransfer: {
     329             :     const auto *SA = cast<CFUnknownTransferAttr>(A);
     330           0 :     Record.push_back(SA->isInherited());
     331           0 :     Record.push_back(A->isImplicit());
     332           0 :     Record.push_back(A->getSpellingListIndex());
     333             :     break;
     334             :   }
     335             :   case attr::CUDAConstant: {
     336             :     const auto *SA = cast<CUDAConstantAttr>(A);
     337           0 :     Record.push_back(SA->isInherited());
     338           0 :     Record.push_back(A->isImplicit());
     339           0 :     Record.push_back(A->getSpellingListIndex());
     340             :     break;
     341             :   }
     342             :   case attr::CUDADevice: {
     343             :     const auto *SA = cast<CUDADeviceAttr>(A);
     344           4 :     Record.push_back(SA->isInherited());
     345           4 :     Record.push_back(A->isImplicit());
     346           4 :     Record.push_back(A->getSpellingListIndex());
     347             :     break;
     348             :   }
     349             :   case attr::CUDAGlobal: {
     350             :     const auto *SA = cast<CUDAGlobalAttr>(A);
     351           1 :     Record.push_back(SA->isInherited());
     352           1 :     Record.push_back(A->isImplicit());
     353           1 :     Record.push_back(A->getSpellingListIndex());
     354             :     break;
     355             :   }
     356             :   case attr::CUDAHost: {
     357             :     const auto *SA = cast<CUDAHostAttr>(A);
     358           4 :     Record.push_back(SA->isInherited());
     359           4 :     Record.push_back(A->isImplicit());
     360           4 :     Record.push_back(A->getSpellingListIndex());
     361             :     break;
     362             :   }
     363             :   case attr::CUDAInvalidTarget: {
     364             :     const auto *SA = cast<CUDAInvalidTargetAttr>(A);
     365           0 :     Record.push_back(SA->isInherited());
     366           0 :     Record.push_back(A->isImplicit());
     367           0 :     Record.push_back(A->getSpellingListIndex());
     368             :     break;
     369             :   }
     370             :   case attr::CUDALaunchBounds: {
     371             :     const auto *SA = cast<CUDALaunchBoundsAttr>(A);
     372           0 :     Record.push_back(SA->isInherited());
     373           0 :     Record.push_back(A->isImplicit());
     374           0 :     Record.push_back(A->getSpellingListIndex());
     375           0 :     Record.AddStmt(SA->getMaxThreads());
     376           0 :     Record.AddStmt(SA->getMinBlocks());
     377             :     break;
     378             :   }
     379             :   case attr::CUDAShared: {
     380             :     const auto *SA = cast<CUDASharedAttr>(A);
     381           0 :     Record.push_back(SA->isInherited());
     382           0 :     Record.push_back(A->isImplicit());
     383           0 :     Record.push_back(A->getSpellingListIndex());
     384             :     break;
     385             :   }
     386             :   case attr::CXX11NoReturn: {
     387             :     const auto *SA = cast<CXX11NoReturnAttr>(A);
     388           0 :     Record.push_back(SA->isInherited());
     389           0 :     Record.push_back(A->isImplicit());
     390           0 :     Record.push_back(A->getSpellingListIndex());
     391             :     break;
     392             :   }
     393             :   case attr::CallableWhen: {
     394             :     const auto *SA = cast<CallableWhenAttr>(A);
     395           0 :     Record.push_back(SA->isInherited());
     396           0 :     Record.push_back(A->isImplicit());
     397           0 :     Record.push_back(A->getSpellingListIndex());
     398           0 :     Record.push_back(SA->callableStates_size());
     399           0 :     for (CallableWhenAttr::callableStates_iterator i = SA->callableStates_begin(), e = SA->callableStates_end(); i != e; ++i)
     400           0 :       Record.push_back((*i));
     401             :     break;
     402             :   }
     403             :   case attr::Capability: {
     404             :     const auto *SA = cast<CapabilityAttr>(A);
     405           2 :     Record.push_back(SA->isInherited());
     406           2 :     Record.push_back(A->isImplicit());
     407           2 :     Record.push_back(A->getSpellingListIndex());
     408           4 :     Record.AddString(SA->getName());
     409             :     break;
     410             :   }
     411             :   case attr::CapturedRecord: {
     412             :     const auto *SA = cast<CapturedRecordAttr>(A);
     413       19538 :     Record.push_back(SA->isInherited());
     414       19538 :     Record.push_back(A->isImplicit());
     415       19538 :     Record.push_back(A->getSpellingListIndex());
     416             :     break;
     417             :   }
     418             :   case attr::CarriesDependency: {
     419             :     const auto *SA = cast<CarriesDependencyAttr>(A);
     420           0 :     Record.push_back(SA->isInherited());
     421           0 :     Record.push_back(A->isImplicit());
     422           0 :     Record.push_back(A->getSpellingListIndex());
     423             :     break;
     424             :   }
     425             :   case attr::Cleanup: {
     426             :     const auto *SA = cast<CleanupAttr>(A);
     427           0 :     Record.push_back(SA->isInherited());
     428           0 :     Record.push_back(A->isImplicit());
     429           0 :     Record.push_back(A->getSpellingListIndex());
     430           0 :     Record.AddDeclRef(SA->getFunctionDecl());
     431             :     break;
     432             :   }
     433             :   case attr::Cold: {
     434             :     const auto *SA = cast<ColdAttr>(A);
     435           8 :     Record.push_back(SA->isInherited());
     436           8 :     Record.push_back(A->isImplicit());
     437           8 :     Record.push_back(A->getSpellingListIndex());
     438             :     break;
     439             :   }
     440             :   case attr::Common: {
     441             :     const auto *SA = cast<CommonAttr>(A);
     442           0 :     Record.push_back(SA->isInherited());
     443           0 :     Record.push_back(A->isImplicit());
     444           0 :     Record.push_back(A->getSpellingListIndex());
     445             :     break;
     446             :   }
     447             :   case attr::Const: {
     448             :     const auto *SA = cast<ConstAttr>(A);
     449       39498 :     Record.push_back(SA->isInherited());
     450       39498 :     Record.push_back(A->isImplicit());
     451       39498 :     Record.push_back(A->getSpellingListIndex());
     452             :     break;
     453             :   }
     454             :   case attr::Constructor: {
     455             :     const auto *SA = cast<ConstructorAttr>(A);
     456           0 :     Record.push_back(SA->isInherited());
     457           0 :     Record.push_back(A->isImplicit());
     458           0 :     Record.push_back(A->getSpellingListIndex());
     459           0 :     Record.push_back(SA->getPriority());
     460             :     break;
     461             :   }
     462             :   case attr::Consumable: {
     463             :     const auto *SA = cast<ConsumableAttr>(A);
     464           0 :     Record.push_back(SA->isInherited());
     465           0 :     Record.push_back(A->isImplicit());
     466           0 :     Record.push_back(A->getSpellingListIndex());
     467           0 : Record.push_back(SA->getDefaultState());
     468             :     break;
     469             :   }
     470             :   case attr::ConsumableAutoCast: {
     471             :     const auto *SA = cast<ConsumableAutoCastAttr>(A);
     472           0 :     Record.push_back(SA->isInherited());
     473           0 :     Record.push_back(A->isImplicit());
     474           0 :     Record.push_back(A->getSpellingListIndex());
     475             :     break;
     476             :   }
     477             :   case attr::ConsumableSetOnRead: {
     478             :     const auto *SA = cast<ConsumableSetOnReadAttr>(A);
     479           0 :     Record.push_back(SA->isInherited());
     480           0 :     Record.push_back(A->isImplicit());
     481           0 :     Record.push_back(A->getSpellingListIndex());
     482             :     break;
     483             :   }
     484             :   case attr::Convergent: {
     485             :     const auto *SA = cast<ConvergentAttr>(A);
     486         849 :     Record.push_back(SA->isInherited());
     487         849 :     Record.push_back(A->isImplicit());
     488         849 :     Record.push_back(A->getSpellingListIndex());
     489             :     break;
     490             :   }
     491             :   case attr::DLLExport: {
     492             :     const auto *SA = cast<DLLExportAttr>(A);
     493           6 :     Record.push_back(SA->isInherited());
     494           6 :     Record.push_back(A->isImplicit());
     495           6 :     Record.push_back(A->getSpellingListIndex());
     496             :     break;
     497             :   }
     498             :   case attr::DLLImport: {
     499             :     const auto *SA = cast<DLLImportAttr>(A);
     500           0 :     Record.push_back(SA->isInherited());
     501           0 :     Record.push_back(A->isImplicit());
     502           0 :     Record.push_back(A->getSpellingListIndex());
     503             :     break;
     504             :   }
     505             :   case attr::Deprecated: {
     506             :     const auto *SA = cast<DeprecatedAttr>(A);
     507           1 :     Record.push_back(SA->isInherited());
     508           1 :     Record.push_back(A->isImplicit());
     509           1 :     Record.push_back(A->getSpellingListIndex());
     510           2 :     Record.AddString(SA->getMessage());
     511           2 :     Record.AddString(SA->getReplacement());
     512             :     break;
     513             :   }
     514             :   case attr::Destructor: {
     515             :     const auto *SA = cast<DestructorAttr>(A);
     516           0 :     Record.push_back(SA->isInherited());
     517           0 :     Record.push_back(A->isImplicit());
     518           0 :     Record.push_back(A->getSpellingListIndex());
     519           0 :     Record.push_back(SA->getPriority());
     520             :     break;
     521             :   }
     522             :   case attr::DiagnoseIf: {
     523             :     const auto *SA = cast<DiagnoseIfAttr>(A);
     524           0 :     Record.push_back(SA->isInherited());
     525           0 :     Record.push_back(A->isImplicit());
     526           0 :     Record.push_back(A->getSpellingListIndex());
     527           0 :     Record.AddStmt(SA->getCond());
     528           0 :     Record.AddString(SA->getMessage());
     529           0 : Record.push_back(SA->getDiagnosticType());
     530           0 :     Record.push_back(SA->getArgDependent());
     531           0 :     Record.AddDeclRef(SA->getParent());
     532             :     break;
     533             :   }
     534             :   case attr::DisableTailCalls: {
     535             :     const auto *SA = cast<DisableTailCallsAttr>(A);
     536           0 :     Record.push_back(SA->isInherited());
     537           0 :     Record.push_back(A->isImplicit());
     538           0 :     Record.push_back(A->getSpellingListIndex());
     539             :     break;
     540             :   }
     541             :   case attr::EmptyBases: {
     542             :     const auto *SA = cast<EmptyBasesAttr>(A);
     543           0 :     Record.push_back(SA->isInherited());
     544           0 :     Record.push_back(A->isImplicit());
     545           0 :     Record.push_back(A->getSpellingListIndex());
     546             :     break;
     547             :   }
     548             :   case attr::EnableIf: {
     549             :     const auto *SA = cast<EnableIfAttr>(A);
     550           6 :     Record.push_back(SA->isInherited());
     551           6 :     Record.push_back(A->isImplicit());
     552           6 :     Record.push_back(A->getSpellingListIndex());
     553           6 :     Record.AddStmt(SA->getCond());
     554          12 :     Record.AddString(SA->getMessage());
     555             :     break;
     556             :   }
     557             :   case attr::EnumExtensibility: {
     558             :     const auto *SA = cast<EnumExtensibilityAttr>(A);
     559           0 :     Record.push_back(SA->isInherited());
     560           0 :     Record.push_back(A->isImplicit());
     561           0 :     Record.push_back(A->getSpellingListIndex());
     562           0 : Record.push_back(SA->getExtensibility());
     563             :     break;
     564             :   }
     565             :   case attr::ExclusiveTrylockFunction: {
     566             :     const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A);
     567           1 :     Record.push_back(SA->isInherited());
     568           1 :     Record.push_back(A->isImplicit());
     569           1 :     Record.push_back(A->getSpellingListIndex());
     570           1 :     Record.AddStmt(SA->getSuccessValue());
     571           1 :     Record.push_back(SA->args_size());
     572           1 :     for (auto &Val : SA->args())
     573           0 :       Record.AddStmt(Val);
     574             :     break;
     575             :   }
     576             :   case attr::ExternalSourceSymbol: {
     577             :     const auto *SA = cast<ExternalSourceSymbolAttr>(A);
     578           0 :     Record.push_back(SA->isInherited());
     579           0 :     Record.push_back(A->isImplicit());
     580           0 :     Record.push_back(A->getSpellingListIndex());
     581           0 :     Record.AddString(SA->getLanguage());
     582           0 :     Record.AddString(SA->getDefinedIn());
     583           0 :     Record.push_back(SA->getGeneratedDeclaration());
     584             :     break;
     585             :   }
     586             :   case attr::FallThrough: {
     587           4 :     Record.push_back(A->isImplicit());
     588           4 :     Record.push_back(A->getSpellingListIndex());
     589             :     break;
     590             :   }
     591             :   case attr::FastCall: {
     592             :     const auto *SA = cast<FastCallAttr>(A);
     593           0 :     Record.push_back(SA->isInherited());
     594           0 :     Record.push_back(A->isImplicit());
     595           0 :     Record.push_back(A->getSpellingListIndex());
     596             :     break;
     597             :   }
     598             :   case attr::Final: {
     599             :     const auto *SA = cast<FinalAttr>(A);
     600           0 :     Record.push_back(SA->isInherited());
     601           0 :     Record.push_back(A->isImplicit());
     602           0 :     Record.push_back(A->getSpellingListIndex());
     603             :     break;
     604             :   }
     605             :   case attr::FlagEnum: {
     606             :     const auto *SA = cast<FlagEnumAttr>(A);
     607           0 :     Record.push_back(SA->isInherited());
     608           0 :     Record.push_back(A->isImplicit());
     609           0 :     Record.push_back(A->getSpellingListIndex());
     610             :     break;
     611             :   }
     612             :   case attr::Flatten: {
     613             :     const auto *SA = cast<FlattenAttr>(A);
     614           0 :     Record.push_back(SA->isInherited());
     615           0 :     Record.push_back(A->isImplicit());
     616           0 :     Record.push_back(A->getSpellingListIndex());
     617             :     break;
     618             :   }
     619             :   case attr::Format: {
     620             :     const auto *SA = cast<FormatAttr>(A);
     621          42 :     Record.push_back(SA->isInherited());
     622          42 :     Record.push_back(A->isImplicit());
     623          42 :     Record.push_back(A->getSpellingListIndex());
     624          42 :     Record.AddIdentifierRef(SA->getType());
     625          42 :     Record.push_back(SA->getFormatIdx());
     626          42 :     Record.push_back(SA->getFirstArg());
     627             :     break;
     628             :   }
     629             :   case attr::FormatArg: {
     630             :     const auto *SA = cast<FormatArgAttr>(A);
     631           0 :     Record.push_back(SA->isInherited());
     632           0 :     Record.push_back(A->isImplicit());
     633           0 :     Record.push_back(A->getSpellingListIndex());
     634           0 :     Record.push_back(SA->getFormatIdx());
     635             :     break;
     636             :   }
     637             :   case attr::GNUInline: {
     638             :     const auto *SA = cast<GNUInlineAttr>(A);
     639           0 :     Record.push_back(SA->isInherited());
     640           0 :     Record.push_back(A->isImplicit());
     641           0 :     Record.push_back(A->getSpellingListIndex());
     642             :     break;
     643             :   }
     644             :   case attr::GuardedBy: {
     645             :     const auto *SA = cast<GuardedByAttr>(A);
     646           4 :     Record.push_back(SA->isInherited());
     647           4 :     Record.push_back(A->isImplicit());
     648           4 :     Record.push_back(A->getSpellingListIndex());
     649           4 :     Record.AddStmt(SA->getArg());
     650             :     break;
     651             :   }
     652             :   case attr::GuardedVar: {
     653             :     const auto *SA = cast<GuardedVarAttr>(A);
     654           1 :     Record.push_back(SA->isInherited());
     655           1 :     Record.push_back(A->isImplicit());
     656           1 :     Record.push_back(A->getSpellingListIndex());
     657             :     break;
     658             :   }
     659             :   case attr::Hot: {
     660             :     const auto *SA = cast<HotAttr>(A);
     661           0 :     Record.push_back(SA->isInherited());
     662           0 :     Record.push_back(A->isImplicit());
     663           0 :     Record.push_back(A->getSpellingListIndex());
     664             :     break;
     665             :   }
     666             :   case attr::IBAction: {
     667             :     const auto *SA = cast<IBActionAttr>(A);
     668           2 :     Record.push_back(SA->isInherited());
     669           2 :     Record.push_back(A->isImplicit());
     670           2 :     Record.push_back(A->getSpellingListIndex());
     671             :     break;
     672             :   }
     673             :   case attr::IBOutlet: {
     674             :     const auto *SA = cast<IBOutletAttr>(A);
     675           3 :     Record.push_back(SA->isInherited());
     676           3 :     Record.push_back(A->isImplicit());
     677           3 :     Record.push_back(A->getSpellingListIndex());
     678             :     break;
     679             :   }
     680             :   case attr::IBOutletCollection: {
     681             :     const auto *SA = cast<IBOutletCollectionAttr>(A);
     682           1 :     Record.push_back(SA->isInherited());
     683           1 :     Record.push_back(A->isImplicit());
     684           1 :     Record.push_back(A->getSpellingListIndex());
     685           1 :     Record.AddTypeSourceInfo(SA->getInterfaceLoc());
     686           1 :     break;
     687             :   }
     688             :   case attr::IFunc: {
     689             :     const auto *SA = cast<IFuncAttr>(A);
     690           0 :     Record.push_back(A->isImplicit());
     691           0 :     Record.push_back(A->getSpellingListIndex());
     692           0 :     Record.AddString(SA->getResolver());
     693             :     break;
     694             :   }
     695             :   case attr::InitPriority: {
     696             :     const auto *SA = cast<InitPriorityAttr>(A);
     697         216 :     Record.push_back(SA->isInherited());
     698         216 :     Record.push_back(A->isImplicit());
     699         216 :     Record.push_back(A->getSpellingListIndex());
     700         216 :     Record.push_back(SA->getPriority());
     701             :     break;
     702             :   }
     703             :   case attr::InitSeg: {
     704             :     const auto *SA = cast<InitSegAttr>(A);
     705           0 :     Record.push_back(A->isImplicit());
     706           0 :     Record.push_back(A->getSpellingListIndex());
     707           0 :     Record.AddString(SA->getSection());
     708             :     break;
     709             :   }
     710             :   case attr::IntelOclBicc: {
     711             :     const auto *SA = cast<IntelOclBiccAttr>(A);
     712           0 :     Record.push_back(SA->isInherited());
     713           0 :     Record.push_back(A->isImplicit());
     714           0 :     Record.push_back(A->getSpellingListIndex());
     715             :     break;
     716             :   }
     717             :   case attr::InternalLinkage: {
     718             :     const auto *SA = cast<InternalLinkageAttr>(A);
     719           0 :     Record.push_back(SA->isInherited());
     720           0 :     Record.push_back(A->isImplicit());
     721           0 :     Record.push_back(A->getSpellingListIndex());
     722             :     break;
     723             :   }
     724             :   case attr::LTOVisibilityPublic: {
     725             :     const auto *SA = cast<LTOVisibilityPublicAttr>(A);
     726           0 :     Record.push_back(SA->isInherited());
     727           0 :     Record.push_back(A->isImplicit());
     728           0 :     Record.push_back(A->getSpellingListIndex());
     729             :     break;
     730             :   }
     731             :   case attr::LayoutVersion: {
     732             :     const auto *SA = cast<LayoutVersionAttr>(A);
     733           0 :     Record.push_back(SA->isInherited());
     734           0 :     Record.push_back(A->isImplicit());
     735           0 :     Record.push_back(A->getSpellingListIndex());
     736           0 :     Record.push_back(SA->getVersion());
     737             :     break;
     738             :   }
     739             :   case attr::LockReturned: {
     740             :     const auto *SA = cast<LockReturnedAttr>(A);
     741           0 :     Record.push_back(SA->isInherited());
     742           0 :     Record.push_back(A->isImplicit());
     743           0 :     Record.push_back(A->getSpellingListIndex());
     744           0 :     Record.AddStmt(SA->getArg());
     745             :     break;
     746             :   }
     747             :   case attr::LocksExcluded: {
     748             :     const auto *SA = cast<LocksExcludedAttr>(A);
     749           0 :     Record.push_back(SA->isInherited());
     750           0 :     Record.push_back(A->isImplicit());
     751           0 :     Record.push_back(A->getSpellingListIndex());
     752           0 :     Record.push_back(SA->args_size());
     753           0 :     for (auto &Val : SA->args())
     754           0 :       Record.AddStmt(Val);
     755             :     break;
     756             :   }
     757             :   case attr::LoopHint: {
     758             :     const auto *SA = cast<LoopHintAttr>(A);
     759          16 :     Record.push_back(A->isImplicit());
     760          16 :     Record.push_back(A->getSpellingListIndex());
     761          16 : Record.push_back(SA->getOption());
     762          16 : Record.push_back(SA->getState());
     763          16 :     Record.AddStmt(SA->getValue());
     764             :     break;
     765             :   }
     766             :   case attr::MSABI: {
     767             :     const auto *SA = cast<MSABIAttr>(A);
     768           0 :     Record.push_back(SA->isInherited());
     769           0 :     Record.push_back(A->isImplicit());
     770           0 :     Record.push_back(A->getSpellingListIndex());
     771             :     break;
     772             :   }
     773             :   case attr::MSInheritance: {
     774             :     const auto *SA = cast<MSInheritanceAttr>(A);
     775           2 :     Record.push_back(SA->isInherited());
     776           2 :     Record.push_back(A->isImplicit());
     777           2 :     Record.push_back(A->getSpellingListIndex());
     778           2 :     Record.push_back(SA->getBestCase());
     779             :     break;
     780             :   }
     781             :   case attr::MSNoVTable: {
     782             :     const auto *SA = cast<MSNoVTableAttr>(A);
     783           0 :     Record.push_back(SA->isInherited());
     784           0 :     Record.push_back(A->isImplicit());
     785           0 :     Record.push_back(A->getSpellingListIndex());
     786             :     break;
     787             :   }
     788             :   case attr::MSP430Interrupt: {
     789             :     const auto *SA = cast<MSP430InterruptAttr>(A);
     790           0 :     Record.push_back(SA->isInherited());
     791           0 :     Record.push_back(A->isImplicit());
     792           0 :     Record.push_back(A->getSpellingListIndex());
     793           0 :     Record.push_back(SA->getNumber());
     794             :     break;
     795             :   }
     796             :   case attr::MSStruct: {
     797             :     const auto *SA = cast<MSStructAttr>(A);
     798           1 :     Record.push_back(SA->isInherited());
     799           1 :     Record.push_back(A->isImplicit());
     800           1 :     Record.push_back(A->getSpellingListIndex());
     801             :     break;
     802             :   }
     803             :   case attr::MSVtorDisp: {
     804             :     const auto *SA = cast<MSVtorDispAttr>(A);
     805           0 :     Record.push_back(SA->isInherited());
     806           0 :     Record.push_back(A->isImplicit());
     807           0 :     Record.push_back(A->getSpellingListIndex());
     808           0 :     Record.push_back(SA->getVdm());
     809             :     break;
     810             :   }
     811             :   case attr::MaxFieldAlignment: {
     812             :     const auto *SA = cast<MaxFieldAlignmentAttr>(A);
     813           0 :     Record.push_back(SA->isInherited());
     814           0 :     Record.push_back(A->isImplicit());
     815           0 :     Record.push_back(A->getSpellingListIndex());
     816           0 :     Record.push_back(SA->getAlignment());
     817             :     break;
     818             :   }
     819             :   case attr::MayAlias: {
     820             :     const auto *SA = cast<MayAliasAttr>(A);
     821         116 :     Record.push_back(SA->isInherited());
     822         116 :     Record.push_back(A->isImplicit());
     823         116 :     Record.push_back(A->getSpellingListIndex());
     824             :     break;
     825             :   }
     826             :   case attr::MicroMips: {
     827             :     const auto *SA = cast<MicroMipsAttr>(A);
     828           0 :     Record.push_back(SA->isInherited());
     829           0 :     Record.push_back(A->isImplicit());
     830           0 :     Record.push_back(A->getSpellingListIndex());
     831             :     break;
     832             :   }
     833             :   case attr::MinSize: {
     834             :     const auto *SA = cast<MinSizeAttr>(A);
     835           0 :     Record.push_back(SA->isInherited());
     836           0 :     Record.push_back(A->isImplicit());
     837           0 :     Record.push_back(A->getSpellingListIndex());
     838             :     break;
     839             :   }
     840             :   case attr::Mips16: {
     841             :     const auto *SA = cast<Mips16Attr>(A);
     842           0 :     Record.push_back(SA->isInherited());
     843           0 :     Record.push_back(A->isImplicit());
     844           0 :     Record.push_back(A->getSpellingListIndex());
     845             :     break;
     846             :   }
     847             :   case attr::MipsInterrupt: {
     848             :     const auto *SA = cast<MipsInterruptAttr>(A);
     849           0 :     Record.push_back(SA->isInherited());
     850           0 :     Record.push_back(A->isImplicit());
     851           0 :     Record.push_back(A->getSpellingListIndex());
     852           0 : Record.push_back(SA->getInterrupt());
     853             :     break;
     854             :   }
     855             :   case attr::MipsLongCall: {
     856             :     const auto *SA = cast<MipsLongCallAttr>(A);
     857           0 :     Record.push_back(SA->isInherited());
     858           0 :     Record.push_back(A->isImplicit());
     859           0 :     Record.push_back(A->getSpellingListIndex());
     860             :     break;
     861             :   }
     862             :   case attr::MipsShortCall: {
     863             :     const auto *SA = cast<MipsShortCallAttr>(A);
     864           0 :     Record.push_back(SA->isInherited());
     865           0 :     Record.push_back(A->isImplicit());
     866           0 :     Record.push_back(A->getSpellingListIndex());
     867             :     break;
     868             :   }
     869             :   case attr::Mode: {
     870             :     const auto *SA = cast<ModeAttr>(A);
     871           0 :     Record.push_back(A->isImplicit());
     872           0 :     Record.push_back(A->getSpellingListIndex());
     873           0 :     Record.AddIdentifierRef(SA->getMode());
     874             :     break;
     875             :   }
     876             :   case attr::NSConsumed: {
     877             :     const auto *SA = cast<NSConsumedAttr>(A);
     878           0 :     Record.push_back(SA->isInherited());
     879           0 :     Record.push_back(A->isImplicit());
     880           0 :     Record.push_back(A->getSpellingListIndex());
     881             :     break;
     882             :   }
     883             :   case attr::NSConsumesSelf: {
     884             :     const auto *SA = cast<NSConsumesSelfAttr>(A);
     885           0 :     Record.push_back(SA->isInherited());
     886           0 :     Record.push_back(A->isImplicit());
     887           0 :     Record.push_back(A->getSpellingListIndex());
     888             :     break;
     889             :   }
     890             :   case attr::NSReturnsAutoreleased: {
     891             :     const auto *SA = cast<NSReturnsAutoreleasedAttr>(A);
     892           0 :     Record.push_back(SA->isInherited());
     893           0 :     Record.push_back(A->isImplicit());
     894           0 :     Record.push_back(A->getSpellingListIndex());
     895             :     break;
     896             :   }
     897             :   case attr::NSReturnsNotRetained: {
     898             :     const auto *SA = cast<NSReturnsNotRetainedAttr>(A);
     899           3 :     Record.push_back(SA->isInherited());
     900           3 :     Record.push_back(A->isImplicit());
     901           3 :     Record.push_back(A->getSpellingListIndex());
     902             :     break;
     903             :   }
     904             :   case attr::NSReturnsRetained: {
     905             :     const auto *SA = cast<NSReturnsRetainedAttr>(A);
     906          14 :     Record.push_back(SA->isInherited());
     907          14 :     Record.push_back(A->isImplicit());
     908          14 :     Record.push_back(A->getSpellingListIndex());
     909             :     break;
     910             :   }
     911             :   case attr::Naked: {
     912             :     const auto *SA = cast<NakedAttr>(A);
     913           0 :     Record.push_back(SA->isInherited());
     914           0 :     Record.push_back(A->isImplicit());
     915           0 :     Record.push_back(A->getSpellingListIndex());
     916             :     break;
     917             :   }
     918             :   case attr::NoAlias: {
     919             :     const auto *SA = cast<NoAliasAttr>(A);
     920           0 :     Record.push_back(SA->isInherited());
     921           0 :     Record.push_back(A->isImplicit());
     922           0 :     Record.push_back(A->getSpellingListIndex());
     923             :     break;
     924             :   }
     925             :   case attr::NoCommon: {
     926             :     const auto *SA = cast<NoCommonAttr>(A);
     927           0 :     Record.push_back(SA->isInherited());
     928           0 :     Record.push_back(A->isImplicit());
     929           0 :     Record.push_back(A->getSpellingListIndex());
     930             :     break;
     931             :   }
     932             :   case attr::NoDebug: {
     933             :     const auto *SA = cast<NoDebugAttr>(A);
     934       18930 :     Record.push_back(SA->isInherited());
     935       18930 :     Record.push_back(A->isImplicit());
     936       18930 :     Record.push_back(A->getSpellingListIndex());
     937             :     break;
     938             :   }
     939             :   case attr::NoDuplicate: {
     940             :     const auto *SA = cast<NoDuplicateAttr>(A);
     941           0 :     Record.push_back(SA->isInherited());
     942           0 :     Record.push_back(A->isImplicit());
     943           0 :     Record.push_back(A->getSpellingListIndex());
     944             :     break;
     945             :   }
     946             :   case attr::NoEscape: {
     947           0 :     Record.push_back(A->isImplicit());
     948           0 :     Record.push_back(A->getSpellingListIndex());
     949             :     break;
     950             :   }
     951             :   case attr::NoInline: {
     952             :     const auto *SA = cast<NoInlineAttr>(A);
     953           0 :     Record.push_back(SA->isInherited());
     954           0 :     Record.push_back(A->isImplicit());
     955           0 :     Record.push_back(A->getSpellingListIndex());
     956             :     break;
     957             :   }
     958             :   case attr::NoInstrumentFunction: {
     959             :     const auto *SA = cast<NoInstrumentFunctionAttr>(A);
     960           0 :     Record.push_back(SA->isInherited());
     961           0 :     Record.push_back(A->isImplicit());
     962           0 :     Record.push_back(A->getSpellingListIndex());
     963             :     break;
     964             :   }
     965             :   case attr::NoMicroMips: {
     966             :     const auto *SA = cast<NoMicroMipsAttr>(A);
     967           0 :     Record.push_back(SA->isInherited());
     968           0 :     Record.push_back(A->isImplicit());
     969           0 :     Record.push_back(A->getSpellingListIndex());
     970             :     break;
     971             :   }
     972             :   case attr::NoMips16: {
     973             :     const auto *SA = cast<NoMips16Attr>(A);
     974           0 :     Record.push_back(SA->isInherited());
     975           0 :     Record.push_back(A->isImplicit());
     976           0 :     Record.push_back(A->getSpellingListIndex());
     977             :     break;
     978             :   }
     979             :   case attr::NoReturn: {
     980             :     const auto *SA = cast<NoReturnAttr>(A);
     981           0 :     Record.push_back(SA->isInherited());
     982           0 :     Record.push_back(A->isImplicit());
     983           0 :     Record.push_back(A->getSpellingListIndex());
     984             :     break;
     985             :   }
     986             :   case attr::NoSanitize: {
     987             :     const auto *SA = cast<NoSanitizeAttr>(A);
     988           1 :     Record.push_back(SA->isInherited());
     989           1 :     Record.push_back(A->isImplicit());
     990           1 :     Record.push_back(A->getSpellingListIndex());
     991           1 :     Record.push_back(SA->sanitizers_size());
     992           5 :     for (auto &Val : SA->sanitizers())
     993           2 :       Record.AddString(Val);
     994             :     break;
     995             :   }
     996             :   case attr::NoSplitStack: {
     997             :     const auto *SA = cast<NoSplitStackAttr>(A);
     998           0 :     Record.push_back(SA->isInherited());
     999           0 :     Record.push_back(A->isImplicit());
    1000           0 :     Record.push_back(A->getSpellingListIndex());
    1001             :     break;
    1002             :   }
    1003             :   case attr::NoThreadSafetyAnalysis: {
    1004             :     const auto *SA = cast<NoThreadSafetyAnalysisAttr>(A);
    1005           0 :     Record.push_back(SA->isInherited());
    1006           0 :     Record.push_back(A->isImplicit());
    1007           0 :     Record.push_back(A->getSpellingListIndex());
    1008             :     break;
    1009             :   }
    1010             :   case attr::NoThrow: {
    1011             :     const auto *SA = cast<NoThrowAttr>(A);
    1012         830 :     Record.push_back(SA->isInherited());
    1013         830 :     Record.push_back(A->isImplicit());
    1014         830 :     Record.push_back(A->getSpellingListIndex());
    1015             :     break;
    1016             :   }
    1017             :   case attr::NonNull: {
    1018             :     const auto *SA = cast<NonNullAttr>(A);
    1019           0 :     Record.push_back(SA->isInherited());
    1020           0 :     Record.push_back(A->isImplicit());
    1021           0 :     Record.push_back(A->getSpellingListIndex());
    1022           0 :     Record.push_back(SA->args_size());
    1023           0 :     for (auto &Val : SA->args())
    1024           0 :       Record.push_back(Val);
    1025             :     break;
    1026             :   }
    1027             :   case attr::NotTailCalled: {
    1028             :     const auto *SA = cast<NotTailCalledAttr>(A);
    1029           1 :     Record.push_back(SA->isInherited());
    1030           1 :     Record.push_back(A->isImplicit());
    1031           1 :     Record.push_back(A->getSpellingListIndex());
    1032             :     break;
    1033             :   }
    1034             :   case attr::OMPCaptureKind: {
    1035             :     const auto *SA = cast<OMPCaptureKindAttr>(A);
    1036       17174 :     Record.push_back(A->isImplicit());
    1037       17174 :     Record.push_back(A->getSpellingListIndex());
    1038       17174 :     Record.push_back(SA->getCaptureKind());
    1039             :     break;
    1040             :   }
    1041             :   case attr::OMPCaptureNoInit: {
    1042             :     const auto *SA = cast<OMPCaptureNoInitAttr>(A);
    1043          18 :     Record.push_back(SA->isInherited());
    1044          18 :     Record.push_back(A->isImplicit());
    1045          18 :     Record.push_back(A->getSpellingListIndex());
    1046             :     break;
    1047             :   }
    1048             :   case attr::OMPDeclareSimdDecl: {
    1049             :     const auto *SA = cast<OMPDeclareSimdDeclAttr>(A);
    1050         124 :     Record.push_back(A->isImplicit());
    1051         124 :     Record.push_back(A->getSpellingListIndex());
    1052         124 : Record.push_back(SA->getBranchState());
    1053         124 :     Record.AddStmt(SA->getSimdlen());
    1054         124 :     Record.push_back(SA->uniforms_size());
    1055         196 :     for (auto &Val : SA->uniforms())
    1056          36 :       Record.AddStmt(Val);
    1057         124 :     Record.push_back(SA->aligneds_size());
    1058         288 :     for (auto &Val : SA->aligneds())
    1059          82 :       Record.AddStmt(Val);
    1060         124 :     Record.push_back(SA->alignments_size());
    1061         288 :     for (auto &Val : SA->alignments())
    1062          82 :       Record.AddStmt(Val);
    1063         124 :     Record.push_back(SA->linears_size());
    1064         232 :     for (auto &Val : SA->linears())
    1065          54 :       Record.AddStmt(Val);
    1066         124 :     Record.push_back(SA->modifiers_size());
    1067         232 :     for (auto &Val : SA->modifiers())
    1068          54 :       Record.push_back(Val);
    1069         124 :     Record.push_back(SA->steps_size());
    1070         232 :     for (auto &Val : SA->steps())
    1071          54 :       Record.AddStmt(Val);
    1072             :     break;
    1073             :   }
    1074             :   case attr::OMPDeclareTargetDecl: {
    1075             :     const auto *SA = cast<OMPDeclareTargetDeclAttr>(A);
    1076          46 :     Record.push_back(A->isImplicit());
    1077          46 :     Record.push_back(A->getSpellingListIndex());
    1078          46 : Record.push_back(SA->getMapType());
    1079             :     break;
    1080             :   }
    1081             :   case attr::OMPThreadPrivateDecl: {
    1082             :     const auto *SA = cast<OMPThreadPrivateDeclAttr>(A);
    1083         162 :     Record.push_back(SA->isInherited());
    1084         162 :     Record.push_back(A->isImplicit());
    1085         162 :     Record.push_back(A->getSpellingListIndex());
    1086             :     break;
    1087             :   }
    1088             :   case attr::ObjCBoxable: {
    1089           2 :     Record.push_back(A->isImplicit());
    1090           2 :     Record.push_back(A->getSpellingListIndex());
    1091             :     break;
    1092             :   }
    1093             :   case attr::ObjCBridge: {
    1094             :     const auto *SA = cast<ObjCBridgeAttr>(A);
    1095           0 :     Record.push_back(SA->isInherited());
    1096           0 :     Record.push_back(A->isImplicit());
    1097           0 :     Record.push_back(A->getSpellingListIndex());
    1098           0 :     Record.AddIdentifierRef(SA->getBridgedType());
    1099             :     break;
    1100             :   }
    1101             :   case attr::ObjCBridgeMutable: {
    1102             :     const auto *SA = cast<ObjCBridgeMutableAttr>(A);
    1103           0 :     Record.push_back(SA->isInherited());
    1104           0 :     Record.push_back(A->isImplicit());
    1105           0 :     Record.push_back(A->getSpellingListIndex());
    1106           0 :     Record.AddIdentifierRef(SA->getBridgedType());
    1107             :     break;
    1108             :   }
    1109             :   case attr::ObjCBridgeRelated: {
    1110             :     const auto *SA = cast<ObjCBridgeRelatedAttr>(A);
    1111           0 :     Record.push_back(SA->isInherited());
    1112           0 :     Record.push_back(A->isImplicit());
    1113           0 :     Record.push_back(A->getSpellingListIndex());
    1114           0 :     Record.AddIdentifierRef(SA->getRelatedClass());
    1115           0 :     Record.AddIdentifierRef(SA->getClassMethod());
    1116           0 :     Record.AddIdentifierRef(SA->getInstanceMethod());
    1117             :     break;
    1118             :   }
    1119             :   case attr::ObjCDesignatedInitializer: {
    1120           1 :     Record.push_back(A->isImplicit());
    1121           1 :     Record.push_back(A->getSpellingListIndex());
    1122             :     break;
    1123             :   }
    1124             :   case attr::ObjCException: {
    1125             :     const auto *SA = cast<ObjCExceptionAttr>(A);
    1126           0 :     Record.push_back(SA->isInherited());
    1127           0 :     Record.push_back(A->isImplicit());
    1128           0 :     Record.push_back(A->getSpellingListIndex());
    1129             :     break;
    1130             :   }
    1131             :   case attr::ObjCExplicitProtocolImpl: {
    1132             :     const auto *SA = cast<ObjCExplicitProtocolImplAttr>(A);
    1133           0 :     Record.push_back(SA->isInherited());
    1134           0 :     Record.push_back(A->isImplicit());
    1135           0 :     Record.push_back(A->getSpellingListIndex());
    1136             :     break;
    1137             :   }
    1138             :   case attr::ObjCIndependentClass: {
    1139             :     const auto *SA = cast<ObjCIndependentClassAttr>(A);
    1140           0 :     Record.push_back(SA->isInherited());
    1141           0 :     Record.push_back(A->isImplicit());
    1142           0 :     Record.push_back(A->getSpellingListIndex());
    1143             :     break;
    1144             :   }
    1145             :   case attr::ObjCMethodFamily: {
    1146             :     const auto *SA = cast<ObjCMethodFamilyAttr>(A);
    1147           0 :     Record.push_back(SA->isInherited());
    1148           0 :     Record.push_back(A->isImplicit());
    1149           0 :     Record.push_back(A->getSpellingListIndex());
    1150           0 : Record.push_back(SA->getFamily());
    1151             :     break;
    1152             :   }
    1153             :   case attr::ObjCNSObject: {
    1154             :     const auto *SA = cast<ObjCNSObjectAttr>(A);
    1155           0 :     Record.push_back(SA->isInherited());
    1156           0 :     Record.push_back(A->isImplicit());
    1157           0 :     Record.push_back(A->getSpellingListIndex());
    1158             :     break;
    1159             :   }
    1160             :   case attr::ObjCPreciseLifetime: {
    1161             :     const auto *SA = cast<ObjCPreciseLifetimeAttr>(A);
    1162           0 :     Record.push_back(SA->isInherited());
    1163           0 :     Record.push_back(A->isImplicit());
    1164           0 :     Record.push_back(A->getSpellingListIndex());
    1165             :     break;
    1166             :   }
    1167             :   case attr::ObjCRequiresPropertyDefs: {
    1168             :     const auto *SA = cast<ObjCRequiresPropertyDefsAttr>(A);
    1169           0 :     Record.push_back(SA->isInherited());
    1170           0 :     Record.push_back(A->isImplicit());
    1171           0 :     Record.push_back(A->getSpellingListIndex());
    1172             :     break;
    1173             :   }
    1174             :   case attr::ObjCRequiresSuper: {
    1175             :     const auto *SA = cast<ObjCRequiresSuperAttr>(A);
    1176           0 :     Record.push_back(SA->isInherited());
    1177           0 :     Record.push_back(A->isImplicit());
    1178           0 :     Record.push_back(A->getSpellingListIndex());
    1179             :     break;
    1180             :   }
    1181             :   case attr::ObjCReturnsInnerPointer: {
    1182             :     const auto *SA = cast<ObjCReturnsInnerPointerAttr>(A);
    1183           0 :     Record.push_back(SA->isInherited());
    1184           0 :     Record.push_back(A->isImplicit());
    1185           0 :     Record.push_back(A->getSpellingListIndex());
    1186             :     break;
    1187             :   }
    1188             :   case attr::ObjCRootClass: {
    1189             :     const auto *SA = cast<ObjCRootClassAttr>(A);
    1190           2 :     Record.push_back(SA->isInherited());
    1191           2 :     Record.push_back(A->isImplicit());
    1192           2 :     Record.push_back(A->getSpellingListIndex());
    1193             :     break;
    1194             :   }
    1195             :   case attr::ObjCRuntimeName: {
    1196             :     const auto *SA = cast<ObjCRuntimeNameAttr>(A);
    1197           0 :     Record.push_back(A->isImplicit());
    1198           0 :     Record.push_back(A->getSpellingListIndex());
    1199           0 :     Record.AddString(SA->getMetadataName());
    1200             :     break;
    1201             :   }
    1202             :   case attr::ObjCRuntimeVisible: {
    1203           0 :     Record.push_back(A->isImplicit());
    1204           0 :     Record.push_back(A->getSpellingListIndex());
    1205             :     break;
    1206             :   }
    1207             :   case attr::ObjCSubclassingRestricted: {
    1208             :     const auto *SA = cast<ObjCSubclassingRestrictedAttr>(A);
    1209           0 :     Record.push_back(SA->isInherited());
    1210           0 :     Record.push_back(A->isImplicit());
    1211           0 :     Record.push_back(A->getSpellingListIndex());
    1212             :     break;
    1213             :   }
    1214             :   case attr::OpenCLAccess: {
    1215        1383 :     Record.push_back(A->isImplicit());
    1216        1383 :     Record.push_back(A->getSpellingListIndex());
    1217             :     break;
    1218             :   }
    1219             :   case attr::OpenCLIntelReqdSubGroupSize: {
    1220             :     const auto *SA = cast<OpenCLIntelReqdSubGroupSizeAttr>(A);
    1221           0 :     Record.push_back(SA->isInherited());
    1222           0 :     Record.push_back(A->isImplicit());
    1223           0 :     Record.push_back(A->getSpellingListIndex());
    1224           0 :     Record.push_back(SA->getSubGroupSize());
    1225             :     break;
    1226             :   }
    1227             :   case attr::OpenCLKernel: {
    1228             :     const auto *SA = cast<OpenCLKernelAttr>(A);
    1229           0 :     Record.push_back(SA->isInherited());
    1230           0 :     Record.push_back(A->isImplicit());
    1231           0 :     Record.push_back(A->getSpellingListIndex());
    1232             :     break;
    1233             :   }
    1234             :   case attr::OpenCLUnrollHint: {
    1235             :     const auto *SA = cast<OpenCLUnrollHintAttr>(A);
    1236           0 :     Record.push_back(SA->isInherited());
    1237           0 :     Record.push_back(A->isImplicit());
    1238           0 :     Record.push_back(A->getSpellingListIndex());
    1239           0 :     Record.push_back(SA->getUnrollHint());
    1240             :     break;
    1241             :   }
    1242             :   case attr::OptimizeNone: {
    1243             :     const auto *SA = cast<OptimizeNoneAttr>(A);
    1244           0 :     Record.push_back(SA->isInherited());
    1245           0 :     Record.push_back(A->isImplicit());
    1246           0 :     Record.push_back(A->getSpellingListIndex());
    1247             :     break;
    1248             :   }
    1249             :   case attr::Overloadable: {
    1250       47164 :     Record.push_back(A->isImplicit());
    1251       47164 :     Record.push_back(A->getSpellingListIndex());
    1252             :     break;
    1253             :   }
    1254             :   case attr::Override: {
    1255             :     const auto *SA = cast<OverrideAttr>(A);
    1256           2 :     Record.push_back(SA->isInherited());
    1257           2 :     Record.push_back(A->isImplicit());
    1258           2 :     Record.push_back(A->getSpellingListIndex());
    1259             :     break;
    1260             :   }
    1261             :   case attr::Ownership: {
    1262             :     const auto *SA = cast<OwnershipAttr>(A);
    1263           0 :     Record.push_back(SA->isInherited());
    1264           0 :     Record.push_back(A->isImplicit());
    1265           0 :     Record.push_back(A->getSpellingListIndex());
    1266           0 :     Record.AddIdentifierRef(SA->getModule());
    1267           0 :     Record.push_back(SA->args_size());
    1268           0 :     for (auto &Val : SA->args())
    1269           0 :       Record.push_back(Val);
    1270             :     break;
    1271             :   }
    1272             :   case attr::Packed: {
    1273             :     const auto *SA = cast<PackedAttr>(A);
    1274         153 :     Record.push_back(SA->isInherited());
    1275         153 :     Record.push_back(A->isImplicit());
    1276         153 :     Record.push_back(A->getSpellingListIndex());
    1277             :     break;
    1278             :   }
    1279             :   case attr::ParamTypestate: {
    1280             :     const auto *SA = cast<ParamTypestateAttr>(A);
    1281           0 :     Record.push_back(SA->isInherited());
    1282           0 :     Record.push_back(A->isImplicit());
    1283           0 :     Record.push_back(A->getSpellingListIndex());
    1284           0 : Record.push_back(SA->getParamState());
    1285             :     break;
    1286             :   }
    1287             :   case attr::Pascal: {
    1288             :     const auto *SA = cast<PascalAttr>(A);
    1289           0 :     Record.push_back(SA->isInherited());
    1290           0 :     Record.push_back(A->isImplicit());
    1291           0 :     Record.push_back(A->getSpellingListIndex());
    1292             :     break;
    1293             :   }
    1294             :   case attr::PassObjectSize: {
    1295             :     const auto *SA = cast<PassObjectSizeAttr>(A);
    1296           2 :     Record.push_back(SA->isInherited());
    1297           2 :     Record.push_back(A->isImplicit());
    1298           2 :     Record.push_back(A->getSpellingListIndex());
    1299           2 :     Record.push_back(SA->getType());
    1300             :     break;
    1301             :   }
    1302             :   case attr::Pcs: {
    1303             :     const auto *SA = cast<PcsAttr>(A);
    1304           0 :     Record.push_back(SA->isInherited());
    1305           0 :     Record.push_back(A->isImplicit());
    1306           0 :     Record.push_back(A->getSpellingListIndex());
    1307           0 : Record.push_back(SA->getPCS());
    1308             :     break;
    1309             :   }
    1310             :   case attr::PragmaClangBSSSection: {
    1311             :     const auto *SA = cast<PragmaClangBSSSectionAttr>(A);
    1312           0 :     Record.push_back(SA->isInherited());
    1313           0 :     Record.push_back(A->isImplicit());
    1314           0 :     Record.push_back(A->getSpellingListIndex());
    1315           0 :     Record.AddString(SA->getName());
    1316             :     break;
    1317             :   }
    1318             :   case attr::PragmaClangDataSection: {
    1319             :     const auto *SA = cast<PragmaClangDataSectionAttr>(A);
    1320           0 :     Record.push_back(SA->isInherited());
    1321           0 :     Record.push_back(A->isImplicit());
    1322           0 :     Record.push_back(A->getSpellingListIndex());
    1323           0 :     Record.AddString(SA->getName());
    1324             :     break;
    1325             :   }
    1326             :   case attr::PragmaClangRodataSection: {
    1327             :     const auto *SA = cast<PragmaClangRodataSectionAttr>(A);
    1328           0 :     Record.push_back(SA->isInherited());
    1329           0 :     Record.push_back(A->isImplicit());
    1330           0 :     Record.push_back(A->getSpellingListIndex());
    1331           0 :     Record.AddString(SA->getName());
    1332             :     break;
    1333             :   }
    1334             :   case attr::PragmaClangTextSection: {
    1335             :     const auto *SA = cast<PragmaClangTextSectionAttr>(A);
    1336           0 :     Record.push_back(SA->isInherited());
    1337           0 :     Record.push_back(A->isImplicit());
    1338           0 :     Record.push_back(A->getSpellingListIndex());
    1339           0 :     Record.AddString(SA->getName());
    1340             :     break;
    1341             :   }
    1342             :   case attr::PreserveAll: {
    1343             :     const auto *SA = cast<PreserveAllAttr>(A);
    1344           0 :     Record.push_back(SA->isInherited());
    1345           0 :     Record.push_back(A->isImplicit());
    1346           0 :     Record.push_back(A->getSpellingListIndex());
    1347             :     break;
    1348             :   }
    1349             :   case attr::PreserveMost: {
    1350             :     const auto *SA = cast<PreserveMostAttr>(A);
    1351           0 :     Record.push_back(SA->isInherited());
    1352           0 :     Record.push_back(A->isImplicit());
    1353           0 :     Record.push_back(A->getSpellingListIndex());
    1354             :     break;
    1355             :   }
    1356             :   case attr::PtGuardedBy: {
    1357             :     const auto *SA = cast<PtGuardedByAttr>(A);
    1358           0 :     Record.push_back(SA->isInherited());
    1359           0 :     Record.push_back(A->isImplicit());
    1360           0 :     Record.push_back(A->getSpellingListIndex());
    1361           0 :     Record.AddStmt(SA->getArg());
    1362             :     break;
    1363             :   }
    1364             :   case attr::PtGuardedVar: {
    1365             :     const auto *SA = cast<PtGuardedVarAttr>(A);
    1366           0 :     Record.push_back(SA->isInherited());
    1367           0 :     Record.push_back(A->isImplicit());
    1368           0 :     Record.push_back(A->getSpellingListIndex());
    1369             :     break;
    1370             :   }
    1371             :   case attr::Pure: {
    1372             :     const auto *SA = cast<PureAttr>(A);
    1373         561 :     Record.push_back(SA->isInherited());
    1374         561 :     Record.push_back(A->isImplicit());
    1375         561 :     Record.push_back(A->getSpellingListIndex());
    1376             :     break;
    1377             :   }
    1378             :   case attr::RegCall: {
    1379             :     const auto *SA = cast<RegCallAttr>(A);
    1380           0 :     Record.push_back(SA->isInherited());
    1381           0 :     Record.push_back(A->isImplicit());
    1382           0 :     Record.push_back(A->getSpellingListIndex());
    1383             :     break;
    1384             :   }
    1385             :   case attr::ReleaseCapability: {
    1386             :     const auto *SA = cast<ReleaseCapabilityAttr>(A);
    1387           9 :     Record.push_back(SA->isInherited());
    1388           9 :     Record.push_back(A->isImplicit());
    1389           9 :     Record.push_back(A->getSpellingListIndex());
    1390           9 :     Record.push_back(SA->args_size());
    1391          15 :     for (auto &Val : SA->args())
    1392           3 :       Record.AddStmt(Val);
    1393             :     break;
    1394             :   }
    1395             :   case attr::RenderScriptKernel: {
    1396           0 :     Record.push_back(A->isImplicit());
    1397           0 :     Record.push_back(A->getSpellingListIndex());
    1398             :     break;
    1399             :   }
    1400             :   case attr::ReqdWorkGroupSize: {
    1401             :     const auto *SA = cast<ReqdWorkGroupSizeAttr>(A);
    1402           0 :     Record.push_back(SA->isInherited());
    1403           0 :     Record.push_back(A->isImplicit());
    1404           0 :     Record.push_back(A->getSpellingListIndex());
    1405           0 :     Record.push_back(SA->getXDim());
    1406           0 :     Record.push_back(SA->getYDim());
    1407           0 :     Record.push_back(SA->getZDim());
    1408             :     break;
    1409             :   }
    1410             :   case attr::RequireConstantInit: {
    1411             :     const auto *SA = cast<RequireConstantInitAttr>(A);
    1412           0 :     Record.push_back(SA->isInherited());
    1413           0 :     Record.push_back(A->isImplicit());
    1414           0 :     Record.push_back(A->getSpellingListIndex());
    1415             :     break;
    1416             :   }
    1417             :   case attr::RequiresCapability: {
    1418             :     const auto *SA = cast<RequiresCapabilityAttr>(A);
    1419           0 :     Record.push_back(SA->isInherited());
    1420           0 :     Record.push_back(A->isImplicit());
    1421           0 :     Record.push_back(A->getSpellingListIndex());
    1422           0 :     Record.push_back(SA->args_size());
    1423           0 :     for (auto &Val : SA->args())
    1424           0 :       Record.AddStmt(Val);
    1425             :     break;
    1426             :   }
    1427             :   case attr::Restrict: {
    1428             :     const auto *SA = cast<RestrictAttr>(A);
    1429           2 :     Record.push_back(SA->isInherited());
    1430           2 :     Record.push_back(A->isImplicit());
    1431           2 :     Record.push_back(A->getSpellingListIndex());
    1432             :     break;
    1433             :   }
    1434             :   case attr::ReturnTypestate: {
    1435             :     const auto *SA = cast<ReturnTypestateAttr>(A);
    1436           0 :     Record.push_back(SA->isInherited());
    1437           0 :     Record.push_back(A->isImplicit());
    1438           0 :     Record.push_back(A->getSpellingListIndex());
    1439           0 : Record.push_back(SA->getState());
    1440             :     break;
    1441             :   }
    1442             :   case attr::ReturnsNonNull: {
    1443             :     const auto *SA = cast<ReturnsNonNullAttr>(A);
    1444           0 :     Record.push_back(SA->isInherited());
    1445           0 :     Record.push_back(A->isImplicit());
    1446           0 :     Record.push_back(A->getSpellingListIndex());
    1447             :     break;
    1448             :   }
    1449             :   case attr::ReturnsTwice: {
    1450             :     const auto *SA = cast<ReturnsTwiceAttr>(A);
    1451           0 :     Record.push_back(SA->isInherited());
    1452           0 :     Record.push_back(A->isImplicit());
    1453           0 :     Record.push_back(A->getSpellingListIndex());
    1454             :     break;
    1455             :   }
    1456             :   case attr::ScopedLockable: {
    1457             :     const auto *SA = cast<ScopedLockableAttr>(A);
    1458           3 :     Record.push_back(SA->isInherited());
    1459           3 :     Record.push_back(A->isImplicit());
    1460           3 :     Record.push_back(A->getSpellingListIndex());
    1461             :     break;
    1462             :   }
    1463             :   case attr::Section: {
    1464             :     const auto *SA = cast<SectionAttr>(A);
    1465           0 :     Record.push_back(SA->isInherited());
    1466           0 :     Record.push_back(A->isImplicit());
    1467           0 :     Record.push_back(A->getSpellingListIndex());
    1468           0 :     Record.AddString(SA->getName());
    1469             :     break;
    1470             :   }
    1471             :   case attr::SelectAny: {
    1472             :     const auto *SA = cast<SelectAnyAttr>(A);
    1473           0 :     Record.push_back(SA->isInherited());
    1474           0 :     Record.push_back(A->isImplicit());
    1475           0 :     Record.push_back(A->getSpellingListIndex());
    1476             :     break;
    1477             :   }
    1478             :   case attr::Sentinel: {
    1479             :     const auto *SA = cast<SentinelAttr>(A);
    1480           0 :     Record.push_back(SA->isInherited());
    1481           0 :     Record.push_back(A->isImplicit());
    1482           0 :     Record.push_back(A->getSpellingListIndex());
    1483           0 :     Record.push_back(SA->getSentinel());
    1484           0 :     Record.push_back(SA->getNullPos());
    1485             :     break;
    1486             :   }
    1487             :   case attr::SetTypestate: {
    1488             :     const auto *SA = cast<SetTypestateAttr>(A);
    1489           0 :     Record.push_back(SA->isInherited());
    1490           0 :     Record.push_back(A->isImplicit());
    1491           0 :     Record.push_back(A->getSpellingListIndex());
    1492           0 : Record.push_back(SA->getNewState());
    1493             :     break;
    1494             :   }
    1495             :   case attr::SharedTrylockFunction: {
    1496             :     const auto *SA = cast<SharedTrylockFunctionAttr>(A);
    1497           1 :     Record.push_back(SA->isInherited());
    1498           1 :     Record.push_back(A->isImplicit());
    1499           1 :     Record.push_back(A->getSpellingListIndex());
    1500           1 :     Record.AddStmt(SA->getSuccessValue());
    1501           1 :     Record.push_back(SA->args_size());
    1502           1 :     for (auto &Val : SA->args())
    1503           0 :       Record.AddStmt(Val);
    1504             :     break;
    1505             :   }
    1506             :   case attr::StdCall: {
    1507             :     const auto *SA = cast<StdCallAttr>(A);
    1508           0 :     Record.push_back(SA->isInherited());
    1509           0 :     Record.push_back(A->isImplicit());
    1510           0 :     Record.push_back(A->getSpellingListIndex());
    1511             :     break;
    1512             :   }
    1513             :   case attr::Suppress: {
    1514             :     const auto *SA = cast<SuppressAttr>(A);
    1515           0 :     Record.push_back(A->isImplicit());
    1516           0 :     Record.push_back(A->getSpellingListIndex());
    1517           0 :     Record.push_back(SA->diagnosticIdentifiers_size());
    1518           0 :     for (auto &Val : SA->diagnosticIdentifiers())
    1519           0 :       Record.AddString(Val);
    1520             :     break;
    1521             :   }
    1522             :   case attr::SwiftCall: {
    1523             :     const auto *SA = cast<SwiftCallAttr>(A);
    1524           0 :     Record.push_back(SA->isInherited());
    1525           0 :     Record.push_back(A->isImplicit());
    1526           0 :     Record.push_back(A->getSpellingListIndex());
    1527             :     break;
    1528             :   }
    1529             :   case attr::SwiftContext: {
    1530             :     const auto *SA = cast<SwiftContextAttr>(A);
    1531           0 :     Record.push_back(SA->isInherited());
    1532           0 :     Record.push_back(A->isImplicit());
    1533           0 :     Record.push_back(A->getSpellingListIndex());
    1534             :     break;
    1535             :   }
    1536             :   case attr::SwiftErrorResult: {
    1537             :     const auto *SA = cast<SwiftErrorResultAttr>(A);
    1538           0 :     Record.push_back(SA->isInherited());
    1539           0 :     Record.push_back(A->isImplicit());
    1540           0 :     Record.push_back(A->getSpellingListIndex());
    1541             :     break;
    1542             :   }
    1543             :   case attr::SwiftIndirectResult: {
    1544             :     const auto *SA = cast<SwiftIndirectResultAttr>(A);
    1545           0 :     Record.push_back(SA->isInherited());
    1546           0 :     Record.push_back(A->isImplicit());
    1547           0 :     Record.push_back(A->getSpellingListIndex());
    1548             :     break;
    1549             :   }
    1550             :   case attr::SysVABI: {
    1551             :     const auto *SA = cast<SysVABIAttr>(A);
    1552           0 :     Record.push_back(SA->isInherited());
    1553           0 :     Record.push_back(A->isImplicit());
    1554           0 :     Record.push_back(A->getSpellingListIndex());
    1555             :     break;
    1556             :   }
    1557             :   case attr::TLSModel: {
    1558             :     const auto *SA = cast<TLSModelAttr>(A);
    1559           0 :     Record.push_back(SA->isInherited());
    1560           0 :     Record.push_back(A->isImplicit());
    1561           0 :     Record.push_back(A->getSpellingListIndex());
    1562           0 :     Record.AddString(SA->getModel());
    1563             :     break;
    1564             :   }
    1565             :   case attr::Target: {
    1566             :     const auto *SA = cast<TargetAttr>(A);
    1567       15269 :     Record.push_back(SA->isInherited());
    1568       15269 :     Record.push_back(A->isImplicit());
    1569       15269 :     Record.push_back(A->getSpellingListIndex());
    1570       30538 :     Record.AddString(SA->getFeaturesStr());
    1571             :     break;
    1572             :   }
    1573             :   case attr::TestTypestate: {
    1574             :     const auto *SA = cast<TestTypestateAttr>(A);
    1575           0 :     Record.push_back(SA->isInherited());
    1576           0 :     Record.push_back(A->isImplicit());
    1577           0 :     Record.push_back(A->getSpellingListIndex());
    1578           0 : Record.push_back(SA->getTestState());
    1579             :     break;
    1580             :   }
    1581             :   case attr::ThisCall: {
    1582             :     const auto *SA = cast<ThisCallAttr>(A);
    1583           0 :     Record.push_back(SA->isInherited());
    1584           0 :     Record.push_back(A->isImplicit());
    1585           0 :     Record.push_back(A->getSpellingListIndex());
    1586             :     break;
    1587             :   }
    1588             :   case attr::Thread: {
    1589           0 :     Record.push_back(A->isImplicit());
    1590           0 :     Record.push_back(A->getSpellingListIndex());
    1591             :     break;
    1592             :   }
    1593             :   case attr::TransparentUnion: {
    1594             :     const auto *SA = cast<TransparentUnionAttr>(A);
    1595           0 :     Record.push_back(SA->isInherited());
    1596           0 :     Record.push_back(A->isImplicit());
    1597           0 :     Record.push_back(A->getSpellingListIndex());
    1598             :     break;
    1599             :   }
    1600             :   case attr::TrivialABI: {
    1601             :     const auto *SA = cast<TrivialABIAttr>(A);
    1602           0 :     Record.push_back(SA->isInherited());
    1603           0 :     Record.push_back(A->isImplicit());
    1604           0 :     Record.push_back(A->getSpellingListIndex());
    1605             :     break;
    1606             :   }
    1607             :   case attr::TryAcquireCapability: {
    1608             :     const auto *SA = cast<TryAcquireCapabilityAttr>(A);
    1609           0 :     Record.push_back(SA->isInherited());
    1610           0 :     Record.push_back(A->isImplicit());
    1611           0 :     Record.push_back(A->getSpellingListIndex());
    1612           0 :     Record.AddStmt(SA->getSuccessValue());
    1613           0 :     Record.push_back(SA->args_size());
    1614           0 :     for (auto &Val : SA->args())
    1615           0 :       Record.AddStmt(Val);
    1616             :     break;
    1617             :   }
    1618             :   case attr::TypeTagForDatatype: {
    1619             :     const auto *SA = cast<TypeTagForDatatypeAttr>(A);
    1620           0 :     Record.push_back(SA->isInherited());
    1621           0 :     Record.push_back(A->isImplicit());
    1622           0 :     Record.push_back(A->getSpellingListIndex());
    1623           0 :     Record.AddIdentifierRef(SA->getArgumentKind());
    1624           0 :     Record.AddTypeSourceInfo(SA->getMatchingCTypeLoc());
    1625           0 :     Record.push_back(SA->getLayoutCompatible());
    1626           0 :     Record.push_back(SA->getMustBeNull());
    1627             :     break;
    1628             :   }
    1629             :   case attr::TypeVisibility: {
    1630             :     const auto *SA = cast<TypeVisibilityAttr>(A);
    1631           7 :     Record.push_back(SA->isInherited());
    1632           7 :     Record.push_back(A->isImplicit());
    1633           7 :     Record.push_back(A->getSpellingListIndex());
    1634           7 : Record.push_back(SA->getVisibility());
    1635             :     break;
    1636             :   }
    1637             :   case attr::Unavailable: {
    1638             :     const auto *SA = cast<UnavailableAttr>(A);
    1639           5 :     Record.push_back(SA->isInherited());
    1640           5 :     Record.push_back(A->isImplicit());
    1641           5 :     Record.push_back(A->getSpellingListIndex());
    1642          10 :     Record.AddString(SA->getMessage());
    1643           5 : Record.push_back(SA->getImplicitReason());
    1644             :     break;
    1645             :   }
    1646             :   case attr::Unused: {
    1647             :     const auto *SA = cast<UnusedAttr>(A);
    1648           0 :     Record.push_back(SA->isInherited());
    1649           0 :     Record.push_back(A->isImplicit());
    1650           0 :     Record.push_back(A->getSpellingListIndex());
    1651             :     break;
    1652             :   }
    1653             :   case attr::Used: {
    1654             :     const auto *SA = cast<UsedAttr>(A);
    1655           0 :     Record.push_back(SA->isInherited());
    1656           0 :     Record.push_back(A->isImplicit());
    1657           0 :     Record.push_back(A->getSpellingListIndex());
    1658             :     break;
    1659             :   }
    1660             :   case attr::Uuid: {
    1661             :     const auto *SA = cast<UuidAttr>(A);
    1662           0 :     Record.push_back(SA->isInherited());
    1663           0 :     Record.push_back(A->isImplicit());
    1664           0 :     Record.push_back(A->getSpellingListIndex());
    1665           0 :     Record.AddString(SA->getGuid());
    1666             :     break;
    1667             :   }
    1668             :   case attr::VecReturn: {
    1669             :     const auto *SA = cast<VecReturnAttr>(A);
    1670           0 :     Record.push_back(SA->isInherited());
    1671           0 :     Record.push_back(A->isImplicit());
    1672           0 :     Record.push_back(A->getSpellingListIndex());
    1673             :     break;
    1674             :   }
    1675             :   case attr::VecTypeHint: {
    1676             :     const auto *SA = cast<VecTypeHintAttr>(A);
    1677           0 :     Record.push_back(SA->isInherited());
    1678           0 :     Record.push_back(A->isImplicit());
    1679           0 :     Record.push_back(A->getSpellingListIndex());
    1680           0 :     Record.AddTypeSourceInfo(SA->getTypeHintLoc());
    1681           0 :     break;
    1682             :   }
    1683             :   case attr::VectorCall: {
    1684             :     const auto *SA = cast<VectorCallAttr>(A);
    1685           0 :     Record.push_back(SA->isInherited());
    1686           0 :     Record.push_back(A->isImplicit());
    1687           0 :     Record.push_back(A->getSpellingListIndex());
    1688             :     break;
    1689             :   }
    1690             :   case attr::Visibility: {
    1691             :     const auto *SA = cast<VisibilityAttr>(A);
    1692          76 :     Record.push_back(SA->isInherited());
    1693          76 :     Record.push_back(A->isImplicit());
    1694          76 :     Record.push_back(A->getSpellingListIndex());
    1695          76 : Record.push_back(SA->getVisibility());
    1696             :     break;
    1697             :   }
    1698             :   case attr::WarnUnused: {
    1699             :     const auto *SA = cast<WarnUnusedAttr>(A);
    1700           0 :     Record.push_back(SA->isInherited());
    1701           0 :     Record.push_back(A->isImplicit());
    1702           0 :     Record.push_back(A->getSpellingListIndex());
    1703             :     break;
    1704             :   }
    1705             :   case attr::WarnUnusedResult: {
    1706             :     const auto *SA = cast<WarnUnusedResultAttr>(A);
    1707           0 :     Record.push_back(SA->isInherited());
    1708           0 :     Record.push_back(A->isImplicit());
    1709           0 :     Record.push_back(A->getSpellingListIndex());
    1710             :     break;
    1711             :   }
    1712             :   case attr::Weak: {
    1713             :     const auto *SA = cast<WeakAttr>(A);
    1714          66 :     Record.push_back(SA->isInherited());
    1715          66 :     Record.push_back(A->isImplicit());
    1716          66 :     Record.push_back(A->getSpellingListIndex());
    1717             :     break;
    1718             :   }
    1719             :   case attr::WeakImport: {
    1720             :     const auto *SA = cast<WeakImportAttr>(A);
    1721           0 :     Record.push_back(SA->isInherited());
    1722           0 :     Record.push_back(A->isImplicit());
    1723           0 :     Record.push_back(A->getSpellingListIndex());
    1724             :     break;
    1725             :   }
    1726             :   case attr::WeakRef: {
    1727             :     const auto *SA = cast<WeakRefAttr>(A);
    1728           0 :     Record.push_back(SA->isInherited());
    1729           0 :     Record.push_back(A->isImplicit());
    1730           0 :     Record.push_back(A->getSpellingListIndex());
    1731           0 :     Record.AddString(SA->getAliasee());
    1732             :     break;
    1733             :   }
    1734             :   case attr::WorkGroupSizeHint: {
    1735             :     const auto *SA = cast<WorkGroupSizeHintAttr>(A);
    1736           0 :     Record.push_back(SA->isInherited());
    1737           0 :     Record.push_back(A->isImplicit());
    1738           0 :     Record.push_back(A->getSpellingListIndex());
    1739           0 :     Record.push_back(SA->getXDim());
    1740           0 :     Record.push_back(SA->getYDim());
    1741           0 :     Record.push_back(SA->getZDim());
    1742             :     break;
    1743             :   }
    1744             :   case attr::X86ForceAlignArgPointer: {
    1745             :     const auto *SA = cast<X86ForceAlignArgPointerAttr>(A);
    1746           0 :     Record.push_back(SA->isInherited());
    1747           0 :     Record.push_back(A->isImplicit());
    1748           0 :     Record.push_back(A->getSpellingListIndex());
    1749             :     break;
    1750             :   }
    1751             :   case attr::XRayInstrument: {
    1752             :     const auto *SA = cast<XRayInstrumentAttr>(A);
    1753           0 :     Record.push_back(SA->isInherited());
    1754           0 :     Record.push_back(A->isImplicit());
    1755           0 :     Record.push_back(A->getSpellingListIndex());
    1756             :     break;
    1757             :   }
    1758             :   case attr::XRayLogArgs: {
    1759             :     const auto *SA = cast<XRayLogArgsAttr>(A);
    1760           0 :     Record.push_back(SA->isInherited());
    1761           0 :     Record.push_back(A->isImplicit());
    1762           0 :     Record.push_back(A->getSpellingListIndex());
    1763           0 :     Record.push_back(SA->getArgumentCount());
    1764             :     break;
    1765             :   }
    1766             :   }

Generated by: LCOV version 1.13