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