Back to home page

EIC code displayed by LXR
 
 

    

Warning, /include/clang/Serialization/AttrPCHWrite.inc is written in an unsupported language. File is not indexed. 

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Attribute serialization code                                               *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009 
0010   switch (A->getKind()) {
0011   case attr::AArch64SVEPcs: {
0012     const auto *SA = cast<AArch64SVEPcsAttr>(A);
0013     Record.push_back(SA->isInherited());
0014     Record.push_back(A->isImplicit());
0015     Record.push_back(A->isPackExpansion());
0016     break;
0017   }
0018   case attr::AArch64VectorPcs: {
0019     const auto *SA = cast<AArch64VectorPcsAttr>(A);
0020     Record.push_back(SA->isInherited());
0021     Record.push_back(A->isImplicit());
0022     Record.push_back(A->isPackExpansion());
0023     break;
0024   }
0025   case attr::AMDGPUFlatWorkGroupSize: {
0026     const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A);
0027     Record.push_back(SA->isInherited());
0028     Record.push_back(A->isImplicit());
0029     Record.push_back(A->isPackExpansion());
0030     Record.AddStmt(SA->getMin());
0031     Record.AddStmt(SA->getMax());
0032     break;
0033   }
0034   case attr::AMDGPUKernelCall: {
0035     const auto *SA = cast<AMDGPUKernelCallAttr>(A);
0036     Record.push_back(SA->isInherited());
0037     Record.push_back(A->isImplicit());
0038     Record.push_back(A->isPackExpansion());
0039     break;
0040   }
0041   case attr::AMDGPUMaxNumWorkGroups: {
0042     const auto *SA = cast<AMDGPUMaxNumWorkGroupsAttr>(A);
0043     Record.push_back(SA->isInherited());
0044     Record.push_back(A->isImplicit());
0045     Record.push_back(A->isPackExpansion());
0046     Record.AddStmt(SA->getMaxNumWorkGroupsX());
0047     Record.AddStmt(SA->getMaxNumWorkGroupsY());
0048     Record.AddStmt(SA->getMaxNumWorkGroupsZ());
0049     break;
0050   }
0051   case attr::AMDGPUNumSGPR: {
0052     const auto *SA = cast<AMDGPUNumSGPRAttr>(A);
0053     Record.push_back(SA->isInherited());
0054     Record.push_back(A->isImplicit());
0055     Record.push_back(A->isPackExpansion());
0056     Record.push_back(SA->getNumSGPR());
0057     break;
0058   }
0059   case attr::AMDGPUNumVGPR: {
0060     const auto *SA = cast<AMDGPUNumVGPRAttr>(A);
0061     Record.push_back(SA->isInherited());
0062     Record.push_back(A->isImplicit());
0063     Record.push_back(A->isPackExpansion());
0064     Record.push_back(SA->getNumVGPR());
0065     break;
0066   }
0067   case attr::AMDGPUWavesPerEU: {
0068     const auto *SA = cast<AMDGPUWavesPerEUAttr>(A);
0069     Record.push_back(SA->isInherited());
0070     Record.push_back(A->isImplicit());
0071     Record.push_back(A->isPackExpansion());
0072     Record.AddStmt(SA->getMin());
0073     Record.AddStmt(SA->getMax());
0074     break;
0075   }
0076   case attr::ARMInterrupt: {
0077     const auto *SA = cast<ARMInterruptAttr>(A);
0078     Record.push_back(SA->isInherited());
0079     Record.push_back(A->isImplicit());
0080     Record.push_back(A->isPackExpansion());
0081 Record.push_back(static_cast<uint64_t>(SA->getInterrupt()));
0082     break;
0083   }
0084   case attr::AVRInterrupt: {
0085     const auto *SA = cast<AVRInterruptAttr>(A);
0086     Record.push_back(SA->isInherited());
0087     Record.push_back(A->isImplicit());
0088     Record.push_back(A->isPackExpansion());
0089     break;
0090   }
0091   case attr::AVRSignal: {
0092     const auto *SA = cast<AVRSignalAttr>(A);
0093     Record.push_back(SA->isInherited());
0094     Record.push_back(A->isImplicit());
0095     Record.push_back(A->isPackExpansion());
0096     break;
0097   }
0098   case attr::AbiTag: {
0099     const auto *SA = cast<AbiTagAttr>(A);
0100     Record.push_back(A->isImplicit());
0101     Record.push_back(A->isPackExpansion());
0102     Record.push_back(SA->tags_size());
0103     for (auto &Val : SA->tags())
0104       Record.AddString(Val);
0105     break;
0106   }
0107   case attr::AcquireCapability: {
0108     const auto *SA = cast<AcquireCapabilityAttr>(A);
0109     Record.push_back(SA->isInherited());
0110     Record.push_back(A->isImplicit());
0111     Record.push_back(A->isPackExpansion());
0112     Record.push_back(SA->args_size());
0113     for (auto &Val : SA->args())
0114       Record.AddStmt(Val);
0115     break;
0116   }
0117   case attr::AcquireHandle: {
0118     const auto *SA = cast<AcquireHandleAttr>(A);
0119     Record.push_back(SA->isInherited());
0120     Record.push_back(A->isImplicit());
0121     Record.push_back(A->isPackExpansion());
0122     Record.AddString(SA->getHandleType());
0123     break;
0124   }
0125   case attr::AcquiredAfter: {
0126     const auto *SA = cast<AcquiredAfterAttr>(A);
0127     Record.push_back(SA->isInherited());
0128     Record.push_back(A->isImplicit());
0129     Record.push_back(A->isPackExpansion());
0130     Record.push_back(SA->args_size());
0131     for (auto &Val : SA->args())
0132       Record.AddStmt(Val);
0133     break;
0134   }
0135   case attr::AcquiredBefore: {
0136     const auto *SA = cast<AcquiredBeforeAttr>(A);
0137     Record.push_back(SA->isInherited());
0138     Record.push_back(A->isImplicit());
0139     Record.push_back(A->isPackExpansion());
0140     Record.push_back(SA->args_size());
0141     for (auto &Val : SA->args())
0142       Record.AddStmt(Val);
0143     break;
0144   }
0145   case attr::AddressSpace: {
0146     const auto *SA = cast<AddressSpaceAttr>(A);
0147     Record.push_back(A->isImplicit());
0148     Record.push_back(A->isPackExpansion());
0149     Record.push_back(SA->getAddressSpace());
0150     break;
0151   }
0152   case attr::Alias: {
0153     const auto *SA = cast<AliasAttr>(A);
0154     Record.push_back(A->isImplicit());
0155     Record.push_back(A->isPackExpansion());
0156     Record.AddString(SA->getAliasee());
0157     break;
0158   }
0159   case attr::AlignMac68k: {
0160     const auto *SA = cast<AlignMac68kAttr>(A);
0161     Record.push_back(SA->isInherited());
0162     Record.push_back(A->isImplicit());
0163     Record.push_back(A->isPackExpansion());
0164     break;
0165   }
0166   case attr::AlignNatural: {
0167     const auto *SA = cast<AlignNaturalAttr>(A);
0168     Record.push_back(SA->isInherited());
0169     Record.push_back(A->isImplicit());
0170     Record.push_back(A->isPackExpansion());
0171     break;
0172   }
0173   case attr::AlignValue: {
0174     const auto *SA = cast<AlignValueAttr>(A);
0175     Record.push_back(A->isImplicit());
0176     Record.push_back(A->isPackExpansion());
0177     Record.AddStmt(SA->getAlignment());
0178     break;
0179   }
0180   case attr::Aligned: {
0181     const auto *SA = cast<AlignedAttr>(A);
0182     Record.push_back(SA->isInherited());
0183     Record.push_back(A->isImplicit());
0184     Record.push_back(A->isPackExpansion());
0185     Record.push_back(SA->isAlignmentExpr());
0186     if (SA->isAlignmentExpr())
0187       Record.AddStmt(SA->getAlignmentExpr());
0188     else
0189       Record.AddTypeSourceInfo(SA->getAlignmentType());
0190     break;
0191   }
0192   case attr::AllocAlign: {
0193     const auto *SA = cast<AllocAlignAttr>(A);
0194     Record.push_back(SA->isInherited());
0195     Record.push_back(A->isImplicit());
0196     Record.push_back(A->isPackExpansion());
0197     Record.push_back(SA->getParamIndex().serialize());
0198     break;
0199   }
0200   case attr::AllocSize: {
0201     const auto *SA = cast<AllocSizeAttr>(A);
0202     Record.push_back(SA->isInherited());
0203     Record.push_back(A->isImplicit());
0204     Record.push_back(A->isPackExpansion());
0205     Record.push_back(SA->getElemSizeParam().serialize());
0206     Record.push_back(SA->getNumElemsParam().serialize());
0207     break;
0208   }
0209   case attr::Allocating: {
0210     Record.push_back(A->isImplicit());
0211     Record.push_back(A->isPackExpansion());
0212     break;
0213   }
0214   case attr::AlwaysDestroy: {
0215     const auto *SA = cast<AlwaysDestroyAttr>(A);
0216     Record.push_back(SA->isInherited());
0217     Record.push_back(A->isImplicit());
0218     Record.push_back(A->isPackExpansion());
0219     break;
0220   }
0221   case attr::AlwaysInline: {
0222     const auto *SA = cast<AlwaysInlineAttr>(A);
0223     Record.push_back(SA->isInherited());
0224     Record.push_back(A->isImplicit());
0225     Record.push_back(A->isPackExpansion());
0226     break;
0227   }
0228   case attr::AnalyzerNoReturn: {
0229     const auto *SA = cast<AnalyzerNoReturnAttr>(A);
0230     Record.push_back(SA->isInherited());
0231     Record.push_back(A->isImplicit());
0232     Record.push_back(A->isPackExpansion());
0233     break;
0234   }
0235   case attr::Annotate: {
0236     const auto *SA = cast<AnnotateAttr>(A);
0237     Record.push_back(SA->isInherited());
0238     Record.push_back(A->isImplicit());
0239     Record.push_back(A->isPackExpansion());
0240     Record.push_back(SA->delayedArgs_size());
0241     for (auto &Val : SA->delayedArgs())
0242       Record.AddStmt(Val);
0243     Record.AddString(SA->getAnnotation());
0244     Record.push_back(SA->args_size());
0245     for (auto &Val : SA->args())
0246       Record.AddStmt(Val);
0247     break;
0248   }
0249   case attr::AnnotateType: {
0250     const auto *SA = cast<AnnotateTypeAttr>(A);
0251     Record.push_back(A->isImplicit());
0252     Record.push_back(A->isPackExpansion());
0253     Record.push_back(SA->delayedArgs_size());
0254     for (auto &Val : SA->delayedArgs())
0255       Record.AddStmt(Val);
0256     Record.AddString(SA->getAnnotation());
0257     Record.push_back(SA->args_size());
0258     for (auto &Val : SA->args())
0259       Record.AddStmt(Val);
0260     break;
0261   }
0262   case attr::AnyX86Interrupt: {
0263     const auto *SA = cast<AnyX86InterruptAttr>(A);
0264     Record.push_back(SA->isInherited());
0265     Record.push_back(A->isImplicit());
0266     Record.push_back(A->isPackExpansion());
0267     break;
0268   }
0269   case attr::AnyX86NoCallerSavedRegisters: {
0270     const auto *SA = cast<AnyX86NoCallerSavedRegistersAttr>(A);
0271     Record.push_back(SA->isInherited());
0272     Record.push_back(A->isImplicit());
0273     Record.push_back(A->isPackExpansion());
0274     break;
0275   }
0276   case attr::AnyX86NoCfCheck: {
0277     const auto *SA = cast<AnyX86NoCfCheckAttr>(A);
0278     Record.push_back(SA->isInherited());
0279     Record.push_back(A->isImplicit());
0280     Record.push_back(A->isPackExpansion());
0281     break;
0282   }
0283   case attr::ArcWeakrefUnavailable: {
0284     const auto *SA = cast<ArcWeakrefUnavailableAttr>(A);
0285     Record.push_back(SA->isInherited());
0286     Record.push_back(A->isImplicit());
0287     Record.push_back(A->isPackExpansion());
0288     break;
0289   }
0290   case attr::ArgumentWithTypeTag: {
0291     const auto *SA = cast<ArgumentWithTypeTagAttr>(A);
0292     Record.push_back(SA->isInherited());
0293     Record.push_back(A->isImplicit());
0294     Record.push_back(A->isPackExpansion());
0295     Record.AddIdentifierRef(SA->getArgumentKind());
0296     Record.push_back(SA->getArgumentIdx().serialize());
0297     Record.push_back(SA->getTypeTagIdx().serialize());
0298     Record.push_back(SA->getIsPointer());
0299     break;
0300   }
0301   case attr::ArmAgnostic: {
0302     const auto *SA = cast<ArmAgnosticAttr>(A);
0303     Record.push_back(A->isImplicit());
0304     Record.push_back(A->isPackExpansion());
0305     Record.push_back(SA->agnosticArgs_size());
0306     for (auto &Val : SA->agnosticArgs())
0307       Record.AddString(Val);
0308     break;
0309   }
0310   case attr::ArmBuiltinAlias: {
0311     const auto *SA = cast<ArmBuiltinAliasAttr>(A);
0312     Record.push_back(SA->isInherited());
0313     Record.push_back(A->isImplicit());
0314     Record.push_back(A->isPackExpansion());
0315     Record.AddIdentifierRef(SA->getBuiltinName());
0316     break;
0317   }
0318   case attr::ArmIn: {
0319     const auto *SA = cast<ArmInAttr>(A);
0320     Record.push_back(A->isImplicit());
0321     Record.push_back(A->isPackExpansion());
0322     Record.push_back(SA->inArgs_size());
0323     for (auto &Val : SA->inArgs())
0324       Record.AddString(Val);
0325     break;
0326   }
0327   case attr::ArmInOut: {
0328     const auto *SA = cast<ArmInOutAttr>(A);
0329     Record.push_back(A->isImplicit());
0330     Record.push_back(A->isPackExpansion());
0331     Record.push_back(SA->inOutArgs_size());
0332     for (auto &Val : SA->inOutArgs())
0333       Record.AddString(Val);
0334     break;
0335   }
0336   case attr::ArmLocallyStreaming: {
0337     const auto *SA = cast<ArmLocallyStreamingAttr>(A);
0338     Record.push_back(SA->isInherited());
0339     Record.push_back(A->isImplicit());
0340     Record.push_back(A->isPackExpansion());
0341     break;
0342   }
0343   case attr::ArmMveStrictPolymorphism: {
0344     Record.push_back(A->isImplicit());
0345     Record.push_back(A->isPackExpansion());
0346     break;
0347   }
0348   case attr::ArmNew: {
0349     const auto *SA = cast<ArmNewAttr>(A);
0350     Record.push_back(SA->isInherited());
0351     Record.push_back(A->isImplicit());
0352     Record.push_back(A->isPackExpansion());
0353     Record.push_back(SA->newArgs_size());
0354     for (auto &Val : SA->newArgs())
0355       Record.AddString(Val);
0356     break;
0357   }
0358   case attr::ArmOut: {
0359     const auto *SA = cast<ArmOutAttr>(A);
0360     Record.push_back(A->isImplicit());
0361     Record.push_back(A->isPackExpansion());
0362     Record.push_back(SA->outArgs_size());
0363     for (auto &Val : SA->outArgs())
0364       Record.AddString(Val);
0365     break;
0366   }
0367   case attr::ArmPreserves: {
0368     const auto *SA = cast<ArmPreservesAttr>(A);
0369     Record.push_back(A->isImplicit());
0370     Record.push_back(A->isPackExpansion());
0371     Record.push_back(SA->preserveArgs_size());
0372     for (auto &Val : SA->preserveArgs())
0373       Record.AddString(Val);
0374     break;
0375   }
0376   case attr::ArmStreaming: {
0377     Record.push_back(A->isImplicit());
0378     Record.push_back(A->isPackExpansion());
0379     break;
0380   }
0381   case attr::ArmStreamingCompatible: {
0382     Record.push_back(A->isImplicit());
0383     Record.push_back(A->isPackExpansion());
0384     break;
0385   }
0386   case attr::Artificial: {
0387     const auto *SA = cast<ArtificialAttr>(A);
0388     Record.push_back(SA->isInherited());
0389     Record.push_back(A->isImplicit());
0390     Record.push_back(A->isPackExpansion());
0391     break;
0392   }
0393   case attr::AsmLabel: {
0394     const auto *SA = cast<AsmLabelAttr>(A);
0395     Record.push_back(SA->isInherited());
0396     Record.push_back(A->isImplicit());
0397     Record.push_back(A->isPackExpansion());
0398     Record.AddString(SA->getLabel());
0399     Record.push_back(SA->getIsLiteralLabel());
0400     break;
0401   }
0402   case attr::AssertCapability: {
0403     const auto *SA = cast<AssertCapabilityAttr>(A);
0404     Record.push_back(SA->isInherited());
0405     Record.push_back(A->isImplicit());
0406     Record.push_back(A->isPackExpansion());
0407     Record.push_back(SA->args_size());
0408     for (auto &Val : SA->args())
0409       Record.AddStmt(Val);
0410     break;
0411   }
0412   case attr::AssertExclusiveLock: {
0413     const auto *SA = cast<AssertExclusiveLockAttr>(A);
0414     Record.push_back(SA->isInherited());
0415     Record.push_back(A->isImplicit());
0416     Record.push_back(A->isPackExpansion());
0417     Record.push_back(SA->args_size());
0418     for (auto &Val : SA->args())
0419       Record.AddStmt(Val);
0420     break;
0421   }
0422   case attr::AssertSharedLock: {
0423     const auto *SA = cast<AssertSharedLockAttr>(A);
0424     Record.push_back(SA->isInherited());
0425     Record.push_back(A->isImplicit());
0426     Record.push_back(A->isPackExpansion());
0427     Record.push_back(SA->args_size());
0428     for (auto &Val : SA->args())
0429       Record.AddStmt(Val);
0430     break;
0431   }
0432   case attr::AssumeAligned: {
0433     const auto *SA = cast<AssumeAlignedAttr>(A);
0434     Record.push_back(SA->isInherited());
0435     Record.push_back(A->isImplicit());
0436     Record.push_back(A->isPackExpansion());
0437     Record.AddStmt(SA->getAlignment());
0438     Record.AddStmt(SA->getOffset());
0439     break;
0440   }
0441   case attr::Availability: {
0442     const auto *SA = cast<AvailabilityAttr>(A);
0443     Record.push_back(SA->isInherited());
0444     Record.push_back(A->isImplicit());
0445     Record.push_back(A->isPackExpansion());
0446     Record.AddIdentifierRef(SA->getPlatform());
0447     Record.AddVersionTuple(SA->getIntroduced());
0448     Record.AddVersionTuple(SA->getDeprecated());
0449     Record.AddVersionTuple(SA->getObsoleted());
0450     Record.push_back(SA->getUnavailable());
0451     Record.AddString(SA->getMessage());
0452     Record.push_back(SA->getStrict());
0453     Record.AddString(SA->getReplacement());
0454     Record.push_back(SA->getPriority());
0455     Record.AddIdentifierRef(SA->getEnvironment());
0456     break;
0457   }
0458   case attr::AvailableOnlyInDefaultEvalMethod: {
0459     const auto *SA = cast<AvailableOnlyInDefaultEvalMethodAttr>(A);
0460     Record.push_back(SA->isInherited());
0461     Record.push_back(A->isImplicit());
0462     Record.push_back(A->isPackExpansion());
0463     break;
0464   }
0465   case attr::BPFFastCall: {
0466     const auto *SA = cast<BPFFastCallAttr>(A);
0467     Record.push_back(SA->isInherited());
0468     Record.push_back(A->isImplicit());
0469     Record.push_back(A->isPackExpansion());
0470     break;
0471   }
0472   case attr::BPFPreserveAccessIndex: {
0473     const auto *SA = cast<BPFPreserveAccessIndexAttr>(A);
0474     Record.push_back(SA->isInherited());
0475     Record.push_back(A->isImplicit());
0476     Record.push_back(A->isPackExpansion());
0477     break;
0478   }
0479   case attr::BPFPreserveStaticOffset: {
0480     const auto *SA = cast<BPFPreserveStaticOffsetAttr>(A);
0481     Record.push_back(SA->isInherited());
0482     Record.push_back(A->isImplicit());
0483     Record.push_back(A->isPackExpansion());
0484     break;
0485   }
0486   case attr::BTFDeclTag: {
0487     const auto *SA = cast<BTFDeclTagAttr>(A);
0488     Record.push_back(SA->isInherited());
0489     Record.push_back(A->isImplicit());
0490     Record.push_back(A->isPackExpansion());
0491     Record.AddString(SA->getBTFDeclTag());
0492     break;
0493   }
0494   case attr::BTFTypeTag: {
0495     const auto *SA = cast<BTFTypeTagAttr>(A);
0496     Record.push_back(A->isImplicit());
0497     Record.push_back(A->isPackExpansion());
0498     Record.AddString(SA->getBTFTypeTag());
0499     break;
0500   }
0501   case attr::Blocking: {
0502     Record.push_back(A->isImplicit());
0503     Record.push_back(A->isPackExpansion());
0504     break;
0505   }
0506   case attr::Blocks: {
0507     const auto *SA = cast<BlocksAttr>(A);
0508     Record.push_back(SA->isInherited());
0509     Record.push_back(A->isImplicit());
0510     Record.push_back(A->isPackExpansion());
0511 Record.push_back(static_cast<uint64_t>(SA->getType()));
0512     break;
0513   }
0514   case attr::Builtin: {
0515     const auto *SA = cast<BuiltinAttr>(A);
0516     Record.push_back(SA->isInherited());
0517     Record.push_back(A->isImplicit());
0518     Record.push_back(A->isPackExpansion());
0519     Record.push_back(SA->getID());
0520     break;
0521   }
0522   case attr::BuiltinAlias: {
0523     const auto *SA = cast<BuiltinAliasAttr>(A);
0524     Record.push_back(A->isImplicit());
0525     Record.push_back(A->isPackExpansion());
0526     Record.AddIdentifierRef(SA->getBuiltinName());
0527     break;
0528   }
0529   case attr::C11NoReturn: {
0530     const auto *SA = cast<C11NoReturnAttr>(A);
0531     Record.push_back(SA->isInherited());
0532     Record.push_back(A->isImplicit());
0533     Record.push_back(A->isPackExpansion());
0534     break;
0535   }
0536   case attr::CDecl: {
0537     const auto *SA = cast<CDeclAttr>(A);
0538     Record.push_back(SA->isInherited());
0539     Record.push_back(A->isImplicit());
0540     Record.push_back(A->isPackExpansion());
0541     break;
0542   }
0543   case attr::CFAuditedTransfer: {
0544     const auto *SA = cast<CFAuditedTransferAttr>(A);
0545     Record.push_back(SA->isInherited());
0546     Record.push_back(A->isImplicit());
0547     Record.push_back(A->isPackExpansion());
0548     break;
0549   }
0550   case attr::CFConsumed: {
0551     const auto *SA = cast<CFConsumedAttr>(A);
0552     Record.push_back(SA->isInherited());
0553     Record.push_back(A->isImplicit());
0554     Record.push_back(A->isPackExpansion());
0555     break;
0556   }
0557   case attr::CFGuard: {
0558     const auto *SA = cast<CFGuardAttr>(A);
0559     Record.push_back(SA->isInherited());
0560     Record.push_back(A->isImplicit());
0561     Record.push_back(A->isPackExpansion());
0562 Record.push_back(static_cast<uint64_t>(SA->getGuard()));
0563     break;
0564   }
0565   case attr::CFICanonicalJumpTable: {
0566     const auto *SA = cast<CFICanonicalJumpTableAttr>(A);
0567     Record.push_back(SA->isInherited());
0568     Record.push_back(A->isImplicit());
0569     Record.push_back(A->isPackExpansion());
0570     break;
0571   }
0572   case attr::CFReturnsNotRetained: {
0573     const auto *SA = cast<CFReturnsNotRetainedAttr>(A);
0574     Record.push_back(SA->isInherited());
0575     Record.push_back(A->isImplicit());
0576     Record.push_back(A->isPackExpansion());
0577     break;
0578   }
0579   case attr::CFReturnsRetained: {
0580     const auto *SA = cast<CFReturnsRetainedAttr>(A);
0581     Record.push_back(SA->isInherited());
0582     Record.push_back(A->isImplicit());
0583     Record.push_back(A->isPackExpansion());
0584     break;
0585   }
0586   case attr::CFUnknownTransfer: {
0587     const auto *SA = cast<CFUnknownTransferAttr>(A);
0588     Record.push_back(SA->isInherited());
0589     Record.push_back(A->isImplicit());
0590     Record.push_back(A->isPackExpansion());
0591     break;
0592   }
0593   case attr::CPUDispatch: {
0594     const auto *SA = cast<CPUDispatchAttr>(A);
0595     Record.push_back(SA->isInherited());
0596     Record.push_back(A->isImplicit());
0597     Record.push_back(A->isPackExpansion());
0598     Record.push_back(SA->cpus_size());
0599     for (auto &Val : SA->cpus())
0600       Record.AddIdentifierRef(Val);
0601     break;
0602   }
0603   case attr::CPUSpecific: {
0604     const auto *SA = cast<CPUSpecificAttr>(A);
0605     Record.push_back(SA->isInherited());
0606     Record.push_back(A->isImplicit());
0607     Record.push_back(A->isPackExpansion());
0608     Record.push_back(SA->cpus_size());
0609     for (auto &Val : SA->cpus())
0610       Record.AddIdentifierRef(Val);
0611     break;
0612   }
0613   case attr::CUDAConstant: {
0614     const auto *SA = cast<CUDAConstantAttr>(A);
0615     Record.push_back(SA->isInherited());
0616     Record.push_back(A->isImplicit());
0617     Record.push_back(A->isPackExpansion());
0618     break;
0619   }
0620   case attr::CUDADevice: {
0621     const auto *SA = cast<CUDADeviceAttr>(A);
0622     Record.push_back(SA->isInherited());
0623     Record.push_back(A->isImplicit());
0624     Record.push_back(A->isPackExpansion());
0625     break;
0626   }
0627   case attr::CUDADeviceBuiltinSurfaceType: {
0628     const auto *SA = cast<CUDADeviceBuiltinSurfaceTypeAttr>(A);
0629     Record.push_back(SA->isInherited());
0630     Record.push_back(A->isImplicit());
0631     Record.push_back(A->isPackExpansion());
0632     break;
0633   }
0634   case attr::CUDADeviceBuiltinTextureType: {
0635     const auto *SA = cast<CUDADeviceBuiltinTextureTypeAttr>(A);
0636     Record.push_back(SA->isInherited());
0637     Record.push_back(A->isImplicit());
0638     Record.push_back(A->isPackExpansion());
0639     break;
0640   }
0641   case attr::CUDAGlobal: {
0642     const auto *SA = cast<CUDAGlobalAttr>(A);
0643     Record.push_back(SA->isInherited());
0644     Record.push_back(A->isImplicit());
0645     Record.push_back(A->isPackExpansion());
0646     break;
0647   }
0648   case attr::CUDAGridConstant: {
0649     const auto *SA = cast<CUDAGridConstantAttr>(A);
0650     Record.push_back(SA->isInherited());
0651     Record.push_back(A->isImplicit());
0652     Record.push_back(A->isPackExpansion());
0653     break;
0654   }
0655   case attr::CUDAHost: {
0656     const auto *SA = cast<CUDAHostAttr>(A);
0657     Record.push_back(SA->isInherited());
0658     Record.push_back(A->isImplicit());
0659     Record.push_back(A->isPackExpansion());
0660     break;
0661   }
0662   case attr::CUDAInvalidTarget: {
0663     const auto *SA = cast<CUDAInvalidTargetAttr>(A);
0664     Record.push_back(SA->isInherited());
0665     Record.push_back(A->isImplicit());
0666     Record.push_back(A->isPackExpansion());
0667     break;
0668   }
0669   case attr::CUDALaunchBounds: {
0670     const auto *SA = cast<CUDALaunchBoundsAttr>(A);
0671     Record.push_back(SA->isInherited());
0672     Record.push_back(A->isImplicit());
0673     Record.push_back(A->isPackExpansion());
0674     Record.AddStmt(SA->getMaxThreads());
0675     Record.AddStmt(SA->getMinBlocks());
0676     Record.AddStmt(SA->getMaxBlocks());
0677     break;
0678   }
0679   case attr::CUDAShared: {
0680     const auto *SA = cast<CUDASharedAttr>(A);
0681     Record.push_back(SA->isInherited());
0682     Record.push_back(A->isImplicit());
0683     Record.push_back(A->isPackExpansion());
0684     break;
0685   }
0686   case attr::CXX11NoReturn: {
0687     const auto *SA = cast<CXX11NoReturnAttr>(A);
0688     Record.push_back(SA->isInherited());
0689     Record.push_back(A->isImplicit());
0690     Record.push_back(A->isPackExpansion());
0691     break;
0692   }
0693   case attr::CXXAssume: {
0694     const auto *SA = cast<CXXAssumeAttr>(A);
0695     Record.push_back(A->isImplicit());
0696     Record.push_back(A->isPackExpansion());
0697     Record.AddStmt(SA->getAssumption());
0698     break;
0699   }
0700   case attr::CallableWhen: {
0701     const auto *SA = cast<CallableWhenAttr>(A);
0702     Record.push_back(SA->isInherited());
0703     Record.push_back(A->isImplicit());
0704     Record.push_back(A->isPackExpansion());
0705     Record.push_back(SA->callableStates_size());
0706     for (CallableWhenAttr::callableStates_iterator i = SA->callableStates_begin(), e = SA->callableStates_end(); i != e; ++i)
0707       Record.push_back((*i));
0708     break;
0709   }
0710   case attr::Callback: {
0711     const auto *SA = cast<CallbackAttr>(A);
0712     Record.push_back(SA->isInherited());
0713     Record.push_back(A->isImplicit());
0714     Record.push_back(A->isPackExpansion());
0715     Record.push_back(SA->encoding_size());
0716     for (auto &Val : SA->encoding())
0717       Record.push_back(Val);
0718     break;
0719   }
0720   case attr::CalledOnce: {
0721     Record.push_back(A->isImplicit());
0722     Record.push_back(A->isPackExpansion());
0723     break;
0724   }
0725   case attr::Capability: {
0726     const auto *SA = cast<CapabilityAttr>(A);
0727     Record.push_back(SA->isInherited());
0728     Record.push_back(A->isImplicit());
0729     Record.push_back(A->isPackExpansion());
0730     Record.AddString(SA->getName());
0731     break;
0732   }
0733   case attr::CapturedRecord: {
0734     const auto *SA = cast<CapturedRecordAttr>(A);
0735     Record.push_back(SA->isInherited());
0736     Record.push_back(A->isImplicit());
0737     Record.push_back(A->isPackExpansion());
0738     break;
0739   }
0740   case attr::CarriesDependency: {
0741     const auto *SA = cast<CarriesDependencyAttr>(A);
0742     Record.push_back(SA->isInherited());
0743     Record.push_back(A->isImplicit());
0744     Record.push_back(A->isPackExpansion());
0745     break;
0746   }
0747   case attr::Cleanup: {
0748     const auto *SA = cast<CleanupAttr>(A);
0749     Record.push_back(SA->isInherited());
0750     Record.push_back(A->isImplicit());
0751     Record.push_back(A->isPackExpansion());
0752     Record.AddDeclRef(SA->getFunctionDecl());
0753     break;
0754   }
0755   case attr::ClspvLibclcBuiltin: {
0756     const auto *SA = cast<ClspvLibclcBuiltinAttr>(A);
0757     Record.push_back(SA->isInherited());
0758     Record.push_back(A->isImplicit());
0759     Record.push_back(A->isPackExpansion());
0760     break;
0761   }
0762   case attr::CmseNSCall: {
0763     Record.push_back(A->isImplicit());
0764     Record.push_back(A->isPackExpansion());
0765     break;
0766   }
0767   case attr::CmseNSEntry: {
0768     const auto *SA = cast<CmseNSEntryAttr>(A);
0769     Record.push_back(SA->isInherited());
0770     Record.push_back(A->isImplicit());
0771     Record.push_back(A->isPackExpansion());
0772     break;
0773   }
0774   case attr::CodeAlign: {
0775     const auto *SA = cast<CodeAlignAttr>(A);
0776     Record.push_back(A->isImplicit());
0777     Record.push_back(A->isPackExpansion());
0778     Record.AddStmt(SA->getAlignment());
0779     break;
0780   }
0781   case attr::CodeModel: {
0782     const auto *SA = cast<CodeModelAttr>(A);
0783     Record.push_back(SA->isInherited());
0784     Record.push_back(A->isImplicit());
0785     Record.push_back(A->isPackExpansion());
0786 Record.push_back(static_cast<uint64_t>(SA->getModel()));
0787     break;
0788   }
0789   case attr::CodeSeg: {
0790     const auto *SA = cast<CodeSegAttr>(A);
0791     Record.push_back(SA->isInherited());
0792     Record.push_back(A->isImplicit());
0793     Record.push_back(A->isPackExpansion());
0794     Record.AddString(SA->getName());
0795     break;
0796   }
0797   case attr::Cold: {
0798     const auto *SA = cast<ColdAttr>(A);
0799     Record.push_back(SA->isInherited());
0800     Record.push_back(A->isImplicit());
0801     Record.push_back(A->isPackExpansion());
0802     break;
0803   }
0804   case attr::Common: {
0805     const auto *SA = cast<CommonAttr>(A);
0806     Record.push_back(SA->isInherited());
0807     Record.push_back(A->isImplicit());
0808     Record.push_back(A->isPackExpansion());
0809     break;
0810   }
0811   case attr::Const: {
0812     const auto *SA = cast<ConstAttr>(A);
0813     Record.push_back(SA->isInherited());
0814     Record.push_back(A->isImplicit());
0815     Record.push_back(A->isPackExpansion());
0816     break;
0817   }
0818   case attr::ConstInit: {
0819     const auto *SA = cast<ConstInitAttr>(A);
0820     Record.push_back(SA->isInherited());
0821     Record.push_back(A->isImplicit());
0822     Record.push_back(A->isPackExpansion());
0823     break;
0824   }
0825   case attr::Constructor: {
0826     const auto *SA = cast<ConstructorAttr>(A);
0827     Record.push_back(SA->isInherited());
0828     Record.push_back(A->isImplicit());
0829     Record.push_back(A->isPackExpansion());
0830     Record.push_back(SA->getPriority());
0831     break;
0832   }
0833   case attr::Consumable: {
0834     const auto *SA = cast<ConsumableAttr>(A);
0835     Record.push_back(SA->isInherited());
0836     Record.push_back(A->isImplicit());
0837     Record.push_back(A->isPackExpansion());
0838 Record.push_back(static_cast<uint64_t>(SA->getDefaultState()));
0839     break;
0840   }
0841   case attr::ConsumableAutoCast: {
0842     const auto *SA = cast<ConsumableAutoCastAttr>(A);
0843     Record.push_back(SA->isInherited());
0844     Record.push_back(A->isImplicit());
0845     Record.push_back(A->isPackExpansion());
0846     break;
0847   }
0848   case attr::ConsumableSetOnRead: {
0849     const auto *SA = cast<ConsumableSetOnReadAttr>(A);
0850     Record.push_back(SA->isInherited());
0851     Record.push_back(A->isImplicit());
0852     Record.push_back(A->isPackExpansion());
0853     break;
0854   }
0855   case attr::Convergent: {
0856     const auto *SA = cast<ConvergentAttr>(A);
0857     Record.push_back(SA->isInherited());
0858     Record.push_back(A->isImplicit());
0859     Record.push_back(A->isPackExpansion());
0860     break;
0861   }
0862   case attr::CoroAwaitElidable: {
0863     const auto *SA = cast<CoroAwaitElidableAttr>(A);
0864     Record.push_back(SA->isInherited());
0865     Record.push_back(A->isImplicit());
0866     Record.push_back(A->isPackExpansion());
0867     break;
0868   }
0869   case attr::CoroAwaitElidableArgument: {
0870     const auto *SA = cast<CoroAwaitElidableArgumentAttr>(A);
0871     Record.push_back(SA->isInherited());
0872     Record.push_back(A->isImplicit());
0873     Record.push_back(A->isPackExpansion());
0874     break;
0875   }
0876   case attr::CoroDisableLifetimeBound: {
0877     const auto *SA = cast<CoroDisableLifetimeBoundAttr>(A);
0878     Record.push_back(SA->isInherited());
0879     Record.push_back(A->isImplicit());
0880     Record.push_back(A->isPackExpansion());
0881     break;
0882   }
0883   case attr::CoroLifetimeBound: {
0884     const auto *SA = cast<CoroLifetimeBoundAttr>(A);
0885     Record.push_back(SA->isInherited());
0886     Record.push_back(A->isImplicit());
0887     Record.push_back(A->isPackExpansion());
0888     break;
0889   }
0890   case attr::CoroOnlyDestroyWhenComplete: {
0891     const auto *SA = cast<CoroOnlyDestroyWhenCompleteAttr>(A);
0892     Record.push_back(SA->isInherited());
0893     Record.push_back(A->isImplicit());
0894     Record.push_back(A->isPackExpansion());
0895     break;
0896   }
0897   case attr::CoroReturnType: {
0898     const auto *SA = cast<CoroReturnTypeAttr>(A);
0899     Record.push_back(SA->isInherited());
0900     Record.push_back(A->isImplicit());
0901     Record.push_back(A->isPackExpansion());
0902     break;
0903   }
0904   case attr::CoroWrapper: {
0905     const auto *SA = cast<CoroWrapperAttr>(A);
0906     Record.push_back(SA->isInherited());
0907     Record.push_back(A->isImplicit());
0908     Record.push_back(A->isPackExpansion());
0909     break;
0910   }
0911   case attr::CountedBy: {
0912     const auto *SA = cast<CountedByAttr>(A);
0913     Record.push_back(SA->isInherited());
0914     Record.push_back(A->isImplicit());
0915     Record.push_back(A->isPackExpansion());
0916     Record.AddStmt(SA->getCount());
0917     Record.push_back(SA->getNestedLevel());
0918     break;
0919   }
0920   case attr::CountedByOrNull: {
0921     const auto *SA = cast<CountedByOrNullAttr>(A);
0922     Record.push_back(SA->isInherited());
0923     Record.push_back(A->isImplicit());
0924     Record.push_back(A->isPackExpansion());
0925     Record.AddStmt(SA->getCount());
0926     Record.push_back(SA->getNestedLevel());
0927     break;
0928   }
0929   case attr::DLLExport: {
0930     const auto *SA = cast<DLLExportAttr>(A);
0931     Record.push_back(SA->isInherited());
0932     Record.push_back(A->isImplicit());
0933     Record.push_back(A->isPackExpansion());
0934     break;
0935   }
0936   case attr::DLLExportStaticLocal: {
0937     const auto *SA = cast<DLLExportStaticLocalAttr>(A);
0938     Record.push_back(SA->isInherited());
0939     Record.push_back(A->isImplicit());
0940     Record.push_back(A->isPackExpansion());
0941     break;
0942   }
0943   case attr::DLLImport: {
0944     const auto *SA = cast<DLLImportAttr>(A);
0945     Record.push_back(SA->isInherited());
0946     Record.push_back(A->isImplicit());
0947     Record.push_back(A->isPackExpansion());
0948     break;
0949   }
0950   case attr::DLLImportStaticLocal: {
0951     const auto *SA = cast<DLLImportStaticLocalAttr>(A);
0952     Record.push_back(SA->isInherited());
0953     Record.push_back(A->isImplicit());
0954     Record.push_back(A->isPackExpansion());
0955     break;
0956   }
0957   case attr::Deprecated: {
0958     const auto *SA = cast<DeprecatedAttr>(A);
0959     Record.push_back(SA->isInherited());
0960     Record.push_back(A->isImplicit());
0961     Record.push_back(A->isPackExpansion());
0962     Record.AddString(SA->getMessage());
0963     Record.AddString(SA->getReplacement());
0964     break;
0965   }
0966   case attr::Destructor: {
0967     const auto *SA = cast<DestructorAttr>(A);
0968     Record.push_back(SA->isInherited());
0969     Record.push_back(A->isImplicit());
0970     Record.push_back(A->isPackExpansion());
0971     Record.push_back(SA->getPriority());
0972     break;
0973   }
0974   case attr::DiagnoseAsBuiltin: {
0975     const auto *SA = cast<DiagnoseAsBuiltinAttr>(A);
0976     Record.push_back(SA->isInherited());
0977     Record.push_back(A->isImplicit());
0978     Record.push_back(A->isPackExpansion());
0979     Record.AddDeclRef(SA->getFunction());
0980     Record.push_back(SA->argIndices_size());
0981     for (auto &Val : SA->argIndices())
0982       Record.push_back(Val);
0983     break;
0984   }
0985   case attr::DiagnoseIf: {
0986     const auto *SA = cast<DiagnoseIfAttr>(A);
0987     Record.push_back(SA->isInherited());
0988     Record.push_back(A->isImplicit());
0989     Record.push_back(A->isPackExpansion());
0990     Record.AddStmt(SA->getCond());
0991     Record.AddString(SA->getMessage());
0992 Record.push_back(static_cast<uint64_t>(SA->getDefaultSeverity()));
0993     Record.AddString(SA->getWarningGroup());
0994     Record.push_back(SA->getArgDependent());
0995     Record.AddDeclRef(SA->getParent());
0996     break;
0997   }
0998   case attr::DisableSanitizerInstrumentation: {
0999     const auto *SA = cast<DisableSanitizerInstrumentationAttr>(A);
1000     Record.push_back(SA->isInherited());
1001     Record.push_back(A->isImplicit());
1002     Record.push_back(A->isPackExpansion());
1003     break;
1004   }
1005   case attr::DisableTailCalls: {
1006     const auto *SA = cast<DisableTailCallsAttr>(A);
1007     Record.push_back(SA->isInherited());
1008     Record.push_back(A->isImplicit());
1009     Record.push_back(A->isPackExpansion());
1010     break;
1011   }
1012   case attr::EmptyBases: {
1013     const auto *SA = cast<EmptyBasesAttr>(A);
1014     Record.push_back(SA->isInherited());
1015     Record.push_back(A->isImplicit());
1016     Record.push_back(A->isPackExpansion());
1017     break;
1018   }
1019   case attr::EnableIf: {
1020     const auto *SA = cast<EnableIfAttr>(A);
1021     Record.push_back(SA->isInherited());
1022     Record.push_back(A->isImplicit());
1023     Record.push_back(A->isPackExpansion());
1024     Record.AddStmt(SA->getCond());
1025     Record.AddString(SA->getMessage());
1026     break;
1027   }
1028   case attr::EnforceTCB: {
1029     const auto *SA = cast<EnforceTCBAttr>(A);
1030     Record.push_back(SA->isInherited());
1031     Record.push_back(A->isImplicit());
1032     Record.push_back(A->isPackExpansion());
1033     Record.AddString(SA->getTCBName());
1034     break;
1035   }
1036   case attr::EnforceTCBLeaf: {
1037     const auto *SA = cast<EnforceTCBLeafAttr>(A);
1038     Record.push_back(SA->isInherited());
1039     Record.push_back(A->isImplicit());
1040     Record.push_back(A->isPackExpansion());
1041     Record.AddString(SA->getTCBName());
1042     break;
1043   }
1044   case attr::EnumExtensibility: {
1045     const auto *SA = cast<EnumExtensibilityAttr>(A);
1046     Record.push_back(SA->isInherited());
1047     Record.push_back(A->isImplicit());
1048     Record.push_back(A->isPackExpansion());
1049 Record.push_back(static_cast<uint64_t>(SA->getExtensibility()));
1050     break;
1051   }
1052   case attr::Error: {
1053     const auto *SA = cast<ErrorAttr>(A);
1054     Record.push_back(SA->isInherited());
1055     Record.push_back(A->isImplicit());
1056     Record.push_back(A->isPackExpansion());
1057     Record.AddString(SA->getUserDiagnostic());
1058     break;
1059   }
1060   case attr::ExcludeFromExplicitInstantiation: {
1061     const auto *SA = cast<ExcludeFromExplicitInstantiationAttr>(A);
1062     Record.push_back(SA->isInherited());
1063     Record.push_back(A->isImplicit());
1064     Record.push_back(A->isPackExpansion());
1065     break;
1066   }
1067   case attr::ExclusiveTrylockFunction: {
1068     const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A);
1069     Record.push_back(SA->isInherited());
1070     Record.push_back(A->isImplicit());
1071     Record.push_back(A->isPackExpansion());
1072     Record.AddStmt(SA->getSuccessValue());
1073     Record.push_back(SA->args_size());
1074     for (auto &Val : SA->args())
1075       Record.AddStmt(Val);
1076     break;
1077   }
1078   case attr::ExplicitInit: {
1079     const auto *SA = cast<ExplicitInitAttr>(A);
1080     Record.push_back(SA->isInherited());
1081     Record.push_back(A->isImplicit());
1082     Record.push_back(A->isPackExpansion());
1083     break;
1084   }
1085   case attr::ExternalSourceSymbol: {
1086     const auto *SA = cast<ExternalSourceSymbolAttr>(A);
1087     Record.push_back(SA->isInherited());
1088     Record.push_back(A->isImplicit());
1089     Record.push_back(A->isPackExpansion());
1090     Record.AddString(SA->getLanguage());
1091     Record.AddString(SA->getDefinedIn());
1092     Record.push_back(SA->getGeneratedDeclaration());
1093     Record.AddString(SA->getUSR());
1094     break;
1095   }
1096   case attr::FallThrough: {
1097     Record.push_back(A->isImplicit());
1098     Record.push_back(A->isPackExpansion());
1099     break;
1100   }
1101   case attr::FastCall: {
1102     const auto *SA = cast<FastCallAttr>(A);
1103     Record.push_back(SA->isInherited());
1104     Record.push_back(A->isImplicit());
1105     Record.push_back(A->isPackExpansion());
1106     break;
1107   }
1108   case attr::Final: {
1109     const auto *SA = cast<FinalAttr>(A);
1110     Record.push_back(SA->isInherited());
1111     Record.push_back(A->isImplicit());
1112     Record.push_back(A->isPackExpansion());
1113     break;
1114   }
1115   case attr::FlagEnum: {
1116     const auto *SA = cast<FlagEnumAttr>(A);
1117     Record.push_back(SA->isInherited());
1118     Record.push_back(A->isImplicit());
1119     Record.push_back(A->isPackExpansion());
1120     break;
1121   }
1122   case attr::Flatten: {
1123     const auto *SA = cast<FlattenAttr>(A);
1124     Record.push_back(SA->isInherited());
1125     Record.push_back(A->isImplicit());
1126     Record.push_back(A->isPackExpansion());
1127     break;
1128   }
1129   case attr::Format: {
1130     const auto *SA = cast<FormatAttr>(A);
1131     Record.push_back(SA->isInherited());
1132     Record.push_back(A->isImplicit());
1133     Record.push_back(A->isPackExpansion());
1134     Record.AddIdentifierRef(SA->getType());
1135     Record.push_back(SA->getFormatIdx());
1136     Record.push_back(SA->getFirstArg());
1137     break;
1138   }
1139   case attr::FormatArg: {
1140     const auto *SA = cast<FormatArgAttr>(A);
1141     Record.push_back(SA->isInherited());
1142     Record.push_back(A->isImplicit());
1143     Record.push_back(A->isPackExpansion());
1144     Record.push_back(SA->getFormatIdx().serialize());
1145     break;
1146   }
1147   case attr::FunctionReturnThunks: {
1148     const auto *SA = cast<FunctionReturnThunksAttr>(A);
1149     Record.push_back(SA->isInherited());
1150     Record.push_back(A->isImplicit());
1151     Record.push_back(A->isPackExpansion());
1152 Record.push_back(static_cast<uint64_t>(SA->getThunkType()));
1153     break;
1154   }
1155   case attr::GNUInline: {
1156     const auto *SA = cast<GNUInlineAttr>(A);
1157     Record.push_back(SA->isInherited());
1158     Record.push_back(A->isImplicit());
1159     Record.push_back(A->isPackExpansion());
1160     break;
1161   }
1162   case attr::GuardedBy: {
1163     const auto *SA = cast<GuardedByAttr>(A);
1164     Record.push_back(SA->isInherited());
1165     Record.push_back(A->isImplicit());
1166     Record.push_back(A->isPackExpansion());
1167     Record.AddStmt(SA->getArg());
1168     break;
1169   }
1170   case attr::GuardedVar: {
1171     const auto *SA = cast<GuardedVarAttr>(A);
1172     Record.push_back(SA->isInherited());
1173     Record.push_back(A->isImplicit());
1174     Record.push_back(A->isPackExpansion());
1175     break;
1176   }
1177   case attr::HIPManaged: {
1178     const auto *SA = cast<HIPManagedAttr>(A);
1179     Record.push_back(SA->isInherited());
1180     Record.push_back(A->isImplicit());
1181     Record.push_back(A->isPackExpansion());
1182     break;
1183   }
1184   case attr::HLSLContainedType: {
1185     const auto *SA = cast<HLSLContainedTypeAttr>(A);
1186     Record.push_back(A->isImplicit());
1187     Record.push_back(A->isPackExpansion());
1188     Record.AddTypeSourceInfo(SA->getTypeLoc());
1189     break;
1190   }
1191   case attr::HLSLControlFlowHint: {
1192     Record.push_back(A->isImplicit());
1193     Record.push_back(A->isPackExpansion());
1194     break;
1195   }
1196   case attr::HLSLGroupSharedAddressSpace: {
1197     Record.push_back(A->isImplicit());
1198     Record.push_back(A->isPackExpansion());
1199     break;
1200   }
1201   case attr::HLSLLoopHint: {
1202     const auto *SA = cast<HLSLLoopHintAttr>(A);
1203     Record.push_back(A->isImplicit());
1204     Record.push_back(A->isPackExpansion());
1205     Record.push_back(SA->getDirective());
1206     break;
1207   }
1208   case attr::HLSLNumThreads: {
1209     const auto *SA = cast<HLSLNumThreadsAttr>(A);
1210     Record.push_back(SA->isInherited());
1211     Record.push_back(A->isImplicit());
1212     Record.push_back(A->isPackExpansion());
1213     Record.push_back(SA->getX());
1214     Record.push_back(SA->getY());
1215     Record.push_back(SA->getZ());
1216     break;
1217   }
1218   case attr::HLSLPackOffset: {
1219     const auto *SA = cast<HLSLPackOffsetAttr>(A);
1220     Record.push_back(SA->isInherited());
1221     Record.push_back(A->isImplicit());
1222     Record.push_back(A->isPackExpansion());
1223     Record.push_back(SA->getSubcomponent());
1224     Record.push_back(SA->getComponent());
1225     break;
1226   }
1227   case attr::HLSLParamModifier: {
1228     const auto *SA = cast<HLSLParamModifierAttr>(A);
1229     Record.push_back(SA->isInherited());
1230     Record.push_back(A->isImplicit());
1231     Record.push_back(A->isPackExpansion());
1232     Record.push_back(SA->getMergedSpelling());
1233     break;
1234   }
1235   case attr::HLSLROV: {
1236     Record.push_back(A->isImplicit());
1237     Record.push_back(A->isPackExpansion());
1238     break;
1239   }
1240   case attr::HLSLRawBuffer: {
1241     Record.push_back(A->isImplicit());
1242     Record.push_back(A->isPackExpansion());
1243     break;
1244   }
1245   case attr::HLSLResource: {
1246     const auto *SA = cast<HLSLResourceAttr>(A);
1247     Record.push_back(SA->isInherited());
1248     Record.push_back(A->isImplicit());
1249     Record.push_back(A->isPackExpansion());
1250 Record.push_back(static_cast<uint64_t>(SA->getResourceKind()));
1251     break;
1252   }
1253   case attr::HLSLResourceBinding: {
1254     const auto *SA = cast<HLSLResourceBindingAttr>(A);
1255     Record.push_back(SA->isInherited());
1256     Record.push_back(A->isImplicit());
1257     Record.push_back(A->isPackExpansion());
1258     Record.AddString(SA->getSlot());
1259     Record.AddString(SA->getSpace());
1260     break;
1261   }
1262   case attr::HLSLResourceClass: {
1263     const auto *SA = cast<HLSLResourceClassAttr>(A);
1264     Record.push_back(A->isImplicit());
1265     Record.push_back(A->isPackExpansion());
1266 Record.push_back(static_cast<uint64_t>(SA->getResourceClass()));
1267     break;
1268   }
1269   case attr::HLSLSV_DispatchThreadID: {
1270     const auto *SA = cast<HLSLSV_DispatchThreadIDAttr>(A);
1271     Record.push_back(SA->isInherited());
1272     Record.push_back(A->isImplicit());
1273     Record.push_back(A->isPackExpansion());
1274     break;
1275   }
1276   case attr::HLSLSV_GroupID: {
1277     const auto *SA = cast<HLSLSV_GroupIDAttr>(A);
1278     Record.push_back(SA->isInherited());
1279     Record.push_back(A->isImplicit());
1280     Record.push_back(A->isPackExpansion());
1281     break;
1282   }
1283   case attr::HLSLSV_GroupIndex: {
1284     const auto *SA = cast<HLSLSV_GroupIndexAttr>(A);
1285     Record.push_back(SA->isInherited());
1286     Record.push_back(A->isImplicit());
1287     Record.push_back(A->isPackExpansion());
1288     break;
1289   }
1290   case attr::HLSLSV_GroupThreadID: {
1291     const auto *SA = cast<HLSLSV_GroupThreadIDAttr>(A);
1292     Record.push_back(SA->isInherited());
1293     Record.push_back(A->isImplicit());
1294     Record.push_back(A->isPackExpansion());
1295     break;
1296   }
1297   case attr::HLSLShader: {
1298     const auto *SA = cast<HLSLShaderAttr>(A);
1299     Record.push_back(SA->isInherited());
1300     Record.push_back(A->isImplicit());
1301     Record.push_back(A->isPackExpansion());
1302 Record.push_back(static_cast<uint64_t>(SA->getType()));
1303     break;
1304   }
1305   case attr::HLSLWaveSize: {
1306     const auto *SA = cast<HLSLWaveSizeAttr>(A);
1307     Record.push_back(SA->isInherited());
1308     Record.push_back(A->isImplicit());
1309     Record.push_back(A->isPackExpansion());
1310     Record.push_back(SA->getMin());
1311     Record.push_back(SA->getMax());
1312     Record.push_back(SA->getPreferred());
1313     break;
1314   }
1315   case attr::Hot: {
1316     const auto *SA = cast<HotAttr>(A);
1317     Record.push_back(SA->isInherited());
1318     Record.push_back(A->isImplicit());
1319     Record.push_back(A->isPackExpansion());
1320     break;
1321   }
1322   case attr::HybridPatchable: {
1323     const auto *SA = cast<HybridPatchableAttr>(A);
1324     Record.push_back(SA->isInherited());
1325     Record.push_back(A->isImplicit());
1326     Record.push_back(A->isPackExpansion());
1327     break;
1328   }
1329   case attr::IBAction: {
1330     const auto *SA = cast<IBActionAttr>(A);
1331     Record.push_back(SA->isInherited());
1332     Record.push_back(A->isImplicit());
1333     Record.push_back(A->isPackExpansion());
1334     break;
1335   }
1336   case attr::IBOutlet: {
1337     const auto *SA = cast<IBOutletAttr>(A);
1338     Record.push_back(SA->isInherited());
1339     Record.push_back(A->isImplicit());
1340     Record.push_back(A->isPackExpansion());
1341     break;
1342   }
1343   case attr::IBOutletCollection: {
1344     const auto *SA = cast<IBOutletCollectionAttr>(A);
1345     Record.push_back(SA->isInherited());
1346     Record.push_back(A->isImplicit());
1347     Record.push_back(A->isPackExpansion());
1348     Record.AddTypeSourceInfo(SA->getInterfaceLoc());
1349     break;
1350   }
1351   case attr::IFunc: {
1352     const auto *SA = cast<IFuncAttr>(A);
1353     Record.push_back(A->isImplicit());
1354     Record.push_back(A->isPackExpansion());
1355     Record.AddString(SA->getResolver());
1356     break;
1357   }
1358   case attr::InitPriority: {
1359     const auto *SA = cast<InitPriorityAttr>(A);
1360     Record.push_back(SA->isInherited());
1361     Record.push_back(A->isImplicit());
1362     Record.push_back(A->isPackExpansion());
1363     Record.push_back(SA->getPriority());
1364     break;
1365   }
1366   case attr::InitSeg: {
1367     const auto *SA = cast<InitSegAttr>(A);
1368     Record.push_back(A->isImplicit());
1369     Record.push_back(A->isPackExpansion());
1370     Record.AddString(SA->getSection());
1371     break;
1372   }
1373   case attr::IntelOclBicc: {
1374     const auto *SA = cast<IntelOclBiccAttr>(A);
1375     Record.push_back(SA->isInherited());
1376     Record.push_back(A->isImplicit());
1377     Record.push_back(A->isPackExpansion());
1378     break;
1379   }
1380   case attr::InternalLinkage: {
1381     const auto *SA = cast<InternalLinkageAttr>(A);
1382     Record.push_back(SA->isInherited());
1383     Record.push_back(A->isImplicit());
1384     Record.push_back(A->isPackExpansion());
1385     break;
1386   }
1387   case attr::LTOVisibilityPublic: {
1388     const auto *SA = cast<LTOVisibilityPublicAttr>(A);
1389     Record.push_back(SA->isInherited());
1390     Record.push_back(A->isImplicit());
1391     Record.push_back(A->isPackExpansion());
1392     break;
1393   }
1394   case attr::LayoutVersion: {
1395     const auto *SA = cast<LayoutVersionAttr>(A);
1396     Record.push_back(SA->isInherited());
1397     Record.push_back(A->isImplicit());
1398     Record.push_back(A->isPackExpansion());
1399     Record.push_back(SA->getVersion());
1400     break;
1401   }
1402   case attr::Leaf: {
1403     const auto *SA = cast<LeafAttr>(A);
1404     Record.push_back(SA->isInherited());
1405     Record.push_back(A->isImplicit());
1406     Record.push_back(A->isPackExpansion());
1407     break;
1408   }
1409   case attr::LifetimeBound: {
1410     const auto *SA = cast<LifetimeBoundAttr>(A);
1411     Record.push_back(SA->isInherited());
1412     Record.push_back(A->isImplicit());
1413     Record.push_back(A->isPackExpansion());
1414     break;
1415   }
1416   case attr::LifetimeCaptureBy: {
1417     const auto *SA = cast<LifetimeCaptureByAttr>(A);
1418     Record.push_back(SA->isInherited());
1419     Record.push_back(A->isImplicit());
1420     Record.push_back(A->isPackExpansion());
1421     Record.push_back(SA->params_size());
1422     for (auto &Val : SA->params())
1423       Record.push_back(Val);
1424     break;
1425   }
1426   case attr::Likely: {
1427     Record.push_back(A->isImplicit());
1428     Record.push_back(A->isPackExpansion());
1429     break;
1430   }
1431   case attr::LoaderUninitialized: {
1432     Record.push_back(A->isImplicit());
1433     Record.push_back(A->isPackExpansion());
1434     break;
1435   }
1436   case attr::LockReturned: {
1437     const auto *SA = cast<LockReturnedAttr>(A);
1438     Record.push_back(SA->isInherited());
1439     Record.push_back(A->isImplicit());
1440     Record.push_back(A->isPackExpansion());
1441     Record.AddStmt(SA->getArg());
1442     break;
1443   }
1444   case attr::LocksExcluded: {
1445     const auto *SA = cast<LocksExcludedAttr>(A);
1446     Record.push_back(SA->isInherited());
1447     Record.push_back(A->isImplicit());
1448     Record.push_back(A->isPackExpansion());
1449     Record.push_back(SA->args_size());
1450     for (auto &Val : SA->args())
1451       Record.AddStmt(Val);
1452     break;
1453   }
1454   case attr::LoopHint: {
1455     const auto *SA = cast<LoopHintAttr>(A);
1456     Record.push_back(A->isImplicit());
1457     Record.push_back(A->isPackExpansion());
1458 Record.push_back(static_cast<uint64_t>(SA->getOption()));
1459 Record.push_back(static_cast<uint64_t>(SA->getState()));
1460     Record.AddStmt(SA->getValue());
1461     break;
1462   }
1463   case attr::M68kInterrupt: {
1464     const auto *SA = cast<M68kInterruptAttr>(A);
1465     Record.push_back(SA->isInherited());
1466     Record.push_back(A->isImplicit());
1467     Record.push_back(A->isPackExpansion());
1468     Record.push_back(SA->getNumber());
1469     break;
1470   }
1471   case attr::M68kRTD: {
1472     const auto *SA = cast<M68kRTDAttr>(A);
1473     Record.push_back(SA->isInherited());
1474     Record.push_back(A->isImplicit());
1475     Record.push_back(A->isPackExpansion());
1476     break;
1477   }
1478   case attr::MIGServerRoutine: {
1479     const auto *SA = cast<MIGServerRoutineAttr>(A);
1480     Record.push_back(SA->isInherited());
1481     Record.push_back(A->isImplicit());
1482     Record.push_back(A->isPackExpansion());
1483     break;
1484   }
1485   case attr::MSABI: {
1486     const auto *SA = cast<MSABIAttr>(A);
1487     Record.push_back(SA->isInherited());
1488     Record.push_back(A->isImplicit());
1489     Record.push_back(A->isPackExpansion());
1490     break;
1491   }
1492   case attr::MSAllocator: {
1493     const auto *SA = cast<MSAllocatorAttr>(A);
1494     Record.push_back(SA->isInherited());
1495     Record.push_back(A->isImplicit());
1496     Record.push_back(A->isPackExpansion());
1497     break;
1498   }
1499   case attr::MSConstexpr: {
1500     const auto *SA = cast<MSConstexprAttr>(A);
1501     Record.push_back(SA->isInherited());
1502     Record.push_back(A->isImplicit());
1503     Record.push_back(A->isPackExpansion());
1504     break;
1505   }
1506   case attr::MSInheritance: {
1507     const auto *SA = cast<MSInheritanceAttr>(A);
1508     Record.push_back(SA->isInherited());
1509     Record.push_back(A->isImplicit());
1510     Record.push_back(A->isPackExpansion());
1511     Record.push_back(SA->getBestCase());
1512     break;
1513   }
1514   case attr::MSNoVTable: {
1515     const auto *SA = cast<MSNoVTableAttr>(A);
1516     Record.push_back(SA->isInherited());
1517     Record.push_back(A->isImplicit());
1518     Record.push_back(A->isPackExpansion());
1519     break;
1520   }
1521   case attr::MSP430Interrupt: {
1522     const auto *SA = cast<MSP430InterruptAttr>(A);
1523     Record.push_back(SA->isInherited());
1524     Record.push_back(A->isImplicit());
1525     Record.push_back(A->isPackExpansion());
1526     Record.push_back(SA->getNumber());
1527     break;
1528   }
1529   case attr::MSStruct: {
1530     const auto *SA = cast<MSStructAttr>(A);
1531     Record.push_back(SA->isInherited());
1532     Record.push_back(A->isImplicit());
1533     Record.push_back(A->isPackExpansion());
1534     break;
1535   }
1536   case attr::MSVtorDisp: {
1537     const auto *SA = cast<MSVtorDispAttr>(A);
1538     Record.push_back(SA->isInherited());
1539     Record.push_back(A->isImplicit());
1540     Record.push_back(A->isPackExpansion());
1541     Record.push_back(SA->getVdm());
1542     break;
1543   }
1544   case attr::MaxFieldAlignment: {
1545     const auto *SA = cast<MaxFieldAlignmentAttr>(A);
1546     Record.push_back(SA->isInherited());
1547     Record.push_back(A->isImplicit());
1548     Record.push_back(A->isPackExpansion());
1549     Record.push_back(SA->getAlignment());
1550     break;
1551   }
1552   case attr::MayAlias: {
1553     const auto *SA = cast<MayAliasAttr>(A);
1554     Record.push_back(SA->isInherited());
1555     Record.push_back(A->isImplicit());
1556     Record.push_back(A->isPackExpansion());
1557     break;
1558   }
1559   case attr::MaybeUndef: {
1560     const auto *SA = cast<MaybeUndefAttr>(A);
1561     Record.push_back(SA->isInherited());
1562     Record.push_back(A->isImplicit());
1563     Record.push_back(A->isPackExpansion());
1564     break;
1565   }
1566   case attr::MicroMips: {
1567     const auto *SA = cast<MicroMipsAttr>(A);
1568     Record.push_back(SA->isInherited());
1569     Record.push_back(A->isImplicit());
1570     Record.push_back(A->isPackExpansion());
1571     break;
1572   }
1573   case attr::MinSize: {
1574     const auto *SA = cast<MinSizeAttr>(A);
1575     Record.push_back(SA->isInherited());
1576     Record.push_back(A->isImplicit());
1577     Record.push_back(A->isPackExpansion());
1578     break;
1579   }
1580   case attr::MinVectorWidth: {
1581     const auto *SA = cast<MinVectorWidthAttr>(A);
1582     Record.push_back(SA->isInherited());
1583     Record.push_back(A->isImplicit());
1584     Record.push_back(A->isPackExpansion());
1585     Record.push_back(SA->getVectorWidth());
1586     break;
1587   }
1588   case attr::Mips16: {
1589     const auto *SA = cast<Mips16Attr>(A);
1590     Record.push_back(SA->isInherited());
1591     Record.push_back(A->isImplicit());
1592     Record.push_back(A->isPackExpansion());
1593     break;
1594   }
1595   case attr::MipsInterrupt: {
1596     const auto *SA = cast<MipsInterruptAttr>(A);
1597     Record.push_back(SA->isInherited());
1598     Record.push_back(A->isImplicit());
1599     Record.push_back(A->isPackExpansion());
1600 Record.push_back(static_cast<uint64_t>(SA->getInterrupt()));
1601     break;
1602   }
1603   case attr::MipsLongCall: {
1604     const auto *SA = cast<MipsLongCallAttr>(A);
1605     Record.push_back(SA->isInherited());
1606     Record.push_back(A->isImplicit());
1607     Record.push_back(A->isPackExpansion());
1608     break;
1609   }
1610   case attr::MipsShortCall: {
1611     const auto *SA = cast<MipsShortCallAttr>(A);
1612     Record.push_back(SA->isInherited());
1613     Record.push_back(A->isImplicit());
1614     Record.push_back(A->isPackExpansion());
1615     break;
1616   }
1617   case attr::Mode: {
1618     const auto *SA = cast<ModeAttr>(A);
1619     Record.push_back(A->isImplicit());
1620     Record.push_back(A->isPackExpansion());
1621     Record.AddIdentifierRef(SA->getMode());
1622     break;
1623   }
1624   case attr::MustTail: {
1625     Record.push_back(A->isImplicit());
1626     Record.push_back(A->isPackExpansion());
1627     break;
1628   }
1629   case attr::NSConsumed: {
1630     const auto *SA = cast<NSConsumedAttr>(A);
1631     Record.push_back(SA->isInherited());
1632     Record.push_back(A->isImplicit());
1633     Record.push_back(A->isPackExpansion());
1634     break;
1635   }
1636   case attr::NSConsumesSelf: {
1637     const auto *SA = cast<NSConsumesSelfAttr>(A);
1638     Record.push_back(SA->isInherited());
1639     Record.push_back(A->isImplicit());
1640     Record.push_back(A->isPackExpansion());
1641     break;
1642   }
1643   case attr::NSErrorDomain: {
1644     const auto *SA = cast<NSErrorDomainAttr>(A);
1645     Record.push_back(SA->isInherited());
1646     Record.push_back(A->isImplicit());
1647     Record.push_back(A->isPackExpansion());
1648     Record.AddIdentifierRef(SA->getErrorDomain());
1649     break;
1650   }
1651   case attr::NSReturnsAutoreleased: {
1652     const auto *SA = cast<NSReturnsAutoreleasedAttr>(A);
1653     Record.push_back(SA->isInherited());
1654     Record.push_back(A->isImplicit());
1655     Record.push_back(A->isPackExpansion());
1656     break;
1657   }
1658   case attr::NSReturnsNotRetained: {
1659     const auto *SA = cast<NSReturnsNotRetainedAttr>(A);
1660     Record.push_back(SA->isInherited());
1661     Record.push_back(A->isImplicit());
1662     Record.push_back(A->isPackExpansion());
1663     break;
1664   }
1665   case attr::NSReturnsRetained: {
1666     const auto *SA = cast<NSReturnsRetainedAttr>(A);
1667     Record.push_back(SA->isInherited());
1668     Record.push_back(A->isImplicit());
1669     Record.push_back(A->isPackExpansion());
1670     break;
1671   }
1672   case attr::NVPTXKernel: {
1673     const auto *SA = cast<NVPTXKernelAttr>(A);
1674     Record.push_back(SA->isInherited());
1675     Record.push_back(A->isImplicit());
1676     Record.push_back(A->isPackExpansion());
1677     break;
1678   }
1679   case attr::Naked: {
1680     const auto *SA = cast<NakedAttr>(A);
1681     Record.push_back(SA->isInherited());
1682     Record.push_back(A->isImplicit());
1683     Record.push_back(A->isPackExpansion());
1684     break;
1685   }
1686   case attr::NoAlias: {
1687     const auto *SA = cast<NoAliasAttr>(A);
1688     Record.push_back(SA->isInherited());
1689     Record.push_back(A->isImplicit());
1690     Record.push_back(A->isPackExpansion());
1691     break;
1692   }
1693   case attr::NoBuiltin: {
1694     const auto *SA = cast<NoBuiltinAttr>(A);
1695     Record.push_back(A->isImplicit());
1696     Record.push_back(A->isPackExpansion());
1697     Record.push_back(SA->builtinNames_size());
1698     for (auto &Val : SA->builtinNames())
1699       Record.AddString(Val);
1700     break;
1701   }
1702   case attr::NoCommon: {
1703     const auto *SA = cast<NoCommonAttr>(A);
1704     Record.push_back(SA->isInherited());
1705     Record.push_back(A->isImplicit());
1706     Record.push_back(A->isPackExpansion());
1707     break;
1708   }
1709   case attr::NoConvergent: {
1710     const auto *SA = cast<NoConvergentAttr>(A);
1711     Record.push_back(SA->isInherited());
1712     Record.push_back(A->isImplicit());
1713     Record.push_back(A->isPackExpansion());
1714     break;
1715   }
1716   case attr::NoDebug: {
1717     const auto *SA = cast<NoDebugAttr>(A);
1718     Record.push_back(SA->isInherited());
1719     Record.push_back(A->isImplicit());
1720     Record.push_back(A->isPackExpansion());
1721     break;
1722   }
1723   case attr::NoDeref: {
1724     Record.push_back(A->isImplicit());
1725     Record.push_back(A->isPackExpansion());
1726     break;
1727   }
1728   case attr::NoDestroy: {
1729     const auto *SA = cast<NoDestroyAttr>(A);
1730     Record.push_back(SA->isInherited());
1731     Record.push_back(A->isImplicit());
1732     Record.push_back(A->isPackExpansion());
1733     break;
1734   }
1735   case attr::NoDuplicate: {
1736     const auto *SA = cast<NoDuplicateAttr>(A);
1737     Record.push_back(SA->isInherited());
1738     Record.push_back(A->isImplicit());
1739     Record.push_back(A->isPackExpansion());
1740     break;
1741   }
1742   case attr::NoEscape: {
1743     Record.push_back(A->isImplicit());
1744     Record.push_back(A->isPackExpansion());
1745     break;
1746   }
1747   case attr::NoInline: {
1748     const auto *SA = cast<NoInlineAttr>(A);
1749     Record.push_back(SA->isInherited());
1750     Record.push_back(A->isImplicit());
1751     Record.push_back(A->isPackExpansion());
1752     break;
1753   }
1754   case attr::NoInstrumentFunction: {
1755     const auto *SA = cast<NoInstrumentFunctionAttr>(A);
1756     Record.push_back(SA->isInherited());
1757     Record.push_back(A->isImplicit());
1758     Record.push_back(A->isPackExpansion());
1759     break;
1760   }
1761   case attr::NoMerge: {
1762     const auto *SA = cast<NoMergeAttr>(A);
1763     Record.push_back(SA->isInherited());
1764     Record.push_back(A->isImplicit());
1765     Record.push_back(A->isPackExpansion());
1766     break;
1767   }
1768   case attr::NoMicroMips: {
1769     const auto *SA = cast<NoMicroMipsAttr>(A);
1770     Record.push_back(SA->isInherited());
1771     Record.push_back(A->isImplicit());
1772     Record.push_back(A->isPackExpansion());
1773     break;
1774   }
1775   case attr::NoMips16: {
1776     const auto *SA = cast<NoMips16Attr>(A);
1777     Record.push_back(SA->isInherited());
1778     Record.push_back(A->isImplicit());
1779     Record.push_back(A->isPackExpansion());
1780     break;
1781   }
1782   case attr::NoProfileFunction: {
1783     const auto *SA = cast<NoProfileFunctionAttr>(A);
1784     Record.push_back(SA->isInherited());
1785     Record.push_back(A->isImplicit());
1786     Record.push_back(A->isPackExpansion());
1787     break;
1788   }
1789   case attr::NoRandomizeLayout: {
1790     const auto *SA = cast<NoRandomizeLayoutAttr>(A);
1791     Record.push_back(SA->isInherited());
1792     Record.push_back(A->isImplicit());
1793     Record.push_back(A->isPackExpansion());
1794     break;
1795   }
1796   case attr::NoReturn: {
1797     const auto *SA = cast<NoReturnAttr>(A);
1798     Record.push_back(SA->isInherited());
1799     Record.push_back(A->isImplicit());
1800     Record.push_back(A->isPackExpansion());
1801     break;
1802   }
1803   case attr::NoSanitize: {
1804     const auto *SA = cast<NoSanitizeAttr>(A);
1805     Record.push_back(SA->isInherited());
1806     Record.push_back(A->isImplicit());
1807     Record.push_back(A->isPackExpansion());
1808     Record.push_back(SA->sanitizers_size());
1809     for (auto &Val : SA->sanitizers())
1810       Record.AddString(Val);
1811     break;
1812   }
1813   case attr::NoSpecializations: {
1814     const auto *SA = cast<NoSpecializationsAttr>(A);
1815     Record.push_back(SA->isInherited());
1816     Record.push_back(A->isImplicit());
1817     Record.push_back(A->isPackExpansion());
1818     Record.AddString(SA->getMessage());
1819     break;
1820   }
1821   case attr::NoSpeculativeLoadHardening: {
1822     const auto *SA = cast<NoSpeculativeLoadHardeningAttr>(A);
1823     Record.push_back(SA->isInherited());
1824     Record.push_back(A->isImplicit());
1825     Record.push_back(A->isPackExpansion());
1826     break;
1827   }
1828   case attr::NoSplitStack: {
1829     const auto *SA = cast<NoSplitStackAttr>(A);
1830     Record.push_back(SA->isInherited());
1831     Record.push_back(A->isImplicit());
1832     Record.push_back(A->isPackExpansion());
1833     break;
1834   }
1835   case attr::NoStackProtector: {
1836     const auto *SA = cast<NoStackProtectorAttr>(A);
1837     Record.push_back(SA->isInherited());
1838     Record.push_back(A->isImplicit());
1839     Record.push_back(A->isPackExpansion());
1840     break;
1841   }
1842   case attr::NoThreadSafetyAnalysis: {
1843     const auto *SA = cast<NoThreadSafetyAnalysisAttr>(A);
1844     Record.push_back(SA->isInherited());
1845     Record.push_back(A->isImplicit());
1846     Record.push_back(A->isPackExpansion());
1847     break;
1848   }
1849   case attr::NoThrow: {
1850     const auto *SA = cast<NoThrowAttr>(A);
1851     Record.push_back(SA->isInherited());
1852     Record.push_back(A->isImplicit());
1853     Record.push_back(A->isPackExpansion());
1854     break;
1855   }
1856   case attr::NoTrivialAutoVarInit: {
1857     const auto *SA = cast<NoTrivialAutoVarInitAttr>(A);
1858     Record.push_back(SA->isInherited());
1859     Record.push_back(A->isImplicit());
1860     Record.push_back(A->isPackExpansion());
1861     break;
1862   }
1863   case attr::NoUniqueAddress: {
1864     const auto *SA = cast<NoUniqueAddressAttr>(A);
1865     Record.push_back(SA->isInherited());
1866     Record.push_back(A->isImplicit());
1867     Record.push_back(A->isPackExpansion());
1868     break;
1869   }
1870   case attr::NoUwtable: {
1871     const auto *SA = cast<NoUwtableAttr>(A);
1872     Record.push_back(SA->isInherited());
1873     Record.push_back(A->isImplicit());
1874     Record.push_back(A->isPackExpansion());
1875     break;
1876   }
1877   case attr::NonAllocating: {
1878     const auto *SA = cast<NonAllocatingAttr>(A);
1879     Record.push_back(A->isImplicit());
1880     Record.push_back(A->isPackExpansion());
1881     Record.AddStmt(SA->getCond());
1882     break;
1883   }
1884   case attr::NonBlocking: {
1885     const auto *SA = cast<NonBlockingAttr>(A);
1886     Record.push_back(A->isImplicit());
1887     Record.push_back(A->isPackExpansion());
1888     Record.AddStmt(SA->getCond());
1889     break;
1890   }
1891   case attr::NonNull: {
1892     const auto *SA = cast<NonNullAttr>(A);
1893     Record.push_back(SA->isInherited());
1894     Record.push_back(A->isImplicit());
1895     Record.push_back(A->isPackExpansion());
1896     Record.push_back(SA->args_size());
1897     for (auto &Val : SA->args())
1898       Record.push_back(Val.serialize());
1899     break;
1900   }
1901   case attr::NotTailCalled: {
1902     const auto *SA = cast<NotTailCalledAttr>(A);
1903     Record.push_back(SA->isInherited());
1904     Record.push_back(A->isImplicit());
1905     Record.push_back(A->isPackExpansion());
1906     break;
1907   }
1908   case attr::OMPAllocateDecl: {
1909     const auto *SA = cast<OMPAllocateDeclAttr>(A);
1910     Record.push_back(SA->isInherited());
1911     Record.push_back(A->isImplicit());
1912     Record.push_back(A->isPackExpansion());
1913 Record.push_back(static_cast<uint64_t>(SA->getAllocatorType()));
1914     Record.AddStmt(SA->getAllocator());
1915     Record.AddStmt(SA->getAlignment());
1916     break;
1917   }
1918   case attr::OMPAssume: {
1919     const auto *SA = cast<OMPAssumeAttr>(A);
1920     Record.push_back(SA->isInherited());
1921     Record.push_back(A->isImplicit());
1922     Record.push_back(A->isPackExpansion());
1923     Record.AddString(SA->getAssumption());
1924     break;
1925   }
1926   case attr::OMPCaptureKind: {
1927     const auto *SA = cast<OMPCaptureKindAttr>(A);
1928     Record.push_back(A->isImplicit());
1929     Record.push_back(A->isPackExpansion());
1930     Record.push_back(SA->getCaptureKindVal());
1931     break;
1932   }
1933   case attr::OMPCaptureNoInit: {
1934     const auto *SA = cast<OMPCaptureNoInitAttr>(A);
1935     Record.push_back(SA->isInherited());
1936     Record.push_back(A->isImplicit());
1937     Record.push_back(A->isPackExpansion());
1938     break;
1939   }
1940   case attr::OMPDeclareSimdDecl: {
1941     const auto *SA = cast<OMPDeclareSimdDeclAttr>(A);
1942     Record.push_back(A->isImplicit());
1943     Record.push_back(A->isPackExpansion());
1944 Record.push_back(static_cast<uint64_t>(SA->getBranchState()));
1945     Record.AddStmt(SA->getSimdlen());
1946     Record.push_back(SA->uniforms_size());
1947     for (auto &Val : SA->uniforms())
1948       Record.AddStmt(Val);
1949     Record.push_back(SA->aligneds_size());
1950     for (auto &Val : SA->aligneds())
1951       Record.AddStmt(Val);
1952     Record.push_back(SA->alignments_size());
1953     for (auto &Val : SA->alignments())
1954       Record.AddStmt(Val);
1955     Record.push_back(SA->linears_size());
1956     for (auto &Val : SA->linears())
1957       Record.AddStmt(Val);
1958     Record.push_back(SA->modifiers_size());
1959     for (auto &Val : SA->modifiers())
1960       Record.push_back(Val);
1961     Record.push_back(SA->steps_size());
1962     for (auto &Val : SA->steps())
1963       Record.AddStmt(Val);
1964     break;
1965   }
1966   case attr::OMPDeclareTargetDecl: {
1967     const auto *SA = cast<OMPDeclareTargetDeclAttr>(A);
1968     Record.push_back(SA->isInherited());
1969     Record.push_back(A->isImplicit());
1970     Record.push_back(A->isPackExpansion());
1971 Record.push_back(static_cast<uint64_t>(SA->getMapType()));
1972 Record.push_back(static_cast<uint64_t>(SA->getDevType()));
1973     Record.AddStmt(SA->getIndirectExpr());
1974     Record.push_back(SA->getIndirect());
1975     Record.push_back(SA->getLevel());
1976     break;
1977   }
1978   case attr::OMPDeclareVariant: {
1979     const auto *SA = cast<OMPDeclareVariantAttr>(A);
1980     Record.push_back(SA->isInherited());
1981     Record.push_back(A->isImplicit());
1982     Record.push_back(A->isPackExpansion());
1983     Record.AddStmt(SA->getVariantFuncRef());
1984     Record.writeOMPTraitInfo(SA->getTraitInfos());
1985     Record.push_back(SA->adjustArgsNothing_size());
1986     for (auto &Val : SA->adjustArgsNothing())
1987       Record.AddStmt(Val);
1988     Record.push_back(SA->adjustArgsNeedDevicePtr_size());
1989     for (auto &Val : SA->adjustArgsNeedDevicePtr())
1990       Record.AddStmt(Val);
1991     Record.push_back(SA->appendArgs_size());
1992     for (OMPDeclareVariantAttr::appendArgs_iterator I = SA->appendArgs_begin(), E = SA->appendArgs_end(); I != E; ++I) {
1993       Record.writeBool(I->IsTarget);
1994       Record.writeBool(I->IsTargetSync);
1995     }
1996     break;
1997   }
1998   case attr::OMPReferencedVar: {
1999     const auto *SA = cast<OMPReferencedVarAttr>(A);
2000     Record.push_back(A->isImplicit());
2001     Record.push_back(A->isPackExpansion());
2002     Record.AddStmt(SA->getRef());
2003     break;
2004   }
2005   case attr::OMPThreadPrivateDecl: {
2006     const auto *SA = cast<OMPThreadPrivateDeclAttr>(A);
2007     Record.push_back(SA->isInherited());
2008     Record.push_back(A->isImplicit());
2009     Record.push_back(A->isPackExpansion());
2010     break;
2011   }
2012   case attr::OSConsumed: {
2013     const auto *SA = cast<OSConsumedAttr>(A);
2014     Record.push_back(SA->isInherited());
2015     Record.push_back(A->isImplicit());
2016     Record.push_back(A->isPackExpansion());
2017     break;
2018   }
2019   case attr::OSConsumesThis: {
2020     const auto *SA = cast<OSConsumesThisAttr>(A);
2021     Record.push_back(SA->isInherited());
2022     Record.push_back(A->isImplicit());
2023     Record.push_back(A->isPackExpansion());
2024     break;
2025   }
2026   case attr::OSReturnsNotRetained: {
2027     const auto *SA = cast<OSReturnsNotRetainedAttr>(A);
2028     Record.push_back(SA->isInherited());
2029     Record.push_back(A->isImplicit());
2030     Record.push_back(A->isPackExpansion());
2031     break;
2032   }
2033   case attr::OSReturnsRetained: {
2034     const auto *SA = cast<OSReturnsRetainedAttr>(A);
2035     Record.push_back(SA->isInherited());
2036     Record.push_back(A->isImplicit());
2037     Record.push_back(A->isPackExpansion());
2038     break;
2039   }
2040   case attr::OSReturnsRetainedOnNonZero: {
2041     const auto *SA = cast<OSReturnsRetainedOnNonZeroAttr>(A);
2042     Record.push_back(SA->isInherited());
2043     Record.push_back(A->isImplicit());
2044     Record.push_back(A->isPackExpansion());
2045     break;
2046   }
2047   case attr::OSReturnsRetainedOnZero: {
2048     const auto *SA = cast<OSReturnsRetainedOnZeroAttr>(A);
2049     Record.push_back(SA->isInherited());
2050     Record.push_back(A->isImplicit());
2051     Record.push_back(A->isPackExpansion());
2052     break;
2053   }
2054   case attr::ObjCBoxable: {
2055     Record.push_back(A->isImplicit());
2056     Record.push_back(A->isPackExpansion());
2057     break;
2058   }
2059   case attr::ObjCBridge: {
2060     const auto *SA = cast<ObjCBridgeAttr>(A);
2061     Record.push_back(SA->isInherited());
2062     Record.push_back(A->isImplicit());
2063     Record.push_back(A->isPackExpansion());
2064     Record.AddIdentifierRef(SA->getBridgedType());
2065     break;
2066   }
2067   case attr::ObjCBridgeMutable: {
2068     const auto *SA = cast<ObjCBridgeMutableAttr>(A);
2069     Record.push_back(SA->isInherited());
2070     Record.push_back(A->isImplicit());
2071     Record.push_back(A->isPackExpansion());
2072     Record.AddIdentifierRef(SA->getBridgedType());
2073     break;
2074   }
2075   case attr::ObjCBridgeRelated: {
2076     const auto *SA = cast<ObjCBridgeRelatedAttr>(A);
2077     Record.push_back(SA->isInherited());
2078     Record.push_back(A->isImplicit());
2079     Record.push_back(A->isPackExpansion());
2080     Record.AddIdentifierRef(SA->getRelatedClass());
2081     Record.AddIdentifierRef(SA->getClassMethod());
2082     Record.AddIdentifierRef(SA->getInstanceMethod());
2083     break;
2084   }
2085   case attr::ObjCClassStub: {
2086     Record.push_back(A->isImplicit());
2087     Record.push_back(A->isPackExpansion());
2088     break;
2089   }
2090   case attr::ObjCDesignatedInitializer: {
2091     Record.push_back(A->isImplicit());
2092     Record.push_back(A->isPackExpansion());
2093     break;
2094   }
2095   case attr::ObjCDirect: {
2096     Record.push_back(A->isImplicit());
2097     Record.push_back(A->isPackExpansion());
2098     break;
2099   }
2100   case attr::ObjCDirectMembers: {
2101     Record.push_back(A->isImplicit());
2102     Record.push_back(A->isPackExpansion());
2103     break;
2104   }
2105   case attr::ObjCException: {
2106     const auto *SA = cast<ObjCExceptionAttr>(A);
2107     Record.push_back(SA->isInherited());
2108     Record.push_back(A->isImplicit());
2109     Record.push_back(A->isPackExpansion());
2110     break;
2111   }
2112   case attr::ObjCExplicitProtocolImpl: {
2113     const auto *SA = cast<ObjCExplicitProtocolImplAttr>(A);
2114     Record.push_back(SA->isInherited());
2115     Record.push_back(A->isImplicit());
2116     Record.push_back(A->isPackExpansion());
2117     break;
2118   }
2119   case attr::ObjCExternallyRetained: {
2120     const auto *SA = cast<ObjCExternallyRetainedAttr>(A);
2121     Record.push_back(SA->isInherited());
2122     Record.push_back(A->isImplicit());
2123     Record.push_back(A->isPackExpansion());
2124     break;
2125   }
2126   case attr::ObjCGC: {
2127     const auto *SA = cast<ObjCGCAttr>(A);
2128     Record.push_back(A->isImplicit());
2129     Record.push_back(A->isPackExpansion());
2130     Record.AddIdentifierRef(SA->getKind());
2131     break;
2132   }
2133   case attr::ObjCIndependentClass: {
2134     const auto *SA = cast<ObjCIndependentClassAttr>(A);
2135     Record.push_back(SA->isInherited());
2136     Record.push_back(A->isImplicit());
2137     Record.push_back(A->isPackExpansion());
2138     break;
2139   }
2140   case attr::ObjCInertUnsafeUnretained: {
2141     Record.push_back(A->isImplicit());
2142     Record.push_back(A->isPackExpansion());
2143     break;
2144   }
2145   case attr::ObjCKindOf: {
2146     Record.push_back(A->isImplicit());
2147     Record.push_back(A->isPackExpansion());
2148     break;
2149   }
2150   case attr::ObjCMethodFamily: {
2151     const auto *SA = cast<ObjCMethodFamilyAttr>(A);
2152     Record.push_back(SA->isInherited());
2153     Record.push_back(A->isImplicit());
2154     Record.push_back(A->isPackExpansion());
2155 Record.push_back(static_cast<uint64_t>(SA->getFamily()));
2156     break;
2157   }
2158   case attr::ObjCNSObject: {
2159     const auto *SA = cast<ObjCNSObjectAttr>(A);
2160     Record.push_back(SA->isInherited());
2161     Record.push_back(A->isImplicit());
2162     Record.push_back(A->isPackExpansion());
2163     break;
2164   }
2165   case attr::ObjCNonLazyClass: {
2166     Record.push_back(A->isImplicit());
2167     Record.push_back(A->isPackExpansion());
2168     break;
2169   }
2170   case attr::ObjCNonRuntimeProtocol: {
2171     Record.push_back(A->isImplicit());
2172     Record.push_back(A->isPackExpansion());
2173     break;
2174   }
2175   case attr::ObjCOwnership: {
2176     const auto *SA = cast<ObjCOwnershipAttr>(A);
2177     Record.push_back(SA->isInherited());
2178     Record.push_back(A->isImplicit());
2179     Record.push_back(A->isPackExpansion());
2180     Record.AddIdentifierRef(SA->getKind());
2181     break;
2182   }
2183   case attr::ObjCPreciseLifetime: {
2184     const auto *SA = cast<ObjCPreciseLifetimeAttr>(A);
2185     Record.push_back(SA->isInherited());
2186     Record.push_back(A->isImplicit());
2187     Record.push_back(A->isPackExpansion());
2188     break;
2189   }
2190   case attr::ObjCRequiresPropertyDefs: {
2191     const auto *SA = cast<ObjCRequiresPropertyDefsAttr>(A);
2192     Record.push_back(SA->isInherited());
2193     Record.push_back(A->isImplicit());
2194     Record.push_back(A->isPackExpansion());
2195     break;
2196   }
2197   case attr::ObjCRequiresSuper: {
2198     const auto *SA = cast<ObjCRequiresSuperAttr>(A);
2199     Record.push_back(SA->isInherited());
2200     Record.push_back(A->isImplicit());
2201     Record.push_back(A->isPackExpansion());
2202     break;
2203   }
2204   case attr::ObjCReturnsInnerPointer: {
2205     const auto *SA = cast<ObjCReturnsInnerPointerAttr>(A);
2206     Record.push_back(SA->isInherited());
2207     Record.push_back(A->isImplicit());
2208     Record.push_back(A->isPackExpansion());
2209     break;
2210   }
2211   case attr::ObjCRootClass: {
2212     const auto *SA = cast<ObjCRootClassAttr>(A);
2213     Record.push_back(SA->isInherited());
2214     Record.push_back(A->isImplicit());
2215     Record.push_back(A->isPackExpansion());
2216     break;
2217   }
2218   case attr::ObjCRuntimeName: {
2219     const auto *SA = cast<ObjCRuntimeNameAttr>(A);
2220     Record.push_back(A->isImplicit());
2221     Record.push_back(A->isPackExpansion());
2222     Record.AddString(SA->getMetadataName());
2223     break;
2224   }
2225   case attr::ObjCRuntimeVisible: {
2226     Record.push_back(A->isImplicit());
2227     Record.push_back(A->isPackExpansion());
2228     break;
2229   }
2230   case attr::ObjCSubclassingRestricted: {
2231     const auto *SA = cast<ObjCSubclassingRestrictedAttr>(A);
2232     Record.push_back(SA->isInherited());
2233     Record.push_back(A->isImplicit());
2234     Record.push_back(A->isPackExpansion());
2235     break;
2236   }
2237   case attr::OpenCLAccess: {
2238     Record.push_back(A->isImplicit());
2239     Record.push_back(A->isPackExpansion());
2240     break;
2241   }
2242   case attr::OpenCLConstantAddressSpace: {
2243     Record.push_back(A->isImplicit());
2244     Record.push_back(A->isPackExpansion());
2245     break;
2246   }
2247   case attr::OpenCLGenericAddressSpace: {
2248     Record.push_back(A->isImplicit());
2249     Record.push_back(A->isPackExpansion());
2250     break;
2251   }
2252   case attr::OpenCLGlobalAddressSpace: {
2253     Record.push_back(A->isImplicit());
2254     Record.push_back(A->isPackExpansion());
2255     break;
2256   }
2257   case attr::OpenCLGlobalDeviceAddressSpace: {
2258     Record.push_back(A->isImplicit());
2259     Record.push_back(A->isPackExpansion());
2260     break;
2261   }
2262   case attr::OpenCLGlobalHostAddressSpace: {
2263     Record.push_back(A->isImplicit());
2264     Record.push_back(A->isPackExpansion());
2265     break;
2266   }
2267   case attr::OpenCLIntelReqdSubGroupSize: {
2268     const auto *SA = cast<OpenCLIntelReqdSubGroupSizeAttr>(A);
2269     Record.push_back(SA->isInherited());
2270     Record.push_back(A->isImplicit());
2271     Record.push_back(A->isPackExpansion());
2272     Record.push_back(SA->getSubGroupSize());
2273     break;
2274   }
2275   case attr::OpenCLKernel: {
2276     const auto *SA = cast<OpenCLKernelAttr>(A);
2277     Record.push_back(SA->isInherited());
2278     Record.push_back(A->isImplicit());
2279     Record.push_back(A->isPackExpansion());
2280     break;
2281   }
2282   case attr::OpenCLLocalAddressSpace: {
2283     Record.push_back(A->isImplicit());
2284     Record.push_back(A->isPackExpansion());
2285     break;
2286   }
2287   case attr::OpenCLPrivateAddressSpace: {
2288     Record.push_back(A->isImplicit());
2289     Record.push_back(A->isPackExpansion());
2290     break;
2291   }
2292   case attr::OpenCLUnrollHint: {
2293     const auto *SA = cast<OpenCLUnrollHintAttr>(A);
2294     Record.push_back(A->isImplicit());
2295     Record.push_back(A->isPackExpansion());
2296     Record.push_back(SA->getUnrollHint());
2297     break;
2298   }
2299   case attr::OptimizeNone: {
2300     const auto *SA = cast<OptimizeNoneAttr>(A);
2301     Record.push_back(SA->isInherited());
2302     Record.push_back(A->isImplicit());
2303     Record.push_back(A->isPackExpansion());
2304     break;
2305   }
2306   case attr::Overloadable: {
2307     Record.push_back(A->isImplicit());
2308     Record.push_back(A->isPackExpansion());
2309     break;
2310   }
2311   case attr::Override: {
2312     const auto *SA = cast<OverrideAttr>(A);
2313     Record.push_back(SA->isInherited());
2314     Record.push_back(A->isImplicit());
2315     Record.push_back(A->isPackExpansion());
2316     break;
2317   }
2318   case attr::Owner: {
2319     const auto *SA = cast<OwnerAttr>(A);
2320     Record.push_back(SA->isInherited());
2321     Record.push_back(A->isImplicit());
2322     Record.push_back(A->isPackExpansion());
2323     Record.AddTypeSourceInfo(SA->getDerefTypeLoc());
2324     break;
2325   }
2326   case attr::Ownership: {
2327     const auto *SA = cast<OwnershipAttr>(A);
2328     Record.push_back(SA->isInherited());
2329     Record.push_back(A->isImplicit());
2330     Record.push_back(A->isPackExpansion());
2331     Record.AddIdentifierRef(SA->getModule());
2332     Record.push_back(SA->args_size());
2333     for (auto &Val : SA->args())
2334       Record.push_back(Val.serialize());
2335     break;
2336   }
2337   case attr::Packed: {
2338     const auto *SA = cast<PackedAttr>(A);
2339     Record.push_back(SA->isInherited());
2340     Record.push_back(A->isImplicit());
2341     Record.push_back(A->isPackExpansion());
2342     break;
2343   }
2344   case attr::ParamTypestate: {
2345     const auto *SA = cast<ParamTypestateAttr>(A);
2346     Record.push_back(SA->isInherited());
2347     Record.push_back(A->isImplicit());
2348     Record.push_back(A->isPackExpansion());
2349 Record.push_back(static_cast<uint64_t>(SA->getParamState()));
2350     break;
2351   }
2352   case attr::Pascal: {
2353     const auto *SA = cast<PascalAttr>(A);
2354     Record.push_back(SA->isInherited());
2355     Record.push_back(A->isImplicit());
2356     Record.push_back(A->isPackExpansion());
2357     break;
2358   }
2359   case attr::PassObjectSize: {
2360     const auto *SA = cast<PassObjectSizeAttr>(A);
2361     Record.push_back(SA->isInherited());
2362     Record.push_back(A->isImplicit());
2363     Record.push_back(A->isPackExpansion());
2364     Record.push_back(SA->getType());
2365     break;
2366   }
2367   case attr::PatchableFunctionEntry: {
2368     const auto *SA = cast<PatchableFunctionEntryAttr>(A);
2369     Record.push_back(SA->isInherited());
2370     Record.push_back(A->isImplicit());
2371     Record.push_back(A->isPackExpansion());
2372     Record.push_back(SA->getCount());
2373     Record.push_back(SA->getOffset());
2374     break;
2375   }
2376   case attr::Pcs: {
2377     const auto *SA = cast<PcsAttr>(A);
2378     Record.push_back(SA->isInherited());
2379     Record.push_back(A->isImplicit());
2380     Record.push_back(A->isPackExpansion());
2381 Record.push_back(static_cast<uint64_t>(SA->getPCS()));
2382     break;
2383   }
2384   case attr::Pointer: {
2385     const auto *SA = cast<PointerAttr>(A);
2386     Record.push_back(SA->isInherited());
2387     Record.push_back(A->isImplicit());
2388     Record.push_back(A->isPackExpansion());
2389     Record.AddTypeSourceInfo(SA->getDerefTypeLoc());
2390     break;
2391   }
2392   case attr::PragmaClangBSSSection: {
2393     const auto *SA = cast<PragmaClangBSSSectionAttr>(A);
2394     Record.push_back(SA->isInherited());
2395     Record.push_back(A->isImplicit());
2396     Record.push_back(A->isPackExpansion());
2397     Record.AddString(SA->getName());
2398     break;
2399   }
2400   case attr::PragmaClangDataSection: {
2401     const auto *SA = cast<PragmaClangDataSectionAttr>(A);
2402     Record.push_back(SA->isInherited());
2403     Record.push_back(A->isImplicit());
2404     Record.push_back(A->isPackExpansion());
2405     Record.AddString(SA->getName());
2406     break;
2407   }
2408   case attr::PragmaClangRelroSection: {
2409     const auto *SA = cast<PragmaClangRelroSectionAttr>(A);
2410     Record.push_back(SA->isInherited());
2411     Record.push_back(A->isImplicit());
2412     Record.push_back(A->isPackExpansion());
2413     Record.AddString(SA->getName());
2414     break;
2415   }
2416   case attr::PragmaClangRodataSection: {
2417     const auto *SA = cast<PragmaClangRodataSectionAttr>(A);
2418     Record.push_back(SA->isInherited());
2419     Record.push_back(A->isImplicit());
2420     Record.push_back(A->isPackExpansion());
2421     Record.AddString(SA->getName());
2422     break;
2423   }
2424   case attr::PragmaClangTextSection: {
2425     const auto *SA = cast<PragmaClangTextSectionAttr>(A);
2426     Record.push_back(SA->isInherited());
2427     Record.push_back(A->isImplicit());
2428     Record.push_back(A->isPackExpansion());
2429     Record.AddString(SA->getName());
2430     break;
2431   }
2432   case attr::PreferredName: {
2433     const auto *SA = cast<PreferredNameAttr>(A);
2434     Record.push_back(SA->isInherited());
2435     Record.push_back(A->isImplicit());
2436     Record.push_back(A->isPackExpansion());
2437     Record.AddTypeSourceInfo(SA->getTypedefTypeLoc());
2438     break;
2439   }
2440   case attr::PreferredType: {
2441     const auto *SA = cast<PreferredTypeAttr>(A);
2442     Record.push_back(SA->isInherited());
2443     Record.push_back(A->isImplicit());
2444     Record.push_back(A->isPackExpansion());
2445     Record.AddTypeSourceInfo(SA->getTypeLoc());
2446     break;
2447   }
2448   case attr::PreserveAll: {
2449     const auto *SA = cast<PreserveAllAttr>(A);
2450     Record.push_back(SA->isInherited());
2451     Record.push_back(A->isImplicit());
2452     Record.push_back(A->isPackExpansion());
2453     break;
2454   }
2455   case attr::PreserveMost: {
2456     const auto *SA = cast<PreserveMostAttr>(A);
2457     Record.push_back(SA->isInherited());
2458     Record.push_back(A->isImplicit());
2459     Record.push_back(A->isPackExpansion());
2460     break;
2461   }
2462   case attr::PreserveNone: {
2463     const auto *SA = cast<PreserveNoneAttr>(A);
2464     Record.push_back(SA->isInherited());
2465     Record.push_back(A->isImplicit());
2466     Record.push_back(A->isPackExpansion());
2467     break;
2468   }
2469   case attr::PtGuardedBy: {
2470     const auto *SA = cast<PtGuardedByAttr>(A);
2471     Record.push_back(SA->isInherited());
2472     Record.push_back(A->isImplicit());
2473     Record.push_back(A->isPackExpansion());
2474     Record.AddStmt(SA->getArg());
2475     break;
2476   }
2477   case attr::PtGuardedVar: {
2478     const auto *SA = cast<PtGuardedVarAttr>(A);
2479     Record.push_back(SA->isInherited());
2480     Record.push_back(A->isImplicit());
2481     Record.push_back(A->isPackExpansion());
2482     break;
2483   }
2484   case attr::Ptr32: {
2485     Record.push_back(A->isImplicit());
2486     Record.push_back(A->isPackExpansion());
2487     break;
2488   }
2489   case attr::Ptr64: {
2490     Record.push_back(A->isImplicit());
2491     Record.push_back(A->isPackExpansion());
2492     break;
2493   }
2494   case attr::Pure: {
2495     const auto *SA = cast<PureAttr>(A);
2496     Record.push_back(SA->isInherited());
2497     Record.push_back(A->isImplicit());
2498     Record.push_back(A->isPackExpansion());
2499     break;
2500   }
2501   case attr::RISCVInterrupt: {
2502     const auto *SA = cast<RISCVInterruptAttr>(A);
2503     Record.push_back(SA->isInherited());
2504     Record.push_back(A->isImplicit());
2505     Record.push_back(A->isPackExpansion());
2506 Record.push_back(static_cast<uint64_t>(SA->getInterrupt()));
2507     break;
2508   }
2509   case attr::RISCVVectorCC: {
2510     const auto *SA = cast<RISCVVectorCCAttr>(A);
2511     Record.push_back(SA->isInherited());
2512     Record.push_back(A->isImplicit());
2513     Record.push_back(A->isPackExpansion());
2514     break;
2515   }
2516   case attr::RandomizeLayout: {
2517     const auto *SA = cast<RandomizeLayoutAttr>(A);
2518     Record.push_back(SA->isInherited());
2519     Record.push_back(A->isImplicit());
2520     Record.push_back(A->isPackExpansion());
2521     break;
2522   }
2523   case attr::ReadOnlyPlacement: {
2524     const auto *SA = cast<ReadOnlyPlacementAttr>(A);
2525     Record.push_back(SA->isInherited());
2526     Record.push_back(A->isImplicit());
2527     Record.push_back(A->isPackExpansion());
2528     break;
2529   }
2530   case attr::RegCall: {
2531     const auto *SA = cast<RegCallAttr>(A);
2532     Record.push_back(SA->isInherited());
2533     Record.push_back(A->isImplicit());
2534     Record.push_back(A->isPackExpansion());
2535     break;
2536   }
2537   case attr::Reinitializes: {
2538     const auto *SA = cast<ReinitializesAttr>(A);
2539     Record.push_back(SA->isInherited());
2540     Record.push_back(A->isImplicit());
2541     Record.push_back(A->isPackExpansion());
2542     break;
2543   }
2544   case attr::ReleaseCapability: {
2545     const auto *SA = cast<ReleaseCapabilityAttr>(A);
2546     Record.push_back(SA->isInherited());
2547     Record.push_back(A->isImplicit());
2548     Record.push_back(A->isPackExpansion());
2549     Record.push_back(SA->args_size());
2550     for (auto &Val : SA->args())
2551       Record.AddStmt(Val);
2552     break;
2553   }
2554   case attr::ReleaseHandle: {
2555     const auto *SA = cast<ReleaseHandleAttr>(A);
2556     Record.push_back(SA->isInherited());
2557     Record.push_back(A->isImplicit());
2558     Record.push_back(A->isPackExpansion());
2559     Record.AddString(SA->getHandleType());
2560     break;
2561   }
2562   case attr::ReqdWorkGroupSize: {
2563     const auto *SA = cast<ReqdWorkGroupSizeAttr>(A);
2564     Record.push_back(SA->isInherited());
2565     Record.push_back(A->isImplicit());
2566     Record.push_back(A->isPackExpansion());
2567     Record.push_back(SA->getXDim());
2568     Record.push_back(SA->getYDim());
2569     Record.push_back(SA->getZDim());
2570     break;
2571   }
2572   case attr::RequiresCapability: {
2573     const auto *SA = cast<RequiresCapabilityAttr>(A);
2574     Record.push_back(SA->isInherited());
2575     Record.push_back(A->isImplicit());
2576     Record.push_back(A->isPackExpansion());
2577     Record.push_back(SA->args_size());
2578     for (auto &Val : SA->args())
2579       Record.AddStmt(Val);
2580     break;
2581   }
2582   case attr::Restrict: {
2583     const auto *SA = cast<RestrictAttr>(A);
2584     Record.push_back(SA->isInherited());
2585     Record.push_back(A->isImplicit());
2586     Record.push_back(A->isPackExpansion());
2587     break;
2588   }
2589   case attr::Retain: {
2590     const auto *SA = cast<RetainAttr>(A);
2591     Record.push_back(SA->isInherited());
2592     Record.push_back(A->isImplicit());
2593     Record.push_back(A->isPackExpansion());
2594     break;
2595   }
2596   case attr::ReturnTypestate: {
2597     const auto *SA = cast<ReturnTypestateAttr>(A);
2598     Record.push_back(SA->isInherited());
2599     Record.push_back(A->isImplicit());
2600     Record.push_back(A->isPackExpansion());
2601 Record.push_back(static_cast<uint64_t>(SA->getState()));
2602     break;
2603   }
2604   case attr::ReturnsNonNull: {
2605     const auto *SA = cast<ReturnsNonNullAttr>(A);
2606     Record.push_back(SA->isInherited());
2607     Record.push_back(A->isImplicit());
2608     Record.push_back(A->isPackExpansion());
2609     break;
2610   }
2611   case attr::ReturnsTwice: {
2612     const auto *SA = cast<ReturnsTwiceAttr>(A);
2613     Record.push_back(SA->isInherited());
2614     Record.push_back(A->isImplicit());
2615     Record.push_back(A->isPackExpansion());
2616     break;
2617   }
2618   case attr::SPtr: {
2619     Record.push_back(A->isImplicit());
2620     Record.push_back(A->isPackExpansion());
2621     break;
2622   }
2623   case attr::SYCLKernel: {
2624     const auto *SA = cast<SYCLKernelAttr>(A);
2625     Record.push_back(SA->isInherited());
2626     Record.push_back(A->isImplicit());
2627     Record.push_back(A->isPackExpansion());
2628     break;
2629   }
2630   case attr::SYCLKernelEntryPoint: {
2631     const auto *SA = cast<SYCLKernelEntryPointAttr>(A);
2632     Record.push_back(SA->isInherited());
2633     Record.push_back(A->isImplicit());
2634     Record.push_back(A->isPackExpansion());
2635     Record.AddTypeSourceInfo(SA->getKernelNameLoc());
2636     Record.push_back(SA->getInvalid());
2637     break;
2638   }
2639   case attr::SYCLSpecialClass: {
2640     const auto *SA = cast<SYCLSpecialClassAttr>(A);
2641     Record.push_back(SA->isInherited());
2642     Record.push_back(A->isImplicit());
2643     Record.push_back(A->isPackExpansion());
2644     break;
2645   }
2646   case attr::ScopedLockable: {
2647     const auto *SA = cast<ScopedLockableAttr>(A);
2648     Record.push_back(SA->isInherited());
2649     Record.push_back(A->isImplicit());
2650     Record.push_back(A->isPackExpansion());
2651     break;
2652   }
2653   case attr::Section: {
2654     const auto *SA = cast<SectionAttr>(A);
2655     Record.push_back(SA->isInherited());
2656     Record.push_back(A->isImplicit());
2657     Record.push_back(A->isPackExpansion());
2658     Record.AddString(SA->getName());
2659     break;
2660   }
2661   case attr::SelectAny: {
2662     const auto *SA = cast<SelectAnyAttr>(A);
2663     Record.push_back(SA->isInherited());
2664     Record.push_back(A->isImplicit());
2665     Record.push_back(A->isPackExpansion());
2666     break;
2667   }
2668   case attr::Sentinel: {
2669     const auto *SA = cast<SentinelAttr>(A);
2670     Record.push_back(SA->isInherited());
2671     Record.push_back(A->isImplicit());
2672     Record.push_back(A->isPackExpansion());
2673     Record.push_back(SA->getSentinel());
2674     Record.push_back(SA->getNullPos());
2675     break;
2676   }
2677   case attr::SetTypestate: {
2678     const auto *SA = cast<SetTypestateAttr>(A);
2679     Record.push_back(SA->isInherited());
2680     Record.push_back(A->isImplicit());
2681     Record.push_back(A->isPackExpansion());
2682 Record.push_back(static_cast<uint64_t>(SA->getNewState()));
2683     break;
2684   }
2685   case attr::SharedTrylockFunction: {
2686     const auto *SA = cast<SharedTrylockFunctionAttr>(A);
2687     Record.push_back(SA->isInherited());
2688     Record.push_back(A->isImplicit());
2689     Record.push_back(A->isPackExpansion());
2690     Record.AddStmt(SA->getSuccessValue());
2691     Record.push_back(SA->args_size());
2692     for (auto &Val : SA->args())
2693       Record.AddStmt(Val);
2694     break;
2695   }
2696   case attr::SizedBy: {
2697     const auto *SA = cast<SizedByAttr>(A);
2698     Record.push_back(SA->isInherited());
2699     Record.push_back(A->isImplicit());
2700     Record.push_back(A->isPackExpansion());
2701     Record.AddStmt(SA->getSize());
2702     Record.push_back(SA->getNestedLevel());
2703     break;
2704   }
2705   case attr::SizedByOrNull: {
2706     const auto *SA = cast<SizedByOrNullAttr>(A);
2707     Record.push_back(SA->isInherited());
2708     Record.push_back(A->isImplicit());
2709     Record.push_back(A->isPackExpansion());
2710     Record.AddStmt(SA->getSize());
2711     Record.push_back(SA->getNestedLevel());
2712     break;
2713   }
2714   case attr::SpeculativeLoadHardening: {
2715     const auto *SA = cast<SpeculativeLoadHardeningAttr>(A);
2716     Record.push_back(SA->isInherited());
2717     Record.push_back(A->isImplicit());
2718     Record.push_back(A->isPackExpansion());
2719     break;
2720   }
2721   case attr::StandaloneDebug: {
2722     const auto *SA = cast<StandaloneDebugAttr>(A);
2723     Record.push_back(SA->isInherited());
2724     Record.push_back(A->isImplicit());
2725     Record.push_back(A->isPackExpansion());
2726     break;
2727   }
2728   case attr::StdCall: {
2729     const auto *SA = cast<StdCallAttr>(A);
2730     Record.push_back(SA->isInherited());
2731     Record.push_back(A->isImplicit());
2732     Record.push_back(A->isPackExpansion());
2733     break;
2734   }
2735   case attr::StrictFP: {
2736     const auto *SA = cast<StrictFPAttr>(A);
2737     Record.push_back(SA->isInherited());
2738     Record.push_back(A->isImplicit());
2739     Record.push_back(A->isPackExpansion());
2740     break;
2741   }
2742   case attr::StrictGuardStackCheck: {
2743     const auto *SA = cast<StrictGuardStackCheckAttr>(A);
2744     Record.push_back(SA->isInherited());
2745     Record.push_back(A->isImplicit());
2746     Record.push_back(A->isPackExpansion());
2747     break;
2748   }
2749   case attr::Suppress: {
2750     const auto *SA = cast<SuppressAttr>(A);
2751     Record.push_back(SA->isInherited());
2752     Record.push_back(A->isImplicit());
2753     Record.push_back(A->isPackExpansion());
2754     Record.push_back(SA->diagnosticIdentifiers_size());
2755     for (auto &Val : SA->diagnosticIdentifiers())
2756       Record.AddString(Val);
2757     break;
2758   }
2759   case attr::SwiftAsync: {
2760     const auto *SA = cast<SwiftAsyncAttr>(A);
2761     Record.push_back(SA->isInherited());
2762     Record.push_back(A->isImplicit());
2763     Record.push_back(A->isPackExpansion());
2764 Record.push_back(static_cast<uint64_t>(SA->getKind()));
2765     Record.push_back(SA->getCompletionHandlerIndex().serialize());
2766     break;
2767   }
2768   case attr::SwiftAsyncCall: {
2769     const auto *SA = cast<SwiftAsyncCallAttr>(A);
2770     Record.push_back(SA->isInherited());
2771     Record.push_back(A->isImplicit());
2772     Record.push_back(A->isPackExpansion());
2773     break;
2774   }
2775   case attr::SwiftAsyncContext: {
2776     const auto *SA = cast<SwiftAsyncContextAttr>(A);
2777     Record.push_back(SA->isInherited());
2778     Record.push_back(A->isImplicit());
2779     Record.push_back(A->isPackExpansion());
2780     break;
2781   }
2782   case attr::SwiftAsyncError: {
2783     const auto *SA = cast<SwiftAsyncErrorAttr>(A);
2784     Record.push_back(SA->isInherited());
2785     Record.push_back(A->isImplicit());
2786     Record.push_back(A->isPackExpansion());
2787 Record.push_back(static_cast<uint64_t>(SA->getConvention()));
2788     Record.push_back(SA->getHandlerParamIdx());
2789     break;
2790   }
2791   case attr::SwiftAsyncName: {
2792     const auto *SA = cast<SwiftAsyncNameAttr>(A);
2793     Record.push_back(SA->isInherited());
2794     Record.push_back(A->isImplicit());
2795     Record.push_back(A->isPackExpansion());
2796     Record.AddString(SA->getName());
2797     break;
2798   }
2799   case attr::SwiftAttr: {
2800     const auto *SA = cast<SwiftAttrAttr>(A);
2801     Record.push_back(SA->isInherited());
2802     Record.push_back(A->isImplicit());
2803     Record.push_back(A->isPackExpansion());
2804     Record.AddString(SA->getAttribute());
2805     break;
2806   }
2807   case attr::SwiftBridge: {
2808     const auto *SA = cast<SwiftBridgeAttr>(A);
2809     Record.push_back(SA->isInherited());
2810     Record.push_back(A->isImplicit());
2811     Record.push_back(A->isPackExpansion());
2812     Record.AddString(SA->getSwiftType());
2813     break;
2814   }
2815   case attr::SwiftBridgedTypedef: {
2816     const auto *SA = cast<SwiftBridgedTypedefAttr>(A);
2817     Record.push_back(SA->isInherited());
2818     Record.push_back(A->isImplicit());
2819     Record.push_back(A->isPackExpansion());
2820     break;
2821   }
2822   case attr::SwiftCall: {
2823     const auto *SA = cast<SwiftCallAttr>(A);
2824     Record.push_back(SA->isInherited());
2825     Record.push_back(A->isImplicit());
2826     Record.push_back(A->isPackExpansion());
2827     break;
2828   }
2829   case attr::SwiftContext: {
2830     const auto *SA = cast<SwiftContextAttr>(A);
2831     Record.push_back(SA->isInherited());
2832     Record.push_back(A->isImplicit());
2833     Record.push_back(A->isPackExpansion());
2834     break;
2835   }
2836   case attr::SwiftError: {
2837     const auto *SA = cast<SwiftErrorAttr>(A);
2838     Record.push_back(SA->isInherited());
2839     Record.push_back(A->isImplicit());
2840     Record.push_back(A->isPackExpansion());
2841 Record.push_back(static_cast<uint64_t>(SA->getConvention()));
2842     break;
2843   }
2844   case attr::SwiftErrorResult: {
2845     const auto *SA = cast<SwiftErrorResultAttr>(A);
2846     Record.push_back(SA->isInherited());
2847     Record.push_back(A->isImplicit());
2848     Record.push_back(A->isPackExpansion());
2849     break;
2850   }
2851   case attr::SwiftImportAsNonGeneric: {
2852     const auto *SA = cast<SwiftImportAsNonGenericAttr>(A);
2853     Record.push_back(SA->isInherited());
2854     Record.push_back(A->isImplicit());
2855     Record.push_back(A->isPackExpansion());
2856     break;
2857   }
2858   case attr::SwiftImportPropertyAsAccessors: {
2859     const auto *SA = cast<SwiftImportPropertyAsAccessorsAttr>(A);
2860     Record.push_back(SA->isInherited());
2861     Record.push_back(A->isImplicit());
2862     Record.push_back(A->isPackExpansion());
2863     break;
2864   }
2865   case attr::SwiftIndirectResult: {
2866     const auto *SA = cast<SwiftIndirectResultAttr>(A);
2867     Record.push_back(SA->isInherited());
2868     Record.push_back(A->isImplicit());
2869     Record.push_back(A->isPackExpansion());
2870     break;
2871   }
2872   case attr::SwiftName: {
2873     const auto *SA = cast<SwiftNameAttr>(A);
2874     Record.push_back(SA->isInherited());
2875     Record.push_back(A->isImplicit());
2876     Record.push_back(A->isPackExpansion());
2877     Record.AddString(SA->getName());
2878     break;
2879   }
2880   case attr::SwiftNewType: {
2881     const auto *SA = cast<SwiftNewTypeAttr>(A);
2882     Record.push_back(SA->isInherited());
2883     Record.push_back(A->isImplicit());
2884     Record.push_back(A->isPackExpansion());
2885 Record.push_back(static_cast<uint64_t>(SA->getNewtypeKind()));
2886     break;
2887   }
2888   case attr::SwiftObjCMembers: {
2889     Record.push_back(A->isImplicit());
2890     Record.push_back(A->isPackExpansion());
2891     break;
2892   }
2893   case attr::SwiftPrivate: {
2894     const auto *SA = cast<SwiftPrivateAttr>(A);
2895     Record.push_back(SA->isInherited());
2896     Record.push_back(A->isImplicit());
2897     Record.push_back(A->isPackExpansion());
2898     break;
2899   }
2900   case attr::SwiftVersionedAddition: {
2901     const auto *SA = cast<SwiftVersionedAdditionAttr>(A);
2902     Record.push_back(A->isImplicit());
2903     Record.push_back(A->isPackExpansion());
2904     Record.AddVersionTuple(SA->getVersion());
2905     AddAttr(SA->getAdditionalAttr());    Record.push_back(SA->getIsReplacedByActive());
2906     break;
2907   }
2908   case attr::SwiftVersionedRemoval: {
2909     const auto *SA = cast<SwiftVersionedRemovalAttr>(A);
2910     Record.push_back(A->isImplicit());
2911     Record.push_back(A->isPackExpansion());
2912     Record.AddVersionTuple(SA->getVersion());
2913     Record.push_back(SA->getRawKind());
2914     Record.push_back(SA->getIsReplacedByActive());
2915     break;
2916   }
2917   case attr::SysVABI: {
2918     const auto *SA = cast<SysVABIAttr>(A);
2919     Record.push_back(SA->isInherited());
2920     Record.push_back(A->isImplicit());
2921     Record.push_back(A->isPackExpansion());
2922     break;
2923   }
2924   case attr::TLSModel: {
2925     const auto *SA = cast<TLSModelAttr>(A);
2926     Record.push_back(SA->isInherited());
2927     Record.push_back(A->isImplicit());
2928     Record.push_back(A->isPackExpansion());
2929     Record.AddString(SA->getModel());
2930     break;
2931   }
2932   case attr::Target: {
2933     const auto *SA = cast<TargetAttr>(A);
2934     Record.push_back(SA->isInherited());
2935     Record.push_back(A->isImplicit());
2936     Record.push_back(A->isPackExpansion());
2937     Record.AddString(SA->getFeaturesStr());
2938     break;
2939   }
2940   case attr::TargetClones: {
2941     const auto *SA = cast<TargetClonesAttr>(A);
2942     Record.push_back(SA->isInherited());
2943     Record.push_back(A->isImplicit());
2944     Record.push_back(A->isPackExpansion());
2945     Record.push_back(SA->featuresStrs_size());
2946     for (auto &Val : SA->featuresStrs())
2947       Record.AddString(Val);
2948     break;
2949   }
2950   case attr::TargetVersion: {
2951     const auto *SA = cast<TargetVersionAttr>(A);
2952     Record.push_back(SA->isInherited());
2953     Record.push_back(A->isImplicit());
2954     Record.push_back(A->isPackExpansion());
2955     Record.AddString(SA->getNamesStr());
2956     break;
2957   }
2958   case attr::TestTypestate: {
2959     const auto *SA = cast<TestTypestateAttr>(A);
2960     Record.push_back(SA->isInherited());
2961     Record.push_back(A->isImplicit());
2962     Record.push_back(A->isPackExpansion());
2963 Record.push_back(static_cast<uint64_t>(SA->getTestState()));
2964     break;
2965   }
2966   case attr::ThisCall: {
2967     const auto *SA = cast<ThisCallAttr>(A);
2968     Record.push_back(SA->isInherited());
2969     Record.push_back(A->isImplicit());
2970     Record.push_back(A->isPackExpansion());
2971     break;
2972   }
2973   case attr::Thread: {
2974     Record.push_back(A->isImplicit());
2975     Record.push_back(A->isPackExpansion());
2976     break;
2977   }
2978   case attr::TransparentUnion: {
2979     const auto *SA = cast<TransparentUnionAttr>(A);
2980     Record.push_back(SA->isInherited());
2981     Record.push_back(A->isImplicit());
2982     Record.push_back(A->isPackExpansion());
2983     break;
2984   }
2985   case attr::TrivialABI: {
2986     const auto *SA = cast<TrivialABIAttr>(A);
2987     Record.push_back(SA->isInherited());
2988     Record.push_back(A->isImplicit());
2989     Record.push_back(A->isPackExpansion());
2990     break;
2991   }
2992   case attr::TryAcquireCapability: {
2993     const auto *SA = cast<TryAcquireCapabilityAttr>(A);
2994     Record.push_back(SA->isInherited());
2995     Record.push_back(A->isImplicit());
2996     Record.push_back(A->isPackExpansion());
2997     Record.AddStmt(SA->getSuccessValue());
2998     Record.push_back(SA->args_size());
2999     for (auto &Val : SA->args())
3000       Record.AddStmt(Val);
3001     break;
3002   }
3003   case attr::TypeNonNull: {
3004     Record.push_back(A->isImplicit());
3005     Record.push_back(A->isPackExpansion());
3006     break;
3007   }
3008   case attr::TypeNullUnspecified: {
3009     Record.push_back(A->isImplicit());
3010     Record.push_back(A->isPackExpansion());
3011     break;
3012   }
3013   case attr::TypeNullable: {
3014     const auto *SA = cast<TypeNullableAttr>(A);
3015     Record.push_back(SA->isInherited());
3016     Record.push_back(A->isImplicit());
3017     Record.push_back(A->isPackExpansion());
3018     break;
3019   }
3020   case attr::TypeNullableResult: {
3021     Record.push_back(A->isImplicit());
3022     Record.push_back(A->isPackExpansion());
3023     break;
3024   }
3025   case attr::TypeTagForDatatype: {
3026     const auto *SA = cast<TypeTagForDatatypeAttr>(A);
3027     Record.push_back(SA->isInherited());
3028     Record.push_back(A->isImplicit());
3029     Record.push_back(A->isPackExpansion());
3030     Record.AddIdentifierRef(SA->getArgumentKind());
3031     Record.AddTypeSourceInfo(SA->getMatchingCTypeLoc());
3032     Record.push_back(SA->getLayoutCompatible());
3033     Record.push_back(SA->getMustBeNull());
3034     break;
3035   }
3036   case attr::TypeVisibility: {
3037     const auto *SA = cast<TypeVisibilityAttr>(A);
3038     Record.push_back(SA->isInherited());
3039     Record.push_back(A->isImplicit());
3040     Record.push_back(A->isPackExpansion());
3041 Record.push_back(static_cast<uint64_t>(SA->getVisibility()));
3042     break;
3043   }
3044   case attr::UPtr: {
3045     Record.push_back(A->isImplicit());
3046     Record.push_back(A->isPackExpansion());
3047     break;
3048   }
3049   case attr::Unavailable: {
3050     const auto *SA = cast<UnavailableAttr>(A);
3051     Record.push_back(SA->isInherited());
3052     Record.push_back(A->isImplicit());
3053     Record.push_back(A->isPackExpansion());
3054     Record.AddString(SA->getMessage());
3055 Record.push_back(static_cast<uint64_t>(SA->getImplicitReason()));
3056     break;
3057   }
3058   case attr::Uninitialized: {
3059     const auto *SA = cast<UninitializedAttr>(A);
3060     Record.push_back(SA->isInherited());
3061     Record.push_back(A->isImplicit());
3062     Record.push_back(A->isPackExpansion());
3063     break;
3064   }
3065   case attr::Unlikely: {
3066     Record.push_back(A->isImplicit());
3067     Record.push_back(A->isPackExpansion());
3068     break;
3069   }
3070   case attr::UnsafeBufferUsage: {
3071     const auto *SA = cast<UnsafeBufferUsageAttr>(A);
3072     Record.push_back(SA->isInherited());
3073     Record.push_back(A->isImplicit());
3074     Record.push_back(A->isPackExpansion());
3075     break;
3076   }
3077   case attr::Unused: {
3078     const auto *SA = cast<UnusedAttr>(A);
3079     Record.push_back(SA->isInherited());
3080     Record.push_back(A->isImplicit());
3081     Record.push_back(A->isPackExpansion());
3082     break;
3083   }
3084   case attr::UseHandle: {
3085     const auto *SA = cast<UseHandleAttr>(A);
3086     Record.push_back(SA->isInherited());
3087     Record.push_back(A->isImplicit());
3088     Record.push_back(A->isPackExpansion());
3089     Record.AddString(SA->getHandleType());
3090     break;
3091   }
3092   case attr::Used: {
3093     const auto *SA = cast<UsedAttr>(A);
3094     Record.push_back(SA->isInherited());
3095     Record.push_back(A->isImplicit());
3096     Record.push_back(A->isPackExpansion());
3097     break;
3098   }
3099   case attr::UsingIfExists: {
3100     const auto *SA = cast<UsingIfExistsAttr>(A);
3101     Record.push_back(SA->isInherited());
3102     Record.push_back(A->isImplicit());
3103     Record.push_back(A->isPackExpansion());
3104     break;
3105   }
3106   case attr::Uuid: {
3107     const auto *SA = cast<UuidAttr>(A);
3108     Record.push_back(SA->isInherited());
3109     Record.push_back(A->isImplicit());
3110     Record.push_back(A->isPackExpansion());
3111     Record.AddString(SA->getGuid());
3112     Record.AddDeclRef(SA->getGuidDecl());
3113     break;
3114   }
3115   case attr::VTablePointerAuthentication: {
3116     const auto *SA = cast<VTablePointerAuthenticationAttr>(A);
3117     Record.push_back(SA->isInherited());
3118     Record.push_back(A->isImplicit());
3119     Record.push_back(A->isPackExpansion());
3120 Record.push_back(static_cast<uint64_t>(SA->getKey()));
3121 Record.push_back(static_cast<uint64_t>(SA->getAddressDiscrimination()));
3122 Record.push_back(static_cast<uint64_t>(SA->getExtraDiscrimination()));
3123     Record.push_back(SA->getCustomDiscriminationValue());
3124     break;
3125   }
3126   case attr::VecReturn: {
3127     const auto *SA = cast<VecReturnAttr>(A);
3128     Record.push_back(SA->isInherited());
3129     Record.push_back(A->isImplicit());
3130     Record.push_back(A->isPackExpansion());
3131     break;
3132   }
3133   case attr::VecTypeHint: {
3134     const auto *SA = cast<VecTypeHintAttr>(A);
3135     Record.push_back(SA->isInherited());
3136     Record.push_back(A->isImplicit());
3137     Record.push_back(A->isPackExpansion());
3138     Record.AddTypeSourceInfo(SA->getTypeHintLoc());
3139     break;
3140   }
3141   case attr::VectorCall: {
3142     const auto *SA = cast<VectorCallAttr>(A);
3143     Record.push_back(SA->isInherited());
3144     Record.push_back(A->isImplicit());
3145     Record.push_back(A->isPackExpansion());
3146     break;
3147   }
3148   case attr::Visibility: {
3149     const auto *SA = cast<VisibilityAttr>(A);
3150     Record.push_back(SA->isInherited());
3151     Record.push_back(A->isImplicit());
3152     Record.push_back(A->isPackExpansion());
3153 Record.push_back(static_cast<uint64_t>(SA->getVisibility()));
3154     break;
3155   }
3156   case attr::WarnUnused: {
3157     const auto *SA = cast<WarnUnusedAttr>(A);
3158     Record.push_back(SA->isInherited());
3159     Record.push_back(A->isImplicit());
3160     Record.push_back(A->isPackExpansion());
3161     break;
3162   }
3163   case attr::WarnUnusedResult: {
3164     const auto *SA = cast<WarnUnusedResultAttr>(A);
3165     Record.push_back(SA->isInherited());
3166     Record.push_back(A->isImplicit());
3167     Record.push_back(A->isPackExpansion());
3168     Record.AddString(SA->getMessage());
3169     break;
3170   }
3171   case attr::Weak: {
3172     const auto *SA = cast<WeakAttr>(A);
3173     Record.push_back(SA->isInherited());
3174     Record.push_back(A->isImplicit());
3175     Record.push_back(A->isPackExpansion());
3176     break;
3177   }
3178   case attr::WeakImport: {
3179     const auto *SA = cast<WeakImportAttr>(A);
3180     Record.push_back(SA->isInherited());
3181     Record.push_back(A->isImplicit());
3182     Record.push_back(A->isPackExpansion());
3183     break;
3184   }
3185   case attr::WeakRef: {
3186     const auto *SA = cast<WeakRefAttr>(A);
3187     Record.push_back(SA->isInherited());
3188     Record.push_back(A->isImplicit());
3189     Record.push_back(A->isPackExpansion());
3190     Record.AddString(SA->getAliasee());
3191     break;
3192   }
3193   case attr::WebAssemblyExportName: {
3194     const auto *SA = cast<WebAssemblyExportNameAttr>(A);
3195     Record.push_back(SA->isInherited());
3196     Record.push_back(A->isImplicit());
3197     Record.push_back(A->isPackExpansion());
3198     Record.AddString(SA->getExportName());
3199     break;
3200   }
3201   case attr::WebAssemblyFuncref: {
3202     Record.push_back(A->isImplicit());
3203     Record.push_back(A->isPackExpansion());
3204     break;
3205   }
3206   case attr::WebAssemblyImportModule: {
3207     const auto *SA = cast<WebAssemblyImportModuleAttr>(A);
3208     Record.push_back(SA->isInherited());
3209     Record.push_back(A->isImplicit());
3210     Record.push_back(A->isPackExpansion());
3211     Record.AddString(SA->getImportModule());
3212     break;
3213   }
3214   case attr::WebAssemblyImportName: {
3215     const auto *SA = cast<WebAssemblyImportNameAttr>(A);
3216     Record.push_back(SA->isInherited());
3217     Record.push_back(A->isImplicit());
3218     Record.push_back(A->isPackExpansion());
3219     Record.AddString(SA->getImportName());
3220     break;
3221   }
3222   case attr::WorkGroupSizeHint: {
3223     const auto *SA = cast<WorkGroupSizeHintAttr>(A);
3224     Record.push_back(SA->isInherited());
3225     Record.push_back(A->isImplicit());
3226     Record.push_back(A->isPackExpansion());
3227     Record.push_back(SA->getXDim());
3228     Record.push_back(SA->getYDim());
3229     Record.push_back(SA->getZDim());
3230     break;
3231   }
3232   case attr::X86ForceAlignArgPointer: {
3233     const auto *SA = cast<X86ForceAlignArgPointerAttr>(A);
3234     Record.push_back(SA->isInherited());
3235     Record.push_back(A->isImplicit());
3236     Record.push_back(A->isPackExpansion());
3237     break;
3238   }
3239   case attr::XRayInstrument: {
3240     const auto *SA = cast<XRayInstrumentAttr>(A);
3241     Record.push_back(SA->isInherited());
3242     Record.push_back(A->isImplicit());
3243     Record.push_back(A->isPackExpansion());
3244     break;
3245   }
3246   case attr::XRayLogArgs: {
3247     const auto *SA = cast<XRayLogArgsAttr>(A);
3248     Record.push_back(SA->isInherited());
3249     Record.push_back(A->isImplicit());
3250     Record.push_back(A->isPackExpansion());
3251     Record.push_back(SA->getArgumentCount());
3252     break;
3253   }
3254   case attr::ZeroCallUsedRegs: {
3255     const auto *SA = cast<ZeroCallUsedRegsAttr>(A);
3256     Record.push_back(SA->isInherited());
3257     Record.push_back(A->isImplicit());
3258     Record.push_back(A->isPackExpansion());
3259 Record.push_back(static_cast<uint64_t>(SA->getZeroCallUsedRegs()));
3260     break;
3261   }
3262   }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!