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

Generated by: LCOV version 1.13