clang/Serialization/AttrPCHRead.inc

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Attribute deserialization code                                             *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009
0010   switch (Kind) {
0011   case attr::AArch64SVEPcs: {
0012     bool isInherited = Record.readInt();
0013     bool isImplicit = Record.readInt();
0014     bool isPackExpansion = Record.readInt();
0015     New = new (Context) AArch64SVEPcsAttr(Context, Info);
0016     cast<InheritableAttr>(New)->setInherited(isInherited);
0017     New->setImplicit(isImplicit);
0018     New->setPackExpansion(isPackExpansion);
0019     break;
0020   }
0021   case attr::AArch64VectorPcs: {
0022     bool isInherited = Record.readInt();
0023     bool isImplicit = Record.readInt();
0024     bool isPackExpansion = Record.readInt();
0025     New = new (Context) AArch64VectorPcsAttr(Context, Info);
0026     cast<InheritableAttr>(New)->setInherited(isInherited);
0027     New->setImplicit(isImplicit);
0028     New->setPackExpansion(isPackExpansion);
0029     break;
0030   }
0031   case attr::AMDGPUFlatWorkGroupSize: {
0032     bool isInherited = Record.readInt();
0033     bool isImplicit = Record.readInt();
0034     bool isPackExpansion = Record.readInt();
0035     Expr * min = Record.readExpr();
0036     Expr * max = Record.readExpr();
0037     New = new (Context) AMDGPUFlatWorkGroupSizeAttr(Context, Info, min, max);
0038     cast<InheritableAttr>(New)->setInherited(isInherited);
0039     New->setImplicit(isImplicit);
0040     New->setPackExpansion(isPackExpansion);
0041     break;
0042   }
0043   case attr::AMDGPUKernelCall: {
0044     bool isInherited = Record.readInt();
0045     bool isImplicit = Record.readInt();
0046     bool isPackExpansion = Record.readInt();
0047     New = new (Context) AMDGPUKernelCallAttr(Context, Info);
0048     cast<InheritableAttr>(New)->setInherited(isInherited);
0049     New->setImplicit(isImplicit);
0050     New->setPackExpansion(isPackExpansion);
0051     break;
0052   }
0053   case attr::AMDGPUMaxNumWorkGroups: {
0054     bool isInherited = Record.readInt();
0055     bool isImplicit = Record.readInt();
0056     bool isPackExpansion = Record.readInt();
0057     Expr * maxNumWorkGroupsX = Record.readExpr();
0058     Expr * maxNumWorkGroupsY = Record.readExpr();
0059     Expr * maxNumWorkGroupsZ = Record.readExpr();
0060     New = new (Context) AMDGPUMaxNumWorkGroupsAttr(Context, Info, maxNumWorkGroupsX, maxNumWorkGroupsY, maxNumWorkGroupsZ);
0061     cast<InheritableAttr>(New)->setInherited(isInherited);
0062     New->setImplicit(isImplicit);
0063     New->setPackExpansion(isPackExpansion);
0064     break;
0065   }
0066   case attr::AMDGPUNumSGPR: {
0067     bool isInherited = Record.readInt();
0068     bool isImplicit = Record.readInt();
0069     bool isPackExpansion = Record.readInt();
0070     unsigned numSGPR = Record.readInt();
0071     New = new (Context) AMDGPUNumSGPRAttr(Context, Info, numSGPR);
0072     cast<InheritableAttr>(New)->setInherited(isInherited);
0073     New->setImplicit(isImplicit);
0074     New->setPackExpansion(isPackExpansion);
0075     break;
0076   }
0077   case attr::AMDGPUNumVGPR: {
0078     bool isInherited = Record.readInt();
0079     bool isImplicit = Record.readInt();
0080     bool isPackExpansion = Record.readInt();
0081     unsigned numVGPR = Record.readInt();
0082     New = new (Context) AMDGPUNumVGPRAttr(Context, Info, numVGPR);
0083     cast<InheritableAttr>(New)->setInherited(isInherited);
0084     New->setImplicit(isImplicit);
0085     New->setPackExpansion(isPackExpansion);
0086     break;
0087   }
0088   case attr::AMDGPUWavesPerEU: {
0089     bool isInherited = Record.readInt();
0090     bool isImplicit = Record.readInt();
0091     bool isPackExpansion = Record.readInt();
0092     Expr * min = Record.readExpr();
0093     Expr * max = Record.readExpr();
0094     New = new (Context) AMDGPUWavesPerEUAttr(Context, Info, min, max);
0095     cast<InheritableAttr>(New)->setInherited(isInherited);
0096     New->setImplicit(isImplicit);
0097     New->setPackExpansion(isPackExpansion);
0098     break;
0099   }
0100   case attr::ARMInterrupt: {
0101     bool isInherited = Record.readInt();
0102     bool isImplicit = Record.readInt();
0103     bool isPackExpansion = Record.readInt();
0104     ARMInterruptAttr::InterruptType interrupt(static_cast<ARMInterruptAttr::InterruptType>(Record.readInt()));
0105     New = new (Context) ARMInterruptAttr(Context, Info, interrupt);
0106     cast<InheritableAttr>(New)->setInherited(isInherited);
0107     New->setImplicit(isImplicit);
0108     New->setPackExpansion(isPackExpansion);
0109     break;
0110   }
0111   case attr::AVRInterrupt: {
0112     bool isInherited = Record.readInt();
0113     bool isImplicit = Record.readInt();
0114     bool isPackExpansion = Record.readInt();
0115     New = new (Context) AVRInterruptAttr(Context, Info);
0116     cast<InheritableAttr>(New)->setInherited(isInherited);
0117     New->setImplicit(isImplicit);
0118     New->setPackExpansion(isPackExpansion);
0119     break;
0120   }
0121   case attr::AVRSignal: {
0122     bool isInherited = Record.readInt();
0123     bool isImplicit = Record.readInt();
0124     bool isPackExpansion = Record.readInt();
0125     New = new (Context) AVRSignalAttr(Context, Info);
0126     cast<InheritableAttr>(New)->setInherited(isInherited);
0127     New->setImplicit(isImplicit);
0128     New->setPackExpansion(isPackExpansion);
0129     break;
0130   }
0131   case attr::AbiTag: {
0132     bool isImplicit = Record.readInt();
0133     bool isPackExpansion = Record.readInt();
0134     unsigned tagsSize = Record.readInt();
0135     SmallVector<StringRef, 4> tags;
0136     tags.reserve(tagsSize);
0137     SmallVector<std::string, 4> tagsStorage;
0138     tagsStorage.reserve(tagsSize);
0139     for (unsigned i = 0; i != tagsSize; ++i)
0140       tagsStorage.push_back(Record.readString());
0141     for (unsigned i = 0; i != tagsSize; ++i)
0142       tags.push_back(tagsStorage[i]);
0143     New = new (Context) AbiTagAttr(Context, Info, tags.data(), tagsSize);
0144     New->setImplicit(isImplicit);
0145     New->setPackExpansion(isPackExpansion);
0146     break;
0147   }
0148   case attr::AcquireCapability: {
0149     bool isInherited = Record.readInt();
0150     bool isImplicit = Record.readInt();
0151     bool isPackExpansion = Record.readInt();
0152     unsigned argsSize = Record.readInt();
0153     SmallVector<Expr *, 4> args;
0154     args.reserve(argsSize);
0155     for (unsigned i = 0; i != argsSize; ++i)
0156       args.push_back(Record.readExpr());
0157     New = new (Context) AcquireCapabilityAttr(Context, Info, args.data(), argsSize);
0158     cast<InheritableAttr>(New)->setInherited(isInherited);
0159     New->setImplicit(isImplicit);
0160     New->setPackExpansion(isPackExpansion);
0161     break;
0162   }
0163   case attr::AcquireHandle: {
0164     bool isInherited = Record.readInt();
0165     bool isImplicit = Record.readInt();
0166     bool isPackExpansion = Record.readInt();
0167     std::string handleType= Record.readString();
0168     New = new (Context) AcquireHandleAttr(Context, Info, handleType);
0169     cast<InheritableAttr>(New)->setInherited(isInherited);
0170     New->setImplicit(isImplicit);
0171     New->setPackExpansion(isPackExpansion);
0172     break;
0173   }
0174   case attr::AcquiredAfter: {
0175     bool isInherited = Record.readInt();
0176     bool isImplicit = Record.readInt();
0177     bool isPackExpansion = Record.readInt();
0178     unsigned argsSize = Record.readInt();
0179     SmallVector<Expr *, 4> args;
0180     args.reserve(argsSize);
0181     for (unsigned i = 0; i != argsSize; ++i)
0182       args.push_back(Record.readExpr());
0183     New = new (Context) AcquiredAfterAttr(Context, Info, args.data(), argsSize);
0184     cast<InheritableAttr>(New)->setInherited(isInherited);
0185     New->setImplicit(isImplicit);
0186     New->setPackExpansion(isPackExpansion);
0187     break;
0188   }
0189   case attr::AcquiredBefore: {
0190     bool isInherited = Record.readInt();
0191     bool isImplicit = Record.readInt();
0192     bool isPackExpansion = Record.readInt();
0193     unsigned argsSize = Record.readInt();
0194     SmallVector<Expr *, 4> args;
0195     args.reserve(argsSize);
0196     for (unsigned i = 0; i != argsSize; ++i)
0197       args.push_back(Record.readExpr());
0198     New = new (Context) AcquiredBeforeAttr(Context, Info, args.data(), argsSize);
0199     cast<InheritableAttr>(New)->setInherited(isInherited);
0200     New->setImplicit(isImplicit);
0201     New->setPackExpansion(isPackExpansion);
0202     break;
0203   }
0204   case attr::AddressSpace: {
0205     bool isImplicit = Record.readInt();
0206     bool isPackExpansion = Record.readInt();
0207     int addressSpace = Record.readInt();
0208     New = new (Context) AddressSpaceAttr(Context, Info, addressSpace);
0209     New->setImplicit(isImplicit);
0210     New->setPackExpansion(isPackExpansion);
0211     break;
0212   }
0213   case attr::Alias: {
0214     bool isImplicit = Record.readInt();
0215     bool isPackExpansion = Record.readInt();
0216     std::string aliasee= Record.readString();
0217     New = new (Context) AliasAttr(Context, Info, aliasee);
0218     New->setImplicit(isImplicit);
0219     New->setPackExpansion(isPackExpansion);
0220     break;
0221   }
0222   case attr::AlignMac68k: {
0223     bool isInherited = Record.readInt();
0224     bool isImplicit = Record.readInt();
0225     bool isPackExpansion = Record.readInt();
0226     New = new (Context) AlignMac68kAttr(Context, Info);
0227     cast<InheritableAttr>(New)->setInherited(isInherited);
0228     New->setImplicit(isImplicit);
0229     New->setPackExpansion(isPackExpansion);
0230     break;
0231   }
0232   case attr::AlignNatural: {
0233     bool isInherited = Record.readInt();
0234     bool isImplicit = Record.readInt();
0235     bool isPackExpansion = Record.readInt();
0236     New = new (Context) AlignNaturalAttr(Context, Info);
0237     cast<InheritableAttr>(New)->setInherited(isInherited);
0238     New->setImplicit(isImplicit);
0239     New->setPackExpansion(isPackExpansion);
0240     break;
0241   }
0242   case attr::AlignValue: {
0243     bool isImplicit = Record.readInt();
0244     bool isPackExpansion = Record.readInt();
0245     Expr * alignment = Record.readExpr();
0246     New = new (Context) AlignValueAttr(Context, Info, alignment);
0247     New->setImplicit(isImplicit);
0248     New->setPackExpansion(isPackExpansion);
0249     break;
0250   }
0251   case attr::Aligned: {
0252     bool isInherited = Record.readInt();
0253     bool isImplicit = Record.readInt();
0254     bool isPackExpansion = Record.readInt();
0255     bool isalignmentExpr = Record.readInt();
0256     void *alignmentPtr;
0257     if (isalignmentExpr)
0258       alignmentPtr = Record.readExpr();
0259     else
0260       alignmentPtr = Record.readTypeSourceInfo();
0261     New = new (Context) AlignedAttr(Context, Info, isalignmentExpr, alignmentPtr);
0262     cast<InheritableAttr>(New)->setInherited(isInherited);
0263     New->setImplicit(isImplicit);
0264     New->setPackExpansion(isPackExpansion);
0265     break;
0266   }
0267   case attr::AllocAlign: {
0268     bool isInherited = Record.readInt();
0269     bool isImplicit = Record.readInt();
0270     bool isPackExpansion = Record.readInt();
0271     ParamIdx paramIndex = ParamIdx::deserialize(Record.readInt());
0272     New = new (Context) AllocAlignAttr(Context, Info, paramIndex);
0273     cast<InheritableAttr>(New)->setInherited(isInherited);
0274     New->setImplicit(isImplicit);
0275     New->setPackExpansion(isPackExpansion);
0276     break;
0277   }
0278   case attr::AllocSize: {
0279     bool isInherited = Record.readInt();
0280     bool isImplicit = Record.readInt();
0281     bool isPackExpansion = Record.readInt();
0282     ParamIdx elemSizeParam = ParamIdx::deserialize(Record.readInt());
0283     ParamIdx numElemsParam = ParamIdx::deserialize(Record.readInt());
0284     New = new (Context) AllocSizeAttr(Context, Info, elemSizeParam, numElemsParam);
0285     cast<InheritableAttr>(New)->setInherited(isInherited);
0286     New->setImplicit(isImplicit);
0287     New->setPackExpansion(isPackExpansion);
0288     break;
0289   }
0290   case attr::Allocating: {
0291     bool isImplicit = Record.readInt();
0292     bool isPackExpansion = Record.readInt();
0293     New = new (Context) AllocatingAttr(Context, Info);
0294     New->setImplicit(isImplicit);
0295     New->setPackExpansion(isPackExpansion);
0296     break;
0297   }
0298   case attr::AlwaysDestroy: {
0299     bool isInherited = Record.readInt();
0300     bool isImplicit = Record.readInt();
0301     bool isPackExpansion = Record.readInt();
0302     New = new (Context) AlwaysDestroyAttr(Context, Info);
0303     cast<InheritableAttr>(New)->setInherited(isInherited);
0304     New->setImplicit(isImplicit);
0305     New->setPackExpansion(isPackExpansion);
0306     break;
0307   }
0308   case attr::AlwaysInline: {
0309     bool isInherited = Record.readInt();
0310     bool isImplicit = Record.readInt();
0311     bool isPackExpansion = Record.readInt();
0312     New = new (Context) AlwaysInlineAttr(Context, Info);
0313     cast<InheritableAttr>(New)->setInherited(isInherited);
0314     New->setImplicit(isImplicit);
0315     New->setPackExpansion(isPackExpansion);
0316     break;
0317   }
0318   case attr::AnalyzerNoReturn: {
0319     bool isInherited = Record.readInt();
0320     bool isImplicit = Record.readInt();
0321     bool isPackExpansion = Record.readInt();
0322     New = new (Context) AnalyzerNoReturnAttr(Context, Info);
0323     cast<InheritableAttr>(New)->setInherited(isInherited);
0324     New->setImplicit(isImplicit);
0325     New->setPackExpansion(isPackExpansion);
0326     break;
0327   }
0328   case attr::Annotate: {
0329     bool isInherited = Record.readInt();
0330     bool isImplicit = Record.readInt();
0331     bool isPackExpansion = Record.readInt();
0332     unsigned delayedArgsSize = Record.readInt();
0333     SmallVector<Expr *, 4> delayedArgs;
0334     delayedArgs.reserve(delayedArgsSize);
0335     for (unsigned i = 0; i != delayedArgsSize; ++i)
0336       delayedArgs.push_back(Record.readExpr());
0337     std::string annotation= Record.readString();
0338     unsigned argsSize = Record.readInt();
0339     SmallVector<Expr *, 4> args;
0340     args.reserve(argsSize);
0341     for (unsigned i = 0; i != argsSize; ++i)
0342       args.push_back(Record.readExpr());
0343     New = new (Context) AnnotateAttr(Context, Info, annotation, args.data(), argsSize);
0344     cast<InheritableAttr>(New)->setInherited(isInherited);
0345     New->setImplicit(isImplicit);
0346     New->setPackExpansion(isPackExpansion);
0347     cast<AnnotateAttr>(New)->setDelayedArgs(Context, delayedArgs.data(), delayedArgsSize);
0348     break;
0349   }
0350   case attr::AnnotateType: {
0351     bool isImplicit = Record.readInt();
0352     bool isPackExpansion = Record.readInt();
0353     unsigned delayedArgsSize = Record.readInt();
0354     SmallVector<Expr *, 4> delayedArgs;
0355     delayedArgs.reserve(delayedArgsSize);
0356     for (unsigned i = 0; i != delayedArgsSize; ++i)
0357       delayedArgs.push_back(Record.readExpr());
0358     std::string annotation= Record.readString();
0359     unsigned argsSize = Record.readInt();
0360     SmallVector<Expr *, 4> args;
0361     args.reserve(argsSize);
0362     for (unsigned i = 0; i != argsSize; ++i)
0363       args.push_back(Record.readExpr());
0364     New = new (Context) AnnotateTypeAttr(Context, Info, annotation, args.data(), argsSize);
0365     New->setImplicit(isImplicit);
0366     New->setPackExpansion(isPackExpansion);
0367     cast<AnnotateTypeAttr>(New)->setDelayedArgs(Context, delayedArgs.data(), delayedArgsSize);
0368     break;
0369   }
0370   case attr::AnyX86Interrupt: {
0371     bool isInherited = Record.readInt();
0372     bool isImplicit = Record.readInt();
0373     bool isPackExpansion = Record.readInt();
0374     New = new (Context) AnyX86InterruptAttr(Context, Info);
0375     cast<InheritableAttr>(New)->setInherited(isInherited);
0376     New->setImplicit(isImplicit);
0377     New->setPackExpansion(isPackExpansion);
0378     break;
0379   }
0380   case attr::AnyX86NoCallerSavedRegisters: {
0381     bool isInherited = Record.readInt();
0382     bool isImplicit = Record.readInt();
0383     bool isPackExpansion = Record.readInt();
0384     New = new (Context) AnyX86NoCallerSavedRegistersAttr(Context, Info);
0385     cast<InheritableAttr>(New)->setInherited(isInherited);
0386     New->setImplicit(isImplicit);
0387     New->setPackExpansion(isPackExpansion);
0388     break;
0389   }
0390   case attr::AnyX86NoCfCheck: {
0391     bool isInherited = Record.readInt();
0392     bool isImplicit = Record.readInt();
0393     bool isPackExpansion = Record.readInt();
0394     New = new (Context) AnyX86NoCfCheckAttr(Context, Info);
0395     cast<InheritableAttr>(New)->setInherited(isInherited);
0396     New->setImplicit(isImplicit);
0397     New->setPackExpansion(isPackExpansion);
0398     break;
0399   }
0400   case attr::ArcWeakrefUnavailable: {
0401     bool isInherited = Record.readInt();
0402     bool isImplicit = Record.readInt();
0403     bool isPackExpansion = Record.readInt();
0404     New = new (Context) ArcWeakrefUnavailableAttr(Context, Info);
0405     cast<InheritableAttr>(New)->setInherited(isInherited);
0406     New->setImplicit(isImplicit);
0407     New->setPackExpansion(isPackExpansion);
0408     break;
0409   }
0410   case attr::ArgumentWithTypeTag: {
0411     bool isInherited = Record.readInt();
0412     bool isImplicit = Record.readInt();
0413     bool isPackExpansion = Record.readInt();
0414     IdentifierInfo * argumentKind = Record.readIdentifier();
0415     ParamIdx argumentIdx = ParamIdx::deserialize(Record.readInt());
0416     ParamIdx typeTagIdx = ParamIdx::deserialize(Record.readInt());
0417     bool isPointer = Record.readInt();
0418     New = new (Context) ArgumentWithTypeTagAttr(Context, Info, argumentKind, argumentIdx, typeTagIdx, isPointer);
0419     cast<InheritableAttr>(New)->setInherited(isInherited);
0420     New->setImplicit(isImplicit);
0421     New->setPackExpansion(isPackExpansion);
0422     break;
0423   }
0424   case attr::ArmAgnostic: {
0425     bool isImplicit = Record.readInt();
0426     bool isPackExpansion = Record.readInt();
0427     unsigned agnosticArgsSize = Record.readInt();
0428     SmallVector<StringRef, 4> agnosticArgs;
0429     agnosticArgs.reserve(agnosticArgsSize);
0430     SmallVector<std::string, 4> agnosticArgsStorage;
0431     agnosticArgsStorage.reserve(agnosticArgsSize);
0432     for (unsigned i = 0; i != agnosticArgsSize; ++i)
0433       agnosticArgsStorage.push_back(Record.readString());
0434     for (unsigned i = 0; i != agnosticArgsSize; ++i)
0435       agnosticArgs.push_back(agnosticArgsStorage[i]);
0436     New = new (Context) ArmAgnosticAttr(Context, Info, agnosticArgs.data(), agnosticArgsSize);
0437     New->setImplicit(isImplicit);
0438     New->setPackExpansion(isPackExpansion);
0439     break;
0440   }
0441   case attr::ArmBuiltinAlias: {
0442     bool isInherited = Record.readInt();
0443     bool isImplicit = Record.readInt();
0444     bool isPackExpansion = Record.readInt();
0445     IdentifierInfo * builtinName = Record.readIdentifier();
0446     New = new (Context) ArmBuiltinAliasAttr(Context, Info, builtinName);
0447     cast<InheritableAttr>(New)->setInherited(isInherited);
0448     New->setImplicit(isImplicit);
0449     New->setPackExpansion(isPackExpansion);
0450     break;
0451   }
0452   case attr::ArmIn: {
0453     bool isImplicit = Record.readInt();
0454     bool isPackExpansion = Record.readInt();
0455     unsigned inArgsSize = Record.readInt();
0456     SmallVector<StringRef, 4> inArgs;
0457     inArgs.reserve(inArgsSize);
0458     SmallVector<std::string, 4> inArgsStorage;
0459     inArgsStorage.reserve(inArgsSize);
0460     for (unsigned i = 0; i != inArgsSize; ++i)
0461       inArgsStorage.push_back(Record.readString());
0462     for (unsigned i = 0; i != inArgsSize; ++i)
0463       inArgs.push_back(inArgsStorage[i]);
0464     New = new (Context) ArmInAttr(Context, Info, inArgs.data(), inArgsSize);
0465     New->setImplicit(isImplicit);
0466     New->setPackExpansion(isPackExpansion);
0467     break;
0468   }
0469   case attr::ArmInOut: {
0470     bool isImplicit = Record.readInt();
0471     bool isPackExpansion = Record.readInt();
0472     unsigned inOutArgsSize = Record.readInt();
0473     SmallVector<StringRef, 4> inOutArgs;
0474     inOutArgs.reserve(inOutArgsSize);
0475     SmallVector<std::string, 4> inOutArgsStorage;
0476     inOutArgsStorage.reserve(inOutArgsSize);
0477     for (unsigned i = 0; i != inOutArgsSize; ++i)
0478       inOutArgsStorage.push_back(Record.readString());
0479     for (unsigned i = 0; i != inOutArgsSize; ++i)
0480       inOutArgs.push_back(inOutArgsStorage[i]);
0481     New = new (Context) ArmInOutAttr(Context, Info, inOutArgs.data(), inOutArgsSize);
0482     New->setImplicit(isImplicit);
0483     New->setPackExpansion(isPackExpansion);
0484     break;
0485   }
0486   case attr::ArmLocallyStreaming: {
0487     bool isInherited = Record.readInt();
0488     bool isImplicit = Record.readInt();
0489     bool isPackExpansion = Record.readInt();
0490     New = new (Context) ArmLocallyStreamingAttr(Context, Info);
0491     cast<InheritableAttr>(New)->setInherited(isInherited);
0492     New->setImplicit(isImplicit);
0493     New->setPackExpansion(isPackExpansion);
0494     break;
0495   }
0496   case attr::ArmMveStrictPolymorphism: {
0497     bool isImplicit = Record.readInt();
0498     bool isPackExpansion = Record.readInt();
0499     New = new (Context) ArmMveStrictPolymorphismAttr(Context, Info);
0500     New->setImplicit(isImplicit);
0501     New->setPackExpansion(isPackExpansion);
0502     break;
0503   }
0504   case attr::ArmNew: {
0505     bool isInherited = Record.readInt();
0506     bool isImplicit = Record.readInt();
0507     bool isPackExpansion = Record.readInt();
0508     unsigned newArgsSize = Record.readInt();
0509     SmallVector<StringRef, 4> newArgs;
0510     newArgs.reserve(newArgsSize);
0511     SmallVector<std::string, 4> newArgsStorage;
0512     newArgsStorage.reserve(newArgsSize);
0513     for (unsigned i = 0; i != newArgsSize; ++i)
0514       newArgsStorage.push_back(Record.readString());
0515     for (unsigned i = 0; i != newArgsSize; ++i)
0516       newArgs.push_back(newArgsStorage[i]);
0517     New = new (Context) ArmNewAttr(Context, Info, newArgs.data(), newArgsSize);
0518     cast<InheritableAttr>(New)->setInherited(isInherited);
0519     New->setImplicit(isImplicit);
0520     New->setPackExpansion(isPackExpansion);
0521     break;
0522   }
0523   case attr::ArmOut: {
0524     bool isImplicit = Record.readInt();
0525     bool isPackExpansion = Record.readInt();
0526     unsigned outArgsSize = Record.readInt();
0527     SmallVector<StringRef, 4> outArgs;
0528     outArgs.reserve(outArgsSize);
0529     SmallVector<std::string, 4> outArgsStorage;
0530     outArgsStorage.reserve(outArgsSize);
0531     for (unsigned i = 0; i != outArgsSize; ++i)
0532       outArgsStorage.push_back(Record.readString());
0533     for (unsigned i = 0; i != outArgsSize; ++i)
0534       outArgs.push_back(outArgsStorage[i]);
0535     New = new (Context) ArmOutAttr(Context, Info, outArgs.data(), outArgsSize);
0536     New->setImplicit(isImplicit);
0537     New->setPackExpansion(isPackExpansion);
0538     break;
0539   }
0540   case attr::ArmPreserves: {
0541     bool isImplicit = Record.readInt();
0542     bool isPackExpansion = Record.readInt();
0543     unsigned preserveArgsSize = Record.readInt();
0544     SmallVector<StringRef, 4> preserveArgs;
0545     preserveArgs.reserve(preserveArgsSize);
0546     SmallVector<std::string, 4> preserveArgsStorage;
0547     preserveArgsStorage.reserve(preserveArgsSize);
0548     for (unsigned i = 0; i != preserveArgsSize; ++i)
0549       preserveArgsStorage.push_back(Record.readString());
0550     for (unsigned i = 0; i != preserveArgsSize; ++i)
0551       preserveArgs.push_back(preserveArgsStorage[i]);
0552     New = new (Context) ArmPreservesAttr(Context, Info, preserveArgs.data(), preserveArgsSize);
0553     New->setImplicit(isImplicit);
0554     New->setPackExpansion(isPackExpansion);
0555     break;
0556   }
0557   case attr::ArmStreaming: {
0558     bool isImplicit = Record.readInt();
0559     bool isPackExpansion = Record.readInt();
0560     New = new (Context) ArmStreamingAttr(Context, Info);
0561     New->setImplicit(isImplicit);
0562     New->setPackExpansion(isPackExpansion);
0563     break;
0564   }
0565   case attr::ArmStreamingCompatible: {
0566     bool isImplicit = Record.readInt();
0567     bool isPackExpansion = Record.readInt();
0568     New = new (Context) ArmStreamingCompatibleAttr(Context, Info);
0569     New->setImplicit(isImplicit);
0570     New->setPackExpansion(isPackExpansion);
0571     break;
0572   }
0573   case attr::Artificial: {
0574     bool isInherited = Record.readInt();
0575     bool isImplicit = Record.readInt();
0576     bool isPackExpansion = Record.readInt();
0577     New = new (Context) ArtificialAttr(Context, Info);
0578     cast<InheritableAttr>(New)->setInherited(isInherited);
0579     New->setImplicit(isImplicit);
0580     New->setPackExpansion(isPackExpansion);
0581     break;
0582   }
0583   case attr::AsmLabel: {
0584     bool isInherited = Record.readInt();
0585     bool isImplicit = Record.readInt();
0586     bool isPackExpansion = Record.readInt();
0587     std::string label= Record.readString();
0588     bool isLiteralLabel = Record.readInt();
0589     New = new (Context) AsmLabelAttr(Context, Info, label, isLiteralLabel);
0590     cast<InheritableAttr>(New)->setInherited(isInherited);
0591     New->setImplicit(isImplicit);
0592     New->setPackExpansion(isPackExpansion);
0593     break;
0594   }
0595   case attr::AssertCapability: {
0596     bool isInherited = Record.readInt();
0597     bool isImplicit = Record.readInt();
0598     bool isPackExpansion = Record.readInt();
0599     unsigned argsSize = Record.readInt();
0600     SmallVector<Expr *, 4> args;
0601     args.reserve(argsSize);
0602     for (unsigned i = 0; i != argsSize; ++i)
0603       args.push_back(Record.readExpr());
0604     New = new (Context) AssertCapabilityAttr(Context, Info, args.data(), argsSize);
0605     cast<InheritableAttr>(New)->setInherited(isInherited);
0606     New->setImplicit(isImplicit);
0607     New->setPackExpansion(isPackExpansion);
0608     break;
0609   }
0610   case attr::AssertExclusiveLock: {
0611     bool isInherited = Record.readInt();
0612     bool isImplicit = Record.readInt();
0613     bool isPackExpansion = Record.readInt();
0614     unsigned argsSize = Record.readInt();
0615     SmallVector<Expr *, 4> args;
0616     args.reserve(argsSize);
0617     for (unsigned i = 0; i != argsSize; ++i)
0618       args.push_back(Record.readExpr());
0619     New = new (Context) AssertExclusiveLockAttr(Context, Info, args.data(), argsSize);
0620     cast<InheritableAttr>(New)->setInherited(isInherited);
0621     New->setImplicit(isImplicit);
0622     New->setPackExpansion(isPackExpansion);
0623     break;
0624   }
0625   case attr::AssertSharedLock: {
0626     bool isInherited = Record.readInt();
0627     bool isImplicit = Record.readInt();
0628     bool isPackExpansion = Record.readInt();
0629     unsigned argsSize = Record.readInt();
0630     SmallVector<Expr *, 4> args;
0631     args.reserve(argsSize);
0632     for (unsigned i = 0; i != argsSize; ++i)
0633       args.push_back(Record.readExpr());
0634     New = new (Context) AssertSharedLockAttr(Context, Info, args.data(), argsSize);
0635     cast<InheritableAttr>(New)->setInherited(isInherited);
0636     New->setImplicit(isImplicit);
0637     New->setPackExpansion(isPackExpansion);
0638     break;
0639   }
0640   case attr::AssumeAligned: {
0641     bool isInherited = Record.readInt();
0642     bool isImplicit = Record.readInt();
0643     bool isPackExpansion = Record.readInt();
0644     Expr * alignment = Record.readExpr();
0645     Expr * offset = Record.readExpr();
0646     New = new (Context) AssumeAlignedAttr(Context, Info, alignment, offset);
0647     cast<InheritableAttr>(New)->setInherited(isInherited);
0648     New->setImplicit(isImplicit);
0649     New->setPackExpansion(isPackExpansion);
0650     break;
0651   }
0652   case attr::Availability: {
0653     bool isInherited = Record.readInt();
0654     bool isImplicit = Record.readInt();
0655     bool isPackExpansion = Record.readInt();
0656     IdentifierInfo * platform = Record.readIdentifier();
0657     VersionTuple introduced= Record.readVersionTuple();
0658     VersionTuple deprecated= Record.readVersionTuple();
0659     VersionTuple obsoleted= Record.readVersionTuple();
0660     bool unavailable = Record.readInt();
0661     std::string message= Record.readString();
0662     bool strict = Record.readInt();
0663     std::string replacement= Record.readString();
0664     int priority = Record.readInt();
0665     IdentifierInfo * environment = Record.readIdentifier();
0666     New = new (Context) AvailabilityAttr(Context, Info, platform, introduced, deprecated, obsoleted, unavailable, message, strict, replacement, priority, environment);
0667     cast<InheritableAttr>(New)->setInherited(isInherited);
0668     New->setImplicit(isImplicit);
0669     New->setPackExpansion(isPackExpansion);
0670     break;
0671   }
0672   case attr::AvailableOnlyInDefaultEvalMethod: {
0673     bool isInherited = Record.readInt();
0674     bool isImplicit = Record.readInt();
0675     bool isPackExpansion = Record.readInt();
0676     New = new (Context) AvailableOnlyInDefaultEvalMethodAttr(Context, Info);
0677     cast<InheritableAttr>(New)->setInherited(isInherited);
0678     New->setImplicit(isImplicit);
0679     New->setPackExpansion(isPackExpansion);
0680     break;
0681   }
0682   case attr::BPFFastCall: {
0683     bool isInherited = Record.readInt();
0684     bool isImplicit = Record.readInt();
0685     bool isPackExpansion = Record.readInt();
0686     New = new (Context) BPFFastCallAttr(Context, Info);
0687     cast<InheritableAttr>(New)->setInherited(isInherited);
0688     New->setImplicit(isImplicit);
0689     New->setPackExpansion(isPackExpansion);
0690     break;
0691   }
0692   case attr::BPFPreserveAccessIndex: {
0693     bool isInherited = Record.readInt();
0694     bool isImplicit = Record.readInt();
0695     bool isPackExpansion = Record.readInt();
0696     New = new (Context) BPFPreserveAccessIndexAttr(Context, Info);
0697     cast<InheritableAttr>(New)->setInherited(isInherited);
0698     New->setImplicit(isImplicit);
0699     New->setPackExpansion(isPackExpansion);
0700     break;
0701   }
0702   case attr::BPFPreserveStaticOffset: {
0703     bool isInherited = Record.readInt();
0704     bool isImplicit = Record.readInt();
0705     bool isPackExpansion = Record.readInt();
0706     New = new (Context) BPFPreserveStaticOffsetAttr(Context, Info);
0707     cast<InheritableAttr>(New)->setInherited(isInherited);
0708     New->setImplicit(isImplicit);
0709     New->setPackExpansion(isPackExpansion);
0710     break;
0711   }
0712   case attr::BTFDeclTag: {
0713     bool isInherited = Record.readInt();
0714     bool isImplicit = Record.readInt();
0715     bool isPackExpansion = Record.readInt();
0716     std::string bTFDeclTag= Record.readString();
0717     New = new (Context) BTFDeclTagAttr(Context, Info, bTFDeclTag);
0718     cast<InheritableAttr>(New)->setInherited(isInherited);
0719     New->setImplicit(isImplicit);
0720     New->setPackExpansion(isPackExpansion);
0721     break;
0722   }
0723   case attr::BTFTypeTag: {
0724     bool isImplicit = Record.readInt();
0725     bool isPackExpansion = Record.readInt();
0726     std::string bTFTypeTag= Record.readString();
0727     New = new (Context) BTFTypeTagAttr(Context, Info, bTFTypeTag);
0728     New->setImplicit(isImplicit);
0729     New->setPackExpansion(isPackExpansion);
0730     break;
0731   }
0732   case attr::Blocking: {
0733     bool isImplicit = Record.readInt();
0734     bool isPackExpansion = Record.readInt();
0735     New = new (Context) BlockingAttr(Context, Info);
0736     New->setImplicit(isImplicit);
0737     New->setPackExpansion(isPackExpansion);
0738     break;
0739   }
0740   case attr::Blocks: {
0741     bool isInherited = Record.readInt();
0742     bool isImplicit = Record.readInt();
0743     bool isPackExpansion = Record.readInt();
0744     BlocksAttr::BlockType type(static_cast<BlocksAttr::BlockType>(Record.readInt()));
0745     New = new (Context) BlocksAttr(Context, Info, type);
0746     cast<InheritableAttr>(New)->setInherited(isInherited);
0747     New->setImplicit(isImplicit);
0748     New->setPackExpansion(isPackExpansion);
0749     break;
0750   }
0751   case attr::Builtin: {
0752     bool isInherited = Record.readInt();
0753     bool isImplicit = Record.readInt();
0754     bool isPackExpansion = Record.readInt();
0755     unsigned iD = Record.readInt();
0756     New = new (Context) BuiltinAttr(Context, Info, iD);
0757     cast<InheritableAttr>(New)->setInherited(isInherited);
0758     New->setImplicit(isImplicit);
0759     New->setPackExpansion(isPackExpansion);
0760     break;
0761   }
0762   case attr::BuiltinAlias: {
0763     bool isImplicit = Record.readInt();
0764     bool isPackExpansion = Record.readInt();
0765     IdentifierInfo * builtinName = Record.readIdentifier();
0766     New = new (Context) BuiltinAliasAttr(Context, Info, builtinName);
0767     New->setImplicit(isImplicit);
0768     New->setPackExpansion(isPackExpansion);
0769     break;
0770   }
0771   case attr::C11NoReturn: {
0772     bool isInherited = Record.readInt();
0773     bool isImplicit = Record.readInt();
0774     bool isPackExpansion = Record.readInt();
0775     New = new (Context) C11NoReturnAttr(Context, Info);
0776     cast<InheritableAttr>(New)->setInherited(isInherited);
0777     New->setImplicit(isImplicit);
0778     New->setPackExpansion(isPackExpansion);
0779     break;
0780   }
0781   case attr::CDecl: {
0782     bool isInherited = Record.readInt();
0783     bool isImplicit = Record.readInt();
0784     bool isPackExpansion = Record.readInt();
0785     New = new (Context) CDeclAttr(Context, Info);
0786     cast<InheritableAttr>(New)->setInherited(isInherited);
0787     New->setImplicit(isImplicit);
0788     New->setPackExpansion(isPackExpansion);
0789     break;
0790   }
0791   case attr::CFAuditedTransfer: {
0792     bool isInherited = Record.readInt();
0793     bool isImplicit = Record.readInt();
0794     bool isPackExpansion = Record.readInt();
0795     New = new (Context) CFAuditedTransferAttr(Context, Info);
0796     cast<InheritableAttr>(New)->setInherited(isInherited);
0797     New->setImplicit(isImplicit);
0798     New->setPackExpansion(isPackExpansion);
0799     break;
0800   }
0801   case attr::CFConsumed: {
0802     bool isInherited = Record.readInt();
0803     bool isImplicit = Record.readInt();
0804     bool isPackExpansion = Record.readInt();
0805     New = new (Context) CFConsumedAttr(Context, Info);
0806     cast<InheritableAttr>(New)->setInherited(isInherited);
0807     New->setImplicit(isImplicit);
0808     New->setPackExpansion(isPackExpansion);
0809     break;
0810   }
0811   case attr::CFGuard: {
0812     bool isInherited = Record.readInt();
0813     bool isImplicit = Record.readInt();
0814     bool isPackExpansion = Record.readInt();
0815     CFGuardAttr::GuardArg guard(static_cast<CFGuardAttr::GuardArg>(Record.readInt()));
0816     New = new (Context) CFGuardAttr(Context, Info, guard);
0817     cast<InheritableAttr>(New)->setInherited(isInherited);
0818     New->setImplicit(isImplicit);
0819     New->setPackExpansion(isPackExpansion);
0820     break;
0821   }
0822   case attr::CFICanonicalJumpTable: {
0823     bool isInherited = Record.readInt();
0824     bool isImplicit = Record.readInt();
0825     bool isPackExpansion = Record.readInt();
0826     New = new (Context) CFICanonicalJumpTableAttr(Context, Info);
0827     cast<InheritableAttr>(New)->setInherited(isInherited);
0828     New->setImplicit(isImplicit);
0829     New->setPackExpansion(isPackExpansion);
0830     break;
0831   }
0832   case attr::CFReturnsNotRetained: {
0833     bool isInherited = Record.readInt();
0834     bool isImplicit = Record.readInt();
0835     bool isPackExpansion = Record.readInt();
0836     New = new (Context) CFReturnsNotRetainedAttr(Context, Info);
0837     cast<InheritableAttr>(New)->setInherited(isInherited);
0838     New->setImplicit(isImplicit);
0839     New->setPackExpansion(isPackExpansion);
0840     break;
0841   }
0842   case attr::CFReturnsRetained: {
0843     bool isInherited = Record.readInt();
0844     bool isImplicit = Record.readInt();
0845     bool isPackExpansion = Record.readInt();
0846     New = new (Context) CFReturnsRetainedAttr(Context, Info);
0847     cast<InheritableAttr>(New)->setInherited(isInherited);
0848     New->setImplicit(isImplicit);
0849     New->setPackExpansion(isPackExpansion);
0850     break;
0851   }
0852   case attr::CFUnknownTransfer: {
0853     bool isInherited = Record.readInt();
0854     bool isImplicit = Record.readInt();
0855     bool isPackExpansion = Record.readInt();
0856     New = new (Context) CFUnknownTransferAttr(Context, Info);
0857     cast<InheritableAttr>(New)->setInherited(isInherited);
0858     New->setImplicit(isImplicit);
0859     New->setPackExpansion(isPackExpansion);
0860     break;
0861   }
0862   case attr::CPUDispatch: {
0863     bool isInherited = Record.readInt();
0864     bool isImplicit = Record.readInt();
0865     bool isPackExpansion = Record.readInt();
0866     unsigned cpusSize = Record.readInt();
0867     SmallVector<IdentifierInfo *, 4> cpus;
0868     cpus.reserve(cpusSize);
0869     for (unsigned i = 0; i != cpusSize; ++i)
0870       cpus.push_back(Record.readIdentifier());
0871     New = new (Context) CPUDispatchAttr(Context, Info, cpus.data(), cpusSize);
0872     cast<InheritableAttr>(New)->setInherited(isInherited);
0873     New->setImplicit(isImplicit);
0874     New->setPackExpansion(isPackExpansion);
0875     break;
0876   }
0877   case attr::CPUSpecific: {
0878     bool isInherited = Record.readInt();
0879     bool isImplicit = Record.readInt();
0880     bool isPackExpansion = Record.readInt();
0881     unsigned cpusSize = Record.readInt();
0882     SmallVector<IdentifierInfo *, 4> cpus;
0883     cpus.reserve(cpusSize);
0884     for (unsigned i = 0; i != cpusSize; ++i)
0885       cpus.push_back(Record.readIdentifier());
0886     New = new (Context) CPUSpecificAttr(Context, Info, cpus.data(), cpusSize);
0887     cast<InheritableAttr>(New)->setInherited(isInherited);
0888     New->setImplicit(isImplicit);
0889     New->setPackExpansion(isPackExpansion);
0890     break;
0891   }
0892   case attr::CUDAConstant: {
0893     bool isInherited = Record.readInt();
0894     bool isImplicit = Record.readInt();
0895     bool isPackExpansion = Record.readInt();
0896     New = new (Context) CUDAConstantAttr(Context, Info);
0897     cast<InheritableAttr>(New)->setInherited(isInherited);
0898     New->setImplicit(isImplicit);
0899     New->setPackExpansion(isPackExpansion);
0900     break;
0901   }
0902   case attr::CUDADevice: {
0903     bool isInherited = Record.readInt();
0904     bool isImplicit = Record.readInt();
0905     bool isPackExpansion = Record.readInt();
0906     New = new (Context) CUDADeviceAttr(Context, Info);
0907     cast<InheritableAttr>(New)->setInherited(isInherited);
0908     New->setImplicit(isImplicit);
0909     New->setPackExpansion(isPackExpansion);
0910     break;
0911   }
0912   case attr::CUDADeviceBuiltinSurfaceType: {
0913     bool isInherited = Record.readInt();
0914     bool isImplicit = Record.readInt();
0915     bool isPackExpansion = Record.readInt();
0916     New = new (Context) CUDADeviceBuiltinSurfaceTypeAttr(Context, Info);
0917     cast<InheritableAttr>(New)->setInherited(isInherited);
0918     New->setImplicit(isImplicit);
0919     New->setPackExpansion(isPackExpansion);
0920     break;
0921   }
0922   case attr::CUDADeviceBuiltinTextureType: {
0923     bool isInherited = Record.readInt();
0924     bool isImplicit = Record.readInt();
0925     bool isPackExpansion = Record.readInt();
0926     New = new (Context) CUDADeviceBuiltinTextureTypeAttr(Context, Info);
0927     cast<InheritableAttr>(New)->setInherited(isInherited);
0928     New->setImplicit(isImplicit);
0929     New->setPackExpansion(isPackExpansion);
0930     break;
0931   }
0932   case attr::CUDAGlobal: {
0933     bool isInherited = Record.readInt();
0934     bool isImplicit = Record.readInt();
0935     bool isPackExpansion = Record.readInt();
0936     New = new (Context) CUDAGlobalAttr(Context, Info);
0937     cast<InheritableAttr>(New)->setInherited(isInherited);
0938     New->setImplicit(isImplicit);
0939     New->setPackExpansion(isPackExpansion);
0940     break;
0941   }
0942   case attr::CUDAGridConstant: {
0943     bool isInherited = Record.readInt();
0944     bool isImplicit = Record.readInt();
0945     bool isPackExpansion = Record.readInt();
0946     New = new (Context) CUDAGridConstantAttr(Context, Info);
0947     cast<InheritableAttr>(New)->setInherited(isInherited);
0948     New->setImplicit(isImplicit);
0949     New->setPackExpansion(isPackExpansion);
0950     break;
0951   }
0952   case attr::CUDAHost: {
0953     bool isInherited = Record.readInt();
0954     bool isImplicit = Record.readInt();
0955     bool isPackExpansion = Record.readInt();
0956     New = new (Context) CUDAHostAttr(Context, Info);
0957     cast<InheritableAttr>(New)->setInherited(isInherited);
0958     New->setImplicit(isImplicit);
0959     New->setPackExpansion(isPackExpansion);
0960     break;
0961   }
0962   case attr::CUDAInvalidTarget: {
0963     bool isInherited = Record.readInt();
0964     bool isImplicit = Record.readInt();
0965     bool isPackExpansion = Record.readInt();
0966     New = new (Context) CUDAInvalidTargetAttr(Context, Info);
0967     cast<InheritableAttr>(New)->setInherited(isInherited);
0968     New->setImplicit(isImplicit);
0969     New->setPackExpansion(isPackExpansion);
0970     break;
0971   }
0972   case attr::CUDALaunchBounds: {
0973     bool isInherited = Record.readInt();
0974     bool isImplicit = Record.readInt();
0975     bool isPackExpansion = Record.readInt();
0976     Expr * maxThreads = Record.readExpr();
0977     Expr * minBlocks = Record.readExpr();
0978     Expr * maxBlocks = Record.readExpr();
0979     New = new (Context) CUDALaunchBoundsAttr(Context, Info, maxThreads, minBlocks, maxBlocks);
0980     cast<InheritableAttr>(New)->setInherited(isInherited);
0981     New->setImplicit(isImplicit);
0982     New->setPackExpansion(isPackExpansion);
0983     break;
0984   }
0985   case attr::CUDAShared: {
0986     bool isInherited = Record.readInt();
0987     bool isImplicit = Record.readInt();
0988     bool isPackExpansion = Record.readInt();
0989     New = new (Context) CUDASharedAttr(Context, Info);
0990     cast<InheritableAttr>(New)->setInherited(isInherited);
0991     New->setImplicit(isImplicit);
0992     New->setPackExpansion(isPackExpansion);
0993     break;
0994   }
0995   case attr::CXX11NoReturn: {
0996     bool isInherited = Record.readInt();
0997     bool isImplicit = Record.readInt();
0998     bool isPackExpansion = Record.readInt();
0999     New = new (Context) CXX11NoReturnAttr(Context, Info);
1000     cast<InheritableAttr>(New)->setInherited(isInherited);
1001     New->setImplicit(isImplicit);
1002     New->setPackExpansion(isPackExpansion);
1003     break;
1004   }
1005   case attr::CXXAssume: {
1006     bool isImplicit = Record.readInt();
1007     bool isPackExpansion = Record.readInt();
1008     Expr * assumption = Record.readExpr();
1009     New = new (Context) CXXAssumeAttr(Context, Info, assumption);
1010     New->setImplicit(isImplicit);
1011     New->setPackExpansion(isPackExpansion);
1012     break;
1013   }
1014   case attr::CallableWhen: {
1015     bool isInherited = Record.readInt();
1016     bool isImplicit = Record.readInt();
1017     bool isPackExpansion = Record.readInt();
1018     unsigned callableStatesSize = Record.readInt();
1019     SmallVector<CallableWhenAttr::ConsumedState, 4> callableStates;
1020     callableStates.reserve(callableStatesSize);
1021     for (unsigned i = callableStatesSize; i; --i)
1022       callableStates.push_back(static_cast<CallableWhenAttr::ConsumedState>(Record.readInt()));
1023     New = new (Context) CallableWhenAttr(Context, Info, callableStates.data(), callableStatesSize);
1024     cast<InheritableAttr>(New)->setInherited(isInherited);
1025     New->setImplicit(isImplicit);
1026     New->setPackExpansion(isPackExpansion);
1027     break;
1028   }
1029   case attr::Callback: {
1030     bool isInherited = Record.readInt();
1031     bool isImplicit = Record.readInt();
1032     bool isPackExpansion = Record.readInt();
1033     unsigned encodingSize = Record.readInt();
1034     SmallVector<int, 4> encoding;
1035     encoding.reserve(encodingSize);
1036     for (unsigned i = 0; i != encodingSize; ++i)
1037       encoding.push_back(Record.readInt());
1038     New = new (Context) CallbackAttr(Context, Info, encoding.data(), encodingSize);
1039     cast<InheritableAttr>(New)->setInherited(isInherited);
1040     New->setImplicit(isImplicit);
1041     New->setPackExpansion(isPackExpansion);
1042     break;
1043   }
1044   case attr::CalledOnce: {
1045     bool isImplicit = Record.readInt();
1046     bool isPackExpansion = Record.readInt();
1047     New = new (Context) CalledOnceAttr(Context, Info);
1048     New->setImplicit(isImplicit);
1049     New->setPackExpansion(isPackExpansion);
1050     break;
1051   }
1052   case attr::Capability: {
1053     bool isInherited = Record.readInt();
1054     bool isImplicit = Record.readInt();
1055     bool isPackExpansion = Record.readInt();
1056     std::string name= Record.readString();
1057     New = new (Context) CapabilityAttr(Context, Info, name);
1058     cast<InheritableAttr>(New)->setInherited(isInherited);
1059     New->setImplicit(isImplicit);
1060     New->setPackExpansion(isPackExpansion);
1061     break;
1062   }
1063   case attr::CapturedRecord: {
1064     bool isInherited = Record.readInt();
1065     bool isImplicit = Record.readInt();
1066     bool isPackExpansion = Record.readInt();
1067     New = new (Context) CapturedRecordAttr(Context, Info);
1068     cast<InheritableAttr>(New)->setInherited(isInherited);
1069     New->setImplicit(isImplicit);
1070     New->setPackExpansion(isPackExpansion);
1071     break;
1072   }
1073   case attr::CarriesDependency: {
1074     bool isInherited = Record.readInt();
1075     bool isImplicit = Record.readInt();
1076     bool isPackExpansion = Record.readInt();
1077     New = new (Context) CarriesDependencyAttr(Context, Info);
1078     cast<InheritableAttr>(New)->setInherited(isInherited);
1079     New->setImplicit(isImplicit);
1080     New->setPackExpansion(isPackExpansion);
1081     break;
1082   }
1083   case attr::Cleanup: {
1084     bool isInherited = Record.readInt();
1085     bool isImplicit = Record.readInt();
1086     bool isPackExpansion = Record.readInt();
1087     FunctionDecl * functionDecl = Record.readDeclAs<FunctionDecl >();
1088     New = new (Context) CleanupAttr(Context, Info, functionDecl);
1089     cast<InheritableAttr>(New)->setInherited(isInherited);
1090     New->setImplicit(isImplicit);
1091     New->setPackExpansion(isPackExpansion);
1092     break;
1093   }
1094   case attr::ClspvLibclcBuiltin: {
1095     bool isInherited = Record.readInt();
1096     bool isImplicit = Record.readInt();
1097     bool isPackExpansion = Record.readInt();
1098     New = new (Context) ClspvLibclcBuiltinAttr(Context, Info);
1099     cast<InheritableAttr>(New)->setInherited(isInherited);
1100     New->setImplicit(isImplicit);
1101     New->setPackExpansion(isPackExpansion);
1102     break;
1103   }
1104   case attr::CmseNSCall: {
1105     bool isImplicit = Record.readInt();
1106     bool isPackExpansion = Record.readInt();
1107     New = new (Context) CmseNSCallAttr(Context, Info);
1108     New->setImplicit(isImplicit);
1109     New->setPackExpansion(isPackExpansion);
1110     break;
1111   }
1112   case attr::CmseNSEntry: {
1113     bool isInherited = Record.readInt();
1114     bool isImplicit = Record.readInt();
1115     bool isPackExpansion = Record.readInt();
1116     New = new (Context) CmseNSEntryAttr(Context, Info);
1117     cast<InheritableAttr>(New)->setInherited(isInherited);
1118     New->setImplicit(isImplicit);
1119     New->setPackExpansion(isPackExpansion);
1120     break;
1121   }
1122   case attr::CodeAlign: {
1123     bool isImplicit = Record.readInt();
1124     bool isPackExpansion = Record.readInt();
1125     Expr * alignment = Record.readExpr();
1126     New = new (Context) CodeAlignAttr(Context, Info, alignment);
1127     New->setImplicit(isImplicit);
1128     New->setPackExpansion(isPackExpansion);
1129     break;
1130   }
1131   case attr::CodeModel: {
1132     bool isInherited = Record.readInt();
1133     bool isImplicit = Record.readInt();
1134     bool isPackExpansion = Record.readInt();
1135     llvm::CodeModel::Model model(static_cast<llvm::CodeModel::Model>(Record.readInt()));
1136     New = new (Context) CodeModelAttr(Context, Info, model);
1137     cast<InheritableAttr>(New)->setInherited(isInherited);
1138     New->setImplicit(isImplicit);
1139     New->setPackExpansion(isPackExpansion);
1140     break;
1141   }
1142   case attr::CodeSeg: {
1143     bool isInherited = Record.readInt();
1144     bool isImplicit = Record.readInt();
1145     bool isPackExpansion = Record.readInt();
1146     std::string name= Record.readString();
1147     New = new (Context) CodeSegAttr(Context, Info, name);
1148     cast<InheritableAttr>(New)->setInherited(isInherited);
1149     New->setImplicit(isImplicit);
1150     New->setPackExpansion(isPackExpansion);
1151     break;
1152   }
1153   case attr::Cold: {
1154     bool isInherited = Record.readInt();
1155     bool isImplicit = Record.readInt();
1156     bool isPackExpansion = Record.readInt();
1157     New = new (Context) ColdAttr(Context, Info);
1158     cast<InheritableAttr>(New)->setInherited(isInherited);
1159     New->setImplicit(isImplicit);
1160     New->setPackExpansion(isPackExpansion);
1161     break;
1162   }
1163   case attr::Common: {
1164     bool isInherited = Record.readInt();
1165     bool isImplicit = Record.readInt();
1166     bool isPackExpansion = Record.readInt();
1167     New = new (Context) CommonAttr(Context, Info);
1168     cast<InheritableAttr>(New)->setInherited(isInherited);
1169     New->setImplicit(isImplicit);
1170     New->setPackExpansion(isPackExpansion);
1171     break;
1172   }
1173   case attr::Const: {
1174     bool isInherited = Record.readInt();
1175     bool isImplicit = Record.readInt();
1176     bool isPackExpansion = Record.readInt();
1177     New = new (Context) ConstAttr(Context, Info);
1178     cast<InheritableAttr>(New)->setInherited(isInherited);
1179     New->setImplicit(isImplicit);
1180     New->setPackExpansion(isPackExpansion);
1181     break;
1182   }
1183   case attr::ConstInit: {
1184     bool isInherited = Record.readInt();
1185     bool isImplicit = Record.readInt();
1186     bool isPackExpansion = Record.readInt();
1187     New = new (Context) ConstInitAttr(Context, Info);
1188     cast<InheritableAttr>(New)->setInherited(isInherited);
1189     New->setImplicit(isImplicit);
1190     New->setPackExpansion(isPackExpansion);
1191     break;
1192   }
1193   case attr::Constructor: {
1194     bool isInherited = Record.readInt();
1195     bool isImplicit = Record.readInt();
1196     bool isPackExpansion = Record.readInt();
1197     int priority = Record.readInt();
1198     New = new (Context) ConstructorAttr(Context, Info, priority);
1199     cast<InheritableAttr>(New)->setInherited(isInherited);
1200     New->setImplicit(isImplicit);
1201     New->setPackExpansion(isPackExpansion);
1202     break;
1203   }
1204   case attr::Consumable: {
1205     bool isInherited = Record.readInt();
1206     bool isImplicit = Record.readInt();
1207     bool isPackExpansion = Record.readInt();
1208     ConsumableAttr::ConsumedState defaultState(static_cast<ConsumableAttr::ConsumedState>(Record.readInt()));
1209     New = new (Context) ConsumableAttr(Context, Info, defaultState);
1210     cast<InheritableAttr>(New)->setInherited(isInherited);
1211     New->setImplicit(isImplicit);
1212     New->setPackExpansion(isPackExpansion);
1213     break;
1214   }
1215   case attr::ConsumableAutoCast: {
1216     bool isInherited = Record.readInt();
1217     bool isImplicit = Record.readInt();
1218     bool isPackExpansion = Record.readInt();
1219     New = new (Context) ConsumableAutoCastAttr(Context, Info);
1220     cast<InheritableAttr>(New)->setInherited(isInherited);
1221     New->setImplicit(isImplicit);
1222     New->setPackExpansion(isPackExpansion);
1223     break;
1224   }
1225   case attr::ConsumableSetOnRead: {
1226     bool isInherited = Record.readInt();
1227     bool isImplicit = Record.readInt();
1228     bool isPackExpansion = Record.readInt();
1229     New = new (Context) ConsumableSetOnReadAttr(Context, Info);
1230     cast<InheritableAttr>(New)->setInherited(isInherited);
1231     New->setImplicit(isImplicit);
1232     New->setPackExpansion(isPackExpansion);
1233     break;
1234   }
1235   case attr::Convergent: {
1236     bool isInherited = Record.readInt();
1237     bool isImplicit = Record.readInt();
1238     bool isPackExpansion = Record.readInt();
1239     New = new (Context) ConvergentAttr(Context, Info);
1240     cast<InheritableAttr>(New)->setInherited(isInherited);
1241     New->setImplicit(isImplicit);
1242     New->setPackExpansion(isPackExpansion);
1243     break;
1244   }
1245   case attr::CoroAwaitElidable: {
1246     bool isInherited = Record.readInt();
1247     bool isImplicit = Record.readInt();
1248     bool isPackExpansion = Record.readInt();
1249     New = new (Context) CoroAwaitElidableAttr(Context, Info);
1250     cast<InheritableAttr>(New)->setInherited(isInherited);
1251     New->setImplicit(isImplicit);
1252     New->setPackExpansion(isPackExpansion);
1253     break;
1254   }
1255   case attr::CoroAwaitElidableArgument: {
1256     bool isInherited = Record.readInt();
1257     bool isImplicit = Record.readInt();
1258     bool isPackExpansion = Record.readInt();
1259     New = new (Context) CoroAwaitElidableArgumentAttr(Context, Info);
1260     cast<InheritableAttr>(New)->setInherited(isInherited);
1261     New->setImplicit(isImplicit);
1262     New->setPackExpansion(isPackExpansion);
1263     break;
1264   }
1265   case attr::CoroDisableLifetimeBound: {
1266     bool isInherited = Record.readInt();
1267     bool isImplicit = Record.readInt();
1268     bool isPackExpansion = Record.readInt();
1269     New = new (Context) CoroDisableLifetimeBoundAttr(Context, Info);
1270     cast<InheritableAttr>(New)->setInherited(isInherited);
1271     New->setImplicit(isImplicit);
1272     New->setPackExpansion(isPackExpansion);
1273     break;
1274   }
1275   case attr::CoroLifetimeBound: {
1276     bool isInherited = Record.readInt();
1277     bool isImplicit = Record.readInt();
1278     bool isPackExpansion = Record.readInt();
1279     New = new (Context) CoroLifetimeBoundAttr(Context, Info);
1280     cast<InheritableAttr>(New)->setInherited(isInherited);
1281     New->setImplicit(isImplicit);
1282     New->setPackExpansion(isPackExpansion);
1283     break;
1284   }
1285   case attr::CoroOnlyDestroyWhenComplete: {
1286     bool isInherited = Record.readInt();
1287     bool isImplicit = Record.readInt();
1288     bool isPackExpansion = Record.readInt();
1289     New = new (Context) CoroOnlyDestroyWhenCompleteAttr(Context, Info);
1290     cast<InheritableAttr>(New)->setInherited(isInherited);
1291     New->setImplicit(isImplicit);
1292     New->setPackExpansion(isPackExpansion);
1293     break;
1294   }
1295   case attr::CoroReturnType: {
1296     bool isInherited = Record.readInt();
1297     bool isImplicit = Record.readInt();
1298     bool isPackExpansion = Record.readInt();
1299     New = new (Context) CoroReturnTypeAttr(Context, Info);
1300     cast<InheritableAttr>(New)->setInherited(isInherited);
1301     New->setImplicit(isImplicit);
1302     New->setPackExpansion(isPackExpansion);
1303     break;
1304   }
1305   case attr::CoroWrapper: {
1306     bool isInherited = Record.readInt();
1307     bool isImplicit = Record.readInt();
1308     bool isPackExpansion = Record.readInt();
1309     New = new (Context) CoroWrapperAttr(Context, Info);
1310     cast<InheritableAttr>(New)->setInherited(isInherited);
1311     New->setImplicit(isImplicit);
1312     New->setPackExpansion(isPackExpansion);
1313     break;
1314   }
1315   case attr::CountedBy: {
1316     bool isInherited = Record.readInt();
1317     bool isImplicit = Record.readInt();
1318     bool isPackExpansion = Record.readInt();
1319     Expr * count = Record.readExpr();
1320     int nestedLevel = Record.readInt();
1321     New = new (Context) CountedByAttr(Context, Info, count, nestedLevel);
1322     cast<InheritableAttr>(New)->setInherited(isInherited);
1323     New->setImplicit(isImplicit);
1324     New->setPackExpansion(isPackExpansion);
1325     break;
1326   }
1327   case attr::CountedByOrNull: {
1328     bool isInherited = Record.readInt();
1329     bool isImplicit = Record.readInt();
1330     bool isPackExpansion = Record.readInt();
1331     Expr * count = Record.readExpr();
1332     int nestedLevel = Record.readInt();
1333     New = new (Context) CountedByOrNullAttr(Context, Info, count, nestedLevel);
1334     cast<InheritableAttr>(New)->setInherited(isInherited);
1335     New->setImplicit(isImplicit);
1336     New->setPackExpansion(isPackExpansion);
1337     break;
1338   }
1339   case attr::DLLExport: {
1340     bool isInherited = Record.readInt();
1341     bool isImplicit = Record.readInt();
1342     bool isPackExpansion = Record.readInt();
1343     New = new (Context) DLLExportAttr(Context, Info);
1344     cast<InheritableAttr>(New)->setInherited(isInherited);
1345     New->setImplicit(isImplicit);
1346     New->setPackExpansion(isPackExpansion);
1347     break;
1348   }
1349   case attr::DLLExportStaticLocal: {
1350     bool isInherited = Record.readInt();
1351     bool isImplicit = Record.readInt();
1352     bool isPackExpansion = Record.readInt();
1353     New = new (Context) DLLExportStaticLocalAttr(Context, Info);
1354     cast<InheritableAttr>(New)->setInherited(isInherited);
1355     New->setImplicit(isImplicit);
1356     New->setPackExpansion(isPackExpansion);
1357     break;
1358   }
1359   case attr::DLLImport: {
1360     bool isInherited = Record.readInt();
1361     bool isImplicit = Record.readInt();
1362     bool isPackExpansion = Record.readInt();
1363     New = new (Context) DLLImportAttr(Context, Info);
1364     cast<InheritableAttr>(New)->setInherited(isInherited);
1365     New->setImplicit(isImplicit);
1366     New->setPackExpansion(isPackExpansion);
1367     break;
1368   }
1369   case attr::DLLImportStaticLocal: {
1370     bool isInherited = Record.readInt();
1371     bool isImplicit = Record.readInt();
1372     bool isPackExpansion = Record.readInt();
1373     New = new (Context) DLLImportStaticLocalAttr(Context, Info);
1374     cast<InheritableAttr>(New)->setInherited(isInherited);
1375     New->setImplicit(isImplicit);
1376     New->setPackExpansion(isPackExpansion);
1377     break;
1378   }
1379   case attr::Deprecated: {
1380     bool isInherited = Record.readInt();
1381     bool isImplicit = Record.readInt();
1382     bool isPackExpansion = Record.readInt();
1383     std::string message= Record.readString();
1384     std::string replacement= Record.readString();
1385     New = new (Context) DeprecatedAttr(Context, Info, message, replacement);
1386     cast<InheritableAttr>(New)->setInherited(isInherited);
1387     New->setImplicit(isImplicit);
1388     New->setPackExpansion(isPackExpansion);
1389     break;
1390   }
1391   case attr::Destructor: {
1392     bool isInherited = Record.readInt();
1393     bool isImplicit = Record.readInt();
1394     bool isPackExpansion = Record.readInt();
1395     int priority = Record.readInt();
1396     New = new (Context) DestructorAttr(Context, Info, priority);
1397     cast<InheritableAttr>(New)->setInherited(isInherited);
1398     New->setImplicit(isImplicit);
1399     New->setPackExpansion(isPackExpansion);
1400     break;
1401   }
1402   case attr::DiagnoseAsBuiltin: {
1403     bool isInherited = Record.readInt();
1404     bool isImplicit = Record.readInt();
1405     bool isPackExpansion = Record.readInt();
1406     FunctionDecl * function = Record.readDeclAs<FunctionDecl >();
1407     unsigned argIndicesSize = Record.readInt();
1408     SmallVector<unsigned, 4> argIndices;
1409     argIndices.reserve(argIndicesSize);
1410     for (unsigned i = 0; i != argIndicesSize; ++i)
1411       argIndices.push_back(Record.readInt());
1412     New = new (Context) DiagnoseAsBuiltinAttr(Context, Info, function, argIndices.data(), argIndicesSize);
1413     cast<InheritableAttr>(New)->setInherited(isInherited);
1414     New->setImplicit(isImplicit);
1415     New->setPackExpansion(isPackExpansion);
1416     break;
1417   }
1418   case attr::DiagnoseIf: {
1419     bool isInherited = Record.readInt();
1420     bool isImplicit = Record.readInt();
1421     bool isPackExpansion = Record.readInt();
1422     Expr * cond = Record.readExpr();
1423     std::string message= Record.readString();
1424     DiagnoseIfAttr::DefaultSeverity defaultSeverity(static_cast<DiagnoseIfAttr::DefaultSeverity>(Record.readInt()));
1425     std::string warningGroup= Record.readString();
1426     bool argDependent = Record.readInt();
1427     NamedDecl * parent = Record.readDeclAs<NamedDecl >();
1428     New = new (Context) DiagnoseIfAttr(Context, Info, cond, message, defaultSeverity, warningGroup, argDependent, parent);
1429     cast<InheritableAttr>(New)->setInherited(isInherited);
1430     New->setImplicit(isImplicit);
1431     New->setPackExpansion(isPackExpansion);
1432     break;
1433   }
1434   case attr::DisableSanitizerInstrumentation: {
1435     bool isInherited = Record.readInt();
1436     bool isImplicit = Record.readInt();
1437     bool isPackExpansion = Record.readInt();
1438     New = new (Context) DisableSanitizerInstrumentationAttr(Context, Info);
1439     cast<InheritableAttr>(New)->setInherited(isInherited);
1440     New->setImplicit(isImplicit);
1441     New->setPackExpansion(isPackExpansion);
1442     break;
1443   }
1444   case attr::DisableTailCalls: {
1445     bool isInherited = Record.readInt();
1446     bool isImplicit = Record.readInt();
1447     bool isPackExpansion = Record.readInt();
1448     New = new (Context) DisableTailCallsAttr(Context, Info);
1449     cast<InheritableAttr>(New)->setInherited(isInherited);
1450     New->setImplicit(isImplicit);
1451     New->setPackExpansion(isPackExpansion);
1452     break;
1453   }
1454   case attr::EmptyBases: {
1455     bool isInherited = Record.readInt();
1456     bool isImplicit = Record.readInt();
1457     bool isPackExpansion = Record.readInt();
1458     New = new (Context) EmptyBasesAttr(Context, Info);
1459     cast<InheritableAttr>(New)->setInherited(isInherited);
1460     New->setImplicit(isImplicit);
1461     New->setPackExpansion(isPackExpansion);
1462     break;
1463   }
1464   case attr::EnableIf: {
1465     bool isInherited = Record.readInt();
1466     bool isImplicit = Record.readInt();
1467     bool isPackExpansion = Record.readInt();
1468     Expr * cond = Record.readExpr();
1469     std::string message= Record.readString();
1470     New = new (Context) EnableIfAttr(Context, Info, cond, message);
1471     cast<InheritableAttr>(New)->setInherited(isInherited);
1472     New->setImplicit(isImplicit);
1473     New->setPackExpansion(isPackExpansion);
1474     break;
1475   }
1476   case attr::EnforceTCB: {
1477     bool isInherited = Record.readInt();
1478     bool isImplicit = Record.readInt();
1479     bool isPackExpansion = Record.readInt();
1480     std::string tCBName= Record.readString();
1481     New = new (Context) EnforceTCBAttr(Context, Info, tCBName);
1482     cast<InheritableAttr>(New)->setInherited(isInherited);
1483     New->setImplicit(isImplicit);
1484     New->setPackExpansion(isPackExpansion);
1485     break;
1486   }
1487   case attr::EnforceTCBLeaf: {
1488     bool isInherited = Record.readInt();
1489     bool isImplicit = Record.readInt();
1490     bool isPackExpansion = Record.readInt();
1491     std::string tCBName= Record.readString();
1492     New = new (Context) EnforceTCBLeafAttr(Context, Info, tCBName);
1493     cast<InheritableAttr>(New)->setInherited(isInherited);
1494     New->setImplicit(isImplicit);
1495     New->setPackExpansion(isPackExpansion);
1496     break;
1497   }
1498   case attr::EnumExtensibility: {
1499     bool isInherited = Record.readInt();
1500     bool isImplicit = Record.readInt();
1501     bool isPackExpansion = Record.readInt();
1502     EnumExtensibilityAttr::Kind extensibility(static_cast<EnumExtensibilityAttr::Kind>(Record.readInt()));
1503     New = new (Context) EnumExtensibilityAttr(Context, Info, extensibility);
1504     cast<InheritableAttr>(New)->setInherited(isInherited);
1505     New->setImplicit(isImplicit);
1506     New->setPackExpansion(isPackExpansion);
1507     break;
1508   }
1509   case attr::Error: {
1510     bool isInherited = Record.readInt();
1511     bool isImplicit = Record.readInt();
1512     bool isPackExpansion = Record.readInt();
1513     std::string userDiagnostic= Record.readString();
1514     New = new (Context) ErrorAttr(Context, Info, userDiagnostic);
1515     cast<InheritableAttr>(New)->setInherited(isInherited);
1516     New->setImplicit(isImplicit);
1517     New->setPackExpansion(isPackExpansion);
1518     break;
1519   }
1520   case attr::ExcludeFromExplicitInstantiation: {
1521     bool isInherited = Record.readInt();
1522     bool isImplicit = Record.readInt();
1523     bool isPackExpansion = Record.readInt();
1524     New = new (Context) ExcludeFromExplicitInstantiationAttr(Context, Info);
1525     cast<InheritableAttr>(New)->setInherited(isInherited);
1526     New->setImplicit(isImplicit);
1527     New->setPackExpansion(isPackExpansion);
1528     break;
1529   }
1530   case attr::ExclusiveTrylockFunction: {
1531     bool isInherited = Record.readInt();
1532     bool isImplicit = Record.readInt();
1533     bool isPackExpansion = Record.readInt();
1534     Expr * successValue = Record.readExpr();
1535     unsigned argsSize = Record.readInt();
1536     SmallVector<Expr *, 4> args;
1537     args.reserve(argsSize);
1538     for (unsigned i = 0; i != argsSize; ++i)
1539       args.push_back(Record.readExpr());
1540     New = new (Context) ExclusiveTrylockFunctionAttr(Context, Info, successValue, args.data(), argsSize);
1541     cast<InheritableAttr>(New)->setInherited(isInherited);
1542     New->setImplicit(isImplicit);
1543     New->setPackExpansion(isPackExpansion);
1544     break;
1545   }
1546   case attr::ExplicitInit: {
1547     bool isInherited = Record.readInt();
1548     bool isImplicit = Record.readInt();
1549     bool isPackExpansion = Record.readInt();
1550     New = new (Context) ExplicitInitAttr(Context, Info);
1551     cast<InheritableAttr>(New)->setInherited(isInherited);
1552     New->setImplicit(isImplicit);
1553     New->setPackExpansion(isPackExpansion);
1554     break;
1555   }
1556   case attr::ExternalSourceSymbol: {
1557     bool isInherited = Record.readInt();
1558     bool isImplicit = Record.readInt();
1559     bool isPackExpansion = Record.readInt();
1560     std::string language= Record.readString();
1561     std::string definedIn= Record.readString();
1562     bool generatedDeclaration = Record.readInt();
1563     std::string uSR= Record.readString();
1564     New = new (Context) ExternalSourceSymbolAttr(Context, Info, language, definedIn, generatedDeclaration, uSR);
1565     cast<InheritableAttr>(New)->setInherited(isInherited);
1566     New->setImplicit(isImplicit);
1567     New->setPackExpansion(isPackExpansion);
1568     break;
1569   }
1570   case attr::FallThrough: {
1571     bool isImplicit = Record.readInt();
1572     bool isPackExpansion = Record.readInt();
1573     New = new (Context) FallThroughAttr(Context, Info);
1574     New->setImplicit(isImplicit);
1575     New->setPackExpansion(isPackExpansion);
1576     break;
1577   }
1578   case attr::FastCall: {
1579     bool isInherited = Record.readInt();
1580     bool isImplicit = Record.readInt();
1581     bool isPackExpansion = Record.readInt();
1582     New = new (Context) FastCallAttr(Context, Info);
1583     cast<InheritableAttr>(New)->setInherited(isInherited);
1584     New->setImplicit(isImplicit);
1585     New->setPackExpansion(isPackExpansion);
1586     break;
1587   }
1588   case attr::Final: {
1589     bool isInherited = Record.readInt();
1590     bool isImplicit = Record.readInt();
1591     bool isPackExpansion = Record.readInt();
1592     New = new (Context) FinalAttr(Context, Info);
1593     cast<InheritableAttr>(New)->setInherited(isInherited);
1594     New->setImplicit(isImplicit);
1595     New->setPackExpansion(isPackExpansion);
1596     break;
1597   }
1598   case attr::FlagEnum: {
1599     bool isInherited = Record.readInt();
1600     bool isImplicit = Record.readInt();
1601     bool isPackExpansion = Record.readInt();
1602     New = new (Context) FlagEnumAttr(Context, Info);
1603     cast<InheritableAttr>(New)->setInherited(isInherited);
1604     New->setImplicit(isImplicit);
1605     New->setPackExpansion(isPackExpansion);
1606     break;
1607   }
1608   case attr::Flatten: {
1609     bool isInherited = Record.readInt();
1610     bool isImplicit = Record.readInt();
1611     bool isPackExpansion = Record.readInt();
1612     New = new (Context) FlattenAttr(Context, Info);
1613     cast<InheritableAttr>(New)->setInherited(isInherited);
1614     New->setImplicit(isImplicit);
1615     New->setPackExpansion(isPackExpansion);
1616     break;
1617   }
1618   case attr::Format: {
1619     bool isInherited = Record.readInt();
1620     bool isImplicit = Record.readInt();
1621     bool isPackExpansion = Record.readInt();
1622     IdentifierInfo * type = Record.readIdentifier();
1623     int formatIdx = Record.readInt();
1624     int firstArg = Record.readInt();
1625     New = new (Context) FormatAttr(Context, Info, type, formatIdx, firstArg);
1626     cast<InheritableAttr>(New)->setInherited(isInherited);
1627     New->setImplicit(isImplicit);
1628     New->setPackExpansion(isPackExpansion);
1629     break;
1630   }
1631   case attr::FormatArg: {
1632     bool isInherited = Record.readInt();
1633     bool isImplicit = Record.readInt();
1634     bool isPackExpansion = Record.readInt();
1635     ParamIdx formatIdx = ParamIdx::deserialize(Record.readInt());
1636     New = new (Context) FormatArgAttr(Context, Info, formatIdx);
1637     cast<InheritableAttr>(New)->setInherited(isInherited);
1638     New->setImplicit(isImplicit);
1639     New->setPackExpansion(isPackExpansion);
1640     break;
1641   }
1642   case attr::FunctionReturnThunks: {
1643     bool isInherited = Record.readInt();
1644     bool isImplicit = Record.readInt();
1645     bool isPackExpansion = Record.readInt();
1646     FunctionReturnThunksAttr::Kind thunkType(static_cast<FunctionReturnThunksAttr::Kind>(Record.readInt()));
1647     New = new (Context) FunctionReturnThunksAttr(Context, Info, thunkType);
1648     cast<InheritableAttr>(New)->setInherited(isInherited);
1649     New->setImplicit(isImplicit);
1650     New->setPackExpansion(isPackExpansion);
1651     break;
1652   }
1653   case attr::GNUInline: {
1654     bool isInherited = Record.readInt();
1655     bool isImplicit = Record.readInt();
1656     bool isPackExpansion = Record.readInt();
1657     New = new (Context) GNUInlineAttr(Context, Info);
1658     cast<InheritableAttr>(New)->setInherited(isInherited);
1659     New->setImplicit(isImplicit);
1660     New->setPackExpansion(isPackExpansion);
1661     break;
1662   }
1663   case attr::GuardedBy: {
1664     bool isInherited = Record.readInt();
1665     bool isImplicit = Record.readInt();
1666     bool isPackExpansion = Record.readInt();
1667     Expr * arg = Record.readExpr();
1668     New = new (Context) GuardedByAttr(Context, Info, arg);
1669     cast<InheritableAttr>(New)->setInherited(isInherited);
1670     New->setImplicit(isImplicit);
1671     New->setPackExpansion(isPackExpansion);
1672     break;
1673   }
1674   case attr::GuardedVar: {
1675     bool isInherited = Record.readInt();
1676     bool isImplicit = Record.readInt();
1677     bool isPackExpansion = Record.readInt();
1678     New = new (Context) GuardedVarAttr(Context, Info);
1679     cast<InheritableAttr>(New)->setInherited(isInherited);
1680     New->setImplicit(isImplicit);
1681     New->setPackExpansion(isPackExpansion);
1682     break;
1683   }
1684   case attr::HIPManaged: {
1685     bool isInherited = Record.readInt();
1686     bool isImplicit = Record.readInt();
1687     bool isPackExpansion = Record.readInt();
1688     New = new (Context) HIPManagedAttr(Context, Info);
1689     cast<InheritableAttr>(New)->setInherited(isInherited);
1690     New->setImplicit(isImplicit);
1691     New->setPackExpansion(isPackExpansion);
1692     break;
1693   }
1694   case attr::HLSLContainedType: {
1695     bool isImplicit = Record.readInt();
1696     bool isPackExpansion = Record.readInt();
1697     TypeSourceInfo * type = Record.readTypeSourceInfo();
1698     New = new (Context) HLSLContainedTypeAttr(Context, Info, type);
1699     New->setImplicit(isImplicit);
1700     New->setPackExpansion(isPackExpansion);
1701     break;
1702   }
1703   case attr::HLSLControlFlowHint: {
1704     bool isImplicit = Record.readInt();
1705     bool isPackExpansion = Record.readInt();
1706     New = new (Context) HLSLControlFlowHintAttr(Context, Info);
1707     New->setImplicit(isImplicit);
1708     New->setPackExpansion(isPackExpansion);
1709     break;
1710   }
1711   case attr::HLSLGroupSharedAddressSpace: {
1712     bool isImplicit = Record.readInt();
1713     bool isPackExpansion = Record.readInt();
1714     New = new (Context) HLSLGroupSharedAddressSpaceAttr(Context, Info);
1715     New->setImplicit(isImplicit);
1716     New->setPackExpansion(isPackExpansion);
1717     break;
1718   }
1719   case attr::HLSLLoopHint: {
1720     bool isImplicit = Record.readInt();
1721     bool isPackExpansion = Record.readInt();
1722     unsigned directive = Record.readInt();
1723     New = new (Context) HLSLLoopHintAttr(Context, Info, directive);
1724     New->setImplicit(isImplicit);
1725     New->setPackExpansion(isPackExpansion);
1726     break;
1727   }
1728   case attr::HLSLNumThreads: {
1729     bool isInherited = Record.readInt();
1730     bool isImplicit = Record.readInt();
1731     bool isPackExpansion = Record.readInt();
1732     int x = Record.readInt();
1733     int y = Record.readInt();
1734     int z = Record.readInt();
1735     New = new (Context) HLSLNumThreadsAttr(Context, Info, x, y, z);
1736     cast<InheritableAttr>(New)->setInherited(isInherited);
1737     New->setImplicit(isImplicit);
1738     New->setPackExpansion(isPackExpansion);
1739     break;
1740   }
1741   case attr::HLSLPackOffset: {
1742     bool isInherited = Record.readInt();
1743     bool isImplicit = Record.readInt();
1744     bool isPackExpansion = Record.readInt();
1745     int subcomponent = Record.readInt();
1746     int component = Record.readInt();
1747     New = new (Context) HLSLPackOffsetAttr(Context, Info, subcomponent, component);
1748     cast<InheritableAttr>(New)->setInherited(isInherited);
1749     New->setImplicit(isImplicit);
1750     New->setPackExpansion(isPackExpansion);
1751     break;
1752   }
1753   case attr::HLSLParamModifier: {
1754     bool isInherited = Record.readInt();
1755     bool isImplicit = Record.readInt();
1756     bool isPackExpansion = Record.readInt();
1757     bool mergedSpelling = Record.readInt();
1758     New = new (Context) HLSLParamModifierAttr(Context, Info, mergedSpelling);
1759     cast<InheritableAttr>(New)->setInherited(isInherited);
1760     New->setImplicit(isImplicit);
1761     New->setPackExpansion(isPackExpansion);
1762     break;
1763   }
1764   case attr::HLSLROV: {
1765     bool isImplicit = Record.readInt();
1766     bool isPackExpansion = Record.readInt();
1767     New = new (Context) HLSLROVAttr(Context, Info);
1768     New->setImplicit(isImplicit);
1769     New->setPackExpansion(isPackExpansion);
1770     break;
1771   }
1772   case attr::HLSLRawBuffer: {
1773     bool isImplicit = Record.readInt();
1774     bool isPackExpansion = Record.readInt();
1775     New = new (Context) HLSLRawBufferAttr(Context, Info);
1776     New->setImplicit(isImplicit);
1777     New->setPackExpansion(isPackExpansion);
1778     break;
1779   }
1780   case attr::HLSLResource: {
1781     bool isInherited = Record.readInt();
1782     bool isImplicit = Record.readInt();
1783     bool isPackExpansion = Record.readInt();
1784     llvm::hlsl::ResourceKind resourceKind(static_cast<llvm::hlsl::ResourceKind>(Record.readInt()));
1785     New = new (Context) HLSLResourceAttr(Context, Info, resourceKind);
1786     cast<InheritableAttr>(New)->setInherited(isInherited);
1787     New->setImplicit(isImplicit);
1788     New->setPackExpansion(isPackExpansion);
1789     break;
1790   }
1791   case attr::HLSLResourceBinding: {
1792     bool isInherited = Record.readInt();
1793     bool isImplicit = Record.readInt();
1794     bool isPackExpansion = Record.readInt();
1795     std::string slot= Record.readString();
1796     std::string space= Record.readString();
1797     New = new (Context) HLSLResourceBindingAttr(Context, Info, slot, space);
1798     cast<InheritableAttr>(New)->setInherited(isInherited);
1799     New->setImplicit(isImplicit);
1800     New->setPackExpansion(isPackExpansion);
1801     break;
1802   }
1803   case attr::HLSLResourceClass: {
1804     bool isImplicit = Record.readInt();
1805     bool isPackExpansion = Record.readInt();
1806     llvm::hlsl::ResourceClass resourceClass(static_cast<llvm::hlsl::ResourceClass>(Record.readInt()));
1807     New = new (Context) HLSLResourceClassAttr(Context, Info, resourceClass);
1808     New->setImplicit(isImplicit);
1809     New->setPackExpansion(isPackExpansion);
1810     break;
1811   }
1812   case attr::HLSLSV_DispatchThreadID: {
1813     bool isInherited = Record.readInt();
1814     bool isImplicit = Record.readInt();
1815     bool isPackExpansion = Record.readInt();
1816     New = new (Context) HLSLSV_DispatchThreadIDAttr(Context, Info);
1817     cast<InheritableAttr>(New)->setInherited(isInherited);
1818     New->setImplicit(isImplicit);
1819     New->setPackExpansion(isPackExpansion);
1820     break;
1821   }
1822   case attr::HLSLSV_GroupID: {
1823     bool isInherited = Record.readInt();
1824     bool isImplicit = Record.readInt();
1825     bool isPackExpansion = Record.readInt();
1826     New = new (Context) HLSLSV_GroupIDAttr(Context, Info);
1827     cast<InheritableAttr>(New)->setInherited(isInherited);
1828     New->setImplicit(isImplicit);
1829     New->setPackExpansion(isPackExpansion);
1830     break;
1831   }
1832   case attr::HLSLSV_GroupIndex: {
1833     bool isInherited = Record.readInt();
1834     bool isImplicit = Record.readInt();
1835     bool isPackExpansion = Record.readInt();
1836     New = new (Context) HLSLSV_GroupIndexAttr(Context, Info);
1837     cast<InheritableAttr>(New)->setInherited(isInherited);
1838     New->setImplicit(isImplicit);
1839     New->setPackExpansion(isPackExpansion);
1840     break;
1841   }
1842   case attr::HLSLSV_GroupThreadID: {
1843     bool isInherited = Record.readInt();
1844     bool isImplicit = Record.readInt();
1845     bool isPackExpansion = Record.readInt();
1846     New = new (Context) HLSLSV_GroupThreadIDAttr(Context, Info);
1847     cast<InheritableAttr>(New)->setInherited(isInherited);
1848     New->setImplicit(isImplicit);
1849     New->setPackExpansion(isPackExpansion);
1850     break;
1851   }
1852   case attr::HLSLShader: {
1853     bool isInherited = Record.readInt();
1854     bool isImplicit = Record.readInt();
1855     bool isPackExpansion = Record.readInt();
1856     llvm::Triple::EnvironmentType type(static_cast<llvm::Triple::EnvironmentType>(Record.readInt()));
1857     New = new (Context) HLSLShaderAttr(Context, Info, type);
1858     cast<InheritableAttr>(New)->setInherited(isInherited);
1859     New->setImplicit(isImplicit);
1860     New->setPackExpansion(isPackExpansion);
1861     break;
1862   }
1863   case attr::HLSLWaveSize: {
1864     bool isInherited = Record.readInt();
1865     bool isImplicit = Record.readInt();
1866     bool isPackExpansion = Record.readInt();
1867     int min = Record.readInt();
1868     int max = Record.readInt();
1869     int preferred = Record.readInt();
1870     New = new (Context) HLSLWaveSizeAttr(Context, Info, min, max, preferred);
1871     cast<InheritableAttr>(New)->setInherited(isInherited);
1872     New->setImplicit(isImplicit);
1873     New->setPackExpansion(isPackExpansion);
1874     break;
1875   }
1876   case attr::Hot: {
1877     bool isInherited = Record.readInt();
1878     bool isImplicit = Record.readInt();
1879     bool isPackExpansion = Record.readInt();
1880     New = new (Context) HotAttr(Context, Info);
1881     cast<InheritableAttr>(New)->setInherited(isInherited);
1882     New->setImplicit(isImplicit);
1883     New->setPackExpansion(isPackExpansion);
1884     break;
1885   }
1886   case attr::HybridPatchable: {
1887     bool isInherited = Record.readInt();
1888     bool isImplicit = Record.readInt();
1889     bool isPackExpansion = Record.readInt();
1890     New = new (Context) HybridPatchableAttr(Context, Info);
1891     cast<InheritableAttr>(New)->setInherited(isInherited);
1892     New->setImplicit(isImplicit);
1893     New->setPackExpansion(isPackExpansion);
1894     break;
1895   }
1896   case attr::IBAction: {
1897     bool isInherited = Record.readInt();
1898     bool isImplicit = Record.readInt();
1899     bool isPackExpansion = Record.readInt();
1900     New = new (Context) IBActionAttr(Context, Info);
1901     cast<InheritableAttr>(New)->setInherited(isInherited);
1902     New->setImplicit(isImplicit);
1903     New->setPackExpansion(isPackExpansion);
1904     break;
1905   }
1906   case attr::IBOutlet: {
1907     bool isInherited = Record.readInt();
1908     bool isImplicit = Record.readInt();
1909     bool isPackExpansion = Record.readInt();
1910     New = new (Context) IBOutletAttr(Context, Info);
1911     cast<InheritableAttr>(New)->setInherited(isInherited);
1912     New->setImplicit(isImplicit);
1913     New->setPackExpansion(isPackExpansion);
1914     break;
1915   }
1916   case attr::IBOutletCollection: {
1917     bool isInherited = Record.readInt();
1918     bool isImplicit = Record.readInt();
1919     bool isPackExpansion = Record.readInt();
1920     TypeSourceInfo * interface_ = Record.readTypeSourceInfo();
1921     New = new (Context) IBOutletCollectionAttr(Context, Info, interface_);
1922     cast<InheritableAttr>(New)->setInherited(isInherited);
1923     New->setImplicit(isImplicit);
1924     New->setPackExpansion(isPackExpansion);
1925     break;
1926   }
1927   case attr::IFunc: {
1928     bool isImplicit = Record.readInt();
1929     bool isPackExpansion = Record.readInt();
1930     std::string resolver= Record.readString();
1931     New = new (Context) IFuncAttr(Context, Info, resolver);
1932     New->setImplicit(isImplicit);
1933     New->setPackExpansion(isPackExpansion);
1934     break;
1935   }
1936   case attr::InitPriority: {
1937     bool isInherited = Record.readInt();
1938     bool isImplicit = Record.readInt();
1939     bool isPackExpansion = Record.readInt();
1940     unsigned priority = Record.readInt();
1941     New = new (Context) InitPriorityAttr(Context, Info, priority);
1942     cast<InheritableAttr>(New)->setInherited(isInherited);
1943     New->setImplicit(isImplicit);
1944     New->setPackExpansion(isPackExpansion);
1945     break;
1946   }
1947   case attr::InitSeg: {
1948     bool isImplicit = Record.readInt();
1949     bool isPackExpansion = Record.readInt();
1950     std::string section= Record.readString();
1951     New = new (Context) InitSegAttr(Context, Info, section);
1952     New->setImplicit(isImplicit);
1953     New->setPackExpansion(isPackExpansion);
1954     break;
1955   }
1956   case attr::IntelOclBicc: {
1957     bool isInherited = Record.readInt();
1958     bool isImplicit = Record.readInt();
1959     bool isPackExpansion = Record.readInt();
1960     New = new (Context) IntelOclBiccAttr(Context, Info);
1961     cast<InheritableAttr>(New)->setInherited(isInherited);
1962     New->setImplicit(isImplicit);
1963     New->setPackExpansion(isPackExpansion);
1964     break;
1965   }
1966   case attr::InternalLinkage: {
1967     bool isInherited = Record.readInt();
1968     bool isImplicit = Record.readInt();
1969     bool isPackExpansion = Record.readInt();
1970     New = new (Context) InternalLinkageAttr(Context, Info);
1971     cast<InheritableAttr>(New)->setInherited(isInherited);
1972     New->setImplicit(isImplicit);
1973     New->setPackExpansion(isPackExpansion);
1974     break;
1975   }
1976   case attr::LTOVisibilityPublic: {
1977     bool isInherited = Record.readInt();
1978     bool isImplicit = Record.readInt();
1979     bool isPackExpansion = Record.readInt();
1980     New = new (Context) LTOVisibilityPublicAttr(Context, Info);
1981     cast<InheritableAttr>(New)->setInherited(isInherited);
1982     New->setImplicit(isImplicit);
1983     New->setPackExpansion(isPackExpansion);
1984     break;
1985   }
1986   case attr::LayoutVersion: {
1987     bool isInherited = Record.readInt();
1988     bool isImplicit = Record.readInt();
1989     bool isPackExpansion = Record.readInt();
1990     unsigned version = Record.readInt();
1991     New = new (Context) LayoutVersionAttr(Context, Info, version);
1992     cast<InheritableAttr>(New)->setInherited(isInherited);
1993     New->setImplicit(isImplicit);
1994     New->setPackExpansion(isPackExpansion);
1995     break;
1996   }
1997   case attr::Leaf: {
1998     bool isInherited = Record.readInt();
1999     bool isImplicit = Record.readInt();
2000     bool isPackExpansion = Record.readInt();
2001     New = new (Context) LeafAttr(Context, Info);
2002     cast<InheritableAttr>(New)->setInherited(isInherited);
2003     New->setImplicit(isImplicit);
2004     New->setPackExpansion(isPackExpansion);
2005     break;
2006   }
2007   case attr::LifetimeBound: {
2008     bool isInherited = Record.readInt();
2009     bool isImplicit = Record.readInt();
2010     bool isPackExpansion = Record.readInt();
2011     New = new (Context) LifetimeBoundAttr(Context, Info);
2012     cast<InheritableAttr>(New)->setInherited(isInherited);
2013     New->setImplicit(isImplicit);
2014     New->setPackExpansion(isPackExpansion);
2015     break;
2016   }
2017   case attr::LifetimeCaptureBy: {
2018     bool isInherited = Record.readInt();
2019     bool isImplicit = Record.readInt();
2020     bool isPackExpansion = Record.readInt();
2021     unsigned paramsSize = Record.readInt();
2022     SmallVector<int, 4> params;
2023     params.reserve(paramsSize);
2024     for (unsigned i = 0; i != paramsSize; ++i)
2025       params.push_back(Record.readInt());
2026     New = new (Context) LifetimeCaptureByAttr(Context, Info, params.data(), paramsSize);
2027     cast<InheritableAttr>(New)->setInherited(isInherited);
2028     New->setImplicit(isImplicit);
2029     New->setPackExpansion(isPackExpansion);
2030     break;
2031   }
2032   case attr::Likely: {
2033     bool isImplicit = Record.readInt();
2034     bool isPackExpansion = Record.readInt();
2035     New = new (Context) LikelyAttr(Context, Info);
2036     New->setImplicit(isImplicit);
2037     New->setPackExpansion(isPackExpansion);
2038     break;
2039   }
2040   case attr::LoaderUninitialized: {
2041     bool isImplicit = Record.readInt();
2042     bool isPackExpansion = Record.readInt();
2043     New = new (Context) LoaderUninitializedAttr(Context, Info);
2044     New->setImplicit(isImplicit);
2045     New->setPackExpansion(isPackExpansion);
2046     break;
2047   }
2048   case attr::LockReturned: {
2049     bool isInherited = Record.readInt();
2050     bool isImplicit = Record.readInt();
2051     bool isPackExpansion = Record.readInt();
2052     Expr * arg = Record.readExpr();
2053     New = new (Context) LockReturnedAttr(Context, Info, arg);
2054     cast<InheritableAttr>(New)->setInherited(isInherited);
2055     New->setImplicit(isImplicit);
2056     New->setPackExpansion(isPackExpansion);
2057     break;
2058   }
2059   case attr::LocksExcluded: {
2060     bool isInherited = Record.readInt();
2061     bool isImplicit = Record.readInt();
2062     bool isPackExpansion = Record.readInt();
2063     unsigned argsSize = Record.readInt();
2064     SmallVector<Expr *, 4> args;
2065     args.reserve(argsSize);
2066     for (unsigned i = 0; i != argsSize; ++i)
2067       args.push_back(Record.readExpr());
2068     New = new (Context) LocksExcludedAttr(Context, Info, args.data(), argsSize);
2069     cast<InheritableAttr>(New)->setInherited(isInherited);
2070     New->setImplicit(isImplicit);
2071     New->setPackExpansion(isPackExpansion);
2072     break;
2073   }
2074   case attr::LoopHint: {
2075     bool isImplicit = Record.readInt();
2076     bool isPackExpansion = Record.readInt();
2077     LoopHintAttr::OptionType option(static_cast<LoopHintAttr::OptionType>(Record.readInt()));
2078     LoopHintAttr::LoopHintState state(static_cast<LoopHintAttr::LoopHintState>(Record.readInt()));
2079     Expr * value = Record.readExpr();
2080     New = new (Context) LoopHintAttr(Context, Info, option, state, value);
2081     New->setImplicit(isImplicit);
2082     New->setPackExpansion(isPackExpansion);
2083     break;
2084   }
2085   case attr::M68kInterrupt: {
2086     bool isInherited = Record.readInt();
2087     bool isImplicit = Record.readInt();
2088     bool isPackExpansion = Record.readInt();
2089     unsigned number = Record.readInt();
2090     New = new (Context) M68kInterruptAttr(Context, Info, number);
2091     cast<InheritableAttr>(New)->setInherited(isInherited);
2092     New->setImplicit(isImplicit);
2093     New->setPackExpansion(isPackExpansion);
2094     break;
2095   }
2096   case attr::M68kRTD: {
2097     bool isInherited = Record.readInt();
2098     bool isImplicit = Record.readInt();
2099     bool isPackExpansion = Record.readInt();
2100     New = new (Context) M68kRTDAttr(Context, Info);
2101     cast<InheritableAttr>(New)->setInherited(isInherited);
2102     New->setImplicit(isImplicit);
2103     New->setPackExpansion(isPackExpansion);
2104     break;
2105   }
2106   case attr::MIGServerRoutine: {
2107     bool isInherited = Record.readInt();
2108     bool isImplicit = Record.readInt();
2109     bool isPackExpansion = Record.readInt();
2110     New = new (Context) MIGServerRoutineAttr(Context, Info);
2111     cast<InheritableAttr>(New)->setInherited(isInherited);
2112     New->setImplicit(isImplicit);
2113     New->setPackExpansion(isPackExpansion);
2114     break;
2115   }
2116   case attr::MSABI: {
2117     bool isInherited = Record.readInt();
2118     bool isImplicit = Record.readInt();
2119     bool isPackExpansion = Record.readInt();
2120     New = new (Context) MSABIAttr(Context, Info);
2121     cast<InheritableAttr>(New)->setInherited(isInherited);
2122     New->setImplicit(isImplicit);
2123     New->setPackExpansion(isPackExpansion);
2124     break;
2125   }
2126   case attr::MSAllocator: {
2127     bool isInherited = Record.readInt();
2128     bool isImplicit = Record.readInt();
2129     bool isPackExpansion = Record.readInt();
2130     New = new (Context) MSAllocatorAttr(Context, Info);
2131     cast<InheritableAttr>(New)->setInherited(isInherited);
2132     New->setImplicit(isImplicit);
2133     New->setPackExpansion(isPackExpansion);
2134     break;
2135   }
2136   case attr::MSConstexpr: {
2137     bool isInherited = Record.readInt();
2138     bool isImplicit = Record.readInt();
2139     bool isPackExpansion = Record.readInt();
2140     New = new (Context) MSConstexprAttr(Context, Info);
2141     cast<InheritableAttr>(New)->setInherited(isInherited);
2142     New->setImplicit(isImplicit);
2143     New->setPackExpansion(isPackExpansion);
2144     break;
2145   }
2146   case attr::MSInheritance: {
2147     bool isInherited = Record.readInt();
2148     bool isImplicit = Record.readInt();
2149     bool isPackExpansion = Record.readInt();
2150     bool bestCase = Record.readInt();
2151     New = new (Context) MSInheritanceAttr(Context, Info, bestCase);
2152     cast<InheritableAttr>(New)->setInherited(isInherited);
2153     New->setImplicit(isImplicit);
2154     New->setPackExpansion(isPackExpansion);
2155     break;
2156   }
2157   case attr::MSNoVTable: {
2158     bool isInherited = Record.readInt();
2159     bool isImplicit = Record.readInt();
2160     bool isPackExpansion = Record.readInt();
2161     New = new (Context) MSNoVTableAttr(Context, Info);
2162     cast<InheritableAttr>(New)->setInherited(isInherited);
2163     New->setImplicit(isImplicit);
2164     New->setPackExpansion(isPackExpansion);
2165     break;
2166   }
2167   case attr::MSP430Interrupt: {
2168     bool isInherited = Record.readInt();
2169     bool isImplicit = Record.readInt();
2170     bool isPackExpansion = Record.readInt();
2171     unsigned number = Record.readInt();
2172     New = new (Context) MSP430InterruptAttr(Context, Info, number);
2173     cast<InheritableAttr>(New)->setInherited(isInherited);
2174     New->setImplicit(isImplicit);
2175     New->setPackExpansion(isPackExpansion);
2176     break;
2177   }
2178   case attr::MSStruct: {
2179     bool isInherited = Record.readInt();
2180     bool isImplicit = Record.readInt();
2181     bool isPackExpansion = Record.readInt();
2182     New = new (Context) MSStructAttr(Context, Info);
2183     cast<InheritableAttr>(New)->setInherited(isInherited);
2184     New->setImplicit(isImplicit);
2185     New->setPackExpansion(isPackExpansion);
2186     break;
2187   }
2188   case attr::MSVtorDisp: {
2189     bool isInherited = Record.readInt();
2190     bool isImplicit = Record.readInt();
2191     bool isPackExpansion = Record.readInt();
2192     unsigned vdm = Record.readInt();
2193     New = new (Context) MSVtorDispAttr(Context, Info, vdm);
2194     cast<InheritableAttr>(New)->setInherited(isInherited);
2195     New->setImplicit(isImplicit);
2196     New->setPackExpansion(isPackExpansion);
2197     break;
2198   }
2199   case attr::MaxFieldAlignment: {
2200     bool isInherited = Record.readInt();
2201     bool isImplicit = Record.readInt();
2202     bool isPackExpansion = Record.readInt();
2203     unsigned alignment = Record.readInt();
2204     New = new (Context) MaxFieldAlignmentAttr(Context, Info, alignment);
2205     cast<InheritableAttr>(New)->setInherited(isInherited);
2206     New->setImplicit(isImplicit);
2207     New->setPackExpansion(isPackExpansion);
2208     break;
2209   }
2210   case attr::MayAlias: {
2211     bool isInherited = Record.readInt();
2212     bool isImplicit = Record.readInt();
2213     bool isPackExpansion = Record.readInt();
2214     New = new (Context) MayAliasAttr(Context, Info);
2215     cast<InheritableAttr>(New)->setInherited(isInherited);
2216     New->setImplicit(isImplicit);
2217     New->setPackExpansion(isPackExpansion);
2218     break;
2219   }
2220   case attr::MaybeUndef: {
2221     bool isInherited = Record.readInt();
2222     bool isImplicit = Record.readInt();
2223     bool isPackExpansion = Record.readInt();
2224     New = new (Context) MaybeUndefAttr(Context, Info);
2225     cast<InheritableAttr>(New)->setInherited(isInherited);
2226     New->setImplicit(isImplicit);
2227     New->setPackExpansion(isPackExpansion);
2228     break;
2229   }
2230   case attr::MicroMips: {
2231     bool isInherited = Record.readInt();
2232     bool isImplicit = Record.readInt();
2233     bool isPackExpansion = Record.readInt();
2234     New = new (Context) MicroMipsAttr(Context, Info);
2235     cast<InheritableAttr>(New)->setInherited(isInherited);
2236     New->setImplicit(isImplicit);
2237     New->setPackExpansion(isPackExpansion);
2238     break;
2239   }
2240   case attr::MinSize: {
2241     bool isInherited = Record.readInt();
2242     bool isImplicit = Record.readInt();
2243     bool isPackExpansion = Record.readInt();
2244     New = new (Context) MinSizeAttr(Context, Info);
2245     cast<InheritableAttr>(New)->setInherited(isInherited);
2246     New->setImplicit(isImplicit);
2247     New->setPackExpansion(isPackExpansion);
2248     break;
2249   }
2250   case attr::MinVectorWidth: {
2251     bool isInherited = Record.readInt();
2252     bool isImplicit = Record.readInt();
2253     bool isPackExpansion = Record.readInt();
2254     unsigned vectorWidth = Record.readInt();
2255     New = new (Context) MinVectorWidthAttr(Context, Info, vectorWidth);
2256     cast<InheritableAttr>(New)->setInherited(isInherited);
2257     New->setImplicit(isImplicit);
2258     New->setPackExpansion(isPackExpansion);
2259     break;
2260   }
2261   case attr::Mips16: {
2262     bool isInherited = Record.readInt();
2263     bool isImplicit = Record.readInt();
2264     bool isPackExpansion = Record.readInt();
2265     New = new (Context) Mips16Attr(Context, Info);
2266     cast<InheritableAttr>(New)->setInherited(isInherited);
2267     New->setImplicit(isImplicit);
2268     New->setPackExpansion(isPackExpansion);
2269     break;
2270   }
2271   case attr::MipsInterrupt: {
2272     bool isInherited = Record.readInt();
2273     bool isImplicit = Record.readInt();
2274     bool isPackExpansion = Record.readInt();
2275     MipsInterruptAttr::InterruptType interrupt(static_cast<MipsInterruptAttr::InterruptType>(Record.readInt()));
2276     New = new (Context) MipsInterruptAttr(Context, Info, interrupt);
2277     cast<InheritableAttr>(New)->setInherited(isInherited);
2278     New->setImplicit(isImplicit);
2279     New->setPackExpansion(isPackExpansion);
2280     break;
2281   }
2282   case attr::MipsLongCall: {
2283     bool isInherited = Record.readInt();
2284     bool isImplicit = Record.readInt();
2285     bool isPackExpansion = Record.readInt();
2286     New = new (Context) MipsLongCallAttr(Context, Info);
2287     cast<InheritableAttr>(New)->setInherited(isInherited);
2288     New->setImplicit(isImplicit);
2289     New->setPackExpansion(isPackExpansion);
2290     break;
2291   }
2292   case attr::MipsShortCall: {
2293     bool isInherited = Record.readInt();
2294     bool isImplicit = Record.readInt();
2295     bool isPackExpansion = Record.readInt();
2296     New = new (Context) MipsShortCallAttr(Context, Info);
2297     cast<InheritableAttr>(New)->setInherited(isInherited);
2298     New->setImplicit(isImplicit);
2299     New->setPackExpansion(isPackExpansion);
2300     break;
2301   }
2302   case attr::Mode: {
2303     bool isImplicit = Record.readInt();
2304     bool isPackExpansion = Record.readInt();
2305     IdentifierInfo * mode = Record.readIdentifier();
2306     New = new (Context) ModeAttr(Context, Info, mode);
2307     New->setImplicit(isImplicit);
2308     New->setPackExpansion(isPackExpansion);
2309     break;
2310   }
2311   case attr::MustTail: {
2312     bool isImplicit = Record.readInt();
2313     bool isPackExpansion = Record.readInt();
2314     New = new (Context) MustTailAttr(Context, Info);
2315     New->setImplicit(isImplicit);
2316     New->setPackExpansion(isPackExpansion);
2317     break;
2318   }
2319   case attr::NSConsumed: {
2320     bool isInherited = Record.readInt();
2321     bool isImplicit = Record.readInt();
2322     bool isPackExpansion = Record.readInt();
2323     New = new (Context) NSConsumedAttr(Context, Info);
2324     cast<InheritableAttr>(New)->setInherited(isInherited);
2325     New->setImplicit(isImplicit);
2326     New->setPackExpansion(isPackExpansion);
2327     break;
2328   }
2329   case attr::NSConsumesSelf: {
2330     bool isInherited = Record.readInt();
2331     bool isImplicit = Record.readInt();
2332     bool isPackExpansion = Record.readInt();
2333     New = new (Context) NSConsumesSelfAttr(Context, Info);
2334     cast<InheritableAttr>(New)->setInherited(isInherited);
2335     New->setImplicit(isImplicit);
2336     New->setPackExpansion(isPackExpansion);
2337     break;
2338   }
2339   case attr::NSErrorDomain: {
2340     bool isInherited = Record.readInt();
2341     bool isImplicit = Record.readInt();
2342     bool isPackExpansion = Record.readInt();
2343     IdentifierInfo * errorDomain = Record.readIdentifier();
2344     New = new (Context) NSErrorDomainAttr(Context, Info, errorDomain);
2345     cast<InheritableAttr>(New)->setInherited(isInherited);
2346     New->setImplicit(isImplicit);
2347     New->setPackExpansion(isPackExpansion);
2348     break;
2349   }
2350   case attr::NSReturnsAutoreleased: {
2351     bool isInherited = Record.readInt();
2352     bool isImplicit = Record.readInt();
2353     bool isPackExpansion = Record.readInt();
2354     New = new (Context) NSReturnsAutoreleasedAttr(Context, Info);
2355     cast<InheritableAttr>(New)->setInherited(isInherited);
2356     New->setImplicit(isImplicit);
2357     New->setPackExpansion(isPackExpansion);
2358     break;
2359   }
2360   case attr::NSReturnsNotRetained: {
2361     bool isInherited = Record.readInt();
2362     bool isImplicit = Record.readInt();
2363     bool isPackExpansion = Record.readInt();
2364     New = new (Context) NSReturnsNotRetainedAttr(Context, Info);
2365     cast<InheritableAttr>(New)->setInherited(isInherited);
2366     New->setImplicit(isImplicit);
2367     New->setPackExpansion(isPackExpansion);
2368     break;
2369   }
2370   case attr::NSReturnsRetained: {
2371     bool isInherited = Record.readInt();
2372     bool isImplicit = Record.readInt();
2373     bool isPackExpansion = Record.readInt();
2374     New = new (Context) NSReturnsRetainedAttr(Context, Info);
2375     cast<InheritableAttr>(New)->setInherited(isInherited);
2376     New->setImplicit(isImplicit);
2377     New->setPackExpansion(isPackExpansion);
2378     break;
2379   }
2380   case attr::NVPTXKernel: {
2381     bool isInherited = Record.readInt();
2382     bool isImplicit = Record.readInt();
2383     bool isPackExpansion = Record.readInt();
2384     New = new (Context) NVPTXKernelAttr(Context, Info);
2385     cast<InheritableAttr>(New)->setInherited(isInherited);
2386     New->setImplicit(isImplicit);
2387     New->setPackExpansion(isPackExpansion);
2388     break;
2389   }
2390   case attr::Naked: {
2391     bool isInherited = Record.readInt();
2392     bool isImplicit = Record.readInt();
2393     bool isPackExpansion = Record.readInt();
2394     New = new (Context) NakedAttr(Context, Info);
2395     cast<InheritableAttr>(New)->setInherited(isInherited);
2396     New->setImplicit(isImplicit);
2397     New->setPackExpansion(isPackExpansion);
2398     break;
2399   }
2400   case attr::NoAlias: {
2401     bool isInherited = Record.readInt();
2402     bool isImplicit = Record.readInt();
2403     bool isPackExpansion = Record.readInt();
2404     New = new (Context) NoAliasAttr(Context, Info);
2405     cast<InheritableAttr>(New)->setInherited(isInherited);
2406     New->setImplicit(isImplicit);
2407     New->setPackExpansion(isPackExpansion);
2408     break;
2409   }
2410   case attr::NoBuiltin: {
2411     bool isImplicit = Record.readInt();
2412     bool isPackExpansion = Record.readInt();
2413     unsigned builtinNamesSize = Record.readInt();
2414     SmallVector<StringRef, 4> builtinNames;
2415     builtinNames.reserve(builtinNamesSize);
2416     SmallVector<std::string, 4> builtinNamesStorage;
2417     builtinNamesStorage.reserve(builtinNamesSize);
2418     for (unsigned i = 0; i != builtinNamesSize; ++i)
2419       builtinNamesStorage.push_back(Record.readString());
2420     for (unsigned i = 0; i != builtinNamesSize; ++i)
2421       builtinNames.push_back(builtinNamesStorage[i]);
2422     New = new (Context) NoBuiltinAttr(Context, Info, builtinNames.data(), builtinNamesSize);
2423     New->setImplicit(isImplicit);
2424     New->setPackExpansion(isPackExpansion);
2425     break;
2426   }
2427   case attr::NoCommon: {
2428     bool isInherited = Record.readInt();
2429     bool isImplicit = Record.readInt();
2430     bool isPackExpansion = Record.readInt();
2431     New = new (Context) NoCommonAttr(Context, Info);
2432     cast<InheritableAttr>(New)->setInherited(isInherited);
2433     New->setImplicit(isImplicit);
2434     New->setPackExpansion(isPackExpansion);
2435     break;
2436   }
2437   case attr::NoConvergent: {
2438     bool isInherited = Record.readInt();
2439     bool isImplicit = Record.readInt();
2440     bool isPackExpansion = Record.readInt();
2441     New = new (Context) NoConvergentAttr(Context, Info);
2442     cast<InheritableAttr>(New)->setInherited(isInherited);
2443     New->setImplicit(isImplicit);
2444     New->setPackExpansion(isPackExpansion);
2445     break;
2446   }
2447   case attr::NoDebug: {
2448     bool isInherited = Record.readInt();
2449     bool isImplicit = Record.readInt();
2450     bool isPackExpansion = Record.readInt();
2451     New = new (Context) NoDebugAttr(Context, Info);
2452     cast<InheritableAttr>(New)->setInherited(isInherited);
2453     New->setImplicit(isImplicit);
2454     New->setPackExpansion(isPackExpansion);
2455     break;
2456   }
2457   case attr::NoDeref: {
2458     bool isImplicit = Record.readInt();
2459     bool isPackExpansion = Record.readInt();
2460     New = new (Context) NoDerefAttr(Context, Info);
2461     New->setImplicit(isImplicit);
2462     New->setPackExpansion(isPackExpansion);
2463     break;
2464   }
2465   case attr::NoDestroy: {
2466     bool isInherited = Record.readInt();
2467     bool isImplicit = Record.readInt();
2468     bool isPackExpansion = Record.readInt();
2469     New = new (Context) NoDestroyAttr(Context, Info);
2470     cast<InheritableAttr>(New)->setInherited(isInherited);
2471     New->setImplicit(isImplicit);
2472     New->setPackExpansion(isPackExpansion);
2473     break;
2474   }
2475   case attr::NoDuplicate: {
2476     bool isInherited = Record.readInt();
2477     bool isImplicit = Record.readInt();
2478     bool isPackExpansion = Record.readInt();
2479     New = new (Context) NoDuplicateAttr(Context, Info);
2480     cast<InheritableAttr>(New)->setInherited(isInherited);
2481     New->setImplicit(isImplicit);
2482     New->setPackExpansion(isPackExpansion);
2483     break;
2484   }
2485   case attr::NoEscape: {
2486     bool isImplicit = Record.readInt();
2487     bool isPackExpansion = Record.readInt();
2488     New = new (Context) NoEscapeAttr(Context, Info);
2489     New->setImplicit(isImplicit);
2490     New->setPackExpansion(isPackExpansion);
2491     break;
2492   }
2493   case attr::NoInline: {
2494     bool isInherited = Record.readInt();
2495     bool isImplicit = Record.readInt();
2496     bool isPackExpansion = Record.readInt();
2497     New = new (Context) NoInlineAttr(Context, Info);
2498     cast<InheritableAttr>(New)->setInherited(isInherited);
2499     New->setImplicit(isImplicit);
2500     New->setPackExpansion(isPackExpansion);
2501     break;
2502   }
2503   case attr::NoInstrumentFunction: {
2504     bool isInherited = Record.readInt();
2505     bool isImplicit = Record.readInt();
2506     bool isPackExpansion = Record.readInt();
2507     New = new (Context) NoInstrumentFunctionAttr(Context, Info);
2508     cast<InheritableAttr>(New)->setInherited(isInherited);
2509     New->setImplicit(isImplicit);
2510     New->setPackExpansion(isPackExpansion);
2511     break;
2512   }
2513   case attr::NoMerge: {
2514     bool isInherited = Record.readInt();
2515     bool isImplicit = Record.readInt();
2516     bool isPackExpansion = Record.readInt();
2517     New = new (Context) NoMergeAttr(Context, Info);
2518     cast<InheritableAttr>(New)->setInherited(isInherited);
2519     New->setImplicit(isImplicit);
2520     New->setPackExpansion(isPackExpansion);
2521     break;
2522   }
2523   case attr::NoMicroMips: {
2524     bool isInherited = Record.readInt();
2525     bool isImplicit = Record.readInt();
2526     bool isPackExpansion = Record.readInt();
2527     New = new (Context) NoMicroMipsAttr(Context, Info);
2528     cast<InheritableAttr>(New)->setInherited(isInherited);
2529     New->setImplicit(isImplicit);
2530     New->setPackExpansion(isPackExpansion);
2531     break;
2532   }
2533   case attr::NoMips16: {
2534     bool isInherited = Record.readInt();
2535     bool isImplicit = Record.readInt();
2536     bool isPackExpansion = Record.readInt();
2537     New = new (Context) NoMips16Attr(Context, Info);
2538     cast<InheritableAttr>(New)->setInherited(isInherited);
2539     New->setImplicit(isImplicit);
2540     New->setPackExpansion(isPackExpansion);
2541     break;
2542   }
2543   case attr::NoProfileFunction: {
2544     bool isInherited = Record.readInt();
2545     bool isImplicit = Record.readInt();
2546     bool isPackExpansion = Record.readInt();
2547     New = new (Context) NoProfileFunctionAttr(Context, Info);
2548     cast<InheritableAttr>(New)->setInherited(isInherited);
2549     New->setImplicit(isImplicit);
2550     New->setPackExpansion(isPackExpansion);
2551     break;
2552   }
2553   case attr::NoRandomizeLayout: {
2554     bool isInherited = Record.readInt();
2555     bool isImplicit = Record.readInt();
2556     bool isPackExpansion = Record.readInt();
2557     New = new (Context) NoRandomizeLayoutAttr(Context, Info);
2558     cast<InheritableAttr>(New)->setInherited(isInherited);
2559     New->setImplicit(isImplicit);
2560     New->setPackExpansion(isPackExpansion);
2561     break;
2562   }
2563   case attr::NoReturn: {
2564     bool isInherited = Record.readInt();
2565     bool isImplicit = Record.readInt();
2566     bool isPackExpansion = Record.readInt();
2567     New = new (Context) NoReturnAttr(Context, Info);
2568     cast<InheritableAttr>(New)->setInherited(isInherited);
2569     New->setImplicit(isImplicit);
2570     New->setPackExpansion(isPackExpansion);
2571     break;
2572   }
2573   case attr::NoSanitize: {
2574     bool isInherited = Record.readInt();
2575     bool isImplicit = Record.readInt();
2576     bool isPackExpansion = Record.readInt();
2577     unsigned sanitizersSize = Record.readInt();
2578     SmallVector<StringRef, 4> sanitizers;
2579     sanitizers.reserve(sanitizersSize);
2580     SmallVector<std::string, 4> sanitizersStorage;
2581     sanitizersStorage.reserve(sanitizersSize);
2582     for (unsigned i = 0; i != sanitizersSize; ++i)
2583       sanitizersStorage.push_back(Record.readString());
2584     for (unsigned i = 0; i != sanitizersSize; ++i)
2585       sanitizers.push_back(sanitizersStorage[i]);
2586     New = new (Context) NoSanitizeAttr(Context, Info, sanitizers.data(), sanitizersSize);
2587     cast<InheritableAttr>(New)->setInherited(isInherited);
2588     New->setImplicit(isImplicit);
2589     New->setPackExpansion(isPackExpansion);
2590     break;
2591   }
2592   case attr::NoSpecializations: {
2593     bool isInherited = Record.readInt();
2594     bool isImplicit = Record.readInt();
2595     bool isPackExpansion = Record.readInt();
2596     std::string message= Record.readString();
2597     New = new (Context) NoSpecializationsAttr(Context, Info, message);
2598     cast<InheritableAttr>(New)->setInherited(isInherited);
2599     New->setImplicit(isImplicit);
2600     New->setPackExpansion(isPackExpansion);
2601     break;
2602   }
2603   case attr::NoSpeculativeLoadHardening: {
2604     bool isInherited = Record.readInt();
2605     bool isImplicit = Record.readInt();
2606     bool isPackExpansion = Record.readInt();
2607     New = new (Context) NoSpeculativeLoadHardeningAttr(Context, Info);
2608     cast<InheritableAttr>(New)->setInherited(isInherited);
2609     New->setImplicit(isImplicit);
2610     New->setPackExpansion(isPackExpansion);
2611     break;
2612   }
2613   case attr::NoSplitStack: {
2614     bool isInherited = Record.readInt();
2615     bool isImplicit = Record.readInt();
2616     bool isPackExpansion = Record.readInt();
2617     New = new (Context) NoSplitStackAttr(Context, Info);
2618     cast<InheritableAttr>(New)->setInherited(isInherited);
2619     New->setImplicit(isImplicit);
2620     New->setPackExpansion(isPackExpansion);
2621     break;
2622   }
2623   case attr::NoStackProtector: {
2624     bool isInherited = Record.readInt();
2625     bool isImplicit = Record.readInt();
2626     bool isPackExpansion = Record.readInt();
2627     New = new (Context) NoStackProtectorAttr(Context, Info);
2628     cast<InheritableAttr>(New)->setInherited(isInherited);
2629     New->setImplicit(isImplicit);
2630     New->setPackExpansion(isPackExpansion);
2631     break;
2632   }
2633   case attr::NoThreadSafetyAnalysis: {
2634     bool isInherited = Record.readInt();
2635     bool isImplicit = Record.readInt();
2636     bool isPackExpansion = Record.readInt();
2637     New = new (Context) NoThreadSafetyAnalysisAttr(Context, Info);
2638     cast<InheritableAttr>(New)->setInherited(isInherited);
2639     New->setImplicit(isImplicit);
2640     New->setPackExpansion(isPackExpansion);
2641     break;
2642   }
2643   case attr::NoThrow: {
2644     bool isInherited = Record.readInt();
2645     bool isImplicit = Record.readInt();
2646     bool isPackExpansion = Record.readInt();
2647     New = new (Context) NoThrowAttr(Context, Info);
2648     cast<InheritableAttr>(New)->setInherited(isInherited);
2649     New->setImplicit(isImplicit);
2650     New->setPackExpansion(isPackExpansion);
2651     break;
2652   }
2653   case attr::NoTrivialAutoVarInit: {
2654     bool isInherited = Record.readInt();
2655     bool isImplicit = Record.readInt();
2656     bool isPackExpansion = Record.readInt();
2657     New = new (Context) NoTrivialAutoVarInitAttr(Context, Info);
2658     cast<InheritableAttr>(New)->setInherited(isInherited);
2659     New->setImplicit(isImplicit);
2660     New->setPackExpansion(isPackExpansion);
2661     break;
2662   }
2663   case attr::NoUniqueAddress: {
2664     bool isInherited = Record.readInt();
2665     bool isImplicit = Record.readInt();
2666     bool isPackExpansion = Record.readInt();
2667     New = new (Context) NoUniqueAddressAttr(Context, Info);
2668     cast<InheritableAttr>(New)->setInherited(isInherited);
2669     New->setImplicit(isImplicit);
2670     New->setPackExpansion(isPackExpansion);
2671     break;
2672   }
2673   case attr::NoUwtable: {
2674     bool isInherited = Record.readInt();
2675     bool isImplicit = Record.readInt();
2676     bool isPackExpansion = Record.readInt();
2677     New = new (Context) NoUwtableAttr(Context, Info);
2678     cast<InheritableAttr>(New)->setInherited(isInherited);
2679     New->setImplicit(isImplicit);
2680     New->setPackExpansion(isPackExpansion);
2681     break;
2682   }
2683   case attr::NonAllocating: {
2684     bool isImplicit = Record.readInt();
2685     bool isPackExpansion = Record.readInt();
2686     Expr * cond = Record.readExpr();
2687     New = new (Context) NonAllocatingAttr(Context, Info, cond);
2688     New->setImplicit(isImplicit);
2689     New->setPackExpansion(isPackExpansion);
2690     break;
2691   }
2692   case attr::NonBlocking: {
2693     bool isImplicit = Record.readInt();
2694     bool isPackExpansion = Record.readInt();
2695     Expr * cond = Record.readExpr();
2696     New = new (Context) NonBlockingAttr(Context, Info, cond);
2697     New->setImplicit(isImplicit);
2698     New->setPackExpansion(isPackExpansion);
2699     break;
2700   }
2701   case attr::NonNull: {
2702     bool isInherited = Record.readInt();
2703     bool isImplicit = Record.readInt();
2704     bool isPackExpansion = Record.readInt();
2705     unsigned argsSize = Record.readInt();
2706     SmallVector<ParamIdx, 4> args;
2707     args.reserve(argsSize);
2708     for (unsigned i = 0; i != argsSize; ++i)
2709       args.push_back(ParamIdx::deserialize(Record.readInt()));
2710     New = new (Context) NonNullAttr(Context, Info, args.data(), argsSize);
2711     cast<InheritableAttr>(New)->setInherited(isInherited);
2712     New->setImplicit(isImplicit);
2713     New->setPackExpansion(isPackExpansion);
2714     break;
2715   }
2716   case attr::NotTailCalled: {
2717     bool isInherited = Record.readInt();
2718     bool isImplicit = Record.readInt();
2719     bool isPackExpansion = Record.readInt();
2720     New = new (Context) NotTailCalledAttr(Context, Info);
2721     cast<InheritableAttr>(New)->setInherited(isInherited);
2722     New->setImplicit(isImplicit);
2723     New->setPackExpansion(isPackExpansion);
2724     break;
2725   }
2726   case attr::OMPAllocateDecl: {
2727     bool isInherited = Record.readInt();
2728     bool isImplicit = Record.readInt();
2729     bool isPackExpansion = Record.readInt();
2730     OMPAllocateDeclAttr::AllocatorTypeTy allocatorType(static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt()));
2731     Expr * allocator = Record.readExpr();
2732     Expr * alignment = Record.readExpr();
2733     New = new (Context) OMPAllocateDeclAttr(Context, Info, allocatorType, allocator, alignment);
2734     cast<InheritableAttr>(New)->setInherited(isInherited);
2735     New->setImplicit(isImplicit);
2736     New->setPackExpansion(isPackExpansion);
2737     break;
2738   }
2739   case attr::OMPAssume: {
2740     bool isInherited = Record.readInt();
2741     bool isImplicit = Record.readInt();
2742     bool isPackExpansion = Record.readInt();
2743     std::string assumption= Record.readString();
2744     New = new (Context) OMPAssumeAttr(Context, Info, assumption);
2745     cast<InheritableAttr>(New)->setInherited(isInherited);
2746     New->setImplicit(isImplicit);
2747     New->setPackExpansion(isPackExpansion);
2748     break;
2749   }
2750   case attr::OMPCaptureKind: {
2751     bool isImplicit = Record.readInt();
2752     bool isPackExpansion = Record.readInt();
2753     unsigned captureKindVal = Record.readInt();
2754     New = new (Context) OMPCaptureKindAttr(Context, Info, captureKindVal);
2755     New->setImplicit(isImplicit);
2756     New->setPackExpansion(isPackExpansion);
2757     break;
2758   }
2759   case attr::OMPCaptureNoInit: {
2760     bool isInherited = Record.readInt();
2761     bool isImplicit = Record.readInt();
2762     bool isPackExpansion = Record.readInt();
2763     New = new (Context) OMPCaptureNoInitAttr(Context, Info);
2764     cast<InheritableAttr>(New)->setInherited(isInherited);
2765     New->setImplicit(isImplicit);
2766     New->setPackExpansion(isPackExpansion);
2767     break;
2768   }
2769   case attr::OMPDeclareSimdDecl: {
2770     bool isImplicit = Record.readInt();
2771     bool isPackExpansion = Record.readInt();
2772     OMPDeclareSimdDeclAttr::BranchStateTy branchState(static_cast<OMPDeclareSimdDeclAttr::BranchStateTy>(Record.readInt()));
2773     Expr * simdlen = Record.readExpr();
2774     unsigned uniformsSize = Record.readInt();
2775     SmallVector<Expr *, 4> uniforms;
2776     uniforms.reserve(uniformsSize);
2777     for (unsigned i = 0; i != uniformsSize; ++i)
2778       uniforms.push_back(Record.readExpr());
2779     unsigned alignedsSize = Record.readInt();
2780     SmallVector<Expr *, 4> aligneds;
2781     aligneds.reserve(alignedsSize);
2782     for (unsigned i = 0; i != alignedsSize; ++i)
2783       aligneds.push_back(Record.readExpr());
2784     unsigned alignmentsSize = Record.readInt();
2785     SmallVector<Expr *, 4> alignments;
2786     alignments.reserve(alignmentsSize);
2787     for (unsigned i = 0; i != alignmentsSize; ++i)
2788       alignments.push_back(Record.readExpr());
2789     unsigned linearsSize = Record.readInt();
2790     SmallVector<Expr *, 4> linears;
2791     linears.reserve(linearsSize);
2792     for (unsigned i = 0; i != linearsSize; ++i)
2793       linears.push_back(Record.readExpr());
2794     unsigned modifiersSize = Record.readInt();
2795     SmallVector<unsigned, 4> modifiers;
2796     modifiers.reserve(modifiersSize);
2797     for (unsigned i = 0; i != modifiersSize; ++i)
2798       modifiers.push_back(Record.readInt());
2799     unsigned stepsSize = Record.readInt();
2800     SmallVector<Expr *, 4> steps;
2801     steps.reserve(stepsSize);
2802     for (unsigned i = 0; i != stepsSize; ++i)
2803       steps.push_back(Record.readExpr());
2804     New = new (Context) OMPDeclareSimdDeclAttr(Context, Info, branchState, simdlen, uniforms.data(), uniformsSize, aligneds.data(), alignedsSize, alignments.data(), alignmentsSize, linears.data(), linearsSize, modifiers.data(), modifiersSize, steps.data(), stepsSize);
2805     New->setImplicit(isImplicit);
2806     New->setPackExpansion(isPackExpansion);
2807     break;
2808   }
2809   case attr::OMPDeclareTargetDecl: {
2810     bool isInherited = Record.readInt();
2811     bool isImplicit = Record.readInt();
2812     bool isPackExpansion = Record.readInt();
2813     OMPDeclareTargetDeclAttr::MapTypeTy mapType(static_cast<OMPDeclareTargetDeclAttr::MapTypeTy>(Record.readInt()));
2814     OMPDeclareTargetDeclAttr::DevTypeTy devType(static_cast<OMPDeclareTargetDeclAttr::DevTypeTy>(Record.readInt()));
2815     Expr * indirectExpr = Record.readExpr();
2816     bool indirect = Record.readInt();
2817     unsigned level = Record.readInt();
2818     New = new (Context) OMPDeclareTargetDeclAttr(Context, Info, mapType, devType, indirectExpr, indirect, level);
2819     cast<InheritableAttr>(New)->setInherited(isInherited);
2820     New->setImplicit(isImplicit);
2821     New->setPackExpansion(isPackExpansion);
2822     break;
2823   }
2824   case attr::OMPDeclareVariant: {
2825     bool isInherited = Record.readInt();
2826     bool isImplicit = Record.readInt();
2827     bool isPackExpansion = Record.readInt();
2828     Expr * variantFuncRef = Record.readExpr();
2829     OMPTraitInfo * traitInfos = Record.readOMPTraitInfo();
2830     unsigned adjustArgsNothingSize = Record.readInt();
2831     SmallVector<Expr *, 4> adjustArgsNothing;
2832     adjustArgsNothing.reserve(adjustArgsNothingSize);
2833     for (unsigned i = 0; i != adjustArgsNothingSize; ++i)
2834       adjustArgsNothing.push_back(Record.readExpr());
2835     unsigned adjustArgsNeedDevicePtrSize = Record.readInt();
2836     SmallVector<Expr *, 4> adjustArgsNeedDevicePtr;
2837     adjustArgsNeedDevicePtr.reserve(adjustArgsNeedDevicePtrSize);
2838     for (unsigned i = 0; i != adjustArgsNeedDevicePtrSize; ++i)
2839       adjustArgsNeedDevicePtr.push_back(Record.readExpr());
2840     unsigned appendArgsSize = Record.readInt();
2841     SmallVector<OMPInteropInfo, 4> appendArgs;
2842     appendArgs.reserve(appendArgsSize);
2843     for (unsigned I = 0, E = appendArgsSize; I != E; ++I) {
2844       bool IsTarget = Record.readBool();
2845       bool IsTargetSync = Record.readBool();
2846       appendArgs.emplace_back(IsTarget, IsTargetSync);
2847     }
2848     New = new (Context) OMPDeclareVariantAttr(Context, Info, variantFuncRef, traitInfos, adjustArgsNothing.data(), adjustArgsNothingSize, adjustArgsNeedDevicePtr.data(), adjustArgsNeedDevicePtrSize, appendArgs.data(), appendArgsSize);
2849     cast<InheritableAttr>(New)->setInherited(isInherited);
2850     New->setImplicit(isImplicit);
2851     New->setPackExpansion(isPackExpansion);
2852     break;
2853   }
2854   case attr::OMPReferencedVar: {
2855     bool isImplicit = Record.readInt();
2856     bool isPackExpansion = Record.readInt();
2857     Expr * ref = Record.readExpr();
2858     New = new (Context) OMPReferencedVarAttr(Context, Info, ref);
2859     New->setImplicit(isImplicit);
2860     New->setPackExpansion(isPackExpansion);
2861     break;
2862   }
2863   case attr::OMPThreadPrivateDecl: {
2864     bool isInherited = Record.readInt();
2865     bool isImplicit = Record.readInt();
2866     bool isPackExpansion = Record.readInt();
2867     New = new (Context) OMPThreadPrivateDeclAttr(Context, Info);
2868     cast<InheritableAttr>(New)->setInherited(isInherited);
2869     New->setImplicit(isImplicit);
2870     New->setPackExpansion(isPackExpansion);
2871     break;
2872   }
2873   case attr::OSConsumed: {
2874     bool isInherited = Record.readInt();
2875     bool isImplicit = Record.readInt();
2876     bool isPackExpansion = Record.readInt();
2877     New = new (Context) OSConsumedAttr(Context, Info);
2878     cast<InheritableAttr>(New)->setInherited(isInherited);
2879     New->setImplicit(isImplicit);
2880     New->setPackExpansion(isPackExpansion);
2881     break;
2882   }
2883   case attr::OSConsumesThis: {
2884     bool isInherited = Record.readInt();
2885     bool isImplicit = Record.readInt();
2886     bool isPackExpansion = Record.readInt();
2887     New = new (Context) OSConsumesThisAttr(Context, Info);
2888     cast<InheritableAttr>(New)->setInherited(isInherited);
2889     New->setImplicit(isImplicit);
2890     New->setPackExpansion(isPackExpansion);
2891     break;
2892   }
2893   case attr::OSReturnsNotRetained: {
2894     bool isInherited = Record.readInt();
2895     bool isImplicit = Record.readInt();
2896     bool isPackExpansion = Record.readInt();
2897     New = new (Context) OSReturnsNotRetainedAttr(Context, Info);
2898     cast<InheritableAttr>(New)->setInherited(isInherited);
2899     New->setImplicit(isImplicit);
2900     New->setPackExpansion(isPackExpansion);
2901     break;
2902   }
2903   case attr::OSReturnsRetained: {
2904     bool isInherited = Record.readInt();
2905     bool isImplicit = Record.readInt();
2906     bool isPackExpansion = Record.readInt();
2907     New = new (Context) OSReturnsRetainedAttr(Context, Info);
2908     cast<InheritableAttr>(New)->setInherited(isInherited);
2909     New->setImplicit(isImplicit);
2910     New->setPackExpansion(isPackExpansion);
2911     break;
2912   }
2913   case attr::OSReturnsRetainedOnNonZero: {
2914     bool isInherited = Record.readInt();
2915     bool isImplicit = Record.readInt();
2916     bool isPackExpansion = Record.readInt();
2917     New = new (Context) OSReturnsRetainedOnNonZeroAttr(Context, Info);
2918     cast<InheritableAttr>(New)->setInherited(isInherited);
2919     New->setImplicit(isImplicit);
2920     New->setPackExpansion(isPackExpansion);
2921     break;
2922   }
2923   case attr::OSReturnsRetainedOnZero: {
2924     bool isInherited = Record.readInt();
2925     bool isImplicit = Record.readInt();
2926     bool isPackExpansion = Record.readInt();
2927     New = new (Context) OSReturnsRetainedOnZeroAttr(Context, Info);
2928     cast<InheritableAttr>(New)->setInherited(isInherited);
2929     New->setImplicit(isImplicit);
2930     New->setPackExpansion(isPackExpansion);
2931     break;
2932   }
2933   case attr::ObjCBoxable: {
2934     bool isImplicit = Record.readInt();
2935     bool isPackExpansion = Record.readInt();
2936     New = new (Context) ObjCBoxableAttr(Context, Info);
2937     New->setImplicit(isImplicit);
2938     New->setPackExpansion(isPackExpansion);
2939     break;
2940   }
2941   case attr::ObjCBridge: {
2942     bool isInherited = Record.readInt();
2943     bool isImplicit = Record.readInt();
2944     bool isPackExpansion = Record.readInt();
2945     IdentifierInfo * bridgedType = Record.readIdentifier();
2946     New = new (Context) ObjCBridgeAttr(Context, Info, bridgedType);
2947     cast<InheritableAttr>(New)->setInherited(isInherited);
2948     New->setImplicit(isImplicit);
2949     New->setPackExpansion(isPackExpansion);
2950     break;
2951   }
2952   case attr::ObjCBridgeMutable: {
2953     bool isInherited = Record.readInt();
2954     bool isImplicit = Record.readInt();
2955     bool isPackExpansion = Record.readInt();
2956     IdentifierInfo * bridgedType = Record.readIdentifier();
2957     New = new (Context) ObjCBridgeMutableAttr(Context, Info, bridgedType);
2958     cast<InheritableAttr>(New)->setInherited(isInherited);
2959     New->setImplicit(isImplicit);
2960     New->setPackExpansion(isPackExpansion);
2961     break;
2962   }
2963   case attr::ObjCBridgeRelated: {
2964     bool isInherited = Record.readInt();
2965     bool isImplicit = Record.readInt();
2966     bool isPackExpansion = Record.readInt();
2967     IdentifierInfo * relatedClass = Record.readIdentifier();
2968     IdentifierInfo * classMethod = Record.readIdentifier();
2969     IdentifierInfo * instanceMethod = Record.readIdentifier();
2970     New = new (Context) ObjCBridgeRelatedAttr(Context, Info, relatedClass, classMethod, instanceMethod);
2971     cast<InheritableAttr>(New)->setInherited(isInherited);
2972     New->setImplicit(isImplicit);
2973     New->setPackExpansion(isPackExpansion);
2974     break;
2975   }
2976   case attr::ObjCClassStub: {
2977     bool isImplicit = Record.readInt();
2978     bool isPackExpansion = Record.readInt();
2979     New = new (Context) ObjCClassStubAttr(Context, Info);
2980     New->setImplicit(isImplicit);
2981     New->setPackExpansion(isPackExpansion);
2982     break;
2983   }
2984   case attr::ObjCDesignatedInitializer: {
2985     bool isImplicit = Record.readInt();
2986     bool isPackExpansion = Record.readInt();
2987     New = new (Context) ObjCDesignatedInitializerAttr(Context, Info);
2988     New->setImplicit(isImplicit);
2989     New->setPackExpansion(isPackExpansion);
2990     break;
2991   }
2992   case attr::ObjCDirect: {
2993     bool isImplicit = Record.readInt();
2994     bool isPackExpansion = Record.readInt();
2995     New = new (Context) ObjCDirectAttr(Context, Info);
2996     New->setImplicit(isImplicit);
2997     New->setPackExpansion(isPackExpansion);
2998     break;
2999   }
3000   case attr::ObjCDirectMembers: {
3001     bool isImplicit = Record.readInt();
3002     bool isPackExpansion = Record.readInt();
3003     New = new (Context) ObjCDirectMembersAttr(Context, Info);
3004     New->setImplicit(isImplicit);
3005     New->setPackExpansion(isPackExpansion);
3006     break;
3007   }
3008   case attr::ObjCException: {
3009     bool isInherited = Record.readInt();
3010     bool isImplicit = Record.readInt();
3011     bool isPackExpansion = Record.readInt();
3012     New = new (Context) ObjCExceptionAttr(Context, Info);
3013     cast<InheritableAttr>(New)->setInherited(isInherited);
3014     New->setImplicit(isImplicit);
3015     New->setPackExpansion(isPackExpansion);
3016     break;
3017   }
3018   case attr::ObjCExplicitProtocolImpl: {
3019     bool isInherited = Record.readInt();
3020     bool isImplicit = Record.readInt();
3021     bool isPackExpansion = Record.readInt();
3022     New = new (Context) ObjCExplicitProtocolImplAttr(Context, Info);
3023     cast<InheritableAttr>(New)->setInherited(isInherited);
3024     New->setImplicit(isImplicit);
3025     New->setPackExpansion(isPackExpansion);
3026     break;
3027   }
3028   case attr::ObjCExternallyRetained: {
3029     bool isInherited = Record.readInt();
3030     bool isImplicit = Record.readInt();
3031     bool isPackExpansion = Record.readInt();
3032     New = new (Context) ObjCExternallyRetainedAttr(Context, Info);
3033     cast<InheritableAttr>(New)->setInherited(isInherited);
3034     New->setImplicit(isImplicit);
3035     New->setPackExpansion(isPackExpansion);
3036     break;
3037   }
3038   case attr::ObjCGC: {
3039     bool isImplicit = Record.readInt();
3040     bool isPackExpansion = Record.readInt();
3041     IdentifierInfo * kind = Record.readIdentifier();
3042     New = new (Context) ObjCGCAttr(Context, Info, kind);
3043     New->setImplicit(isImplicit);
3044     New->setPackExpansion(isPackExpansion);
3045     break;
3046   }
3047   case attr::ObjCIndependentClass: {
3048     bool isInherited = Record.readInt();
3049     bool isImplicit = Record.readInt();
3050     bool isPackExpansion = Record.readInt();
3051     New = new (Context) ObjCIndependentClassAttr(Context, Info);
3052     cast<InheritableAttr>(New)->setInherited(isInherited);
3053     New->setImplicit(isImplicit);
3054     New->setPackExpansion(isPackExpansion);
3055     break;
3056   }
3057   case attr::ObjCInertUnsafeUnretained: {
3058     bool isImplicit = Record.readInt();
3059     bool isPackExpansion = Record.readInt();
3060     New = new (Context) ObjCInertUnsafeUnretainedAttr(Context, Info);
3061     New->setImplicit(isImplicit);
3062     New->setPackExpansion(isPackExpansion);
3063     break;
3064   }
3065   case attr::ObjCKindOf: {
3066     bool isImplicit = Record.readInt();
3067     bool isPackExpansion = Record.readInt();
3068     New = new (Context) ObjCKindOfAttr(Context, Info);
3069     New->setImplicit(isImplicit);
3070     New->setPackExpansion(isPackExpansion);
3071     break;
3072   }
3073   case attr::ObjCMethodFamily: {
3074     bool isInherited = Record.readInt();
3075     bool isImplicit = Record.readInt();
3076     bool isPackExpansion = Record.readInt();
3077     ObjCMethodFamilyAttr::FamilyKind family(static_cast<ObjCMethodFamilyAttr::FamilyKind>(Record.readInt()));
3078     New = new (Context) ObjCMethodFamilyAttr(Context, Info, family);
3079     cast<InheritableAttr>(New)->setInherited(isInherited);
3080     New->setImplicit(isImplicit);
3081     New->setPackExpansion(isPackExpansion);
3082     break;
3083   }
3084   case attr::ObjCNSObject: {
3085     bool isInherited = Record.readInt();
3086     bool isImplicit = Record.readInt();
3087     bool isPackExpansion = Record.readInt();
3088     New = new (Context) ObjCNSObjectAttr(Context, Info);
3089     cast<InheritableAttr>(New)->setInherited(isInherited);
3090     New->setImplicit(isImplicit);
3091     New->setPackExpansion(isPackExpansion);
3092     break;
3093   }
3094   case attr::ObjCNonLazyClass: {
3095     bool isImplicit = Record.readInt();
3096     bool isPackExpansion = Record.readInt();
3097     New = new (Context) ObjCNonLazyClassAttr(Context, Info);
3098     New->setImplicit(isImplicit);
3099     New->setPackExpansion(isPackExpansion);
3100     break;
3101   }
3102   case attr::ObjCNonRuntimeProtocol: {
3103     bool isImplicit = Record.readInt();
3104     bool isPackExpansion = Record.readInt();
3105     New = new (Context) ObjCNonRuntimeProtocolAttr(Context, Info);
3106     New->setImplicit(isImplicit);
3107     New->setPackExpansion(isPackExpansion);
3108     break;
3109   }
3110   case attr::ObjCOwnership: {
3111     bool isInherited = Record.readInt();
3112     bool isImplicit = Record.readInt();
3113     bool isPackExpansion = Record.readInt();
3114     IdentifierInfo * kind = Record.readIdentifier();
3115     New = new (Context) ObjCOwnershipAttr(Context, Info, kind);
3116     cast<InheritableAttr>(New)->setInherited(isInherited);
3117     New->setImplicit(isImplicit);
3118     New->setPackExpansion(isPackExpansion);
3119     break;
3120   }
3121   case attr::ObjCPreciseLifetime: {
3122     bool isInherited = Record.readInt();
3123     bool isImplicit = Record.readInt();
3124     bool isPackExpansion = Record.readInt();
3125     New = new (Context) ObjCPreciseLifetimeAttr(Context, Info);
3126     cast<InheritableAttr>(New)->setInherited(isInherited);
3127     New->setImplicit(isImplicit);
3128     New->setPackExpansion(isPackExpansion);
3129     break;
3130   }
3131   case attr::ObjCRequiresPropertyDefs: {
3132     bool isInherited = Record.readInt();
3133     bool isImplicit = Record.readInt();
3134     bool isPackExpansion = Record.readInt();
3135     New = new (Context) ObjCRequiresPropertyDefsAttr(Context, Info);
3136     cast<InheritableAttr>(New)->setInherited(isInherited);
3137     New->setImplicit(isImplicit);
3138     New->setPackExpansion(isPackExpansion);
3139     break;
3140   }
3141   case attr::ObjCRequiresSuper: {
3142     bool isInherited = Record.readInt();
3143     bool isImplicit = Record.readInt();
3144     bool isPackExpansion = Record.readInt();
3145     New = new (Context) ObjCRequiresSuperAttr(Context, Info);
3146     cast<InheritableAttr>(New)->setInherited(isInherited);
3147     New->setImplicit(isImplicit);
3148     New->setPackExpansion(isPackExpansion);
3149     break;
3150   }
3151   case attr::ObjCReturnsInnerPointer: {
3152     bool isInherited = Record.readInt();
3153     bool isImplicit = Record.readInt();
3154     bool isPackExpansion = Record.readInt();
3155     New = new (Context) ObjCReturnsInnerPointerAttr(Context, Info);
3156     cast<InheritableAttr>(New)->setInherited(isInherited);
3157     New->setImplicit(isImplicit);
3158     New->setPackExpansion(isPackExpansion);
3159     break;
3160   }
3161   case attr::ObjCRootClass: {
3162     bool isInherited = Record.readInt();
3163     bool isImplicit = Record.readInt();
3164     bool isPackExpansion = Record.readInt();
3165     New = new (Context) ObjCRootClassAttr(Context, Info);
3166     cast<InheritableAttr>(New)->setInherited(isInherited);
3167     New->setImplicit(isImplicit);
3168     New->setPackExpansion(isPackExpansion);
3169     break;
3170   }
3171   case attr::ObjCRuntimeName: {
3172     bool isImplicit = Record.readInt();
3173     bool isPackExpansion = Record.readInt();
3174     std::string metadataName= Record.readString();
3175     New = new (Context) ObjCRuntimeNameAttr(Context, Info, metadataName);
3176     New->setImplicit(isImplicit);
3177     New->setPackExpansion(isPackExpansion);
3178     break;
3179   }
3180   case attr::ObjCRuntimeVisible: {
3181     bool isImplicit = Record.readInt();
3182     bool isPackExpansion = Record.readInt();
3183     New = new (Context) ObjCRuntimeVisibleAttr(Context, Info);
3184     New->setImplicit(isImplicit);
3185     New->setPackExpansion(isPackExpansion);
3186     break;
3187   }
3188   case attr::ObjCSubclassingRestricted: {
3189     bool isInherited = Record.readInt();
3190     bool isImplicit = Record.readInt();
3191     bool isPackExpansion = Record.readInt();
3192     New = new (Context) ObjCSubclassingRestrictedAttr(Context, Info);
3193     cast<InheritableAttr>(New)->setInherited(isInherited);
3194     New->setImplicit(isImplicit);
3195     New->setPackExpansion(isPackExpansion);
3196     break;
3197   }
3198   case attr::OpenCLAccess: {
3199     bool isImplicit = Record.readInt();
3200     bool isPackExpansion = Record.readInt();
3201     New = new (Context) OpenCLAccessAttr(Context, Info);
3202     New->setImplicit(isImplicit);
3203     New->setPackExpansion(isPackExpansion);
3204     break;
3205   }
3206   case attr::OpenCLConstantAddressSpace: {
3207     bool isImplicit = Record.readInt();
3208     bool isPackExpansion = Record.readInt();
3209     New = new (Context) OpenCLConstantAddressSpaceAttr(Context, Info);
3210     New->setImplicit(isImplicit);
3211     New->setPackExpansion(isPackExpansion);
3212     break;
3213   }
3214   case attr::OpenCLGenericAddressSpace: {
3215     bool isImplicit = Record.readInt();
3216     bool isPackExpansion = Record.readInt();
3217     New = new (Context) OpenCLGenericAddressSpaceAttr(Context, Info);
3218     New->setImplicit(isImplicit);
3219     New->setPackExpansion(isPackExpansion);
3220     break;
3221   }
3222   case attr::OpenCLGlobalAddressSpace: {
3223     bool isImplicit = Record.readInt();
3224     bool isPackExpansion = Record.readInt();
3225     New = new (Context) OpenCLGlobalAddressSpaceAttr(Context, Info);
3226     New->setImplicit(isImplicit);
3227     New->setPackExpansion(isPackExpansion);
3228     break;
3229   }
3230   case attr::OpenCLGlobalDeviceAddressSpace: {
3231     bool isImplicit = Record.readInt();
3232     bool isPackExpansion = Record.readInt();
3233     New = new (Context) OpenCLGlobalDeviceAddressSpaceAttr(Context, Info);
3234     New->setImplicit(isImplicit);
3235     New->setPackExpansion(isPackExpansion);
3236     break;
3237   }
3238   case attr::OpenCLGlobalHostAddressSpace: {
3239     bool isImplicit = Record.readInt();
3240     bool isPackExpansion = Record.readInt();
3241     New = new (Context) OpenCLGlobalHostAddressSpaceAttr(Context, Info);
3242     New->setImplicit(isImplicit);
3243     New->setPackExpansion(isPackExpansion);
3244     break;
3245   }
3246   case attr::OpenCLIntelReqdSubGroupSize: {
3247     bool isInherited = Record.readInt();
3248     bool isImplicit = Record.readInt();
3249     bool isPackExpansion = Record.readInt();
3250     unsigned subGroupSize = Record.readInt();
3251     New = new (Context) OpenCLIntelReqdSubGroupSizeAttr(Context, Info, subGroupSize);
3252     cast<InheritableAttr>(New)->setInherited(isInherited);
3253     New->setImplicit(isImplicit);
3254     New->setPackExpansion(isPackExpansion);
3255     break;
3256   }
3257   case attr::OpenCLKernel: {
3258     bool isInherited = Record.readInt();
3259     bool isImplicit = Record.readInt();
3260     bool isPackExpansion = Record.readInt();
3261     New = new (Context) OpenCLKernelAttr(Context, Info);
3262     cast<InheritableAttr>(New)->setInherited(isInherited);
3263     New->setImplicit(isImplicit);
3264     New->setPackExpansion(isPackExpansion);
3265     break;
3266   }
3267   case attr::OpenCLLocalAddressSpace: {
3268     bool isImplicit = Record.readInt();
3269     bool isPackExpansion = Record.readInt();
3270     New = new (Context) OpenCLLocalAddressSpaceAttr(Context, Info);
3271     New->setImplicit(isImplicit);
3272     New->setPackExpansion(isPackExpansion);
3273     break;
3274   }
3275   case attr::OpenCLPrivateAddressSpace: {
3276     bool isImplicit = Record.readInt();
3277     bool isPackExpansion = Record.readInt();
3278     New = new (Context) OpenCLPrivateAddressSpaceAttr(Context, Info);
3279     New->setImplicit(isImplicit);
3280     New->setPackExpansion(isPackExpansion);
3281     break;
3282   }
3283   case attr::OpenCLUnrollHint: {
3284     bool isImplicit = Record.readInt();
3285     bool isPackExpansion = Record.readInt();
3286     unsigned unrollHint = Record.readInt();
3287     New = new (Context) OpenCLUnrollHintAttr(Context, Info, unrollHint);
3288     New->setImplicit(isImplicit);
3289     New->setPackExpansion(isPackExpansion);
3290     break;
3291   }
3292   case attr::OptimizeNone: {
3293     bool isInherited = Record.readInt();
3294     bool isImplicit = Record.readInt();
3295     bool isPackExpansion = Record.readInt();
3296     New = new (Context) OptimizeNoneAttr(Context, Info);
3297     cast<InheritableAttr>(New)->setInherited(isInherited);
3298     New->setImplicit(isImplicit);
3299     New->setPackExpansion(isPackExpansion);
3300     break;
3301   }
3302   case attr::Overloadable: {
3303     bool isImplicit = Record.readInt();
3304     bool isPackExpansion = Record.readInt();
3305     New = new (Context) OverloadableAttr(Context, Info);
3306     New->setImplicit(isImplicit);
3307     New->setPackExpansion(isPackExpansion);
3308     break;
3309   }
3310   case attr::Override: {
3311     bool isInherited = Record.readInt();
3312     bool isImplicit = Record.readInt();
3313     bool isPackExpansion = Record.readInt();
3314     New = new (Context) OverrideAttr(Context, Info);
3315     cast<InheritableAttr>(New)->setInherited(isInherited);
3316     New->setImplicit(isImplicit);
3317     New->setPackExpansion(isPackExpansion);
3318     break;
3319   }
3320   case attr::Owner: {
3321     bool isInherited = Record.readInt();
3322     bool isImplicit = Record.readInt();
3323     bool isPackExpansion = Record.readInt();
3324     TypeSourceInfo * derefType = Record.readTypeSourceInfo();
3325     New = new (Context) OwnerAttr(Context, Info, derefType);
3326     cast<InheritableAttr>(New)->setInherited(isInherited);
3327     New->setImplicit(isImplicit);
3328     New->setPackExpansion(isPackExpansion);
3329     break;
3330   }
3331   case attr::Ownership: {
3332     bool isInherited = Record.readInt();
3333     bool isImplicit = Record.readInt();
3334     bool isPackExpansion = Record.readInt();
3335     IdentifierInfo * module = Record.readIdentifier();
3336     unsigned argsSize = Record.readInt();
3337     SmallVector<ParamIdx, 4> args;
3338     args.reserve(argsSize);
3339     for (unsigned i = 0; i != argsSize; ++i)
3340       args.push_back(ParamIdx::deserialize(Record.readInt()));
3341     New = new (Context) OwnershipAttr(Context, Info, module, args.data(), argsSize);
3342     cast<InheritableAttr>(New)->setInherited(isInherited);
3343     New->setImplicit(isImplicit);
3344     New->setPackExpansion(isPackExpansion);
3345     break;
3346   }
3347   case attr::Packed: {
3348     bool isInherited = Record.readInt();
3349     bool isImplicit = Record.readInt();
3350     bool isPackExpansion = Record.readInt();
3351     New = new (Context) PackedAttr(Context, Info);
3352     cast<InheritableAttr>(New)->setInherited(isInherited);
3353     New->setImplicit(isImplicit);
3354     New->setPackExpansion(isPackExpansion);
3355     break;
3356   }
3357   case attr::ParamTypestate: {
3358     bool isInherited = Record.readInt();
3359     bool isImplicit = Record.readInt();
3360     bool isPackExpansion = Record.readInt();
3361     ParamTypestateAttr::ConsumedState paramState(static_cast<ParamTypestateAttr::ConsumedState>(Record.readInt()));
3362     New = new (Context) ParamTypestateAttr(Context, Info, paramState);
3363     cast<InheritableAttr>(New)->setInherited(isInherited);
3364     New->setImplicit(isImplicit);
3365     New->setPackExpansion(isPackExpansion);
3366     break;
3367   }
3368   case attr::Pascal: {
3369     bool isInherited = Record.readInt();
3370     bool isImplicit = Record.readInt();
3371     bool isPackExpansion = Record.readInt();
3372     New = new (Context) PascalAttr(Context, Info);
3373     cast<InheritableAttr>(New)->setInherited(isInherited);
3374     New->setImplicit(isImplicit);
3375     New->setPackExpansion(isPackExpansion);
3376     break;
3377   }
3378   case attr::PassObjectSize: {
3379     bool isInherited = Record.readInt();
3380     bool isImplicit = Record.readInt();
3381     bool isPackExpansion = Record.readInt();
3382     int type = Record.readInt();
3383     New = new (Context) PassObjectSizeAttr(Context, Info, type);
3384     cast<InheritableAttr>(New)->setInherited(isInherited);
3385     New->setImplicit(isImplicit);
3386     New->setPackExpansion(isPackExpansion);
3387     break;
3388   }
3389   case attr::PatchableFunctionEntry: {
3390     bool isInherited = Record.readInt();
3391     bool isImplicit = Record.readInt();
3392     bool isPackExpansion = Record.readInt();
3393     unsigned count = Record.readInt();
3394     int offset = Record.readInt();
3395     New = new (Context) PatchableFunctionEntryAttr(Context, Info, count, offset);
3396     cast<InheritableAttr>(New)->setInherited(isInherited);
3397     New->setImplicit(isImplicit);
3398     New->setPackExpansion(isPackExpansion);
3399     break;
3400   }
3401   case attr::Pcs: {
3402     bool isInherited = Record.readInt();
3403     bool isImplicit = Record.readInt();
3404     bool isPackExpansion = Record.readInt();
3405     PcsAttr::PCSType pCS(static_cast<PcsAttr::PCSType>(Record.readInt()));
3406     New = new (Context) PcsAttr(Context, Info, pCS);
3407     cast<InheritableAttr>(New)->setInherited(isInherited);
3408     New->setImplicit(isImplicit);
3409     New->setPackExpansion(isPackExpansion);
3410     break;
3411   }
3412   case attr::Pointer: {
3413     bool isInherited = Record.readInt();
3414     bool isImplicit = Record.readInt();
3415     bool isPackExpansion = Record.readInt();
3416     TypeSourceInfo * derefType = Record.readTypeSourceInfo();
3417     New = new (Context) PointerAttr(Context, Info, derefType);
3418     cast<InheritableAttr>(New)->setInherited(isInherited);
3419     New->setImplicit(isImplicit);
3420     New->setPackExpansion(isPackExpansion);
3421     break;
3422   }
3423   case attr::PragmaClangBSSSection: {
3424     bool isInherited = Record.readInt();
3425     bool isImplicit = Record.readInt();
3426     bool isPackExpansion = Record.readInt();
3427     std::string name= Record.readString();
3428     New = new (Context) PragmaClangBSSSectionAttr(Context, Info, name);
3429     cast<InheritableAttr>(New)->setInherited(isInherited);
3430     New->setImplicit(isImplicit);
3431     New->setPackExpansion(isPackExpansion);
3432     break;
3433   }
3434   case attr::PragmaClangDataSection: {
3435     bool isInherited = Record.readInt();
3436     bool isImplicit = Record.readInt();
3437     bool isPackExpansion = Record.readInt();
3438     std::string name= Record.readString();
3439     New = new (Context) PragmaClangDataSectionAttr(Context, Info, name);
3440     cast<InheritableAttr>(New)->setInherited(isInherited);
3441     New->setImplicit(isImplicit);
3442     New->setPackExpansion(isPackExpansion);
3443     break;
3444   }
3445   case attr::PragmaClangRelroSection: {
3446     bool isInherited = Record.readInt();
3447     bool isImplicit = Record.readInt();
3448     bool isPackExpansion = Record.readInt();
3449     std::string name= Record.readString();
3450     New = new (Context) PragmaClangRelroSectionAttr(Context, Info, name);
3451     cast<InheritableAttr>(New)->setInherited(isInherited);
3452     New->setImplicit(isImplicit);
3453     New->setPackExpansion(isPackExpansion);
3454     break;
3455   }
3456   case attr::PragmaClangRodataSection: {
3457     bool isInherited = Record.readInt();
3458     bool isImplicit = Record.readInt();
3459     bool isPackExpansion = Record.readInt();
3460     std::string name= Record.readString();
3461     New = new (Context) PragmaClangRodataSectionAttr(Context, Info, name);
3462     cast<InheritableAttr>(New)->setInherited(isInherited);
3463     New->setImplicit(isImplicit);
3464     New->setPackExpansion(isPackExpansion);
3465     break;
3466   }
3467   case attr::PragmaClangTextSection: {
3468     bool isInherited = Record.readInt();
3469     bool isImplicit = Record.readInt();
3470     bool isPackExpansion = Record.readInt();
3471     std::string name= Record.readString();
3472     New = new (Context) PragmaClangTextSectionAttr(Context, Info, name);
3473     cast<InheritableAttr>(New)->setInherited(isInherited);
3474     New->setImplicit(isImplicit);
3475     New->setPackExpansion(isPackExpansion);
3476     break;
3477   }
3478   case attr::PreferredName: {
3479     bool isInherited = Record.readInt();
3480     bool isImplicit = Record.readInt();
3481     bool isPackExpansion = Record.readInt();
3482     TypeSourceInfo * typedefType = Record.readTypeSourceInfo();
3483     New = new (Context) PreferredNameAttr(Context, Info, typedefType);
3484     cast<InheritableAttr>(New)->setInherited(isInherited);
3485     New->setImplicit(isImplicit);
3486     New->setPackExpansion(isPackExpansion);
3487     break;
3488   }
3489   case attr::PreferredType: {
3490     bool isInherited = Record.readInt();
3491     bool isImplicit = Record.readInt();
3492     bool isPackExpansion = Record.readInt();
3493     TypeSourceInfo * type = Record.readTypeSourceInfo();
3494     New = new (Context) PreferredTypeAttr(Context, Info, type);
3495     cast<InheritableAttr>(New)->setInherited(isInherited);
3496     New->setImplicit(isImplicit);
3497     New->setPackExpansion(isPackExpansion);
3498     break;
3499   }
3500   case attr::PreserveAll: {
3501     bool isInherited = Record.readInt();
3502     bool isImplicit = Record.readInt();
3503     bool isPackExpansion = Record.readInt();
3504     New = new (Context) PreserveAllAttr(Context, Info);
3505     cast<InheritableAttr>(New)->setInherited(isInherited);
3506     New->setImplicit(isImplicit);
3507     New->setPackExpansion(isPackExpansion);
3508     break;
3509   }
3510   case attr::PreserveMost: {
3511     bool isInherited = Record.readInt();
3512     bool isImplicit = Record.readInt();
3513     bool isPackExpansion = Record.readInt();
3514     New = new (Context) PreserveMostAttr(Context, Info);
3515     cast<InheritableAttr>(New)->setInherited(isInherited);
3516     New->setImplicit(isImplicit);
3517     New->setPackExpansion(isPackExpansion);
3518     break;
3519   }
3520   case attr::PreserveNone: {
3521     bool isInherited = Record.readInt();
3522     bool isImplicit = Record.readInt();
3523     bool isPackExpansion = Record.readInt();
3524     New = new (Context) PreserveNoneAttr(Context, Info);
3525     cast<InheritableAttr>(New)->setInherited(isInherited);
3526     New->setImplicit(isImplicit);
3527     New->setPackExpansion(isPackExpansion);
3528     break;
3529   }
3530   case attr::PtGuardedBy: {
3531     bool isInherited = Record.readInt();
3532     bool isImplicit = Record.readInt();
3533     bool isPackExpansion = Record.readInt();
3534     Expr * arg = Record.readExpr();
3535     New = new (Context) PtGuardedByAttr(Context, Info, arg);
3536     cast<InheritableAttr>(New)->setInherited(isInherited);
3537     New->setImplicit(isImplicit);
3538     New->setPackExpansion(isPackExpansion);
3539     break;
3540   }
3541   case attr::PtGuardedVar: {
3542     bool isInherited = Record.readInt();
3543     bool isImplicit = Record.readInt();
3544     bool isPackExpansion = Record.readInt();
3545     New = new (Context) PtGuardedVarAttr(Context, Info);
3546     cast<InheritableAttr>(New)->setInherited(isInherited);
3547     New->setImplicit(isImplicit);
3548     New->setPackExpansion(isPackExpansion);
3549     break;
3550   }
3551   case attr::Ptr32: {
3552     bool isImplicit = Record.readInt();
3553     bool isPackExpansion = Record.readInt();
3554     New = new (Context) Ptr32Attr(Context, Info);
3555     New->setImplicit(isImplicit);
3556     New->setPackExpansion(isPackExpansion);
3557     break;
3558   }
3559   case attr::Ptr64: {
3560     bool isImplicit = Record.readInt();
3561     bool isPackExpansion = Record.readInt();
3562     New = new (Context) Ptr64Attr(Context, Info);
3563     New->setImplicit(isImplicit);
3564     New->setPackExpansion(isPackExpansion);
3565     break;
3566   }
3567   case attr::Pure: {
3568     bool isInherited = Record.readInt();
3569     bool isImplicit = Record.readInt();
3570     bool isPackExpansion = Record.readInt();
3571     New = new (Context) PureAttr(Context, Info);
3572     cast<InheritableAttr>(New)->setInherited(isInherited);
3573     New->setImplicit(isImplicit);
3574     New->setPackExpansion(isPackExpansion);
3575     break;
3576   }
3577   case attr::RISCVInterrupt: {
3578     bool isInherited = Record.readInt();
3579     bool isImplicit = Record.readInt();
3580     bool isPackExpansion = Record.readInt();
3581     RISCVInterruptAttr::InterruptType interrupt(static_cast<RISCVInterruptAttr::InterruptType>(Record.readInt()));
3582     New = new (Context) RISCVInterruptAttr(Context, Info, interrupt);
3583     cast<InheritableAttr>(New)->setInherited(isInherited);
3584     New->setImplicit(isImplicit);
3585     New->setPackExpansion(isPackExpansion);
3586     break;
3587   }
3588   case attr::RISCVVectorCC: {
3589     bool isInherited = Record.readInt();
3590     bool isImplicit = Record.readInt();
3591     bool isPackExpansion = Record.readInt();
3592     New = new (Context) RISCVVectorCCAttr(Context, Info);
3593     cast<InheritableAttr>(New)->setInherited(isInherited);
3594     New->setImplicit(isImplicit);
3595     New->setPackExpansion(isPackExpansion);
3596     break;
3597   }
3598   case attr::RandomizeLayout: {
3599     bool isInherited = Record.readInt();
3600     bool isImplicit = Record.readInt();
3601     bool isPackExpansion = Record.readInt();
3602     New = new (Context) RandomizeLayoutAttr(Context, Info);
3603     cast<InheritableAttr>(New)->setInherited(isInherited);
3604     New->setImplicit(isImplicit);
3605     New->setPackExpansion(isPackExpansion);
3606     break;
3607   }
3608   case attr::ReadOnlyPlacement: {
3609     bool isInherited = Record.readInt();
3610     bool isImplicit = Record.readInt();
3611     bool isPackExpansion = Record.readInt();
3612     New = new (Context) ReadOnlyPlacementAttr(Context, Info);
3613     cast<InheritableAttr>(New)->setInherited(isInherited);
3614     New->setImplicit(isImplicit);
3615     New->setPackExpansion(isPackExpansion);
3616     break;
3617   }
3618   case attr::RegCall: {
3619     bool isInherited = Record.readInt();
3620     bool isImplicit = Record.readInt();
3621     bool isPackExpansion = Record.readInt();
3622     New = new (Context) RegCallAttr(Context, Info);
3623     cast<InheritableAttr>(New)->setInherited(isInherited);
3624     New->setImplicit(isImplicit);
3625     New->setPackExpansion(isPackExpansion);
3626     break;
3627   }
3628   case attr::Reinitializes: {
3629     bool isInherited = Record.readInt();
3630     bool isImplicit = Record.readInt();
3631     bool isPackExpansion = Record.readInt();
3632     New = new (Context) ReinitializesAttr(Context, Info);
3633     cast<InheritableAttr>(New)->setInherited(isInherited);
3634     New->setImplicit(isImplicit);
3635     New->setPackExpansion(isPackExpansion);
3636     break;
3637   }
3638   case attr::ReleaseCapability: {
3639     bool isInherited = Record.readInt();
3640     bool isImplicit = Record.readInt();
3641     bool isPackExpansion = Record.readInt();
3642     unsigned argsSize = Record.readInt();
3643     SmallVector<Expr *, 4> args;
3644     args.reserve(argsSize);
3645     for (unsigned i = 0; i != argsSize; ++i)
3646       args.push_back(Record.readExpr());
3647     New = new (Context) ReleaseCapabilityAttr(Context, Info, args.data(), argsSize);
3648     cast<InheritableAttr>(New)->setInherited(isInherited);
3649     New->setImplicit(isImplicit);
3650     New->setPackExpansion(isPackExpansion);
3651     break;
3652   }
3653   case attr::ReleaseHandle: {
3654     bool isInherited = Record.readInt();
3655     bool isImplicit = Record.readInt();
3656     bool isPackExpansion = Record.readInt();
3657     std::string handleType= Record.readString();
3658     New = new (Context) ReleaseHandleAttr(Context, Info, handleType);
3659     cast<InheritableAttr>(New)->setInherited(isInherited);
3660     New->setImplicit(isImplicit);
3661     New->setPackExpansion(isPackExpansion);
3662     break;
3663   }
3664   case attr::ReqdWorkGroupSize: {
3665     bool isInherited = Record.readInt();
3666     bool isImplicit = Record.readInt();
3667     bool isPackExpansion = Record.readInt();
3668     unsigned xDim = Record.readInt();
3669     unsigned yDim = Record.readInt();
3670     unsigned zDim = Record.readInt();
3671     New = new (Context) ReqdWorkGroupSizeAttr(Context, Info, xDim, yDim, zDim);
3672     cast<InheritableAttr>(New)->setInherited(isInherited);
3673     New->setImplicit(isImplicit);
3674     New->setPackExpansion(isPackExpansion);
3675     break;
3676   }
3677   case attr::RequiresCapability: {
3678     bool isInherited = Record.readInt();
3679     bool isImplicit = Record.readInt();
3680     bool isPackExpansion = Record.readInt();
3681     unsigned argsSize = Record.readInt();
3682     SmallVector<Expr *, 4> args;
3683     args.reserve(argsSize);
3684     for (unsigned i = 0; i != argsSize; ++i)
3685       args.push_back(Record.readExpr());
3686     New = new (Context) RequiresCapabilityAttr(Context, Info, args.data(), argsSize);
3687     cast<InheritableAttr>(New)->setInherited(isInherited);
3688     New->setImplicit(isImplicit);
3689     New->setPackExpansion(isPackExpansion);
3690     break;
3691   }
3692   case attr::Restrict: {
3693     bool isInherited = Record.readInt();
3694     bool isImplicit = Record.readInt();
3695     bool isPackExpansion = Record.readInt();
3696     New = new (Context) RestrictAttr(Context, Info);
3697     cast<InheritableAttr>(New)->setInherited(isInherited);
3698     New->setImplicit(isImplicit);
3699     New->setPackExpansion(isPackExpansion);
3700     break;
3701   }
3702   case attr::Retain: {
3703     bool isInherited = Record.readInt();
3704     bool isImplicit = Record.readInt();
3705     bool isPackExpansion = Record.readInt();
3706     New = new (Context) RetainAttr(Context, Info);
3707     cast<InheritableAttr>(New)->setInherited(isInherited);
3708     New->setImplicit(isImplicit);
3709     New->setPackExpansion(isPackExpansion);
3710     break;
3711   }
3712   case attr::ReturnTypestate: {
3713     bool isInherited = Record.readInt();
3714     bool isImplicit = Record.readInt();
3715     bool isPackExpansion = Record.readInt();
3716     ReturnTypestateAttr::ConsumedState state(static_cast<ReturnTypestateAttr::ConsumedState>(Record.readInt()));
3717     New = new (Context) ReturnTypestateAttr(Context, Info, state);
3718     cast<InheritableAttr>(New)->setInherited(isInherited);
3719     New->setImplicit(isImplicit);
3720     New->setPackExpansion(isPackExpansion);
3721     break;
3722   }
3723   case attr::ReturnsNonNull: {
3724     bool isInherited = Record.readInt();
3725     bool isImplicit = Record.readInt();
3726     bool isPackExpansion = Record.readInt();
3727     New = new (Context) ReturnsNonNullAttr(Context, Info);
3728     cast<InheritableAttr>(New)->setInherited(isInherited);
3729     New->setImplicit(isImplicit);
3730     New->setPackExpansion(isPackExpansion);
3731     break;
3732   }
3733   case attr::ReturnsTwice: {
3734     bool isInherited = Record.readInt();
3735     bool isImplicit = Record.readInt();
3736     bool isPackExpansion = Record.readInt();
3737     New = new (Context) ReturnsTwiceAttr(Context, Info);
3738     cast<InheritableAttr>(New)->setInherited(isInherited);
3739     New->setImplicit(isImplicit);
3740     New->setPackExpansion(isPackExpansion);
3741     break;
3742   }
3743   case attr::SPtr: {
3744     bool isImplicit = Record.readInt();
3745     bool isPackExpansion = Record.readInt();
3746     New = new (Context) SPtrAttr(Context, Info);
3747     New->setImplicit(isImplicit);
3748     New->setPackExpansion(isPackExpansion);
3749     break;
3750   }
3751   case attr::SYCLKernel: {
3752     bool isInherited = Record.readInt();
3753     bool isImplicit = Record.readInt();
3754     bool isPackExpansion = Record.readInt();
3755     New = new (Context) SYCLKernelAttr(Context, Info);
3756     cast<InheritableAttr>(New)->setInherited(isInherited);
3757     New->setImplicit(isImplicit);
3758     New->setPackExpansion(isPackExpansion);
3759     break;
3760   }
3761   case attr::SYCLKernelEntryPoint: {
3762     bool isInherited = Record.readInt();
3763     bool isImplicit = Record.readInt();
3764     bool isPackExpansion = Record.readInt();
3765     TypeSourceInfo * kernelName = Record.readTypeSourceInfo();
3766     bool invalid = Record.readInt();
3767     New = new (Context) SYCLKernelEntryPointAttr(Context, Info, kernelName, invalid);
3768     cast<InheritableAttr>(New)->setInherited(isInherited);
3769     New->setImplicit(isImplicit);
3770     New->setPackExpansion(isPackExpansion);
3771     break;
3772   }
3773   case attr::SYCLSpecialClass: {
3774     bool isInherited = Record.readInt();
3775     bool isImplicit = Record.readInt();
3776     bool isPackExpansion = Record.readInt();
3777     New = new (Context) SYCLSpecialClassAttr(Context, Info);
3778     cast<InheritableAttr>(New)->setInherited(isInherited);
3779     New->setImplicit(isImplicit);
3780     New->setPackExpansion(isPackExpansion);
3781     break;
3782   }
3783   case attr::ScopedLockable: {
3784     bool isInherited = Record.readInt();
3785     bool isImplicit = Record.readInt();
3786     bool isPackExpansion = Record.readInt();
3787     New = new (Context) ScopedLockableAttr(Context, Info);
3788     cast<InheritableAttr>(New)->setInherited(isInherited);
3789     New->setImplicit(isImplicit);
3790     New->setPackExpansion(isPackExpansion);
3791     break;
3792   }
3793   case attr::Section: {
3794     bool isInherited = Record.readInt();
3795     bool isImplicit = Record.readInt();
3796     bool isPackExpansion = Record.readInt();
3797     std::string name= Record.readString();
3798     New = new (Context) SectionAttr(Context, Info, name);
3799     cast<InheritableAttr>(New)->setInherited(isInherited);
3800     New->setImplicit(isImplicit);
3801     New->setPackExpansion(isPackExpansion);
3802     break;
3803   }
3804   case attr::SelectAny: {
3805     bool isInherited = Record.readInt();
3806     bool isImplicit = Record.readInt();
3807     bool isPackExpansion = Record.readInt();
3808     New = new (Context) SelectAnyAttr(Context, Info);
3809     cast<InheritableAttr>(New)->setInherited(isInherited);
3810     New->setImplicit(isImplicit);
3811     New->setPackExpansion(isPackExpansion);
3812     break;
3813   }
3814   case attr::Sentinel: {
3815     bool isInherited = Record.readInt();
3816     bool isImplicit = Record.readInt();
3817     bool isPackExpansion = Record.readInt();
3818     int sentinel = Record.readInt();
3819     int nullPos = Record.readInt();
3820     New = new (Context) SentinelAttr(Context, Info, sentinel, nullPos);
3821     cast<InheritableAttr>(New)->setInherited(isInherited);
3822     New->setImplicit(isImplicit);
3823     New->setPackExpansion(isPackExpansion);
3824     break;
3825   }
3826   case attr::SetTypestate: {
3827     bool isInherited = Record.readInt();
3828     bool isImplicit = Record.readInt();
3829     bool isPackExpansion = Record.readInt();
3830     SetTypestateAttr::ConsumedState newState(static_cast<SetTypestateAttr::ConsumedState>(Record.readInt()));
3831     New = new (Context) SetTypestateAttr(Context, Info, newState);
3832     cast<InheritableAttr>(New)->setInherited(isInherited);
3833     New->setImplicit(isImplicit);
3834     New->setPackExpansion(isPackExpansion);
3835     break;
3836   }
3837   case attr::SharedTrylockFunction: {
3838     bool isInherited = Record.readInt();
3839     bool isImplicit = Record.readInt();
3840     bool isPackExpansion = Record.readInt();
3841     Expr * successValue = Record.readExpr();
3842     unsigned argsSize = Record.readInt();
3843     SmallVector<Expr *, 4> args;
3844     args.reserve(argsSize);
3845     for (unsigned i = 0; i != argsSize; ++i)
3846       args.push_back(Record.readExpr());
3847     New = new (Context) SharedTrylockFunctionAttr(Context, Info, successValue, args.data(), argsSize);
3848     cast<InheritableAttr>(New)->setInherited(isInherited);
3849     New->setImplicit(isImplicit);
3850     New->setPackExpansion(isPackExpansion);
3851     break;
3852   }
3853   case attr::SizedBy: {
3854     bool isInherited = Record.readInt();
3855     bool isImplicit = Record.readInt();
3856     bool isPackExpansion = Record.readInt();
3857     Expr * size = Record.readExpr();
3858     int nestedLevel = Record.readInt();
3859     New = new (Context) SizedByAttr(Context, Info, size, nestedLevel);
3860     cast<InheritableAttr>(New)->setInherited(isInherited);
3861     New->setImplicit(isImplicit);
3862     New->setPackExpansion(isPackExpansion);
3863     break;
3864   }
3865   case attr::SizedByOrNull: {
3866     bool isInherited = Record.readInt();
3867     bool isImplicit = Record.readInt();
3868     bool isPackExpansion = Record.readInt();
3869     Expr * size = Record.readExpr();
3870     int nestedLevel = Record.readInt();
3871     New = new (Context) SizedByOrNullAttr(Context, Info, size, nestedLevel);
3872     cast<InheritableAttr>(New)->setInherited(isInherited);
3873     New->setImplicit(isImplicit);
3874     New->setPackExpansion(isPackExpansion);
3875     break;
3876   }
3877   case attr::SpeculativeLoadHardening: {
3878     bool isInherited = Record.readInt();
3879     bool isImplicit = Record.readInt();
3880     bool isPackExpansion = Record.readInt();
3881     New = new (Context) SpeculativeLoadHardeningAttr(Context, Info);
3882     cast<InheritableAttr>(New)->setInherited(isInherited);
3883     New->setImplicit(isImplicit);
3884     New->setPackExpansion(isPackExpansion);
3885     break;
3886   }
3887   case attr::StandaloneDebug: {
3888     bool isInherited = Record.readInt();
3889     bool isImplicit = Record.readInt();
3890     bool isPackExpansion = Record.readInt();
3891     New = new (Context) StandaloneDebugAttr(Context, Info);
3892     cast<InheritableAttr>(New)->setInherited(isInherited);
3893     New->setImplicit(isImplicit);
3894     New->setPackExpansion(isPackExpansion);
3895     break;
3896   }
3897   case attr::StdCall: {
3898     bool isInherited = Record.readInt();
3899     bool isImplicit = Record.readInt();
3900     bool isPackExpansion = Record.readInt();
3901     New = new (Context) StdCallAttr(Context, Info);
3902     cast<InheritableAttr>(New)->setInherited(isInherited);
3903     New->setImplicit(isImplicit);
3904     New->setPackExpansion(isPackExpansion);
3905     break;
3906   }
3907   case attr::StrictFP: {
3908     bool isInherited = Record.readInt();
3909     bool isImplicit = Record.readInt();
3910     bool isPackExpansion = Record.readInt();
3911     New = new (Context) StrictFPAttr(Context, Info);
3912     cast<InheritableAttr>(New)->setInherited(isInherited);
3913     New->setImplicit(isImplicit);
3914     New->setPackExpansion(isPackExpansion);
3915     break;
3916   }
3917   case attr::StrictGuardStackCheck: {
3918     bool isInherited = Record.readInt();
3919     bool isImplicit = Record.readInt();
3920     bool isPackExpansion = Record.readInt();
3921     New = new (Context) StrictGuardStackCheckAttr(Context, Info);
3922     cast<InheritableAttr>(New)->setInherited(isInherited);
3923     New->setImplicit(isImplicit);
3924     New->setPackExpansion(isPackExpansion);
3925     break;
3926   }
3927   case attr::Suppress: {
3928     bool isInherited = Record.readInt();
3929     bool isImplicit = Record.readInt();
3930     bool isPackExpansion = Record.readInt();
3931     unsigned diagnosticIdentifiersSize = Record.readInt();
3932     SmallVector<StringRef, 4> diagnosticIdentifiers;
3933     diagnosticIdentifiers.reserve(diagnosticIdentifiersSize);
3934     SmallVector<std::string, 4> diagnosticIdentifiersStorage;
3935     diagnosticIdentifiersStorage.reserve(diagnosticIdentifiersSize);
3936     for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
3937       diagnosticIdentifiersStorage.push_back(Record.readString());
3938     for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
3939       diagnosticIdentifiers.push_back(diagnosticIdentifiersStorage[i]);
3940     New = new (Context) SuppressAttr(Context, Info, diagnosticIdentifiers.data(), diagnosticIdentifiersSize);
3941     cast<InheritableAttr>(New)->setInherited(isInherited);
3942     New->setImplicit(isImplicit);
3943     New->setPackExpansion(isPackExpansion);
3944     break;
3945   }
3946   case attr::SwiftAsync: {
3947     bool isInherited = Record.readInt();
3948     bool isImplicit = Record.readInt();
3949     bool isPackExpansion = Record.readInt();
3950     SwiftAsyncAttr::Kind kind(static_cast<SwiftAsyncAttr::Kind>(Record.readInt()));
3951     ParamIdx completionHandlerIndex = ParamIdx::deserialize(Record.readInt());
3952     New = new (Context) SwiftAsyncAttr(Context, Info, kind, completionHandlerIndex);
3953     cast<InheritableAttr>(New)->setInherited(isInherited);
3954     New->setImplicit(isImplicit);
3955     New->setPackExpansion(isPackExpansion);
3956     break;
3957   }
3958   case attr::SwiftAsyncCall: {
3959     bool isInherited = Record.readInt();
3960     bool isImplicit = Record.readInt();
3961     bool isPackExpansion = Record.readInt();
3962     New = new (Context) SwiftAsyncCallAttr(Context, Info);
3963     cast<InheritableAttr>(New)->setInherited(isInherited);
3964     New->setImplicit(isImplicit);
3965     New->setPackExpansion(isPackExpansion);
3966     break;
3967   }
3968   case attr::SwiftAsyncContext: {
3969     bool isInherited = Record.readInt();
3970     bool isImplicit = Record.readInt();
3971     bool isPackExpansion = Record.readInt();
3972     New = new (Context) SwiftAsyncContextAttr(Context, Info);
3973     cast<InheritableAttr>(New)->setInherited(isInherited);
3974     New->setImplicit(isImplicit);
3975     New->setPackExpansion(isPackExpansion);
3976     break;
3977   }
3978   case attr::SwiftAsyncError: {
3979     bool isInherited = Record.readInt();
3980     bool isImplicit = Record.readInt();
3981     bool isPackExpansion = Record.readInt();
3982     SwiftAsyncErrorAttr::ConventionKind convention(static_cast<SwiftAsyncErrorAttr::ConventionKind>(Record.readInt()));
3983     unsigned handlerParamIdx = Record.readInt();
3984     New = new (Context) SwiftAsyncErrorAttr(Context, Info, convention, handlerParamIdx);
3985     cast<InheritableAttr>(New)->setInherited(isInherited);
3986     New->setImplicit(isImplicit);
3987     New->setPackExpansion(isPackExpansion);
3988     break;
3989   }
3990   case attr::SwiftAsyncName: {
3991     bool isInherited = Record.readInt();
3992     bool isImplicit = Record.readInt();
3993     bool isPackExpansion = Record.readInt();
3994     std::string name= Record.readString();
3995     New = new (Context) SwiftAsyncNameAttr(Context, Info, name);
3996     cast<InheritableAttr>(New)->setInherited(isInherited);
3997     New->setImplicit(isImplicit);
3998     New->setPackExpansion(isPackExpansion);
3999     break;
4000   }
4001   case attr::SwiftAttr: {
4002     bool isInherited = Record.readInt();
4003     bool isImplicit = Record.readInt();
4004     bool isPackExpansion = Record.readInt();
4005     std::string attribute= Record.readString();
4006     New = new (Context) SwiftAttrAttr(Context, Info, attribute);
4007     cast<InheritableAttr>(New)->setInherited(isInherited);
4008     New->setImplicit(isImplicit);
4009     New->setPackExpansion(isPackExpansion);
4010     break;
4011   }
4012   case attr::SwiftBridge: {
4013     bool isInherited = Record.readInt();
4014     bool isImplicit = Record.readInt();
4015     bool isPackExpansion = Record.readInt();
4016     std::string swiftType= Record.readString();
4017     New = new (Context) SwiftBridgeAttr(Context, Info, swiftType);
4018     cast<InheritableAttr>(New)->setInherited(isInherited);
4019     New->setImplicit(isImplicit);
4020     New->setPackExpansion(isPackExpansion);
4021     break;
4022   }
4023   case attr::SwiftBridgedTypedef: {
4024     bool isInherited = Record.readInt();
4025     bool isImplicit = Record.readInt();
4026     bool isPackExpansion = Record.readInt();
4027     New = new (Context) SwiftBridgedTypedefAttr(Context, Info);
4028     cast<InheritableAttr>(New)->setInherited(isInherited);
4029     New->setImplicit(isImplicit);
4030     New->setPackExpansion(isPackExpansion);
4031     break;
4032   }
4033   case attr::SwiftCall: {
4034     bool isInherited = Record.readInt();
4035     bool isImplicit = Record.readInt();
4036     bool isPackExpansion = Record.readInt();
4037     New = new (Context) SwiftCallAttr(Context, Info);
4038     cast<InheritableAttr>(New)->setInherited(isInherited);
4039     New->setImplicit(isImplicit);
4040     New->setPackExpansion(isPackExpansion);
4041     break;
4042   }
4043   case attr::SwiftContext: {
4044     bool isInherited = Record.readInt();
4045     bool isImplicit = Record.readInt();
4046     bool isPackExpansion = Record.readInt();
4047     New = new (Context) SwiftContextAttr(Context, Info);
4048     cast<InheritableAttr>(New)->setInherited(isInherited);
4049     New->setImplicit(isImplicit);
4050     New->setPackExpansion(isPackExpansion);
4051     break;
4052   }
4053   case attr::SwiftError: {
4054     bool isInherited = Record.readInt();
4055     bool isImplicit = Record.readInt();
4056     bool isPackExpansion = Record.readInt();
4057     SwiftErrorAttr::ConventionKind convention(static_cast<SwiftErrorAttr::ConventionKind>(Record.readInt()));
4058     New = new (Context) SwiftErrorAttr(Context, Info, convention);
4059     cast<InheritableAttr>(New)->setInherited(isInherited);
4060     New->setImplicit(isImplicit);
4061     New->setPackExpansion(isPackExpansion);
4062     break;
4063   }
4064   case attr::SwiftErrorResult: {
4065     bool isInherited = Record.readInt();
4066     bool isImplicit = Record.readInt();
4067     bool isPackExpansion = Record.readInt();
4068     New = new (Context) SwiftErrorResultAttr(Context, Info);
4069     cast<InheritableAttr>(New)->setInherited(isInherited);
4070     New->setImplicit(isImplicit);
4071     New->setPackExpansion(isPackExpansion);
4072     break;
4073   }
4074   case attr::SwiftImportAsNonGeneric: {
4075     bool isInherited = Record.readInt();
4076     bool isImplicit = Record.readInt();
4077     bool isPackExpansion = Record.readInt();
4078     New = new (Context) SwiftImportAsNonGenericAttr(Context, Info);
4079     cast<InheritableAttr>(New)->setInherited(isInherited);
4080     New->setImplicit(isImplicit);
4081     New->setPackExpansion(isPackExpansion);
4082     break;
4083   }
4084   case attr::SwiftImportPropertyAsAccessors: {
4085     bool isInherited = Record.readInt();
4086     bool isImplicit = Record.readInt();
4087     bool isPackExpansion = Record.readInt();
4088     New = new (Context) SwiftImportPropertyAsAccessorsAttr(Context, Info);
4089     cast<InheritableAttr>(New)->setInherited(isInherited);
4090     New->setImplicit(isImplicit);
4091     New->setPackExpansion(isPackExpansion);
4092     break;
4093   }
4094   case attr::SwiftIndirectResult: {
4095     bool isInherited = Record.readInt();
4096     bool isImplicit = Record.readInt();
4097     bool isPackExpansion = Record.readInt();
4098     New = new (Context) SwiftIndirectResultAttr(Context, Info);
4099     cast<InheritableAttr>(New)->setInherited(isInherited);
4100     New->setImplicit(isImplicit);
4101     New->setPackExpansion(isPackExpansion);
4102     break;
4103   }
4104   case attr::SwiftName: {
4105     bool isInherited = Record.readInt();
4106     bool isImplicit = Record.readInt();
4107     bool isPackExpansion = Record.readInt();
4108     std::string name= Record.readString();
4109     New = new (Context) SwiftNameAttr(Context, Info, name);
4110     cast<InheritableAttr>(New)->setInherited(isInherited);
4111     New->setImplicit(isImplicit);
4112     New->setPackExpansion(isPackExpansion);
4113     break;
4114   }
4115   case attr::SwiftNewType: {
4116     bool isInherited = Record.readInt();
4117     bool isImplicit = Record.readInt();
4118     bool isPackExpansion = Record.readInt();
4119     SwiftNewTypeAttr::NewtypeKind newtypeKind(static_cast<SwiftNewTypeAttr::NewtypeKind>(Record.readInt()));
4120     New = new (Context) SwiftNewTypeAttr(Context, Info, newtypeKind);
4121     cast<InheritableAttr>(New)->setInherited(isInherited);
4122     New->setImplicit(isImplicit);
4123     New->setPackExpansion(isPackExpansion);
4124     break;
4125   }
4126   case attr::SwiftObjCMembers: {
4127     bool isImplicit = Record.readInt();
4128     bool isPackExpansion = Record.readInt();
4129     New = new (Context) SwiftObjCMembersAttr(Context, Info);
4130     New->setImplicit(isImplicit);
4131     New->setPackExpansion(isPackExpansion);
4132     break;
4133   }
4134   case attr::SwiftPrivate: {
4135     bool isInherited = Record.readInt();
4136     bool isImplicit = Record.readInt();
4137     bool isPackExpansion = Record.readInt();
4138     New = new (Context) SwiftPrivateAttr(Context, Info);
4139     cast<InheritableAttr>(New)->setInherited(isInherited);
4140     New->setImplicit(isImplicit);
4141     New->setPackExpansion(isPackExpansion);
4142     break;
4143   }
4144   case attr::SwiftVersionedAddition: {
4145     bool isImplicit = Record.readInt();
4146     bool isPackExpansion = Record.readInt();
4147     VersionTuple version= Record.readVersionTuple();
4148     Attr *additionalAttr = Record.readAttr();    bool isReplacedByActive = Record.readInt();
4149     New = new (Context) SwiftVersionedAdditionAttr(Context, Info, version, additionalAttr, isReplacedByActive);
4150     New->setImplicit(isImplicit);
4151     New->setPackExpansion(isPackExpansion);
4152     break;
4153   }
4154   case attr::SwiftVersionedRemoval: {
4155     bool isImplicit = Record.readInt();
4156     bool isPackExpansion = Record.readInt();
4157     VersionTuple version= Record.readVersionTuple();
4158     unsigned rawKind = Record.readInt();
4159     bool isReplacedByActive = Record.readInt();
4160     New = new (Context) SwiftVersionedRemovalAttr(Context, Info, version, rawKind, isReplacedByActive);
4161     New->setImplicit(isImplicit);
4162     New->setPackExpansion(isPackExpansion);
4163     break;
4164   }
4165   case attr::SysVABI: {
4166     bool isInherited = Record.readInt();
4167     bool isImplicit = Record.readInt();
4168     bool isPackExpansion = Record.readInt();
4169     New = new (Context) SysVABIAttr(Context, Info);
4170     cast<InheritableAttr>(New)->setInherited(isInherited);
4171     New->setImplicit(isImplicit);
4172     New->setPackExpansion(isPackExpansion);
4173     break;
4174   }
4175   case attr::TLSModel: {
4176     bool isInherited = Record.readInt();
4177     bool isImplicit = Record.readInt();
4178     bool isPackExpansion = Record.readInt();
4179     std::string model= Record.readString();
4180     New = new (Context) TLSModelAttr(Context, Info, model);
4181     cast<InheritableAttr>(New)->setInherited(isInherited);
4182     New->setImplicit(isImplicit);
4183     New->setPackExpansion(isPackExpansion);
4184     break;
4185   }
4186   case attr::Target: {
4187     bool isInherited = Record.readInt();
4188     bool isImplicit = Record.readInt();
4189     bool isPackExpansion = Record.readInt();
4190     std::string featuresStr= Record.readString();
4191     New = new (Context) TargetAttr(Context, Info, featuresStr);
4192     cast<InheritableAttr>(New)->setInherited(isInherited);
4193     New->setImplicit(isImplicit);
4194     New->setPackExpansion(isPackExpansion);
4195     break;
4196   }
4197   case attr::TargetClones: {
4198     bool isInherited = Record.readInt();
4199     bool isImplicit = Record.readInt();
4200     bool isPackExpansion = Record.readInt();
4201     unsigned featuresStrsSize = Record.readInt();
4202     SmallVector<StringRef, 4> featuresStrs;
4203     featuresStrs.reserve(featuresStrsSize);
4204     SmallVector<std::string, 4> featuresStrsStorage;
4205     featuresStrsStorage.reserve(featuresStrsSize);
4206     for (unsigned i = 0; i != featuresStrsSize; ++i)
4207       featuresStrsStorage.push_back(Record.readString());
4208     for (unsigned i = 0; i != featuresStrsSize; ++i)
4209       featuresStrs.push_back(featuresStrsStorage[i]);
4210     New = new (Context) TargetClonesAttr(Context, Info, featuresStrs.data(), featuresStrsSize);
4211     cast<InheritableAttr>(New)->setInherited(isInherited);
4212     New->setImplicit(isImplicit);
4213     New->setPackExpansion(isPackExpansion);
4214     break;
4215   }
4216   case attr::TargetVersion: {
4217     bool isInherited = Record.readInt();
4218     bool isImplicit = Record.readInt();
4219     bool isPackExpansion = Record.readInt();
4220     std::string namesStr= Record.readString();
4221     New = new (Context) TargetVersionAttr(Context, Info, namesStr);
4222     cast<InheritableAttr>(New)->setInherited(isInherited);
4223     New->setImplicit(isImplicit);
4224     New->setPackExpansion(isPackExpansion);
4225     break;
4226   }
4227   case attr::TestTypestate: {
4228     bool isInherited = Record.readInt();
4229     bool isImplicit = Record.readInt();
4230     bool isPackExpansion = Record.readInt();
4231     TestTypestateAttr::ConsumedState testState(static_cast<TestTypestateAttr::ConsumedState>(Record.readInt()));
4232     New = new (Context) TestTypestateAttr(Context, Info, testState);
4233     cast<InheritableAttr>(New)->setInherited(isInherited);
4234     New->setImplicit(isImplicit);
4235     New->setPackExpansion(isPackExpansion);
4236     break;
4237   }
4238   case attr::ThisCall: {
4239     bool isInherited = Record.readInt();
4240     bool isImplicit = Record.readInt();
4241     bool isPackExpansion = Record.readInt();
4242     New = new (Context) ThisCallAttr(Context, Info);
4243     cast<InheritableAttr>(New)->setInherited(isInherited);
4244     New->setImplicit(isImplicit);
4245     New->setPackExpansion(isPackExpansion);
4246     break;
4247   }
4248   case attr::Thread: {
4249     bool isImplicit = Record.readInt();
4250     bool isPackExpansion = Record.readInt();
4251     New = new (Context) ThreadAttr(Context, Info);
4252     New->setImplicit(isImplicit);
4253     New->setPackExpansion(isPackExpansion);
4254     break;
4255   }
4256   case attr::TransparentUnion: {
4257     bool isInherited = Record.readInt();
4258     bool isImplicit = Record.readInt();
4259     bool isPackExpansion = Record.readInt();
4260     New = new (Context) TransparentUnionAttr(Context, Info);
4261     cast<InheritableAttr>(New)->setInherited(isInherited);
4262     New->setImplicit(isImplicit);
4263     New->setPackExpansion(isPackExpansion);
4264     break;
4265   }
4266   case attr::TrivialABI: {
4267     bool isInherited = Record.readInt();
4268     bool isImplicit = Record.readInt();
4269     bool isPackExpansion = Record.readInt();
4270     New = new (Context) TrivialABIAttr(Context, Info);
4271     cast<InheritableAttr>(New)->setInherited(isInherited);
4272     New->setImplicit(isImplicit);
4273     New->setPackExpansion(isPackExpansion);
4274     break;
4275   }
4276   case attr::TryAcquireCapability: {
4277     bool isInherited = Record.readInt();
4278     bool isImplicit = Record.readInt();
4279     bool isPackExpansion = Record.readInt();
4280     Expr * successValue = Record.readExpr();
4281     unsigned argsSize = Record.readInt();
4282     SmallVector<Expr *, 4> args;
4283     args.reserve(argsSize);
4284     for (unsigned i = 0; i != argsSize; ++i)
4285       args.push_back(Record.readExpr());
4286     New = new (Context) TryAcquireCapabilityAttr(Context, Info, successValue, args.data(), argsSize);
4287     cast<InheritableAttr>(New)->setInherited(isInherited);
4288     New->setImplicit(isImplicit);
4289     New->setPackExpansion(isPackExpansion);
4290     break;
4291   }
4292   case attr::TypeNonNull: {
4293     bool isImplicit = Record.readInt();
4294     bool isPackExpansion = Record.readInt();
4295     New = new (Context) TypeNonNullAttr(Context, Info);
4296     New->setImplicit(isImplicit);
4297     New->setPackExpansion(isPackExpansion);
4298     break;
4299   }
4300   case attr::TypeNullUnspecified: {
4301     bool isImplicit = Record.readInt();
4302     bool isPackExpansion = Record.readInt();
4303     New = new (Context) TypeNullUnspecifiedAttr(Context, Info);
4304     New->setImplicit(isImplicit);
4305     New->setPackExpansion(isPackExpansion);
4306     break;
4307   }
4308   case attr::TypeNullable: {
4309     bool isInherited = Record.readInt();
4310     bool isImplicit = Record.readInt();
4311     bool isPackExpansion = Record.readInt();
4312     New = new (Context) TypeNullableAttr(Context, Info);
4313     cast<InheritableAttr>(New)->setInherited(isInherited);
4314     New->setImplicit(isImplicit);
4315     New->setPackExpansion(isPackExpansion);
4316     break;
4317   }
4318   case attr::TypeNullableResult: {
4319     bool isImplicit = Record.readInt();
4320     bool isPackExpansion = Record.readInt();
4321     New = new (Context) TypeNullableResultAttr(Context, Info);
4322     New->setImplicit(isImplicit);
4323     New->setPackExpansion(isPackExpansion);
4324     break;
4325   }
4326   case attr::TypeTagForDatatype: {
4327     bool isInherited = Record.readInt();
4328     bool isImplicit = Record.readInt();
4329     bool isPackExpansion = Record.readInt();
4330     IdentifierInfo * argumentKind = Record.readIdentifier();
4331     TypeSourceInfo * matchingCType = Record.readTypeSourceInfo();
4332     bool layoutCompatible = Record.readInt();
4333     bool mustBeNull = Record.readInt();
4334     New = new (Context) TypeTagForDatatypeAttr(Context, Info, argumentKind, matchingCType, layoutCompatible, mustBeNull);
4335     cast<InheritableAttr>(New)->setInherited(isInherited);
4336     New->setImplicit(isImplicit);
4337     New->setPackExpansion(isPackExpansion);
4338     break;
4339   }
4340   case attr::TypeVisibility: {
4341     bool isInherited = Record.readInt();
4342     bool isImplicit = Record.readInt();
4343     bool isPackExpansion = Record.readInt();
4344     TypeVisibilityAttr::VisibilityType visibility(static_cast<TypeVisibilityAttr::VisibilityType>(Record.readInt()));
4345     New = new (Context) TypeVisibilityAttr(Context, Info, visibility);
4346     cast<InheritableAttr>(New)->setInherited(isInherited);
4347     New->setImplicit(isImplicit);
4348     New->setPackExpansion(isPackExpansion);
4349     break;
4350   }
4351   case attr::UPtr: {
4352     bool isImplicit = Record.readInt();
4353     bool isPackExpansion = Record.readInt();
4354     New = new (Context) UPtrAttr(Context, Info);
4355     New->setImplicit(isImplicit);
4356     New->setPackExpansion(isPackExpansion);
4357     break;
4358   }
4359   case attr::Unavailable: {
4360     bool isInherited = Record.readInt();
4361     bool isImplicit = Record.readInt();
4362     bool isPackExpansion = Record.readInt();
4363     std::string message= Record.readString();
4364     UnavailableAttr::ImplicitReason implicitReason(static_cast<UnavailableAttr::ImplicitReason>(Record.readInt()));
4365     New = new (Context) UnavailableAttr(Context, Info, message, implicitReason);
4366     cast<InheritableAttr>(New)->setInherited(isInherited);
4367     New->setImplicit(isImplicit);
4368     New->setPackExpansion(isPackExpansion);
4369     break;
4370   }
4371   case attr::Uninitialized: {
4372     bool isInherited = Record.readInt();
4373     bool isImplicit = Record.readInt();
4374     bool isPackExpansion = Record.readInt();
4375     New = new (Context) UninitializedAttr(Context, Info);
4376     cast<InheritableAttr>(New)->setInherited(isInherited);
4377     New->setImplicit(isImplicit);
4378     New->setPackExpansion(isPackExpansion);
4379     break;
4380   }
4381   case attr::Unlikely: {
4382     bool isImplicit = Record.readInt();
4383     bool isPackExpansion = Record.readInt();
4384     New = new (Context) UnlikelyAttr(Context, Info);
4385     New->setImplicit(isImplicit);
4386     New->setPackExpansion(isPackExpansion);
4387     break;
4388   }
4389   case attr::UnsafeBufferUsage: {
4390     bool isInherited = Record.readInt();
4391     bool isImplicit = Record.readInt();
4392     bool isPackExpansion = Record.readInt();
4393     New = new (Context) UnsafeBufferUsageAttr(Context, Info);
4394     cast<InheritableAttr>(New)->setInherited(isInherited);
4395     New->setImplicit(isImplicit);
4396     New->setPackExpansion(isPackExpansion);
4397     break;
4398   }
4399   case attr::Unused: {
4400     bool isInherited = Record.readInt();
4401     bool isImplicit = Record.readInt();
4402     bool isPackExpansion = Record.readInt();
4403     New = new (Context) UnusedAttr(Context, Info);
4404     cast<InheritableAttr>(New)->setInherited(isInherited);
4405     New->setImplicit(isImplicit);
4406     New->setPackExpansion(isPackExpansion);
4407     break;
4408   }
4409   case attr::UseHandle: {
4410     bool isInherited = Record.readInt();
4411     bool isImplicit = Record.readInt();
4412     bool isPackExpansion = Record.readInt();
4413     std::string handleType= Record.readString();
4414     New = new (Context) UseHandleAttr(Context, Info, handleType);
4415     cast<InheritableAttr>(New)->setInherited(isInherited);
4416     New->setImplicit(isImplicit);
4417     New->setPackExpansion(isPackExpansion);
4418     break;
4419   }
4420   case attr::Used: {
4421     bool isInherited = Record.readInt();
4422     bool isImplicit = Record.readInt();
4423     bool isPackExpansion = Record.readInt();
4424     New = new (Context) UsedAttr(Context, Info);
4425     cast<InheritableAttr>(New)->setInherited(isInherited);
4426     New->setImplicit(isImplicit);
4427     New->setPackExpansion(isPackExpansion);
4428     break;
4429   }
4430   case attr::UsingIfExists: {
4431     bool isInherited = Record.readInt();
4432     bool isImplicit = Record.readInt();
4433     bool isPackExpansion = Record.readInt();
4434     New = new (Context) UsingIfExistsAttr(Context, Info);
4435     cast<InheritableAttr>(New)->setInherited(isInherited);
4436     New->setImplicit(isImplicit);
4437     New->setPackExpansion(isPackExpansion);
4438     break;
4439   }
4440   case attr::Uuid: {
4441     bool isInherited = Record.readInt();
4442     bool isImplicit = Record.readInt();
4443     bool isPackExpansion = Record.readInt();
4444     std::string guid= Record.readString();
4445     MSGuidDecl * guidDecl = Record.readDeclAs<MSGuidDecl >();
4446     New = new (Context) UuidAttr(Context, Info, guid, guidDecl);
4447     cast<InheritableAttr>(New)->setInherited(isInherited);
4448     New->setImplicit(isImplicit);
4449     New->setPackExpansion(isPackExpansion);
4450     break;
4451   }
4452   case attr::VTablePointerAuthentication: {
4453     bool isInherited = Record.readInt();
4454     bool isImplicit = Record.readInt();
4455     bool isPackExpansion = Record.readInt();
4456     VTablePointerAuthenticationAttr::VPtrAuthKeyType key(static_cast<VTablePointerAuthenticationAttr::VPtrAuthKeyType>(Record.readInt()));
4457     VTablePointerAuthenticationAttr::AddressDiscriminationMode addressDiscrimination(static_cast<VTablePointerAuthenticationAttr::AddressDiscriminationMode>(Record.readInt()));
4458     VTablePointerAuthenticationAttr::ExtraDiscrimination extraDiscrimination(static_cast<VTablePointerAuthenticationAttr::ExtraDiscrimination>(Record.readInt()));
4459     int customDiscriminationValue = Record.readInt();
4460     New = new (Context) VTablePointerAuthenticationAttr(Context, Info, key, addressDiscrimination, extraDiscrimination, customDiscriminationValue);
4461     cast<InheritableAttr>(New)->setInherited(isInherited);
4462     New->setImplicit(isImplicit);
4463     New->setPackExpansion(isPackExpansion);
4464     break;
4465   }
4466   case attr::VecReturn: {
4467     bool isInherited = Record.readInt();
4468     bool isImplicit = Record.readInt();
4469     bool isPackExpansion = Record.readInt();
4470     New = new (Context) VecReturnAttr(Context, Info);
4471     cast<InheritableAttr>(New)->setInherited(isInherited);
4472     New->setImplicit(isImplicit);
4473     New->setPackExpansion(isPackExpansion);
4474     break;
4475   }
4476   case attr::VecTypeHint: {
4477     bool isInherited = Record.readInt();
4478     bool isImplicit = Record.readInt();
4479     bool isPackExpansion = Record.readInt();
4480     TypeSourceInfo * typeHint = Record.readTypeSourceInfo();
4481     New = new (Context) VecTypeHintAttr(Context, Info, typeHint);
4482     cast<InheritableAttr>(New)->setInherited(isInherited);
4483     New->setImplicit(isImplicit);
4484     New->setPackExpansion(isPackExpansion);
4485     break;
4486   }
4487   case attr::VectorCall: {
4488     bool isInherited = Record.readInt();
4489     bool isImplicit = Record.readInt();
4490     bool isPackExpansion = Record.readInt();
4491     New = new (Context) VectorCallAttr(Context, Info);
4492     cast<InheritableAttr>(New)->setInherited(isInherited);
4493     New->setImplicit(isImplicit);
4494     New->setPackExpansion(isPackExpansion);
4495     break;
4496   }
4497   case attr::Visibility: {
4498     bool isInherited = Record.readInt();
4499     bool isImplicit = Record.readInt();
4500     bool isPackExpansion = Record.readInt();
4501     VisibilityAttr::VisibilityType visibility(static_cast<VisibilityAttr::VisibilityType>(Record.readInt()));
4502     New = new (Context) VisibilityAttr(Context, Info, visibility);
4503     cast<InheritableAttr>(New)->setInherited(isInherited);
4504     New->setImplicit(isImplicit);
4505     New->setPackExpansion(isPackExpansion);
4506     break;
4507   }
4508   case attr::WarnUnused: {
4509     bool isInherited = Record.readInt();
4510     bool isImplicit = Record.readInt();
4511     bool isPackExpansion = Record.readInt();
4512     New = new (Context) WarnUnusedAttr(Context, Info);
4513     cast<InheritableAttr>(New)->setInherited(isInherited);
4514     New->setImplicit(isImplicit);
4515     New->setPackExpansion(isPackExpansion);
4516     break;
4517   }
4518   case attr::WarnUnusedResult: {
4519     bool isInherited = Record.readInt();
4520     bool isImplicit = Record.readInt();
4521     bool isPackExpansion = Record.readInt();
4522     std::string message= Record.readString();
4523     New = new (Context) WarnUnusedResultAttr(Context, Info, message);
4524     cast<InheritableAttr>(New)->setInherited(isInherited);
4525     New->setImplicit(isImplicit);
4526     New->setPackExpansion(isPackExpansion);
4527     break;
4528   }
4529   case attr::Weak: {
4530     bool isInherited = Record.readInt();
4531     bool isImplicit = Record.readInt();
4532     bool isPackExpansion = Record.readInt();
4533     New = new (Context) WeakAttr(Context, Info);
4534     cast<InheritableAttr>(New)->setInherited(isInherited);
4535     New->setImplicit(isImplicit);
4536     New->setPackExpansion(isPackExpansion);
4537     break;
4538   }
4539   case attr::WeakImport: {
4540     bool isInherited = Record.readInt();
4541     bool isImplicit = Record.readInt();
4542     bool isPackExpansion = Record.readInt();
4543     New = new (Context) WeakImportAttr(Context, Info);
4544     cast<InheritableAttr>(New)->setInherited(isInherited);
4545     New->setImplicit(isImplicit);
4546     New->setPackExpansion(isPackExpansion);
4547     break;
4548   }
4549   case attr::WeakRef: {
4550     bool isInherited = Record.readInt();
4551     bool isImplicit = Record.readInt();
4552     bool isPackExpansion = Record.readInt();
4553     std::string aliasee= Record.readString();
4554     New = new (Context) WeakRefAttr(Context, Info, aliasee);
4555     cast<InheritableAttr>(New)->setInherited(isInherited);
4556     New->setImplicit(isImplicit);
4557     New->setPackExpansion(isPackExpansion);
4558     break;
4559   }
4560   case attr::WebAssemblyExportName: {
4561     bool isInherited = Record.readInt();
4562     bool isImplicit = Record.readInt();
4563     bool isPackExpansion = Record.readInt();
4564     std::string exportName= Record.readString();
4565     New = new (Context) WebAssemblyExportNameAttr(Context, Info, exportName);
4566     cast<InheritableAttr>(New)->setInherited(isInherited);
4567     New->setImplicit(isImplicit);
4568     New->setPackExpansion(isPackExpansion);
4569     break;
4570   }
4571   case attr::WebAssemblyFuncref: {
4572     bool isImplicit = Record.readInt();
4573     bool isPackExpansion = Record.readInt();
4574     New = new (Context) WebAssemblyFuncrefAttr(Context, Info);
4575     New->setImplicit(isImplicit);
4576     New->setPackExpansion(isPackExpansion);
4577     break;
4578   }
4579   case attr::WebAssemblyImportModule: {
4580     bool isInherited = Record.readInt();
4581     bool isImplicit = Record.readInt();
4582     bool isPackExpansion = Record.readInt();
4583     std::string importModule= Record.readString();
4584     New = new (Context) WebAssemblyImportModuleAttr(Context, Info, importModule);
4585     cast<InheritableAttr>(New)->setInherited(isInherited);
4586     New->setImplicit(isImplicit);
4587     New->setPackExpansion(isPackExpansion);
4588     break;
4589   }
4590   case attr::WebAssemblyImportName: {
4591     bool isInherited = Record.readInt();
4592     bool isImplicit = Record.readInt();
4593     bool isPackExpansion = Record.readInt();
4594     std::string importName= Record.readString();
4595     New = new (Context) WebAssemblyImportNameAttr(Context, Info, importName);
4596     cast<InheritableAttr>(New)->setInherited(isInherited);
4597     New->setImplicit(isImplicit);
4598     New->setPackExpansion(isPackExpansion);
4599     break;
4600   }
4601   case attr::WorkGroupSizeHint: {
4602     bool isInherited = Record.readInt();
4603     bool isImplicit = Record.readInt();
4604     bool isPackExpansion = Record.readInt();
4605     unsigned xDim = Record.readInt();
4606     unsigned yDim = Record.readInt();
4607     unsigned zDim = Record.readInt();
4608     New = new (Context) WorkGroupSizeHintAttr(Context, Info, xDim, yDim, zDim);
4609     cast<InheritableAttr>(New)->setInherited(isInherited);
4610     New->setImplicit(isImplicit);
4611     New->setPackExpansion(isPackExpansion);
4612     break;
4613   }
4614   case attr::X86ForceAlignArgPointer: {
4615     bool isInherited = Record.readInt();
4616     bool isImplicit = Record.readInt();
4617     bool isPackExpansion = Record.readInt();
4618     New = new (Context) X86ForceAlignArgPointerAttr(Context, Info);
4619     cast<InheritableAttr>(New)->setInherited(isInherited);
4620     New->setImplicit(isImplicit);
4621     New->setPackExpansion(isPackExpansion);
4622     break;
4623   }
4624   case attr::XRayInstrument: {
4625     bool isInherited = Record.readInt();
4626     bool isImplicit = Record.readInt();
4627     bool isPackExpansion = Record.readInt();
4628     New = new (Context) XRayInstrumentAttr(Context, Info);
4629     cast<InheritableAttr>(New)->setInherited(isInherited);
4630     New->setImplicit(isImplicit);
4631     New->setPackExpansion(isPackExpansion);
4632     break;
4633   }
4634   case attr::XRayLogArgs: {
4635     bool isInherited = Record.readInt();
4636     bool isImplicit = Record.readInt();
4637     bool isPackExpansion = Record.readInt();
4638     unsigned argumentCount = Record.readInt();
4639     New = new (Context) XRayLogArgsAttr(Context, Info, argumentCount);
4640     cast<InheritableAttr>(New)->setInherited(isInherited);
4641     New->setImplicit(isImplicit);
4642     New->setPackExpansion(isPackExpansion);
4643     break;
4644   }
4645   case attr::ZeroCallUsedRegs: {
4646     bool isInherited = Record.readInt();
4647     bool isImplicit = Record.readInt();
4648     bool isPackExpansion = Record.readInt();
4649     ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind zeroCallUsedRegs(static_cast<ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind>(Record.readInt()));
4650     New = new (Context) ZeroCallUsedRegsAttr(Context, Info, zeroCallUsedRegs);
4651     cast<InheritableAttr>(New)->setInherited(isInherited);
4652     New->setImplicit(isImplicit);
4653     New->setPackExpansion(isPackExpansion);
4654     break;
4655   }
4656   }