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