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: 378 1290 29.3 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13