1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ 2|* *| 3|* Attribute deserialization code *| 4|* *| 5|* Automatically generated file, do not edit! *| 6|* *| 7\*===----------------------------------------------------------------------===*/ 8 9 switch (Kind) { 10 case attr::AMDGPUFlatWorkGroupSize: { 11 bool isInherited = Record.readInt(); 12 bool isImplicit = Record.readInt(); 13 unsigned Spelling = Record.readInt(); 14 unsigned min = Record.readInt(); 15 unsigned max = Record.readInt(); 16 New = new (Context) AMDGPUFlatWorkGroupSizeAttr(Range, Context, min, max, Spelling); 17 cast<InheritableAttr>(New)->setInherited(isInherited); 18 New->setImplicit(isImplicit); 19 break; 20 } 21 case attr::AMDGPUNumSGPR: { 22 bool isInherited = Record.readInt(); 23 bool isImplicit = Record.readInt(); 24 unsigned Spelling = Record.readInt(); 25 unsigned numSGPR = Record.readInt(); 26 New = new (Context) AMDGPUNumSGPRAttr(Range, Context, numSGPR, Spelling); 27 cast<InheritableAttr>(New)->setInherited(isInherited); 28 New->setImplicit(isImplicit); 29 break; 30 } 31 case attr::AMDGPUNumVGPR: { 32 bool isInherited = Record.readInt(); 33 bool isImplicit = Record.readInt(); 34 unsigned Spelling = Record.readInt(); 35 unsigned numVGPR = Record.readInt(); 36 New = new (Context) AMDGPUNumVGPRAttr(Range, Context, numVGPR, Spelling); 37 cast<InheritableAttr>(New)->setInherited(isInherited); 38 New->setImplicit(isImplicit); 39 break; 40 } 41 case attr::AMDGPUWavesPerEU: { 42 bool isInherited = Record.readInt(); 43 bool isImplicit = Record.readInt(); 44 unsigned Spelling = Record.readInt(); 45 unsigned min = Record.readInt(); 46 unsigned max = Record.readInt(); 47 New = new (Context) AMDGPUWavesPerEUAttr(Range, Context, min, max, Spelling); 48 cast<InheritableAttr>(New)->setInherited(isInherited); 49 New->setImplicit(isImplicit); 50 break; 51 } 52 case attr::ARMInterrupt: { 53 bool isInherited = Record.readInt(); 54 bool isImplicit = Record.readInt(); 55 unsigned Spelling = Record.readInt(); 56 ARMInterruptAttr::InterruptType interrupt(static_cast<ARMInterruptAttr::InterruptType>(Record.readInt())); 57 New = new (Context) ARMInterruptAttr(Range, Context, interrupt, Spelling); 58 cast<InheritableAttr>(New)->setInherited(isInherited); 59 New->setImplicit(isImplicit); 60 break; 61 } 62 case attr::AVRInterrupt: { 63 bool isInherited = Record.readInt(); 64 bool isImplicit = Record.readInt(); 65 unsigned Spelling = Record.readInt(); 66 New = new (Context) AVRInterruptAttr(Range, Context, Spelling); 67 cast<InheritableAttr>(New)->setInherited(isInherited); 68 New->setImplicit(isImplicit); 69 break; 70 } 71 case attr::AVRSignal: { 72 bool isInherited = Record.readInt(); 73 bool isImplicit = Record.readInt(); 74 unsigned Spelling = Record.readInt(); 75 New = new (Context) AVRSignalAttr(Range, Context, Spelling); 76 cast<InheritableAttr>(New)->setInherited(isInherited); 77 New->setImplicit(isImplicit); 78 break; 79 } 80 case attr::AbiTag: { 81 bool isImplicit = Record.readInt(); 82 unsigned Spelling = Record.readInt(); 83 unsigned tagsSize = Record.readInt(); 84 SmallVector<StringRef, 4> tags; 85 tags.reserve(tagsSize); 86 SmallVector<std::string, 4> tagsStorage; 87 tagsStorage.reserve(tagsSize); 88 for (unsigned i = 0; i != tagsSize; ++i) 89 tagsStorage.push_back(Record.readString()); 90 for (unsigned i = 0; i != tagsSize; ++i) 91 tags.push_back(tagsStorage[i]); 92 New = new (Context) AbiTagAttr(Range, Context, tags.data(), tagsSize, Spelling); 93 New->setImplicit(isImplicit); 94 break; 95 } 96 case attr::AcquireCapability: { 97 bool isInherited = Record.readInt(); 98 bool isImplicit = Record.readInt(); 99 unsigned Spelling = Record.readInt(); 100 unsigned argsSize = Record.readInt(); 101 SmallVector<Expr *, 4> args; 102 args.reserve(argsSize); 103 for (unsigned i = 0; i != argsSize; ++i) 104 args.push_back(Record.readExpr()); 105 New = new (Context) AcquireCapabilityAttr(Range, Context, args.data(), argsSize, Spelling); 106 cast<InheritableAttr>(New)->setInherited(isInherited); 107 New->setImplicit(isImplicit); 108 break; 109 } 110 case attr::AcquiredAfter: { 111 bool isInherited = Record.readInt(); 112 bool isImplicit = Record.readInt(); 113 unsigned Spelling = Record.readInt(); 114 unsigned argsSize = Record.readInt(); 115 SmallVector<Expr *, 4> args; 116 args.reserve(argsSize); 117 for (unsigned i = 0; i != argsSize; ++i) 118 args.push_back(Record.readExpr()); 119 New = new (Context) AcquiredAfterAttr(Range, Context, args.data(), argsSize, Spelling); 120 cast<InheritableAttr>(New)->setInherited(isInherited); 121 New->setImplicit(isImplicit); 122 break; 123 } 124 case attr::AcquiredBefore: { 125 bool isInherited = Record.readInt(); 126 bool isImplicit = Record.readInt(); 127 unsigned Spelling = Record.readInt(); 128 unsigned argsSize = Record.readInt(); 129 SmallVector<Expr *, 4> args; 130 args.reserve(argsSize); 131 for (unsigned i = 0; i != argsSize; ++i) 132 args.push_back(Record.readExpr()); 133 New = new (Context) AcquiredBeforeAttr(Range, Context, args.data(), argsSize, Spelling); 134 cast<InheritableAttr>(New)->setInherited(isInherited); 135 New->setImplicit(isImplicit); 136 break; 137 } 138 case attr::Alias: { 139 bool isImplicit = Record.readInt(); 140 unsigned Spelling = Record.readInt(); 141 std::string aliasee= Record.readString(); 142 New = new (Context) AliasAttr(Range, Context, aliasee, Spelling); 143 New->setImplicit(isImplicit); 144 break; 145 } 146 case attr::AlignMac68k: { 147 bool isInherited = Record.readInt(); 148 bool isImplicit = Record.readInt(); 149 unsigned Spelling = Record.readInt(); 150 New = new (Context) AlignMac68kAttr(Range, Context, Spelling); 151 cast<InheritableAttr>(New)->setInherited(isInherited); 152 New->setImplicit(isImplicit); 153 break; 154 } 155 case attr::AlignValue: { 156 bool isImplicit = Record.readInt(); 157 unsigned Spelling = Record.readInt(); 158 Expr * alignment = Record.readExpr(); 159 New = new (Context) AlignValueAttr(Range, Context, alignment, Spelling); 160 New->setImplicit(isImplicit); 161 break; 162 } 163 case attr::Aligned: { 164 bool isInherited = Record.readInt(); 165 bool isImplicit = Record.readInt(); 166 unsigned Spelling = Record.readInt(); 167 bool isalignmentExpr = Record.readInt(); 168 void *alignmentPtr; 169 if (isalignmentExpr) 170 alignmentPtr = Record.readExpr(); 171 else 172 alignmentPtr = Record.getTypeSourceInfo(); 173 New = new (Context) AlignedAttr(Range, Context, isalignmentExpr, alignmentPtr, Spelling); 174 cast<InheritableAttr>(New)->setInherited(isInherited); 175 New->setImplicit(isImplicit); 176 break; 177 } 178 case attr::AllocAlign: { 179 bool isInherited = Record.readInt(); 180 bool isImplicit = Record.readInt(); 181 unsigned Spelling = Record.readInt(); 182 int paramIndex = Record.readInt(); 183 New = new (Context) AllocAlignAttr(Range, Context, paramIndex, Spelling); 184 cast<InheritableAttr>(New)->setInherited(isInherited); 185 New->setImplicit(isImplicit); 186 break; 187 } 188 case attr::AllocSize: { 189 bool isInherited = Record.readInt(); 190 bool isImplicit = Record.readInt(); 191 unsigned Spelling = Record.readInt(); 192 int elemSizeParam = Record.readInt(); 193 int numElemsParam = Record.readInt(); 194 New = new (Context) AllocSizeAttr(Range, Context, elemSizeParam, numElemsParam, Spelling); 195 cast<InheritableAttr>(New)->setInherited(isInherited); 196 New->setImplicit(isImplicit); 197 break; 198 } 199 case attr::AlwaysInline: { 200 bool isInherited = Record.readInt(); 201 bool isImplicit = Record.readInt(); 202 unsigned Spelling = Record.readInt(); 203 New = new (Context) AlwaysInlineAttr(Range, Context, Spelling); 204 cast<InheritableAttr>(New)->setInherited(isInherited); 205 New->setImplicit(isImplicit); 206 break; 207 } 208 case attr::AnalyzerNoReturn: { 209 bool isInherited = Record.readInt(); 210 bool isImplicit = Record.readInt(); 211 unsigned Spelling = Record.readInt(); 212 New = new (Context) AnalyzerNoReturnAttr(Range, Context, Spelling); 213 cast<InheritableAttr>(New)->setInherited(isInherited); 214 New->setImplicit(isImplicit); 215 break; 216 } 217 case attr::Annotate: { 218 bool isInherited = Record.readInt(); 219 bool isImplicit = Record.readInt(); 220 unsigned Spelling = Record.readInt(); 221 std::string annotation= Record.readString(); 222 New = new (Context) AnnotateAttr(Range, Context, annotation, Spelling); 223 cast<InheritableAttr>(New)->setInherited(isInherited); 224 New->setImplicit(isImplicit); 225 break; 226 } 227 case attr::AnyX86Interrupt: { 228 bool isInherited = Record.readInt(); 229 bool isImplicit = Record.readInt(); 230 unsigned Spelling = Record.readInt(); 231 New = new (Context) AnyX86InterruptAttr(Range, Context, Spelling); 232 cast<InheritableAttr>(New)->setInherited(isInherited); 233 New->setImplicit(isImplicit); 234 break; 235 } 236 case attr::AnyX86NoCallerSavedRegisters: { 237 bool isInherited = Record.readInt(); 238 bool isImplicit = Record.readInt(); 239 unsigned Spelling = Record.readInt(); 240 New = new (Context) AnyX86NoCallerSavedRegistersAttr(Range, Context, Spelling); 241 cast<InheritableAttr>(New)->setInherited(isInherited); 242 New->setImplicit(isImplicit); 243 break; 244 } 245 case attr::ArcWeakrefUnavailable: { 246 bool isInherited = Record.readInt(); 247 bool isImplicit = Record.readInt(); 248 unsigned Spelling = Record.readInt(); 249 New = new (Context) ArcWeakrefUnavailableAttr(Range, Context, Spelling); 250 cast<InheritableAttr>(New)->setInherited(isInherited); 251 New->setImplicit(isImplicit); 252 break; 253 } 254 case attr::ArgumentWithTypeTag: { 255 bool isInherited = Record.readInt(); 256 bool isImplicit = Record.readInt(); 257 unsigned Spelling = Record.readInt(); 258 IdentifierInfo * argumentKind = Record.getIdentifierInfo(); 259 unsigned argumentIdx = Record.readInt(); 260 unsigned typeTagIdx = Record.readInt(); 261 bool isPointer = Record.readInt(); 262 New = new (Context) ArgumentWithTypeTagAttr(Range, Context, argumentKind, argumentIdx, typeTagIdx, isPointer, Spelling); 263 cast<InheritableAttr>(New)->setInherited(isInherited); 264 New->setImplicit(isImplicit); 265 break; 266 } 267 case attr::AsmLabel: { 268 bool isInherited = Record.readInt(); 269 bool isImplicit = Record.readInt(); 270 unsigned Spelling = Record.readInt(); 271 std::string label= Record.readString(); 272 New = new (Context) AsmLabelAttr(Range, Context, label, Spelling); 273 cast<InheritableAttr>(New)->setInherited(isInherited); 274 New->setImplicit(isImplicit); 275 break; 276 } 277 case attr::AssertCapability: { 278 bool isInherited = Record.readInt(); 279 bool isImplicit = Record.readInt(); 280 unsigned Spelling = Record.readInt(); 281 Expr * expr = Record.readExpr(); 282 New = new (Context) AssertCapabilityAttr(Range, Context, expr, Spelling); 283 cast<InheritableAttr>(New)->setInherited(isInherited); 284 New->setImplicit(isImplicit); 285 break; 286 } 287 case attr::AssertExclusiveLock: { 288 bool isInherited = Record.readInt(); 289 bool isImplicit = Record.readInt(); 290 unsigned Spelling = Record.readInt(); 291 unsigned argsSize = Record.readInt(); 292 SmallVector<Expr *, 4> args; 293 args.reserve(argsSize); 294 for (unsigned i = 0; i != argsSize; ++i) 295 args.push_back(Record.readExpr()); 296 New = new (Context) AssertExclusiveLockAttr(Range, Context, args.data(), argsSize, Spelling); 297 cast<InheritableAttr>(New)->setInherited(isInherited); 298 New->setImplicit(isImplicit); 299 break; 300 } 301 case attr::AssertSharedLock: { 302 bool isInherited = Record.readInt(); 303 bool isImplicit = Record.readInt(); 304 unsigned Spelling = Record.readInt(); 305 unsigned argsSize = Record.readInt(); 306 SmallVector<Expr *, 4> args; 307 args.reserve(argsSize); 308 for (unsigned i = 0; i != argsSize; ++i) 309 args.push_back(Record.readExpr()); 310 New = new (Context) AssertSharedLockAttr(Range, Context, args.data(), argsSize, Spelling); 311 cast<InheritableAttr>(New)->setInherited(isInherited); 312 New->setImplicit(isImplicit); 313 break; 314 } 315 case attr::AssumeAligned: { 316 bool isInherited = Record.readInt(); 317 bool isImplicit = Record.readInt(); 318 unsigned Spelling = Record.readInt(); 319 Expr * alignment = Record.readExpr(); 320 Expr * offset = Record.readExpr(); 321 New = new (Context) AssumeAlignedAttr(Range, Context, alignment, offset, Spelling); 322 cast<InheritableAttr>(New)->setInherited(isInherited); 323 New->setImplicit(isImplicit); 324 break; 325 } 326 case attr::Availability: { 327 bool isInherited = Record.readInt(); 328 bool isImplicit = Record.readInt(); 329 unsigned Spelling = Record.readInt(); 330 IdentifierInfo * platform = Record.getIdentifierInfo(); 331 VersionTuple introduced= Record.readVersionTuple(); 332 VersionTuple deprecated= Record.readVersionTuple(); 333 VersionTuple obsoleted= Record.readVersionTuple(); 334 bool unavailable = Record.readInt(); 335 std::string message= Record.readString(); 336 bool strict = Record.readInt(); 337 std::string replacement= Record.readString(); 338 New = new (Context) AvailabilityAttr(Range, Context, platform, introduced, deprecated, obsoleted, unavailable, message, strict, replacement, Spelling); 339 cast<InheritableAttr>(New)->setInherited(isInherited); 340 New->setImplicit(isImplicit); 341 break; 342 } 343 case attr::Blocks: { 344 bool isInherited = Record.readInt(); 345 bool isImplicit = Record.readInt(); 346 unsigned Spelling = Record.readInt(); 347 BlocksAttr::BlockType type(static_cast<BlocksAttr::BlockType>(Record.readInt())); 348 New = new (Context) BlocksAttr(Range, Context, type, Spelling); 349 cast<InheritableAttr>(New)->setInherited(isInherited); 350 New->setImplicit(isImplicit); 351 break; 352 } 353 case attr::C11NoReturn: { 354 bool isInherited = Record.readInt(); 355 bool isImplicit = Record.readInt(); 356 unsigned Spelling = Record.readInt(); 357 New = new (Context) C11NoReturnAttr(Range, Context, Spelling); 358 cast<InheritableAttr>(New)->setInherited(isInherited); 359 New->setImplicit(isImplicit); 360 break; 361 } 362 case attr::CDecl: { 363 bool isInherited = Record.readInt(); 364 bool isImplicit = Record.readInt(); 365 unsigned Spelling = Record.readInt(); 366 New = new (Context) CDeclAttr(Range, Context, Spelling); 367 cast<InheritableAttr>(New)->setInherited(isInherited); 368 New->setImplicit(isImplicit); 369 break; 370 } 371 case attr::CFAuditedTransfer: { 372 bool isInherited = Record.readInt(); 373 bool isImplicit = Record.readInt(); 374 unsigned Spelling = Record.readInt(); 375 New = new (Context) CFAuditedTransferAttr(Range, Context, Spelling); 376 cast<InheritableAttr>(New)->setInherited(isInherited); 377 New->setImplicit(isImplicit); 378 break; 379 } 380 case attr::CFConsumed: { 381 bool isInherited = Record.readInt(); 382 bool isImplicit = Record.readInt(); 383 unsigned Spelling = Record.readInt(); 384 New = new (Context) CFConsumedAttr(Range, Context, Spelling); 385 cast<InheritableAttr>(New)->setInherited(isInherited); 386 New->setImplicit(isImplicit); 387 break; 388 } 389 case attr::CFReturnsNotRetained: { 390 bool isInherited = Record.readInt(); 391 bool isImplicit = Record.readInt(); 392 unsigned Spelling = Record.readInt(); 393 New = new (Context) CFReturnsNotRetainedAttr(Range, Context, Spelling); 394 cast<InheritableAttr>(New)->setInherited(isInherited); 395 New->setImplicit(isImplicit); 396 break; 397 } 398 case attr::CFReturnsRetained: { 399 bool isInherited = Record.readInt(); 400 bool isImplicit = Record.readInt(); 401 unsigned Spelling = Record.readInt(); 402 New = new (Context) CFReturnsRetainedAttr(Range, Context, Spelling); 403 cast<InheritableAttr>(New)->setInherited(isInherited); 404 New->setImplicit(isImplicit); 405 break; 406 } 407 case attr::CFUnknownTransfer: { 408 bool isInherited = Record.readInt(); 409 bool isImplicit = Record.readInt(); 410 unsigned Spelling = Record.readInt(); 411 New = new (Context) CFUnknownTransferAttr(Range, Context, Spelling); 412 cast<InheritableAttr>(New)->setInherited(isInherited); 413 New->setImplicit(isImplicit); 414 break; 415 } 416 case attr::CUDAConstant: { 417 bool isInherited = Record.readInt(); 418 bool isImplicit = Record.readInt(); 419 unsigned Spelling = Record.readInt(); 420 New = new (Context) CUDAConstantAttr(Range, Context, Spelling); 421 cast<InheritableAttr>(New)->setInherited(isInherited); 422 New->setImplicit(isImplicit); 423 break; 424 } 425 case attr::CUDADevice: { 426 bool isInherited = Record.readInt(); 427 bool isImplicit = Record.readInt(); 428 unsigned Spelling = Record.readInt(); 429 New = new (Context) CUDADeviceAttr(Range, Context, Spelling); 430 cast<InheritableAttr>(New)->setInherited(isInherited); 431 New->setImplicit(isImplicit); 432 break; 433 } 434 case attr::CUDAGlobal: { 435 bool isInherited = Record.readInt(); 436 bool isImplicit = Record.readInt(); 437 unsigned Spelling = Record.readInt(); 438 New = new (Context) CUDAGlobalAttr(Range, Context, Spelling); 439 cast<InheritableAttr>(New)->setInherited(isInherited); 440 New->setImplicit(isImplicit); 441 break; 442 } 443 case attr::CUDAHost: { 444 bool isInherited = Record.readInt(); 445 bool isImplicit = Record.readInt(); 446 unsigned Spelling = Record.readInt(); 447 New = new (Context) CUDAHostAttr(Range, Context, Spelling); 448 cast<InheritableAttr>(New)->setInherited(isInherited); 449 New->setImplicit(isImplicit); 450 break; 451 } 452 case attr::CUDAInvalidTarget: { 453 bool isInherited = Record.readInt(); 454 bool isImplicit = Record.readInt(); 455 unsigned Spelling = Record.readInt(); 456 New = new (Context) CUDAInvalidTargetAttr(Range, Context, Spelling); 457 cast<InheritableAttr>(New)->setInherited(isInherited); 458 New->setImplicit(isImplicit); 459 break; 460 } 461 case attr::CUDALaunchBounds: { 462 bool isInherited = Record.readInt(); 463 bool isImplicit = Record.readInt(); 464 unsigned Spelling = Record.readInt(); 465 Expr * maxThreads = Record.readExpr(); 466 Expr * minBlocks = Record.readExpr(); 467 New = new (Context) CUDALaunchBoundsAttr(Range, Context, maxThreads, minBlocks, Spelling); 468 cast<InheritableAttr>(New)->setInherited(isInherited); 469 New->setImplicit(isImplicit); 470 break; 471 } 472 case attr::CUDAShared: { 473 bool isInherited = Record.readInt(); 474 bool isImplicit = Record.readInt(); 475 unsigned Spelling = Record.readInt(); 476 New = new (Context) CUDASharedAttr(Range, Context, Spelling); 477 cast<InheritableAttr>(New)->setInherited(isInherited); 478 New->setImplicit(isImplicit); 479 break; 480 } 481 case attr::CXX11NoReturn: { 482 bool isInherited = Record.readInt(); 483 bool isImplicit = Record.readInt(); 484 unsigned Spelling = Record.readInt(); 485 New = new (Context) CXX11NoReturnAttr(Range, Context, Spelling); 486 cast<InheritableAttr>(New)->setInherited(isInherited); 487 New->setImplicit(isImplicit); 488 break; 489 } 490 case attr::CallableWhen: { 491 bool isInherited = Record.readInt(); 492 bool isImplicit = Record.readInt(); 493 unsigned Spelling = Record.readInt(); 494 unsigned callableStatesSize = Record.readInt(); 495 SmallVector<CallableWhenAttr::ConsumedState, 4> callableStates; 496 callableStates.reserve(callableStatesSize); 497 for (unsigned i = callableStatesSize; i; --i) 498 callableStates.push_back(static_cast<CallableWhenAttr::ConsumedState>(Record.readInt())); 499 New = new (Context) CallableWhenAttr(Range, Context, callableStates.data(), callableStatesSize, Spelling); 500 cast<InheritableAttr>(New)->setInherited(isInherited); 501 New->setImplicit(isImplicit); 502 break; 503 } 504 case attr::Capability: { 505 bool isInherited = Record.readInt(); 506 bool isImplicit = Record.readInt(); 507 unsigned Spelling = Record.readInt(); 508 std::string name= Record.readString(); 509 New = new (Context) CapabilityAttr(Range, Context, name, Spelling); 510 cast<InheritableAttr>(New)->setInherited(isInherited); 511 New->setImplicit(isImplicit); 512 break; 513 } 514 case attr::CapturedRecord: { 515 bool isInherited = Record.readInt(); 516 bool isImplicit = Record.readInt(); 517 unsigned Spelling = Record.readInt(); 518 New = new (Context) CapturedRecordAttr(Range, Context, Spelling); 519 cast<InheritableAttr>(New)->setInherited(isInherited); 520 New->setImplicit(isImplicit); 521 break; 522 } 523 case attr::CarriesDependency: { 524 bool isInherited = Record.readInt(); 525 bool isImplicit = Record.readInt(); 526 unsigned Spelling = Record.readInt(); 527 New = new (Context) CarriesDependencyAttr(Range, Context, Spelling); 528 cast<InheritableAttr>(New)->setInherited(isInherited); 529 New->setImplicit(isImplicit); 530 break; 531 } 532 case attr::Cleanup: { 533 bool isInherited = Record.readInt(); 534 bool isImplicit = Record.readInt(); 535 unsigned Spelling = Record.readInt(); 536 FunctionDecl * functionDecl = Record.GetLocalDeclAs<FunctionDecl >(Record.readInt()); 537 New = new (Context) CleanupAttr(Range, Context, functionDecl, Spelling); 538 cast<InheritableAttr>(New)->setInherited(isInherited); 539 New->setImplicit(isImplicit); 540 break; 541 } 542 case attr::Cold: { 543 bool isInherited = Record.readInt(); 544 bool isImplicit = Record.readInt(); 545 unsigned Spelling = Record.readInt(); 546 New = new (Context) ColdAttr(Range, Context, Spelling); 547 cast<InheritableAttr>(New)->setInherited(isInherited); 548 New->setImplicit(isImplicit); 549 break; 550 } 551 case attr::Common: { 552 bool isInherited = Record.readInt(); 553 bool isImplicit = Record.readInt(); 554 unsigned Spelling = Record.readInt(); 555 New = new (Context) CommonAttr(Range, Context, Spelling); 556 cast<InheritableAttr>(New)->setInherited(isInherited); 557 New->setImplicit(isImplicit); 558 break; 559 } 560 case attr::Const: { 561 bool isInherited = Record.readInt(); 562 bool isImplicit = Record.readInt(); 563 unsigned Spelling = Record.readInt(); 564 New = new (Context) ConstAttr(Range, Context, Spelling); 565 cast<InheritableAttr>(New)->setInherited(isInherited); 566 New->setImplicit(isImplicit); 567 break; 568 } 569 case attr::Constructor: { 570 bool isInherited = Record.readInt(); 571 bool isImplicit = Record.readInt(); 572 unsigned Spelling = Record.readInt(); 573 int priority = Record.readInt(); 574 New = new (Context) ConstructorAttr(Range, Context, priority, Spelling); 575 cast<InheritableAttr>(New)->setInherited(isInherited); 576 New->setImplicit(isImplicit); 577 break; 578 } 579 case attr::Consumable: { 580 bool isInherited = Record.readInt(); 581 bool isImplicit = Record.readInt(); 582 unsigned Spelling = Record.readInt(); 583 ConsumableAttr::ConsumedState defaultState(static_cast<ConsumableAttr::ConsumedState>(Record.readInt())); 584 New = new (Context) ConsumableAttr(Range, Context, defaultState, Spelling); 585 cast<InheritableAttr>(New)->setInherited(isInherited); 586 New->setImplicit(isImplicit); 587 break; 588 } 589 case attr::ConsumableAutoCast: { 590 bool isInherited = Record.readInt(); 591 bool isImplicit = Record.readInt(); 592 unsigned Spelling = Record.readInt(); 593 New = new (Context) ConsumableAutoCastAttr(Range, Context, Spelling); 594 cast<InheritableAttr>(New)->setInherited(isInherited); 595 New->setImplicit(isImplicit); 596 break; 597 } 598 case attr::ConsumableSetOnRead: { 599 bool isInherited = Record.readInt(); 600 bool isImplicit = Record.readInt(); 601 unsigned Spelling = Record.readInt(); 602 New = new (Context) ConsumableSetOnReadAttr(Range, Context, Spelling); 603 cast<InheritableAttr>(New)->setInherited(isInherited); 604 New->setImplicit(isImplicit); 605 break; 606 } 607 case attr::Convergent: { 608 bool isInherited = Record.readInt(); 609 bool isImplicit = Record.readInt(); 610 unsigned Spelling = Record.readInt(); 611 New = new (Context) ConvergentAttr(Range, Context, Spelling); 612 cast<InheritableAttr>(New)->setInherited(isInherited); 613 New->setImplicit(isImplicit); 614 break; 615 } 616 case attr::DLLExport: { 617 bool isInherited = Record.readInt(); 618 bool isImplicit = Record.readInt(); 619 unsigned Spelling = Record.readInt(); 620 New = new (Context) DLLExportAttr(Range, Context, Spelling); 621 cast<InheritableAttr>(New)->setInherited(isInherited); 622 New->setImplicit(isImplicit); 623 break; 624 } 625 case attr::DLLImport: { 626 bool isInherited = Record.readInt(); 627 bool isImplicit = Record.readInt(); 628 unsigned Spelling = Record.readInt(); 629 New = new (Context) DLLImportAttr(Range, Context, Spelling); 630 cast<InheritableAttr>(New)->setInherited(isInherited); 631 New->setImplicit(isImplicit); 632 break; 633 } 634 case attr::Deprecated: { 635 bool isInherited = Record.readInt(); 636 bool isImplicit = Record.readInt(); 637 unsigned Spelling = Record.readInt(); 638 std::string message= Record.readString(); 639 std::string replacement= Record.readString(); 640 New = new (Context) DeprecatedAttr(Range, Context, message, replacement, Spelling); 641 cast<InheritableAttr>(New)->setInherited(isInherited); 642 New->setImplicit(isImplicit); 643 break; 644 } 645 case attr::Destructor: { 646 bool isInherited = Record.readInt(); 647 bool isImplicit = Record.readInt(); 648 unsigned Spelling = Record.readInt(); 649 int priority = Record.readInt(); 650 New = new (Context) DestructorAttr(Range, Context, priority, Spelling); 651 cast<InheritableAttr>(New)->setInherited(isInherited); 652 New->setImplicit(isImplicit); 653 break; 654 } 655 case attr::DiagnoseIf: { 656 bool isInherited = Record.readInt(); 657 bool isImplicit = Record.readInt(); 658 unsigned Spelling = Record.readInt(); 659 Expr * cond = Record.readExpr(); 660 std::string message= Record.readString(); 661 DiagnoseIfAttr::DiagnosticType diagnosticType(static_cast<DiagnoseIfAttr::DiagnosticType>(Record.readInt())); 662 bool argDependent = Record.readInt(); 663 NamedDecl * parent = Record.GetLocalDeclAs<NamedDecl >(Record.readInt()); 664 New = new (Context) DiagnoseIfAttr(Range, Context, cond, message, diagnosticType, argDependent, parent, Spelling); 665 cast<InheritableAttr>(New)->setInherited(isInherited); 666 New->setImplicit(isImplicit); 667 break; 668 } 669 case attr::DisableTailCalls: { 670 bool isInherited = Record.readInt(); 671 bool isImplicit = Record.readInt(); 672 unsigned Spelling = Record.readInt(); 673 New = new (Context) DisableTailCallsAttr(Range, Context, Spelling); 674 cast<InheritableAttr>(New)->setInherited(isInherited); 675 New->setImplicit(isImplicit); 676 break; 677 } 678 case attr::EmptyBases: { 679 bool isInherited = Record.readInt(); 680 bool isImplicit = Record.readInt(); 681 unsigned Spelling = Record.readInt(); 682 New = new (Context) EmptyBasesAttr(Range, Context, Spelling); 683 cast<InheritableAttr>(New)->setInherited(isInherited); 684 New->setImplicit(isImplicit); 685 break; 686 } 687 case attr::EnableIf: { 688 bool isInherited = Record.readInt(); 689 bool isImplicit = Record.readInt(); 690 unsigned Spelling = Record.readInt(); 691 Expr * cond = Record.readExpr(); 692 std::string message= Record.readString(); 693 New = new (Context) EnableIfAttr(Range, Context, cond, message, Spelling); 694 cast<InheritableAttr>(New)->setInherited(isInherited); 695 New->setImplicit(isImplicit); 696 break; 697 } 698 case attr::EnumExtensibility: { 699 bool isInherited = Record.readInt(); 700 bool isImplicit = Record.readInt(); 701 unsigned Spelling = Record.readInt(); 702 EnumExtensibilityAttr::Kind extensibility(static_cast<EnumExtensibilityAttr::Kind>(Record.readInt())); 703 New = new (Context) EnumExtensibilityAttr(Range, Context, extensibility, Spelling); 704 cast<InheritableAttr>(New)->setInherited(isInherited); 705 New->setImplicit(isImplicit); 706 break; 707 } 708 case attr::ExclusiveTrylockFunction: { 709 bool isInherited = Record.readInt(); 710 bool isImplicit = Record.readInt(); 711 unsigned Spelling = Record.readInt(); 712 Expr * successValue = Record.readExpr(); 713 unsigned argsSize = Record.readInt(); 714 SmallVector<Expr *, 4> args; 715 args.reserve(argsSize); 716 for (unsigned i = 0; i != argsSize; ++i) 717 args.push_back(Record.readExpr()); 718 New = new (Context) ExclusiveTrylockFunctionAttr(Range, Context, successValue, args.data(), argsSize, Spelling); 719 cast<InheritableAttr>(New)->setInherited(isInherited); 720 New->setImplicit(isImplicit); 721 break; 722 } 723 case attr::ExternalSourceSymbol: { 724 bool isInherited = Record.readInt(); 725 bool isImplicit = Record.readInt(); 726 unsigned Spelling = Record.readInt(); 727 std::string language= Record.readString(); 728 std::string definedIn= Record.readString(); 729 bool generatedDeclaration = Record.readInt(); 730 New = new (Context) ExternalSourceSymbolAttr(Range, Context, language, definedIn, generatedDeclaration, Spelling); 731 cast<InheritableAttr>(New)->setInherited(isInherited); 732 New->setImplicit(isImplicit); 733 break; 734 } 735 case attr::FallThrough: { 736 bool isImplicit = Record.readInt(); 737 unsigned Spelling = Record.readInt(); 738 New = new (Context) FallThroughAttr(Range, Context, Spelling); 739 New->setImplicit(isImplicit); 740 break; 741 } 742 case attr::FastCall: { 743 bool isInherited = Record.readInt(); 744 bool isImplicit = Record.readInt(); 745 unsigned Spelling = Record.readInt(); 746 New = new (Context) FastCallAttr(Range, Context, Spelling); 747 cast<InheritableAttr>(New)->setInherited(isInherited); 748 New->setImplicit(isImplicit); 749 break; 750 } 751 case attr::Final: { 752 bool isInherited = Record.readInt(); 753 bool isImplicit = Record.readInt(); 754 unsigned Spelling = Record.readInt(); 755 New = new (Context) FinalAttr(Range, Context, Spelling); 756 cast<InheritableAttr>(New)->setInherited(isInherited); 757 New->setImplicit(isImplicit); 758 break; 759 } 760 case attr::FlagEnum: { 761 bool isInherited = Record.readInt(); 762 bool isImplicit = Record.readInt(); 763 unsigned Spelling = Record.readInt(); 764 New = new (Context) FlagEnumAttr(Range, Context, Spelling); 765 cast<InheritableAttr>(New)->setInherited(isInherited); 766 New->setImplicit(isImplicit); 767 break; 768 } 769 case attr::Flatten: { 770 bool isInherited = Record.readInt(); 771 bool isImplicit = Record.readInt(); 772 unsigned Spelling = Record.readInt(); 773 New = new (Context) FlattenAttr(Range, Context, Spelling); 774 cast<InheritableAttr>(New)->setInherited(isInherited); 775 New->setImplicit(isImplicit); 776 break; 777 } 778 case attr::Format: { 779 bool isInherited = Record.readInt(); 780 bool isImplicit = Record.readInt(); 781 unsigned Spelling = Record.readInt(); 782 IdentifierInfo * type = Record.getIdentifierInfo(); 783 int formatIdx = Record.readInt(); 784 int firstArg = Record.readInt(); 785 New = new (Context) FormatAttr(Range, Context, type, formatIdx, firstArg, Spelling); 786 cast<InheritableAttr>(New)->setInherited(isInherited); 787 New->setImplicit(isImplicit); 788 break; 789 } 790 case attr::FormatArg: { 791 bool isInherited = Record.readInt(); 792 bool isImplicit = Record.readInt(); 793 unsigned Spelling = Record.readInt(); 794 int formatIdx = Record.readInt(); 795 New = new (Context) FormatArgAttr(Range, Context, formatIdx, Spelling); 796 cast<InheritableAttr>(New)->setInherited(isInherited); 797 New->setImplicit(isImplicit); 798 break; 799 } 800 case attr::GNUInline: { 801 bool isInherited = Record.readInt(); 802 bool isImplicit = Record.readInt(); 803 unsigned Spelling = Record.readInt(); 804 New = new (Context) GNUInlineAttr(Range, Context, Spelling); 805 cast<InheritableAttr>(New)->setInherited(isInherited); 806 New->setImplicit(isImplicit); 807 break; 808 } 809 case attr::GuardedBy: { 810 bool isInherited = Record.readInt(); 811 bool isImplicit = Record.readInt(); 812 unsigned Spelling = Record.readInt(); 813 Expr * arg = Record.readExpr(); 814 New = new (Context) GuardedByAttr(Range, Context, arg, Spelling); 815 cast<InheritableAttr>(New)->setInherited(isInherited); 816 New->setImplicit(isImplicit); 817 break; 818 } 819 case attr::GuardedVar: { 820 bool isInherited = Record.readInt(); 821 bool isImplicit = Record.readInt(); 822 unsigned Spelling = Record.readInt(); 823 New = new (Context) GuardedVarAttr(Range, Context, Spelling); 824 cast<InheritableAttr>(New)->setInherited(isInherited); 825 New->setImplicit(isImplicit); 826 break; 827 } 828 case attr::Hot: { 829 bool isInherited = Record.readInt(); 830 bool isImplicit = Record.readInt(); 831 unsigned Spelling = Record.readInt(); 832 New = new (Context) HotAttr(Range, Context, Spelling); 833 cast<InheritableAttr>(New)->setInherited(isInherited); 834 New->setImplicit(isImplicit); 835 break; 836 } 837 case attr::IBAction: { 838 bool isInherited = Record.readInt(); 839 bool isImplicit = Record.readInt(); 840 unsigned Spelling = Record.readInt(); 841 New = new (Context) IBActionAttr(Range, Context, Spelling); 842 cast<InheritableAttr>(New)->setInherited(isInherited); 843 New->setImplicit(isImplicit); 844 break; 845 } 846 case attr::IBOutlet: { 847 bool isInherited = Record.readInt(); 848 bool isImplicit = Record.readInt(); 849 unsigned Spelling = Record.readInt(); 850 New = new (Context) IBOutletAttr(Range, Context, Spelling); 851 cast<InheritableAttr>(New)->setInherited(isInherited); 852 New->setImplicit(isImplicit); 853 break; 854 } 855 case attr::IBOutletCollection: { 856 bool isInherited = Record.readInt(); 857 bool isImplicit = Record.readInt(); 858 unsigned Spelling = Record.readInt(); 859 TypeSourceInfo * interface_ = Record.getTypeSourceInfo(); 860 New = new (Context) IBOutletCollectionAttr(Range, Context, interface_, Spelling); 861 cast<InheritableAttr>(New)->setInherited(isInherited); 862 New->setImplicit(isImplicit); 863 break; 864 } 865 case attr::IFunc: { 866 bool isImplicit = Record.readInt(); 867 unsigned Spelling = Record.readInt(); 868 std::string resolver= Record.readString(); 869 New = new (Context) IFuncAttr(Range, Context, resolver, Spelling); 870 New->setImplicit(isImplicit); 871 break; 872 } 873 case attr::InitPriority: { 874 bool isInherited = Record.readInt(); 875 bool isImplicit = Record.readInt(); 876 unsigned Spelling = Record.readInt(); 877 unsigned priority = Record.readInt(); 878 New = new (Context) InitPriorityAttr(Range, Context, priority, Spelling); 879 cast<InheritableAttr>(New)->setInherited(isInherited); 880 New->setImplicit(isImplicit); 881 break; 882 } 883 case attr::InitSeg: { 884 bool isImplicit = Record.readInt(); 885 unsigned Spelling = Record.readInt(); 886 std::string section= Record.readString(); 887 New = new (Context) InitSegAttr(Range, Context, section, Spelling); 888 New->setImplicit(isImplicit); 889 break; 890 } 891 case attr::IntelOclBicc: { 892 bool isInherited = Record.readInt(); 893 bool isImplicit = Record.readInt(); 894 unsigned Spelling = Record.readInt(); 895 New = new (Context) IntelOclBiccAttr(Range, Context, Spelling); 896 cast<InheritableAttr>(New)->setInherited(isInherited); 897 New->setImplicit(isImplicit); 898 break; 899 } 900 case attr::InternalLinkage: { 901 bool isInherited = Record.readInt(); 902 bool isImplicit = Record.readInt(); 903 unsigned Spelling = Record.readInt(); 904 New = new (Context) InternalLinkageAttr(Range, Context, Spelling); 905 cast<InheritableAttr>(New)->setInherited(isInherited); 906 New->setImplicit(isImplicit); 907 break; 908 } 909 case attr::LTOVisibilityPublic: { 910 bool isInherited = Record.readInt(); 911 bool isImplicit = Record.readInt(); 912 unsigned Spelling = Record.readInt(); 913 New = new (Context) LTOVisibilityPublicAttr(Range, Context, Spelling); 914 cast<InheritableAttr>(New)->setInherited(isInherited); 915 New->setImplicit(isImplicit); 916 break; 917 } 918 case attr::LayoutVersion: { 919 bool isInherited = Record.readInt(); 920 bool isImplicit = Record.readInt(); 921 unsigned Spelling = Record.readInt(); 922 unsigned version = Record.readInt(); 923 New = new (Context) LayoutVersionAttr(Range, Context, version, Spelling); 924 cast<InheritableAttr>(New)->setInherited(isInherited); 925 New->setImplicit(isImplicit); 926 break; 927 } 928 case attr::LockReturned: { 929 bool isInherited = Record.readInt(); 930 bool isImplicit = Record.readInt(); 931 unsigned Spelling = Record.readInt(); 932 Expr * arg = Record.readExpr(); 933 New = new (Context) LockReturnedAttr(Range, Context, arg, Spelling); 934 cast<InheritableAttr>(New)->setInherited(isInherited); 935 New->setImplicit(isImplicit); 936 break; 937 } 938 case attr::LocksExcluded: { 939 bool isInherited = Record.readInt(); 940 bool isImplicit = Record.readInt(); 941 unsigned Spelling = Record.readInt(); 942 unsigned argsSize = Record.readInt(); 943 SmallVector<Expr *, 4> args; 944 args.reserve(argsSize); 945 for (unsigned i = 0; i != argsSize; ++i) 946 args.push_back(Record.readExpr()); 947 New = new (Context) LocksExcludedAttr(Range, Context, args.data(), argsSize, Spelling); 948 cast<InheritableAttr>(New)->setInherited(isInherited); 949 New->setImplicit(isImplicit); 950 break; 951 } 952 case attr::LoopHint: { 953 bool isImplicit = Record.readInt(); 954 unsigned Spelling = Record.readInt(); 955 LoopHintAttr::OptionType option(static_cast<LoopHintAttr::OptionType>(Record.readInt())); 956 LoopHintAttr::LoopHintState state(static_cast<LoopHintAttr::LoopHintState>(Record.readInt())); 957 Expr * value = Record.readExpr(); 958 New = new (Context) LoopHintAttr(Range, Context, option, state, value, Spelling); 959 New->setImplicit(isImplicit); 960 break; 961 } 962 case attr::MSABI: { 963 bool isInherited = Record.readInt(); 964 bool isImplicit = Record.readInt(); 965 unsigned Spelling = Record.readInt(); 966 New = new (Context) MSABIAttr(Range, Context, Spelling); 967 cast<InheritableAttr>(New)->setInherited(isInherited); 968 New->setImplicit(isImplicit); 969 break; 970 } 971 case attr::MSInheritance: { 972 bool isInherited = Record.readInt(); 973 bool isImplicit = Record.readInt(); 974 unsigned Spelling = Record.readInt(); 975 bool bestCase = Record.readInt(); 976 New = new (Context) MSInheritanceAttr(Range, Context, bestCase, Spelling); 977 cast<InheritableAttr>(New)->setInherited(isInherited); 978 New->setImplicit(isImplicit); 979 break; 980 } 981 case attr::MSNoVTable: { 982 bool isInherited = Record.readInt(); 983 bool isImplicit = Record.readInt(); 984 unsigned Spelling = Record.readInt(); 985 New = new (Context) MSNoVTableAttr(Range, Context, Spelling); 986 cast<InheritableAttr>(New)->setInherited(isInherited); 987 New->setImplicit(isImplicit); 988 break; 989 } 990 case attr::MSP430Interrupt: { 991 bool isInherited = Record.readInt(); 992 bool isImplicit = Record.readInt(); 993 unsigned Spelling = Record.readInt(); 994 unsigned number = Record.readInt(); 995 New = new (Context) MSP430InterruptAttr(Range, Context, number, Spelling); 996 cast<InheritableAttr>(New)->setInherited(isInherited); 997 New->setImplicit(isImplicit); 998 break; 999 } 1000 case attr::MSStruct: { 1001 bool isInherited = Record.readInt(); 1002 bool isImplicit = Record.readInt(); 1003 unsigned Spelling = Record.readInt(); 1004 New = new (Context) MSStructAttr(Range, Context, Spelling); 1005 cast<InheritableAttr>(New)->setInherited(isInherited); 1006 New->setImplicit(isImplicit); 1007 break; 1008 } 1009 case attr::MSVtorDisp: { 1010 bool isInherited = Record.readInt(); 1011 bool isImplicit = Record.readInt(); 1012 unsigned Spelling = Record.readInt(); 1013 unsigned vdm = Record.readInt(); 1014 New = new (Context) MSVtorDispAttr(Range, Context, vdm, Spelling); 1015 cast<InheritableAttr>(New)->setInherited(isInherited); 1016 New->setImplicit(isImplicit); 1017 break; 1018 } 1019 case attr::MaxFieldAlignment: { 1020 bool isInherited = Record.readInt(); 1021 bool isImplicit = Record.readInt(); 1022 unsigned Spelling = Record.readInt(); 1023 unsigned alignment = Record.readInt(); 1024 New = new (Context) MaxFieldAlignmentAttr(Range, Context, alignment, Spelling); 1025 cast<InheritableAttr>(New)->setInherited(isInherited); 1026 New->setImplicit(isImplicit); 1027 break; 1028 } 1029 case attr::MayAlias: { 1030 bool isInherited = Record.readInt(); 1031 bool isImplicit = Record.readInt(); 1032 unsigned Spelling = Record.readInt(); 1033 New = new (Context) MayAliasAttr(Range, Context, Spelling); 1034 cast<InheritableAttr>(New)->setInherited(isInherited); 1035 New->setImplicit(isImplicit); 1036 break; 1037 } 1038 case attr::MicroMips: { 1039 bool isInherited = Record.readInt(); 1040 bool isImplicit = Record.readInt(); 1041 unsigned Spelling = Record.readInt(); 1042 New = new (Context) MicroMipsAttr(Range, Context, Spelling); 1043 cast<InheritableAttr>(New)->setInherited(isInherited); 1044 New->setImplicit(isImplicit); 1045 break; 1046 } 1047 case attr::MinSize: { 1048 bool isInherited = Record.readInt(); 1049 bool isImplicit = Record.readInt(); 1050 unsigned Spelling = Record.readInt(); 1051 New = new (Context) MinSizeAttr(Range, Context, Spelling); 1052 cast<InheritableAttr>(New)->setInherited(isInherited); 1053 New->setImplicit(isImplicit); 1054 break; 1055 } 1056 case attr::Mips16: { 1057 bool isInherited = Record.readInt(); 1058 bool isImplicit = Record.readInt(); 1059 unsigned Spelling = Record.readInt(); 1060 New = new (Context) Mips16Attr(Range, Context, Spelling); 1061 cast<InheritableAttr>(New)->setInherited(isInherited); 1062 New->setImplicit(isImplicit); 1063 break; 1064 } 1065 case attr::MipsInterrupt: { 1066 bool isInherited = Record.readInt(); 1067 bool isImplicit = Record.readInt(); 1068 unsigned Spelling = Record.readInt(); 1069 MipsInterruptAttr::InterruptType interrupt(static_cast<MipsInterruptAttr::InterruptType>(Record.readInt())); 1070 New = new (Context) MipsInterruptAttr(Range, Context, interrupt, Spelling); 1071 cast<InheritableAttr>(New)->setInherited(isInherited); 1072 New->setImplicit(isImplicit); 1073 break; 1074 } 1075 case attr::Mode: { 1076 bool isImplicit = Record.readInt(); 1077 unsigned Spelling = Record.readInt(); 1078 IdentifierInfo * mode = Record.getIdentifierInfo(); 1079 New = new (Context) ModeAttr(Range, Context, mode, Spelling); 1080 New->setImplicit(isImplicit); 1081 break; 1082 } 1083 case attr::NSConsumed: { 1084 bool isInherited = Record.readInt(); 1085 bool isImplicit = Record.readInt(); 1086 unsigned Spelling = Record.readInt(); 1087 New = new (Context) NSConsumedAttr(Range, Context, Spelling); 1088 cast<InheritableAttr>(New)->setInherited(isInherited); 1089 New->setImplicit(isImplicit); 1090 break; 1091 } 1092 case attr::NSConsumesSelf: { 1093 bool isInherited = Record.readInt(); 1094 bool isImplicit = Record.readInt(); 1095 unsigned Spelling = Record.readInt(); 1096 New = new (Context) NSConsumesSelfAttr(Range, Context, Spelling); 1097 cast<InheritableAttr>(New)->setInherited(isInherited); 1098 New->setImplicit(isImplicit); 1099 break; 1100 } 1101 case attr::NSReturnsAutoreleased: { 1102 bool isInherited = Record.readInt(); 1103 bool isImplicit = Record.readInt(); 1104 unsigned Spelling = Record.readInt(); 1105 New = new (Context) NSReturnsAutoreleasedAttr(Range, Context, Spelling); 1106 cast<InheritableAttr>(New)->setInherited(isInherited); 1107 New->setImplicit(isImplicit); 1108 break; 1109 } 1110 case attr::NSReturnsNotRetained: { 1111 bool isInherited = Record.readInt(); 1112 bool isImplicit = Record.readInt(); 1113 unsigned Spelling = Record.readInt(); 1114 New = new (Context) NSReturnsNotRetainedAttr(Range, Context, Spelling); 1115 cast<InheritableAttr>(New)->setInherited(isInherited); 1116 New->setImplicit(isImplicit); 1117 break; 1118 } 1119 case attr::NSReturnsRetained: { 1120 bool isInherited = Record.readInt(); 1121 bool isImplicit = Record.readInt(); 1122 unsigned Spelling = Record.readInt(); 1123 New = new (Context) NSReturnsRetainedAttr(Range, Context, Spelling); 1124 cast<InheritableAttr>(New)->setInherited(isInherited); 1125 New->setImplicit(isImplicit); 1126 break; 1127 } 1128 case attr::Naked: { 1129 bool isInherited = Record.readInt(); 1130 bool isImplicit = Record.readInt(); 1131 unsigned Spelling = Record.readInt(); 1132 New = new (Context) NakedAttr(Range, Context, Spelling); 1133 cast<InheritableAttr>(New)->setInherited(isInherited); 1134 New->setImplicit(isImplicit); 1135 break; 1136 } 1137 case attr::NoAlias: { 1138 bool isInherited = Record.readInt(); 1139 bool isImplicit = Record.readInt(); 1140 unsigned Spelling = Record.readInt(); 1141 New = new (Context) NoAliasAttr(Range, Context, Spelling); 1142 cast<InheritableAttr>(New)->setInherited(isInherited); 1143 New->setImplicit(isImplicit); 1144 break; 1145 } 1146 case attr::NoCommon: { 1147 bool isInherited = Record.readInt(); 1148 bool isImplicit = Record.readInt(); 1149 unsigned Spelling = Record.readInt(); 1150 New = new (Context) NoCommonAttr(Range, Context, Spelling); 1151 cast<InheritableAttr>(New)->setInherited(isInherited); 1152 New->setImplicit(isImplicit); 1153 break; 1154 } 1155 case attr::NoDebug: { 1156 bool isInherited = Record.readInt(); 1157 bool isImplicit = Record.readInt(); 1158 unsigned Spelling = Record.readInt(); 1159 New = new (Context) NoDebugAttr(Range, Context, Spelling); 1160 cast<InheritableAttr>(New)->setInherited(isInherited); 1161 New->setImplicit(isImplicit); 1162 break; 1163 } 1164 case attr::NoDuplicate: { 1165 bool isInherited = Record.readInt(); 1166 bool isImplicit = Record.readInt(); 1167 unsigned Spelling = Record.readInt(); 1168 New = new (Context) NoDuplicateAttr(Range, Context, Spelling); 1169 cast<InheritableAttr>(New)->setInherited(isInherited); 1170 New->setImplicit(isImplicit); 1171 break; 1172 } 1173 case attr::NoInline: { 1174 bool isInherited = Record.readInt(); 1175 bool isImplicit = Record.readInt(); 1176 unsigned Spelling = Record.readInt(); 1177 New = new (Context) NoInlineAttr(Range, Context, Spelling); 1178 cast<InheritableAttr>(New)->setInherited(isInherited); 1179 New->setImplicit(isImplicit); 1180 break; 1181 } 1182 case attr::NoInstrumentFunction: { 1183 bool isInherited = Record.readInt(); 1184 bool isImplicit = Record.readInt(); 1185 unsigned Spelling = Record.readInt(); 1186 New = new (Context) NoInstrumentFunctionAttr(Range, Context, Spelling); 1187 cast<InheritableAttr>(New)->setInherited(isInherited); 1188 New->setImplicit(isImplicit); 1189 break; 1190 } 1191 case attr::NoMicroMips: { 1192 bool isInherited = Record.readInt(); 1193 bool isImplicit = Record.readInt(); 1194 unsigned Spelling = Record.readInt(); 1195 New = new (Context) NoMicroMipsAttr(Range, Context, Spelling); 1196 cast<InheritableAttr>(New)->setInherited(isInherited); 1197 New->setImplicit(isImplicit); 1198 break; 1199 } 1200 case attr::NoMips16: { 1201 bool isInherited = Record.readInt(); 1202 bool isImplicit = Record.readInt(); 1203 unsigned Spelling = Record.readInt(); 1204 New = new (Context) NoMips16Attr(Range, Context, Spelling); 1205 cast<InheritableAttr>(New)->setInherited(isInherited); 1206 New->setImplicit(isImplicit); 1207 break; 1208 } 1209 case attr::NoReturn: { 1210 bool isInherited = Record.readInt(); 1211 bool isImplicit = Record.readInt(); 1212 unsigned Spelling = Record.readInt(); 1213 New = new (Context) NoReturnAttr(Range, Context, Spelling); 1214 cast<InheritableAttr>(New)->setInherited(isInherited); 1215 New->setImplicit(isImplicit); 1216 break; 1217 } 1218 case attr::NoSanitize: { 1219 bool isInherited = Record.readInt(); 1220 bool isImplicit = Record.readInt(); 1221 unsigned Spelling = Record.readInt(); 1222 unsigned sanitizersSize = Record.readInt(); 1223 SmallVector<StringRef, 4> sanitizers; 1224 sanitizers.reserve(sanitizersSize); 1225 SmallVector<std::string, 4> sanitizersStorage; 1226 sanitizersStorage.reserve(sanitizersSize); 1227 for (unsigned i = 0; i != sanitizersSize; ++i) 1228 sanitizersStorage.push_back(Record.readString()); 1229 for (unsigned i = 0; i != sanitizersSize; ++i) 1230 sanitizers.push_back(sanitizersStorage[i]); 1231 New = new (Context) NoSanitizeAttr(Range, Context, sanitizers.data(), sanitizersSize, Spelling); 1232 cast<InheritableAttr>(New)->setInherited(isInherited); 1233 New->setImplicit(isImplicit); 1234 break; 1235 } 1236 case attr::NoSplitStack: { 1237 bool isInherited = Record.readInt(); 1238 bool isImplicit = Record.readInt(); 1239 unsigned Spelling = Record.readInt(); 1240 New = new (Context) NoSplitStackAttr(Range, Context, Spelling); 1241 cast<InheritableAttr>(New)->setInherited(isInherited); 1242 New->setImplicit(isImplicit); 1243 break; 1244 } 1245 case attr::NoThreadSafetyAnalysis: { 1246 bool isInherited = Record.readInt(); 1247 bool isImplicit = Record.readInt(); 1248 unsigned Spelling = Record.readInt(); 1249 New = new (Context) NoThreadSafetyAnalysisAttr(Range, Context, Spelling); 1250 cast<InheritableAttr>(New)->setInherited(isInherited); 1251 New->setImplicit(isImplicit); 1252 break; 1253 } 1254 case attr::NoThrow: { 1255 bool isInherited = Record.readInt(); 1256 bool isImplicit = Record.readInt(); 1257 unsigned Spelling = Record.readInt(); 1258 New = new (Context) NoThrowAttr(Range, Context, Spelling); 1259 cast<InheritableAttr>(New)->setInherited(isInherited); 1260 New->setImplicit(isImplicit); 1261 break; 1262 } 1263 case attr::NonNull: { 1264 bool isInherited = Record.readInt(); 1265 bool isImplicit = Record.readInt(); 1266 unsigned Spelling = Record.readInt(); 1267 unsigned argsSize = Record.readInt(); 1268 SmallVector<unsigned, 4> args; 1269 args.reserve(argsSize); 1270 for (unsigned i = 0; i != argsSize; ++i) 1271 args.push_back(Record.readInt()); 1272 New = new (Context) NonNullAttr(Range, Context, args.data(), argsSize, Spelling); 1273 cast<InheritableAttr>(New)->setInherited(isInherited); 1274 New->setImplicit(isImplicit); 1275 break; 1276 } 1277 case attr::NotTailCalled: { 1278 bool isInherited = Record.readInt(); 1279 bool isImplicit = Record.readInt(); 1280 unsigned Spelling = Record.readInt(); 1281 New = new (Context) NotTailCalledAttr(Range, Context, Spelling); 1282 cast<InheritableAttr>(New)->setInherited(isInherited); 1283 New->setImplicit(isImplicit); 1284 break; 1285 } 1286 case attr::OMPCaptureNoInit: { 1287 bool isInherited = Record.readInt(); 1288 bool isImplicit = Record.readInt(); 1289 unsigned Spelling = Record.readInt(); 1290 New = new (Context) OMPCaptureNoInitAttr(Range, Context, Spelling); 1291 cast<InheritableAttr>(New)->setInherited(isInherited); 1292 New->setImplicit(isImplicit); 1293 break; 1294 } 1295 case attr::OMPDeclareSimdDecl: { 1296 bool isImplicit = Record.readInt(); 1297 unsigned Spelling = Record.readInt(); 1298 OMPDeclareSimdDeclAttr::BranchStateTy branchState(static_cast<OMPDeclareSimdDeclAttr::BranchStateTy>(Record.readInt())); 1299 Expr * simdlen = Record.readExpr(); 1300 unsigned uniformsSize = Record.readInt(); 1301 SmallVector<Expr *, 4> uniforms; 1302 uniforms.reserve(uniformsSize); 1303 for (unsigned i = 0; i != uniformsSize; ++i) 1304 uniforms.push_back(Record.readExpr()); 1305 unsigned alignedsSize = Record.readInt(); 1306 SmallVector<Expr *, 4> aligneds; 1307 aligneds.reserve(alignedsSize); 1308 for (unsigned i = 0; i != alignedsSize; ++i) 1309 aligneds.push_back(Record.readExpr()); 1310 unsigned alignmentsSize = Record.readInt(); 1311 SmallVector<Expr *, 4> alignments; 1312 alignments.reserve(alignmentsSize); 1313 for (unsigned i = 0; i != alignmentsSize; ++i) 1314 alignments.push_back(Record.readExpr()); 1315 unsigned linearsSize = Record.readInt(); 1316 SmallVector<Expr *, 4> linears; 1317 linears.reserve(linearsSize); 1318 for (unsigned i = 0; i != linearsSize; ++i) 1319 linears.push_back(Record.readExpr()); 1320 unsigned modifiersSize = Record.readInt(); 1321 SmallVector<unsigned, 4> modifiers; 1322 modifiers.reserve(modifiersSize); 1323 for (unsigned i = 0; i != modifiersSize; ++i) 1324 modifiers.push_back(Record.readInt()); 1325 unsigned stepsSize = Record.readInt(); 1326 SmallVector<Expr *, 4> steps; 1327 steps.reserve(stepsSize); 1328 for (unsigned i = 0; i != stepsSize; ++i) 1329 steps.push_back(Record.readExpr()); 1330 New = new (Context) OMPDeclareSimdDeclAttr(Range, Context, branchState, simdlen, uniforms.data(), uniformsSize, aligneds.data(), alignedsSize, alignments.data(), alignmentsSize, linears.data(), linearsSize, modifiers.data(), modifiersSize, steps.data(), stepsSize, Spelling); 1331 New->setImplicit(isImplicit); 1332 break; 1333 } 1334 case attr::OMPDeclareTargetDecl: { 1335 bool isImplicit = Record.readInt(); 1336 unsigned Spelling = Record.readInt(); 1337 OMPDeclareTargetDeclAttr::MapTypeTy mapType(static_cast<OMPDeclareTargetDeclAttr::MapTypeTy>(Record.readInt())); 1338 New = new (Context) OMPDeclareTargetDeclAttr(Range, Context, mapType, Spelling); 1339 New->setImplicit(isImplicit); 1340 break; 1341 } 1342 case attr::OMPThreadPrivateDecl: { 1343 bool isInherited = Record.readInt(); 1344 bool isImplicit = Record.readInt(); 1345 unsigned Spelling = Record.readInt(); 1346 New = new (Context) OMPThreadPrivateDeclAttr(Range, Context, Spelling); 1347 cast<InheritableAttr>(New)->setInherited(isInherited); 1348 New->setImplicit(isImplicit); 1349 break; 1350 } 1351 case attr::ObjCBoxable: { 1352 bool isImplicit = Record.readInt(); 1353 unsigned Spelling = Record.readInt(); 1354 New = new (Context) ObjCBoxableAttr(Range, Context, Spelling); 1355 New->setImplicit(isImplicit); 1356 break; 1357 } 1358 case attr::ObjCBridge: { 1359 bool isInherited = Record.readInt(); 1360 bool isImplicit = Record.readInt(); 1361 unsigned Spelling = Record.readInt(); 1362 IdentifierInfo * bridgedType = Record.getIdentifierInfo(); 1363 New = new (Context) ObjCBridgeAttr(Range, Context, bridgedType, Spelling); 1364 cast<InheritableAttr>(New)->setInherited(isInherited); 1365 New->setImplicit(isImplicit); 1366 break; 1367 } 1368 case attr::ObjCBridgeMutable: { 1369 bool isInherited = Record.readInt(); 1370 bool isImplicit = Record.readInt(); 1371 unsigned Spelling = Record.readInt(); 1372 IdentifierInfo * bridgedType = Record.getIdentifierInfo(); 1373 New = new (Context) ObjCBridgeMutableAttr(Range, Context, bridgedType, Spelling); 1374 cast<InheritableAttr>(New)->setInherited(isInherited); 1375 New->setImplicit(isImplicit); 1376 break; 1377 } 1378 case attr::ObjCBridgeRelated: { 1379 bool isInherited = Record.readInt(); 1380 bool isImplicit = Record.readInt(); 1381 unsigned Spelling = Record.readInt(); 1382 IdentifierInfo * relatedClass = Record.getIdentifierInfo(); 1383 IdentifierInfo * classMethod = Record.getIdentifierInfo(); 1384 IdentifierInfo * instanceMethod = Record.getIdentifierInfo(); 1385 New = new (Context) ObjCBridgeRelatedAttr(Range, Context, relatedClass, classMethod, instanceMethod, Spelling); 1386 cast<InheritableAttr>(New)->setInherited(isInherited); 1387 New->setImplicit(isImplicit); 1388 break; 1389 } 1390 case attr::ObjCDesignatedInitializer: { 1391 bool isImplicit = Record.readInt(); 1392 unsigned Spelling = Record.readInt(); 1393 New = new (Context) ObjCDesignatedInitializerAttr(Range, Context, Spelling); 1394 New->setImplicit(isImplicit); 1395 break; 1396 } 1397 case attr::ObjCException: { 1398 bool isInherited = Record.readInt(); 1399 bool isImplicit = Record.readInt(); 1400 unsigned Spelling = Record.readInt(); 1401 New = new (Context) ObjCExceptionAttr(Range, Context, Spelling); 1402 cast<InheritableAttr>(New)->setInherited(isInherited); 1403 New->setImplicit(isImplicit); 1404 break; 1405 } 1406 case attr::ObjCExplicitProtocolImpl: { 1407 bool isInherited = Record.readInt(); 1408 bool isImplicit = Record.readInt(); 1409 unsigned Spelling = Record.readInt(); 1410 New = new (Context) ObjCExplicitProtocolImplAttr(Range, Context, Spelling); 1411 cast<InheritableAttr>(New)->setInherited(isInherited); 1412 New->setImplicit(isImplicit); 1413 break; 1414 } 1415 case attr::ObjCIndependentClass: { 1416 bool isInherited = Record.readInt(); 1417 bool isImplicit = Record.readInt(); 1418 unsigned Spelling = Record.readInt(); 1419 New = new (Context) ObjCIndependentClassAttr(Range, Context, Spelling); 1420 cast<InheritableAttr>(New)->setInherited(isInherited); 1421 New->setImplicit(isImplicit); 1422 break; 1423 } 1424 case attr::ObjCMethodFamily: { 1425 bool isInherited = Record.readInt(); 1426 bool isImplicit = Record.readInt(); 1427 unsigned Spelling = Record.readInt(); 1428 ObjCMethodFamilyAttr::FamilyKind family(static_cast<ObjCMethodFamilyAttr::FamilyKind>(Record.readInt())); 1429 New = new (Context) ObjCMethodFamilyAttr(Range, Context, family, Spelling); 1430 cast<InheritableAttr>(New)->setInherited(isInherited); 1431 New->setImplicit(isImplicit); 1432 break; 1433 } 1434 case attr::ObjCNSObject: { 1435 bool isInherited = Record.readInt(); 1436 bool isImplicit = Record.readInt(); 1437 unsigned Spelling = Record.readInt(); 1438 New = new (Context) ObjCNSObjectAttr(Range, Context, Spelling); 1439 cast<InheritableAttr>(New)->setInherited(isInherited); 1440 New->setImplicit(isImplicit); 1441 break; 1442 } 1443 case attr::ObjCPreciseLifetime: { 1444 bool isInherited = Record.readInt(); 1445 bool isImplicit = Record.readInt(); 1446 unsigned Spelling = Record.readInt(); 1447 New = new (Context) ObjCPreciseLifetimeAttr(Range, Context, Spelling); 1448 cast<InheritableAttr>(New)->setInherited(isInherited); 1449 New->setImplicit(isImplicit); 1450 break; 1451 } 1452 case attr::ObjCRequiresPropertyDefs: { 1453 bool isInherited = Record.readInt(); 1454 bool isImplicit = Record.readInt(); 1455 unsigned Spelling = Record.readInt(); 1456 New = new (Context) ObjCRequiresPropertyDefsAttr(Range, Context, Spelling); 1457 cast<InheritableAttr>(New)->setInherited(isInherited); 1458 New->setImplicit(isImplicit); 1459 break; 1460 } 1461 case attr::ObjCRequiresSuper: { 1462 bool isInherited = Record.readInt(); 1463 bool isImplicit = Record.readInt(); 1464 unsigned Spelling = Record.readInt(); 1465 New = new (Context) ObjCRequiresSuperAttr(Range, Context, Spelling); 1466 cast<InheritableAttr>(New)->setInherited(isInherited); 1467 New->setImplicit(isImplicit); 1468 break; 1469 } 1470 case attr::ObjCReturnsInnerPointer: { 1471 bool isInherited = Record.readInt(); 1472 bool isImplicit = Record.readInt(); 1473 unsigned Spelling = Record.readInt(); 1474 New = new (Context) ObjCReturnsInnerPointerAttr(Range, Context, Spelling); 1475 cast<InheritableAttr>(New)->setInherited(isInherited); 1476 New->setImplicit(isImplicit); 1477 break; 1478 } 1479 case attr::ObjCRootClass: { 1480 bool isInherited = Record.readInt(); 1481 bool isImplicit = Record.readInt(); 1482 unsigned Spelling = Record.readInt(); 1483 New = new (Context) ObjCRootClassAttr(Range, Context, Spelling); 1484 cast<InheritableAttr>(New)->setInherited(isInherited); 1485 New->setImplicit(isImplicit); 1486 break; 1487 } 1488 case attr::ObjCRuntimeName: { 1489 bool isImplicit = Record.readInt(); 1490 unsigned Spelling = Record.readInt(); 1491 std::string metadataName= Record.readString(); 1492 New = new (Context) ObjCRuntimeNameAttr(Range, Context, metadataName, Spelling); 1493 New->setImplicit(isImplicit); 1494 break; 1495 } 1496 case attr::ObjCRuntimeVisible: { 1497 bool isImplicit = Record.readInt(); 1498 unsigned Spelling = Record.readInt(); 1499 New = new (Context) ObjCRuntimeVisibleAttr(Range, Context, Spelling); 1500 New->setImplicit(isImplicit); 1501 break; 1502 } 1503 case attr::ObjCSubclassingRestricted: { 1504 bool isInherited = Record.readInt(); 1505 bool isImplicit = Record.readInt(); 1506 unsigned Spelling = Record.readInt(); 1507 New = new (Context) ObjCSubclassingRestrictedAttr(Range, Context, Spelling); 1508 cast<InheritableAttr>(New)->setInherited(isInherited); 1509 New->setImplicit(isImplicit); 1510 break; 1511 } 1512 case attr::OpenCLAccess: { 1513 bool isImplicit = Record.readInt(); 1514 unsigned Spelling = Record.readInt(); 1515 New = new (Context) OpenCLAccessAttr(Range, Context, Spelling); 1516 New->setImplicit(isImplicit); 1517 break; 1518 } 1519 case attr::OpenCLIntelReqdSubGroupSize: { 1520 bool isInherited = Record.readInt(); 1521 bool isImplicit = Record.readInt(); 1522 unsigned Spelling = Record.readInt(); 1523 unsigned subGroupSize = Record.readInt(); 1524 New = new (Context) OpenCLIntelReqdSubGroupSizeAttr(Range, Context, subGroupSize, Spelling); 1525 cast<InheritableAttr>(New)->setInherited(isInherited); 1526 New->setImplicit(isImplicit); 1527 break; 1528 } 1529 case attr::OpenCLKernel: { 1530 bool isInherited = Record.readInt(); 1531 bool isImplicit = Record.readInt(); 1532 unsigned Spelling = Record.readInt(); 1533 New = new (Context) OpenCLKernelAttr(Range, Context, Spelling); 1534 cast<InheritableAttr>(New)->setInherited(isInherited); 1535 New->setImplicit(isImplicit); 1536 break; 1537 } 1538 case attr::OpenCLUnrollHint: { 1539 bool isInherited = Record.readInt(); 1540 bool isImplicit = Record.readInt(); 1541 unsigned Spelling = Record.readInt(); 1542 unsigned unrollHint = Record.readInt(); 1543 New = new (Context) OpenCLUnrollHintAttr(Range, Context, unrollHint, Spelling); 1544 cast<InheritableAttr>(New)->setInherited(isInherited); 1545 New->setImplicit(isImplicit); 1546 break; 1547 } 1548 case attr::OptimizeNone: { 1549 bool isInherited = Record.readInt(); 1550 bool isImplicit = Record.readInt(); 1551 unsigned Spelling = Record.readInt(); 1552 New = new (Context) OptimizeNoneAttr(Range, Context, Spelling); 1553 cast<InheritableAttr>(New)->setInherited(isInherited); 1554 New->setImplicit(isImplicit); 1555 break; 1556 } 1557 case attr::Overloadable: { 1558 bool isImplicit = Record.readInt(); 1559 unsigned Spelling = Record.readInt(); 1560 New = new (Context) OverloadableAttr(Range, Context, Spelling); 1561 New->setImplicit(isImplicit); 1562 break; 1563 } 1564 case attr::Override: { 1565 bool isInherited = Record.readInt(); 1566 bool isImplicit = Record.readInt(); 1567 unsigned Spelling = Record.readInt(); 1568 New = new (Context) OverrideAttr(Range, Context, Spelling); 1569 cast<InheritableAttr>(New)->setInherited(isInherited); 1570 New->setImplicit(isImplicit); 1571 break; 1572 } 1573 case attr::Ownership: { 1574 bool isInherited = Record.readInt(); 1575 bool isImplicit = Record.readInt(); 1576 unsigned Spelling = Record.readInt(); 1577 IdentifierInfo * module = Record.getIdentifierInfo(); 1578 unsigned argsSize = Record.readInt(); 1579 SmallVector<unsigned, 4> args; 1580 args.reserve(argsSize); 1581 for (unsigned i = 0; i != argsSize; ++i) 1582 args.push_back(Record.readInt()); 1583 New = new (Context) OwnershipAttr(Range, Context, module, args.data(), argsSize, Spelling); 1584 cast<InheritableAttr>(New)->setInherited(isInherited); 1585 New->setImplicit(isImplicit); 1586 break; 1587 } 1588 case attr::Packed: { 1589 bool isInherited = Record.readInt(); 1590 bool isImplicit = Record.readInt(); 1591 unsigned Spelling = Record.readInt(); 1592 New = new (Context) PackedAttr(Range, Context, Spelling); 1593 cast<InheritableAttr>(New)->setInherited(isInherited); 1594 New->setImplicit(isImplicit); 1595 break; 1596 } 1597 case attr::ParamTypestate: { 1598 bool isInherited = Record.readInt(); 1599 bool isImplicit = Record.readInt(); 1600 unsigned Spelling = Record.readInt(); 1601 ParamTypestateAttr::ConsumedState paramState(static_cast<ParamTypestateAttr::ConsumedState>(Record.readInt())); 1602 New = new (Context) ParamTypestateAttr(Range, Context, paramState, Spelling); 1603 cast<InheritableAttr>(New)->setInherited(isInherited); 1604 New->setImplicit(isImplicit); 1605 break; 1606 } 1607 case attr::Pascal: { 1608 bool isInherited = Record.readInt(); 1609 bool isImplicit = Record.readInt(); 1610 unsigned Spelling = Record.readInt(); 1611 New = new (Context) PascalAttr(Range, Context, Spelling); 1612 cast<InheritableAttr>(New)->setInherited(isInherited); 1613 New->setImplicit(isImplicit); 1614 break; 1615 } 1616 case attr::PassObjectSize: { 1617 bool isInherited = Record.readInt(); 1618 bool isImplicit = Record.readInt(); 1619 unsigned Spelling = Record.readInt(); 1620 int type = Record.readInt(); 1621 New = new (Context) PassObjectSizeAttr(Range, Context, type, Spelling); 1622 cast<InheritableAttr>(New)->setInherited(isInherited); 1623 New->setImplicit(isImplicit); 1624 break; 1625 } 1626 case attr::Pcs: { 1627 bool isInherited = Record.readInt(); 1628 bool isImplicit = Record.readInt(); 1629 unsigned Spelling = Record.readInt(); 1630 PcsAttr::PCSType pCS(static_cast<PcsAttr::PCSType>(Record.readInt())); 1631 New = new (Context) PcsAttr(Range, Context, pCS, Spelling); 1632 cast<InheritableAttr>(New)->setInherited(isInherited); 1633 New->setImplicit(isImplicit); 1634 break; 1635 } 1636 case attr::PragmaClangBSSSection: { 1637 bool isInherited = Record.readInt(); 1638 bool isImplicit = Record.readInt(); 1639 unsigned Spelling = Record.readInt(); 1640 std::string name= Record.readString(); 1641 New = new (Context) PragmaClangBSSSectionAttr(Range, Context, name, Spelling); 1642 cast<InheritableAttr>(New)->setInherited(isInherited); 1643 New->setImplicit(isImplicit); 1644 break; 1645 } 1646 case attr::PragmaClangDataSection: { 1647 bool isInherited = Record.readInt(); 1648 bool isImplicit = Record.readInt(); 1649 unsigned Spelling = Record.readInt(); 1650 std::string name= Record.readString(); 1651 New = new (Context) PragmaClangDataSectionAttr(Range, Context, name, Spelling); 1652 cast<InheritableAttr>(New)->setInherited(isInherited); 1653 New->setImplicit(isImplicit); 1654 break; 1655 } 1656 case attr::PragmaClangRodataSection: { 1657 bool isInherited = Record.readInt(); 1658 bool isImplicit = Record.readInt(); 1659 unsigned Spelling = Record.readInt(); 1660 std::string name= Record.readString(); 1661 New = new (Context) PragmaClangRodataSectionAttr(Range, Context, name, Spelling); 1662 cast<InheritableAttr>(New)->setInherited(isInherited); 1663 New->setImplicit(isImplicit); 1664 break; 1665 } 1666 case attr::PragmaClangTextSection: { 1667 bool isInherited = Record.readInt(); 1668 bool isImplicit = Record.readInt(); 1669 unsigned Spelling = Record.readInt(); 1670 std::string name= Record.readString(); 1671 New = new (Context) PragmaClangTextSectionAttr(Range, Context, name, Spelling); 1672 cast<InheritableAttr>(New)->setInherited(isInherited); 1673 New->setImplicit(isImplicit); 1674 break; 1675 } 1676 case attr::PreserveAll: { 1677 bool isInherited = Record.readInt(); 1678 bool isImplicit = Record.readInt(); 1679 unsigned Spelling = Record.readInt(); 1680 New = new (Context) PreserveAllAttr(Range, Context, Spelling); 1681 cast<InheritableAttr>(New)->setInherited(isInherited); 1682 New->setImplicit(isImplicit); 1683 break; 1684 } 1685 case attr::PreserveMost: { 1686 bool isInherited = Record.readInt(); 1687 bool isImplicit = Record.readInt(); 1688 unsigned Spelling = Record.readInt(); 1689 New = new (Context) PreserveMostAttr(Range, Context, Spelling); 1690 cast<InheritableAttr>(New)->setInherited(isInherited); 1691 New->setImplicit(isImplicit); 1692 break; 1693 } 1694 case attr::PtGuardedBy: { 1695 bool isInherited = Record.readInt(); 1696 bool isImplicit = Record.readInt(); 1697 unsigned Spelling = Record.readInt(); 1698 Expr * arg = Record.readExpr(); 1699 New = new (Context) PtGuardedByAttr(Range, Context, arg, Spelling); 1700 cast<InheritableAttr>(New)->setInherited(isInherited); 1701 New->setImplicit(isImplicit); 1702 break; 1703 } 1704 case attr::PtGuardedVar: { 1705 bool isInherited = Record.readInt(); 1706 bool isImplicit = Record.readInt(); 1707 unsigned Spelling = Record.readInt(); 1708 New = new (Context) PtGuardedVarAttr(Range, Context, Spelling); 1709 cast<InheritableAttr>(New)->setInherited(isInherited); 1710 New->setImplicit(isImplicit); 1711 break; 1712 } 1713 case attr::Pure: { 1714 bool isInherited = Record.readInt(); 1715 bool isImplicit = Record.readInt(); 1716 unsigned Spelling = Record.readInt(); 1717 New = new (Context) PureAttr(Range, Context, Spelling); 1718 cast<InheritableAttr>(New)->setInherited(isInherited); 1719 New->setImplicit(isImplicit); 1720 break; 1721 } 1722 case attr::RegCall: { 1723 bool isInherited = Record.readInt(); 1724 bool isImplicit = Record.readInt(); 1725 unsigned Spelling = Record.readInt(); 1726 New = new (Context) RegCallAttr(Range, Context, Spelling); 1727 cast<InheritableAttr>(New)->setInherited(isInherited); 1728 New->setImplicit(isImplicit); 1729 break; 1730 } 1731 case attr::ReleaseCapability: { 1732 bool isInherited = Record.readInt(); 1733 bool isImplicit = Record.readInt(); 1734 unsigned Spelling = Record.readInt(); 1735 unsigned argsSize = Record.readInt(); 1736 SmallVector<Expr *, 4> args; 1737 args.reserve(argsSize); 1738 for (unsigned i = 0; i != argsSize; ++i) 1739 args.push_back(Record.readExpr()); 1740 New = new (Context) ReleaseCapabilityAttr(Range, Context, args.data(), argsSize, Spelling); 1741 cast<InheritableAttr>(New)->setInherited(isInherited); 1742 New->setImplicit(isImplicit); 1743 break; 1744 } 1745 case attr::RenderScriptKernel: { 1746 bool isImplicit = Record.readInt(); 1747 unsigned Spelling = Record.readInt(); 1748 New = new (Context) RenderScriptKernelAttr(Range, Context, Spelling); 1749 New->setImplicit(isImplicit); 1750 break; 1751 } 1752 case attr::ReqdWorkGroupSize: { 1753 bool isInherited = Record.readInt(); 1754 bool isImplicit = Record.readInt(); 1755 unsigned Spelling = Record.readInt(); 1756 unsigned xDim = Record.readInt(); 1757 unsigned yDim = Record.readInt(); 1758 unsigned zDim = Record.readInt(); 1759 New = new (Context) ReqdWorkGroupSizeAttr(Range, Context, xDim, yDim, zDim, Spelling); 1760 cast<InheritableAttr>(New)->setInherited(isInherited); 1761 New->setImplicit(isImplicit); 1762 break; 1763 } 1764 case attr::RequireConstantInit: { 1765 bool isInherited = Record.readInt(); 1766 bool isImplicit = Record.readInt(); 1767 unsigned Spelling = Record.readInt(); 1768 New = new (Context) RequireConstantInitAttr(Range, Context, Spelling); 1769 cast<InheritableAttr>(New)->setInherited(isInherited); 1770 New->setImplicit(isImplicit); 1771 break; 1772 } 1773 case attr::RequiresCapability: { 1774 bool isInherited = Record.readInt(); 1775 bool isImplicit = Record.readInt(); 1776 unsigned Spelling = Record.readInt(); 1777 unsigned argsSize = Record.readInt(); 1778 SmallVector<Expr *, 4> args; 1779 args.reserve(argsSize); 1780 for (unsigned i = 0; i != argsSize; ++i) 1781 args.push_back(Record.readExpr()); 1782 New = new (Context) RequiresCapabilityAttr(Range, Context, args.data(), argsSize, Spelling); 1783 cast<InheritableAttr>(New)->setInherited(isInherited); 1784 New->setImplicit(isImplicit); 1785 break; 1786 } 1787 case attr::Restrict: { 1788 bool isInherited = Record.readInt(); 1789 bool isImplicit = Record.readInt(); 1790 unsigned Spelling = Record.readInt(); 1791 New = new (Context) RestrictAttr(Range, Context, Spelling); 1792 cast<InheritableAttr>(New)->setInherited(isInherited); 1793 New->setImplicit(isImplicit); 1794 break; 1795 } 1796 case attr::ReturnTypestate: { 1797 bool isInherited = Record.readInt(); 1798 bool isImplicit = Record.readInt(); 1799 unsigned Spelling = Record.readInt(); 1800 ReturnTypestateAttr::ConsumedState state(static_cast<ReturnTypestateAttr::ConsumedState>(Record.readInt())); 1801 New = new (Context) ReturnTypestateAttr(Range, Context, state, Spelling); 1802 cast<InheritableAttr>(New)->setInherited(isInherited); 1803 New->setImplicit(isImplicit); 1804 break; 1805 } 1806 case attr::ReturnsNonNull: { 1807 bool isInherited = Record.readInt(); 1808 bool isImplicit = Record.readInt(); 1809 unsigned Spelling = Record.readInt(); 1810 New = new (Context) ReturnsNonNullAttr(Range, Context, Spelling); 1811 cast<InheritableAttr>(New)->setInherited(isInherited); 1812 New->setImplicit(isImplicit); 1813 break; 1814 } 1815 case attr::ReturnsTwice: { 1816 bool isInherited = Record.readInt(); 1817 bool isImplicit = Record.readInt(); 1818 unsigned Spelling = Record.readInt(); 1819 New = new (Context) ReturnsTwiceAttr(Range, Context, Spelling); 1820 cast<InheritableAttr>(New)->setInherited(isInherited); 1821 New->setImplicit(isImplicit); 1822 break; 1823 } 1824 case attr::ScopedLockable: { 1825 bool isInherited = Record.readInt(); 1826 bool isImplicit = Record.readInt(); 1827 unsigned Spelling = Record.readInt(); 1828 New = new (Context) ScopedLockableAttr(Range, Context, Spelling); 1829 cast<InheritableAttr>(New)->setInherited(isInherited); 1830 New->setImplicit(isImplicit); 1831 break; 1832 } 1833 case attr::Section: { 1834 bool isInherited = Record.readInt(); 1835 bool isImplicit = Record.readInt(); 1836 unsigned Spelling = Record.readInt(); 1837 std::string name= Record.readString(); 1838 New = new (Context) SectionAttr(Range, Context, name, Spelling); 1839 cast<InheritableAttr>(New)->setInherited(isInherited); 1840 New->setImplicit(isImplicit); 1841 break; 1842 } 1843 case attr::SelectAny: { 1844 bool isInherited = Record.readInt(); 1845 bool isImplicit = Record.readInt(); 1846 unsigned Spelling = Record.readInt(); 1847 New = new (Context) SelectAnyAttr(Range, Context, Spelling); 1848 cast<InheritableAttr>(New)->setInherited(isInherited); 1849 New->setImplicit(isImplicit); 1850 break; 1851 } 1852 case attr::Sentinel: { 1853 bool isInherited = Record.readInt(); 1854 bool isImplicit = Record.readInt(); 1855 unsigned Spelling = Record.readInt(); 1856 int sentinel = Record.readInt(); 1857 int nullPos = Record.readInt(); 1858 New = new (Context) SentinelAttr(Range, Context, sentinel, nullPos, Spelling); 1859 cast<InheritableAttr>(New)->setInherited(isInherited); 1860 New->setImplicit(isImplicit); 1861 break; 1862 } 1863 case attr::SetTypestate: { 1864 bool isInherited = Record.readInt(); 1865 bool isImplicit = Record.readInt(); 1866 unsigned Spelling = Record.readInt(); 1867 SetTypestateAttr::ConsumedState newState(static_cast<SetTypestateAttr::ConsumedState>(Record.readInt())); 1868 New = new (Context) SetTypestateAttr(Range, Context, newState, Spelling); 1869 cast<InheritableAttr>(New)->setInherited(isInherited); 1870 New->setImplicit(isImplicit); 1871 break; 1872 } 1873 case attr::SharedTrylockFunction: { 1874 bool isInherited = Record.readInt(); 1875 bool isImplicit = Record.readInt(); 1876 unsigned Spelling = Record.readInt(); 1877 Expr * successValue = Record.readExpr(); 1878 unsigned argsSize = Record.readInt(); 1879 SmallVector<Expr *, 4> args; 1880 args.reserve(argsSize); 1881 for (unsigned i = 0; i != argsSize; ++i) 1882 args.push_back(Record.readExpr()); 1883 New = new (Context) SharedTrylockFunctionAttr(Range, Context, successValue, args.data(), argsSize, Spelling); 1884 cast<InheritableAttr>(New)->setInherited(isInherited); 1885 New->setImplicit(isImplicit); 1886 break; 1887 } 1888 case attr::StdCall: { 1889 bool isInherited = Record.readInt(); 1890 bool isImplicit = Record.readInt(); 1891 unsigned Spelling = Record.readInt(); 1892 New = new (Context) StdCallAttr(Range, Context, Spelling); 1893 cast<InheritableAttr>(New)->setInherited(isInherited); 1894 New->setImplicit(isImplicit); 1895 break; 1896 } 1897 case attr::Suppress: { 1898 bool isImplicit = Record.readInt(); 1899 unsigned Spelling = Record.readInt(); 1900 unsigned diagnosticIdentifiersSize = Record.readInt(); 1901 SmallVector<StringRef, 4> diagnosticIdentifiers; 1902 diagnosticIdentifiers.reserve(diagnosticIdentifiersSize); 1903 SmallVector<std::string, 4> diagnosticIdentifiersStorage; 1904 diagnosticIdentifiersStorage.reserve(diagnosticIdentifiersSize); 1905 for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i) 1906 diagnosticIdentifiersStorage.push_back(Record.readString()); 1907 for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i) 1908 diagnosticIdentifiers.push_back(diagnosticIdentifiersStorage[i]); 1909 New = new (Context) SuppressAttr(Range, Context, diagnosticIdentifiers.data(), diagnosticIdentifiersSize, Spelling); 1910 New->setImplicit(isImplicit); 1911 break; 1912 } 1913 case attr::SwiftCall: { 1914 bool isInherited = Record.readInt(); 1915 bool isImplicit = Record.readInt(); 1916 unsigned Spelling = Record.readInt(); 1917 New = new (Context) SwiftCallAttr(Range, Context, Spelling); 1918 cast<InheritableAttr>(New)->setInherited(isInherited); 1919 New->setImplicit(isImplicit); 1920 break; 1921 } 1922 case attr::SwiftContext: { 1923 bool isInherited = Record.readInt(); 1924 bool isImplicit = Record.readInt(); 1925 unsigned Spelling = Record.readInt(); 1926 New = new (Context) SwiftContextAttr(Range, Context, Spelling); 1927 cast<InheritableAttr>(New)->setInherited(isInherited); 1928 New->setImplicit(isImplicit); 1929 break; 1930 } 1931 case attr::SwiftErrorResult: { 1932 bool isInherited = Record.readInt(); 1933 bool isImplicit = Record.readInt(); 1934 unsigned Spelling = Record.readInt(); 1935 New = new (Context) SwiftErrorResultAttr(Range, Context, Spelling); 1936 cast<InheritableAttr>(New)->setInherited(isInherited); 1937 New->setImplicit(isImplicit); 1938 break; 1939 } 1940 case attr::SwiftIndirectResult: { 1941 bool isInherited = Record.readInt(); 1942 bool isImplicit = Record.readInt(); 1943 unsigned Spelling = Record.readInt(); 1944 New = new (Context) SwiftIndirectResultAttr(Range, Context, Spelling); 1945 cast<InheritableAttr>(New)->setInherited(isInherited); 1946 New->setImplicit(isImplicit); 1947 break; 1948 } 1949 case attr::SysVABI: { 1950 bool isInherited = Record.readInt(); 1951 bool isImplicit = Record.readInt(); 1952 unsigned Spelling = Record.readInt(); 1953 New = new (Context) SysVABIAttr(Range, Context, Spelling); 1954 cast<InheritableAttr>(New)->setInherited(isInherited); 1955 New->setImplicit(isImplicit); 1956 break; 1957 } 1958 case attr::TLSModel: { 1959 bool isInherited = Record.readInt(); 1960 bool isImplicit = Record.readInt(); 1961 unsigned Spelling = Record.readInt(); 1962 std::string model= Record.readString(); 1963 New = new (Context) TLSModelAttr(Range, Context, model, Spelling); 1964 cast<InheritableAttr>(New)->setInherited(isInherited); 1965 New->setImplicit(isImplicit); 1966 break; 1967 } 1968 case attr::Target: { 1969 bool isInherited = Record.readInt(); 1970 bool isImplicit = Record.readInt(); 1971 unsigned Spelling = Record.readInt(); 1972 std::string featuresStr= Record.readString(); 1973 New = new (Context) TargetAttr(Range, Context, featuresStr, Spelling); 1974 cast<InheritableAttr>(New)->setInherited(isInherited); 1975 New->setImplicit(isImplicit); 1976 break; 1977 } 1978 case attr::TestTypestate: { 1979 bool isInherited = Record.readInt(); 1980 bool isImplicit = Record.readInt(); 1981 unsigned Spelling = Record.readInt(); 1982 TestTypestateAttr::ConsumedState testState(static_cast<TestTypestateAttr::ConsumedState>(Record.readInt())); 1983 New = new (Context) TestTypestateAttr(Range, Context, testState, Spelling); 1984 cast<InheritableAttr>(New)->setInherited(isInherited); 1985 New->setImplicit(isImplicit); 1986 break; 1987 } 1988 case attr::ThisCall: { 1989 bool isInherited = Record.readInt(); 1990 bool isImplicit = Record.readInt(); 1991 unsigned Spelling = Record.readInt(); 1992 New = new (Context) ThisCallAttr(Range, Context, Spelling); 1993 cast<InheritableAttr>(New)->setInherited(isInherited); 1994 New->setImplicit(isImplicit); 1995 break; 1996 } 1997 case attr::Thread: { 1998 bool isImplicit = Record.readInt(); 1999 unsigned Spelling = Record.readInt(); 2000 New = new (Context) ThreadAttr(Range, Context, Spelling); 2001 New->setImplicit(isImplicit); 2002 break; 2003 } 2004 case attr::TransparentUnion: { 2005 bool isInherited = Record.readInt(); 2006 bool isImplicit = Record.readInt(); 2007 unsigned Spelling = Record.readInt(); 2008 New = new (Context) TransparentUnionAttr(Range, Context, Spelling); 2009 cast<InheritableAttr>(New)->setInherited(isInherited); 2010 New->setImplicit(isImplicit); 2011 break; 2012 } 2013 case attr::TryAcquireCapability: { 2014 bool isInherited = Record.readInt(); 2015 bool isImplicit = Record.readInt(); 2016 unsigned Spelling = Record.readInt(); 2017 Expr * successValue = Record.readExpr(); 2018 unsigned argsSize = Record.readInt(); 2019 SmallVector<Expr *, 4> args; 2020 args.reserve(argsSize); 2021 for (unsigned i = 0; i != argsSize; ++i) 2022 args.push_back(Record.readExpr()); 2023 New = new (Context) TryAcquireCapabilityAttr(Range, Context, successValue, args.data(), argsSize, Spelling); 2024 cast<InheritableAttr>(New)->setInherited(isInherited); 2025 New->setImplicit(isImplicit); 2026 break; 2027 } 2028 case attr::TypeTagForDatatype: { 2029 bool isInherited = Record.readInt(); 2030 bool isImplicit = Record.readInt(); 2031 unsigned Spelling = Record.readInt(); 2032 IdentifierInfo * argumentKind = Record.getIdentifierInfo(); 2033 TypeSourceInfo * matchingCType = Record.getTypeSourceInfo(); 2034 bool layoutCompatible = Record.readInt(); 2035 bool mustBeNull = Record.readInt(); 2036 New = new (Context) TypeTagForDatatypeAttr(Range, Context, argumentKind, matchingCType, layoutCompatible, mustBeNull, Spelling); 2037 cast<InheritableAttr>(New)->setInherited(isInherited); 2038 New->setImplicit(isImplicit); 2039 break; 2040 } 2041 case attr::TypeVisibility: { 2042 bool isInherited = Record.readInt(); 2043 bool isImplicit = Record.readInt(); 2044 unsigned Spelling = Record.readInt(); 2045 TypeVisibilityAttr::VisibilityType visibility(static_cast<TypeVisibilityAttr::VisibilityType>(Record.readInt())); 2046 New = new (Context) TypeVisibilityAttr(Range, Context, visibility, Spelling); 2047 cast<InheritableAttr>(New)->setInherited(isInherited); 2048 New->setImplicit(isImplicit); 2049 break; 2050 } 2051 case attr::Unavailable: { 2052 bool isInherited = Record.readInt(); 2053 bool isImplicit = Record.readInt(); 2054 unsigned Spelling = Record.readInt(); 2055 std::string message= Record.readString(); 2056 UnavailableAttr::ImplicitReason implicitReason(static_cast<UnavailableAttr::ImplicitReason>(Record.readInt())); 2057 New = new (Context) UnavailableAttr(Range, Context, message, implicitReason, Spelling); 2058 cast<InheritableAttr>(New)->setInherited(isInherited); 2059 New->setImplicit(isImplicit); 2060 break; 2061 } 2062 case attr::Unused: { 2063 bool isInherited = Record.readInt(); 2064 bool isImplicit = Record.readInt(); 2065 unsigned Spelling = Record.readInt(); 2066 New = new (Context) UnusedAttr(Range, Context, Spelling); 2067 cast<InheritableAttr>(New)->setInherited(isInherited); 2068 New->setImplicit(isImplicit); 2069 break; 2070 } 2071 case attr::Used: { 2072 bool isInherited = Record.readInt(); 2073 bool isImplicit = Record.readInt(); 2074 unsigned Spelling = Record.readInt(); 2075 New = new (Context) UsedAttr(Range, Context, Spelling); 2076 cast<InheritableAttr>(New)->setInherited(isInherited); 2077 New->setImplicit(isImplicit); 2078 break; 2079 } 2080 case attr::Uuid: { 2081 bool isInherited = Record.readInt(); 2082 bool isImplicit = Record.readInt(); 2083 unsigned Spelling = Record.readInt(); 2084 std::string guid= Record.readString(); 2085 New = new (Context) UuidAttr(Range, Context, guid, Spelling); 2086 cast<InheritableAttr>(New)->setInherited(isInherited); 2087 New->setImplicit(isImplicit); 2088 break; 2089 } 2090 case attr::VecReturn: { 2091 bool isInherited = Record.readInt(); 2092 bool isImplicit = Record.readInt(); 2093 unsigned Spelling = Record.readInt(); 2094 New = new (Context) VecReturnAttr(Range, Context, Spelling); 2095 cast<InheritableAttr>(New)->setInherited(isInherited); 2096 New->setImplicit(isImplicit); 2097 break; 2098 } 2099 case attr::VecTypeHint: { 2100 bool isInherited = Record.readInt(); 2101 bool isImplicit = Record.readInt(); 2102 unsigned Spelling = Record.readInt(); 2103 TypeSourceInfo * typeHint = Record.getTypeSourceInfo(); 2104 New = new (Context) VecTypeHintAttr(Range, Context, typeHint, Spelling); 2105 cast<InheritableAttr>(New)->setInherited(isInherited); 2106 New->setImplicit(isImplicit); 2107 break; 2108 } 2109 case attr::VectorCall: { 2110 bool isInherited = Record.readInt(); 2111 bool isImplicit = Record.readInt(); 2112 unsigned Spelling = Record.readInt(); 2113 New = new (Context) VectorCallAttr(Range, Context, Spelling); 2114 cast<InheritableAttr>(New)->setInherited(isInherited); 2115 New->setImplicit(isImplicit); 2116 break; 2117 } 2118 case attr::Visibility: { 2119 bool isInherited = Record.readInt(); 2120 bool isImplicit = Record.readInt(); 2121 unsigned Spelling = Record.readInt(); 2122 VisibilityAttr::VisibilityType visibility(static_cast<VisibilityAttr::VisibilityType>(Record.readInt())); 2123 New = new (Context) VisibilityAttr(Range, Context, visibility, Spelling); 2124 cast<InheritableAttr>(New)->setInherited(isInherited); 2125 New->setImplicit(isImplicit); 2126 break; 2127 } 2128 case attr::WarnUnused: { 2129 bool isInherited = Record.readInt(); 2130 bool isImplicit = Record.readInt(); 2131 unsigned Spelling = Record.readInt(); 2132 New = new (Context) WarnUnusedAttr(Range, Context, Spelling); 2133 cast<InheritableAttr>(New)->setInherited(isInherited); 2134 New->setImplicit(isImplicit); 2135 break; 2136 } 2137 case attr::WarnUnusedResult: { 2138 bool isInherited = Record.readInt(); 2139 bool isImplicit = Record.readInt(); 2140 unsigned Spelling = Record.readInt(); 2141 New = new (Context) WarnUnusedResultAttr(Range, Context, Spelling); 2142 cast<InheritableAttr>(New)->setInherited(isInherited); 2143 New->setImplicit(isImplicit); 2144 break; 2145 } 2146 case attr::Weak: { 2147 bool isInherited = Record.readInt(); 2148 bool isImplicit = Record.readInt(); 2149 unsigned Spelling = Record.readInt(); 2150 New = new (Context) WeakAttr(Range, Context, Spelling); 2151 cast<InheritableAttr>(New)->setInherited(isInherited); 2152 New->setImplicit(isImplicit); 2153 break; 2154 } 2155 case attr::WeakImport: { 2156 bool isInherited = Record.readInt(); 2157 bool isImplicit = Record.readInt(); 2158 unsigned Spelling = Record.readInt(); 2159 New = new (Context) WeakImportAttr(Range, Context, Spelling); 2160 cast<InheritableAttr>(New)->setInherited(isInherited); 2161 New->setImplicit(isImplicit); 2162 break; 2163 } 2164 case attr::WeakRef: { 2165 bool isInherited = Record.readInt(); 2166 bool isImplicit = Record.readInt(); 2167 unsigned Spelling = Record.readInt(); 2168 std::string aliasee= Record.readString(); 2169 New = new (Context) WeakRefAttr(Range, Context, aliasee, Spelling); 2170 cast<InheritableAttr>(New)->setInherited(isInherited); 2171 New->setImplicit(isImplicit); 2172 break; 2173 } 2174 case attr::WorkGroupSizeHint: { 2175 bool isInherited = Record.readInt(); 2176 bool isImplicit = Record.readInt(); 2177 unsigned Spelling = Record.readInt(); 2178 unsigned xDim = Record.readInt(); 2179 unsigned yDim = Record.readInt(); 2180 unsigned zDim = Record.readInt(); 2181 New = new (Context) WorkGroupSizeHintAttr(Range, Context, xDim, yDim, zDim, Spelling); 2182 cast<InheritableAttr>(New)->setInherited(isInherited); 2183 New->setImplicit(isImplicit); 2184 break; 2185 } 2186 case attr::X86ForceAlignArgPointer: { 2187 bool isInherited = Record.readInt(); 2188 bool isImplicit = Record.readInt(); 2189 unsigned Spelling = Record.readInt(); 2190 New = new (Context) X86ForceAlignArgPointerAttr(Range, Context, Spelling); 2191 cast<InheritableAttr>(New)->setInherited(isInherited); 2192 New->setImplicit(isImplicit); 2193 break; 2194 } 2195 case attr::XRayInstrument: { 2196 bool isInherited = Record.readInt(); 2197 bool isImplicit = Record.readInt(); 2198 unsigned Spelling = Record.readInt(); 2199 New = new (Context) XRayInstrumentAttr(Range, Context, Spelling); 2200 cast<InheritableAttr>(New)->setInherited(isInherited); 2201 New->setImplicit(isImplicit); 2202 break; 2203 } 2204 case attr::XRayLogArgs: { 2205 bool isInherited = Record.readInt(); 2206 bool isImplicit = Record.readInt(); 2207 unsigned Spelling = Record.readInt(); 2208 unsigned argumentCount = Record.readInt(); 2209 New = new (Context) XRayLogArgsAttr(Range, Context, argumentCount, Spelling); 2210 cast<InheritableAttr>(New)->setInherited(isInherited); 2211 New->setImplicit(isImplicit); 2212 break; 2213 } 2214 } 2215