1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ 2|* *| 3|* Attribute classes' definitions *| 4|* *| 5|* Automatically generated file, do not edit! *| 6|* *| 7\*===----------------------------------------------------------------------===*/ 8 9#ifndef LLVM_CLANG_ATTR_CLASSES_INC 10#define LLVM_CLANG_ATTR_CLASSES_INC 11 12class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr { 13unsigned min; 14 15unsigned max; 16 17public: 18 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) { 19 auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0); 20 A->setImplicit(true); 21 return A; 22 } 23 24 AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx 25 , unsigned Min 26 , unsigned Max 27 , unsigned SI 28 ) 29 : InheritableAttr(attr::AMDGPUFlatWorkGroupSize, R, SI, false, false) 30 , min(Min) 31 , max(Max) 32 { 33 } 34 35 AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const; 36 void printPretty(raw_ostream &OS, 37 const PrintingPolicy &Policy) const; 38 const char *getSpelling() const; 39 unsigned getMin() const { 40 return min; 41 } 42 43 unsigned getMax() const { 44 return max; 45 } 46 47 48 49 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; } 50}; 51 52class AMDGPUNumSGPRAttr : public InheritableAttr { 53unsigned numSGPR; 54 55public: 56 static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) { 57 auto *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0); 58 A->setImplicit(true); 59 return A; 60 } 61 62 AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx 63 , unsigned NumSGPR 64 , unsigned SI 65 ) 66 : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, false, false) 67 , numSGPR(NumSGPR) 68 { 69 } 70 71 AMDGPUNumSGPRAttr *clone(ASTContext &C) const; 72 void printPretty(raw_ostream &OS, 73 const PrintingPolicy &Policy) const; 74 const char *getSpelling() const; 75 unsigned getNumSGPR() const { 76 return numSGPR; 77 } 78 79 80 81 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; } 82}; 83 84class AMDGPUNumVGPRAttr : public InheritableAttr { 85unsigned numVGPR; 86 87public: 88 static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) { 89 auto *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0); 90 A->setImplicit(true); 91 return A; 92 } 93 94 AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx 95 , unsigned NumVGPR 96 , unsigned SI 97 ) 98 : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, false, false) 99 , numVGPR(NumVGPR) 100 { 101 } 102 103 AMDGPUNumVGPRAttr *clone(ASTContext &C) const; 104 void printPretty(raw_ostream &OS, 105 const PrintingPolicy &Policy) const; 106 const char *getSpelling() const; 107 unsigned getNumVGPR() const { 108 return numVGPR; 109 } 110 111 112 113 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; } 114}; 115 116class AMDGPUWavesPerEUAttr : public InheritableAttr { 117unsigned min; 118 119unsigned max; 120 121public: 122 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) { 123 auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0); 124 A->setImplicit(true); 125 return A; 126 } 127 128 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx 129 , unsigned Min 130 , unsigned Max 131 , unsigned SI 132 ) 133 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false) 134 , min(Min) 135 , max(Max) 136 { 137 } 138 139 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx 140 , unsigned Min 141 , unsigned SI 142 ) 143 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false) 144 , min(Min) 145 , max() 146 { 147 } 148 149 AMDGPUWavesPerEUAttr *clone(ASTContext &C) const; 150 void printPretty(raw_ostream &OS, 151 const PrintingPolicy &Policy) const; 152 const char *getSpelling() const; 153 unsigned getMin() const { 154 return min; 155 } 156 157 unsigned getMax() const { 158 return max; 159 } 160 161 162 163 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; } 164}; 165 166class ARMInterruptAttr : public InheritableAttr { 167public: 168 enum InterruptType { 169 IRQ, 170 FIQ, 171 SWI, 172 ABORT, 173 UNDEF, 174 Generic 175 }; 176private: 177 InterruptType interrupt; 178 179public: 180 static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) { 181 auto *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0); 182 A->setImplicit(true); 183 return A; 184 } 185 186 ARMInterruptAttr(SourceRange R, ASTContext &Ctx 187 , InterruptType Interrupt 188 , unsigned SI 189 ) 190 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false) 191 , interrupt(Interrupt) 192 { 193 } 194 195 ARMInterruptAttr(SourceRange R, ASTContext &Ctx 196 , unsigned SI 197 ) 198 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false) 199 , interrupt(InterruptType(0)) 200 { 201 } 202 203 ARMInterruptAttr *clone(ASTContext &C) const; 204 void printPretty(raw_ostream &OS, 205 const PrintingPolicy &Policy) const; 206 const char *getSpelling() const; 207 InterruptType getInterrupt() const { 208 return interrupt; 209 } 210 211 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) { 212 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val) 213 .Case("IRQ", ARMInterruptAttr::IRQ) 214 .Case("FIQ", ARMInterruptAttr::FIQ) 215 .Case("SWI", ARMInterruptAttr::SWI) 216 .Case("ABORT", ARMInterruptAttr::ABORT) 217 .Case("UNDEF", ARMInterruptAttr::UNDEF) 218 .Case("", ARMInterruptAttr::Generic) 219 .Default(Optional<InterruptType>()); 220 if (R) { 221 Out = *R; 222 return true; 223 } 224 return false; 225 } 226 227 static const char *ConvertInterruptTypeToStr(InterruptType Val) { 228 switch(Val) { 229 case ARMInterruptAttr::IRQ: return "IRQ"; 230 case ARMInterruptAttr::FIQ: return "FIQ"; 231 case ARMInterruptAttr::SWI: return "SWI"; 232 case ARMInterruptAttr::ABORT: return "ABORT"; 233 case ARMInterruptAttr::UNDEF: return "UNDEF"; 234 case ARMInterruptAttr::Generic: return ""; 235 } 236 llvm_unreachable("No enumerator with that value"); 237 } 238 239 240 static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; } 241}; 242 243class AVRInterruptAttr : public InheritableAttr { 244public: 245 static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 246 auto *A = new (Ctx) AVRInterruptAttr(Loc, Ctx, 0); 247 A->setImplicit(true); 248 return A; 249 } 250 251 AVRInterruptAttr(SourceRange R, ASTContext &Ctx 252 , unsigned SI 253 ) 254 : InheritableAttr(attr::AVRInterrupt, R, SI, false, false) 255 { 256 } 257 258 AVRInterruptAttr *clone(ASTContext &C) const; 259 void printPretty(raw_ostream &OS, 260 const PrintingPolicy &Policy) const; 261 const char *getSpelling() const; 262 263 264 static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; } 265}; 266 267class AVRSignalAttr : public InheritableAttr { 268public: 269 static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 270 auto *A = new (Ctx) AVRSignalAttr(Loc, Ctx, 0); 271 A->setImplicit(true); 272 return A; 273 } 274 275 AVRSignalAttr(SourceRange R, ASTContext &Ctx 276 , unsigned SI 277 ) 278 : InheritableAttr(attr::AVRSignal, R, SI, false, false) 279 { 280 } 281 282 AVRSignalAttr *clone(ASTContext &C) const; 283 void printPretty(raw_ostream &OS, 284 const PrintingPolicy &Policy) const; 285 const char *getSpelling() const; 286 287 288 static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; } 289}; 290 291class AbiTagAttr : public Attr { 292 unsigned tags_Size; 293 StringRef *tags_; 294 295public: 296 static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Loc = SourceRange()) { 297 auto *A = new (Ctx) AbiTagAttr(Loc, Ctx, Tags, TagsSize, 0); 298 A->setImplicit(true); 299 return A; 300 } 301 302 AbiTagAttr(SourceRange R, ASTContext &Ctx 303 , StringRef *Tags, unsigned TagsSize 304 , unsigned SI 305 ) 306 : Attr(attr::AbiTag, R, SI, false, false) 307 , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size]) 308 { 309 for (size_t I = 0, E = tags_Size; I != E; 310 ++I) { 311 StringRef Ref = Tags[I]; 312 if (!Ref.empty()) { 313 char *Mem = new (Ctx, 1) char[Ref.size()]; 314 std::memcpy(Mem, Ref.data(), Ref.size()); 315 tags_[I] = StringRef(Mem, Ref.size()); 316 } 317 } 318 } 319 320 AbiTagAttr(SourceRange R, ASTContext &Ctx 321 , unsigned SI 322 ) 323 : Attr(attr::AbiTag, R, SI, false, false) 324 , tags_Size(0), tags_(nullptr) 325 { 326 } 327 328 AbiTagAttr *clone(ASTContext &C) const; 329 void printPretty(raw_ostream &OS, 330 const PrintingPolicy &Policy) const; 331 const char *getSpelling() const; 332 typedef StringRef* tags_iterator; 333 tags_iterator tags_begin() const { return tags_; } 334 tags_iterator tags_end() const { return tags_ + tags_Size; } 335 unsigned tags_size() const { return tags_Size; } 336 llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); } 337 338 339 340 341 static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; } 342}; 343 344class AcquireCapabilityAttr : public InheritableAttr { 345 unsigned args_Size; 346 Expr * *args_; 347 348public: 349 enum Spelling { 350 GNU_acquire_capability = 0, 351 CXX11_clang_acquire_capability = 1, 352 GNU_acquire_shared_capability = 2, 353 CXX11_clang_acquire_shared_capability = 3, 354 GNU_exclusive_lock_function = 4, 355 GNU_shared_lock_function = 5 356 }; 357 358 static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 359 auto *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S); 360 A->setImplicit(true); 361 return A; 362 } 363 364 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx 365 , Expr * *Args, unsigned ArgsSize 366 , unsigned SI 367 ) 368 : InheritableAttr(attr::AcquireCapability, R, SI, true, true) 369 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 370 { 371 std::copy(Args, Args + args_Size, args_); 372 } 373 374 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx 375 , unsigned SI 376 ) 377 : InheritableAttr(attr::AcquireCapability, R, SI, true, true) 378 , args_Size(0), args_(nullptr) 379 { 380 } 381 382 AcquireCapabilityAttr *clone(ASTContext &C) const; 383 void printPretty(raw_ostream &OS, 384 const PrintingPolicy &Policy) const; 385 const char *getSpelling() const; 386 Spelling getSemanticSpelling() const { 387 switch (SpellingListIndex) { 388 default: llvm_unreachable("Unknown spelling list index"); 389 case 0: return GNU_acquire_capability; 390 case 1: return CXX11_clang_acquire_capability; 391 case 2: return GNU_acquire_shared_capability; 392 case 3: return CXX11_clang_acquire_shared_capability; 393 case 4: return GNU_exclusive_lock_function; 394 case 5: return GNU_shared_lock_function; 395 } 396 } 397 bool isShared() const { return SpellingListIndex == 2 || 398 SpellingListIndex == 3 || 399 SpellingListIndex == 5; } 400 typedef Expr ** args_iterator; 401 args_iterator args_begin() const { return args_; } 402 args_iterator args_end() const { return args_ + args_Size; } 403 unsigned args_size() const { return args_Size; } 404 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 405 406 407 408 409 static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; } 410}; 411 412class AcquiredAfterAttr : public InheritableAttr { 413 unsigned args_Size; 414 Expr * *args_; 415 416public: 417 static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 418 auto *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0); 419 A->setImplicit(true); 420 return A; 421 } 422 423 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx 424 , Expr * *Args, unsigned ArgsSize 425 , unsigned SI 426 ) 427 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true) 428 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 429 { 430 std::copy(Args, Args + args_Size, args_); 431 } 432 433 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx 434 , unsigned SI 435 ) 436 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true) 437 , args_Size(0), args_(nullptr) 438 { 439 } 440 441 AcquiredAfterAttr *clone(ASTContext &C) const; 442 void printPretty(raw_ostream &OS, 443 const PrintingPolicy &Policy) const; 444 const char *getSpelling() const; 445 typedef Expr ** args_iterator; 446 args_iterator args_begin() const { return args_; } 447 args_iterator args_end() const { return args_ + args_Size; } 448 unsigned args_size() const { return args_Size; } 449 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 450 451 452 453 454 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; } 455}; 456 457class AcquiredBeforeAttr : public InheritableAttr { 458 unsigned args_Size; 459 Expr * *args_; 460 461public: 462 static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 463 auto *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0); 464 A->setImplicit(true); 465 return A; 466 } 467 468 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx 469 , Expr * *Args, unsigned ArgsSize 470 , unsigned SI 471 ) 472 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true) 473 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 474 { 475 std::copy(Args, Args + args_Size, args_); 476 } 477 478 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx 479 , unsigned SI 480 ) 481 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true) 482 , args_Size(0), args_(nullptr) 483 { 484 } 485 486 AcquiredBeforeAttr *clone(ASTContext &C) const; 487 void printPretty(raw_ostream &OS, 488 const PrintingPolicy &Policy) const; 489 const char *getSpelling() const; 490 typedef Expr ** args_iterator; 491 args_iterator args_begin() const { return args_; } 492 args_iterator args_end() const { return args_ + args_Size; } 493 unsigned args_size() const { return args_Size; } 494 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 495 496 497 498 499 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; } 500}; 501 502class AliasAttr : public Attr { 503unsigned aliaseeLength; 504char *aliasee; 505 506public: 507 static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) { 508 auto *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0); 509 A->setImplicit(true); 510 return A; 511 } 512 513 AliasAttr(SourceRange R, ASTContext &Ctx 514 , llvm::StringRef Aliasee 515 , unsigned SI 516 ) 517 : Attr(attr::Alias, R, SI, false, false) 518 , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength]) 519 { 520 if (!Aliasee.empty()) 521 std::memcpy(aliasee, Aliasee.data(), aliaseeLength); 522 } 523 524 AliasAttr *clone(ASTContext &C) const; 525 void printPretty(raw_ostream &OS, 526 const PrintingPolicy &Policy) const; 527 const char *getSpelling() const; 528 llvm::StringRef getAliasee() const { 529 return llvm::StringRef(aliasee, aliaseeLength); 530 } 531 unsigned getAliaseeLength() const { 532 return aliaseeLength; 533 } 534 void setAliasee(ASTContext &C, llvm::StringRef S) { 535 aliaseeLength = S.size(); 536 this->aliasee = new (C, 1) char [aliaseeLength]; 537 if (!S.empty()) 538 std::memcpy(this->aliasee, S.data(), aliaseeLength); 539 } 540 541 542 543 static bool classof(const Attr *A) { return A->getKind() == attr::Alias; } 544}; 545 546class AlignMac68kAttr : public InheritableAttr { 547public: 548 static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 549 auto *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0); 550 A->setImplicit(true); 551 return A; 552 } 553 554 AlignMac68kAttr(SourceRange R, ASTContext &Ctx 555 , unsigned SI 556 ) 557 : InheritableAttr(attr::AlignMac68k, R, SI, false, false) 558 { 559 } 560 561 AlignMac68kAttr *clone(ASTContext &C) const; 562 void printPretty(raw_ostream &OS, 563 const PrintingPolicy &Policy) const; 564 const char *getSpelling() const; 565 566 567 static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; } 568}; 569 570class AlignValueAttr : public Attr { 571Expr * alignment; 572 573public: 574 static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) { 575 auto *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0); 576 A->setImplicit(true); 577 return A; 578 } 579 580 AlignValueAttr(SourceRange R, ASTContext &Ctx 581 , Expr * Alignment 582 , unsigned SI 583 ) 584 : Attr(attr::AlignValue, R, SI, false, false) 585 , alignment(Alignment) 586 { 587 } 588 589 AlignValueAttr *clone(ASTContext &C) const; 590 void printPretty(raw_ostream &OS, 591 const PrintingPolicy &Policy) const; 592 const char *getSpelling() const; 593 Expr * getAlignment() const { 594 return alignment; 595 } 596 597 598 599 static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; } 600}; 601 602class AlignedAttr : public InheritableAttr { 603bool isalignmentExpr; 604union { 605Expr *alignmentExpr; 606TypeSourceInfo *alignmentType; 607}; 608 609public: 610 enum Spelling { 611 GNU_aligned = 0, 612 CXX11_gnu_aligned = 1, 613 Declspec_align = 2, 614 Keyword_alignas = 3, 615 Keyword_Alignas = 4 616 }; 617 618 static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) { 619 auto *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S); 620 A->setImplicit(true); 621 return A; 622 } 623 624 AlignedAttr(SourceRange R, ASTContext &Ctx 625 , bool IsAlignmentExpr, void *Alignment 626 , unsigned SI 627 ) 628 : InheritableAttr(attr::Aligned, R, SI, false, false) 629 , isalignmentExpr(IsAlignmentExpr) 630 { 631 if (isalignmentExpr) 632 alignmentExpr = reinterpret_cast<Expr *>(Alignment); 633 else 634 alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment); 635 } 636 637 AlignedAttr(SourceRange R, ASTContext &Ctx 638 , unsigned SI 639 ) 640 : InheritableAttr(attr::Aligned, R, SI, false, false) 641 , isalignmentExpr(false) 642 { 643 } 644 645 AlignedAttr *clone(ASTContext &C) const; 646 void printPretty(raw_ostream &OS, 647 const PrintingPolicy &Policy) const; 648 const char *getSpelling() const; 649 Spelling getSemanticSpelling() const { 650 switch (SpellingListIndex) { 651 default: llvm_unreachable("Unknown spelling list index"); 652 case 0: return GNU_aligned; 653 case 1: return CXX11_gnu_aligned; 654 case 2: return Declspec_align; 655 case 3: return Keyword_alignas; 656 case 4: return Keyword_Alignas; 657 } 658 } 659 bool isGNU() const { return SpellingListIndex == 0 || 660 SpellingListIndex == 1; } 661 bool isC11() const { return SpellingListIndex == 4; } 662 bool isAlignas() const { return SpellingListIndex == 3 || 663 SpellingListIndex == 4; } 664 bool isDeclspec() const { return SpellingListIndex == 2; } 665 bool isAlignmentDependent() const; 666 unsigned getAlignment(ASTContext &Ctx) const; 667 bool isAlignmentExpr() const { 668 return isalignmentExpr; 669 } 670 Expr *getAlignmentExpr() const { 671 assert(isalignmentExpr); 672 return alignmentExpr; 673 } 674 TypeSourceInfo *getAlignmentType() const { 675 assert(!isalignmentExpr); 676 return alignmentType; 677 } 678 679 680 681 static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; } 682}; 683 684class AllocAlignAttr : public InheritableAttr { 685int paramIndex; 686 687public: 688 static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, int ParamIndex, SourceRange Loc = SourceRange()) { 689 auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0); 690 A->setImplicit(true); 691 return A; 692 } 693 694 AllocAlignAttr(SourceRange R, ASTContext &Ctx 695 , int ParamIndex 696 , unsigned SI 697 ) 698 : InheritableAttr(attr::AllocAlign, R, SI, false, false) 699 , paramIndex(ParamIndex) 700 { 701 } 702 703 AllocAlignAttr *clone(ASTContext &C) const; 704 void printPretty(raw_ostream &OS, 705 const PrintingPolicy &Policy) const; 706 const char *getSpelling() const; 707 int getParamIndex() const { 708 return paramIndex; 709 } 710 711 712 713 static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; } 714}; 715 716class AllocSizeAttr : public InheritableAttr { 717int elemSizeParam; 718 719int numElemsParam; 720 721public: 722 static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, int ElemSizeParam, int NumElemsParam, SourceRange Loc = SourceRange()) { 723 auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0); 724 A->setImplicit(true); 725 return A; 726 } 727 728 AllocSizeAttr(SourceRange R, ASTContext &Ctx 729 , int ElemSizeParam 730 , int NumElemsParam 731 , unsigned SI 732 ) 733 : InheritableAttr(attr::AllocSize, R, SI, false, false) 734 , elemSizeParam(ElemSizeParam) 735 , numElemsParam(NumElemsParam) 736 { 737 } 738 739 AllocSizeAttr(SourceRange R, ASTContext &Ctx 740 , int ElemSizeParam 741 , unsigned SI 742 ) 743 : InheritableAttr(attr::AllocSize, R, SI, false, false) 744 , elemSizeParam(ElemSizeParam) 745 , numElemsParam() 746 { 747 } 748 749 AllocSizeAttr *clone(ASTContext &C) const; 750 void printPretty(raw_ostream &OS, 751 const PrintingPolicy &Policy) const; 752 const char *getSpelling() const; 753 int getElemSizeParam() const { 754 return elemSizeParam; 755 } 756 757 int getNumElemsParam() const { 758 return numElemsParam; 759 } 760 761 762 763 static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; } 764}; 765 766class AlwaysInlineAttr : public InheritableAttr { 767public: 768 enum Spelling { 769 GNU_always_inline = 0, 770 CXX11_gnu_always_inline = 1, 771 Keyword_forceinline = 2 772 }; 773 774 static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 775 auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S); 776 A->setImplicit(true); 777 return A; 778 } 779 780 AlwaysInlineAttr(SourceRange R, ASTContext &Ctx 781 , unsigned SI 782 ) 783 : InheritableAttr(attr::AlwaysInline, R, SI, false, false) 784 { 785 } 786 787 AlwaysInlineAttr *clone(ASTContext &C) const; 788 void printPretty(raw_ostream &OS, 789 const PrintingPolicy &Policy) const; 790 const char *getSpelling() const; 791 Spelling getSemanticSpelling() const { 792 switch (SpellingListIndex) { 793 default: llvm_unreachable("Unknown spelling list index"); 794 case 0: return GNU_always_inline; 795 case 1: return CXX11_gnu_always_inline; 796 case 2: return Keyword_forceinline; 797 } 798 } 799 800 801 static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; } 802}; 803 804class AnalyzerNoReturnAttr : public InheritableAttr { 805public: 806 static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 807 auto *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0); 808 A->setImplicit(true); 809 return A; 810 } 811 812 AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx 813 , unsigned SI 814 ) 815 : InheritableAttr(attr::AnalyzerNoReturn, R, SI, false, false) 816 { 817 } 818 819 AnalyzerNoReturnAttr *clone(ASTContext &C) const; 820 void printPretty(raw_ostream &OS, 821 const PrintingPolicy &Policy) const; 822 const char *getSpelling() const; 823 824 825 static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; } 826}; 827 828class AnnotateAttr : public InheritableParamAttr { 829unsigned annotationLength; 830char *annotation; 831 832public: 833 static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) { 834 auto *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0); 835 A->setImplicit(true); 836 return A; 837 } 838 839 AnnotateAttr(SourceRange R, ASTContext &Ctx 840 , llvm::StringRef Annotation 841 , unsigned SI 842 ) 843 : InheritableParamAttr(attr::Annotate, R, SI, false, false) 844 , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength]) 845 { 846 if (!Annotation.empty()) 847 std::memcpy(annotation, Annotation.data(), annotationLength); 848 } 849 850 AnnotateAttr *clone(ASTContext &C) const; 851 void printPretty(raw_ostream &OS, 852 const PrintingPolicy &Policy) const; 853 const char *getSpelling() const; 854 llvm::StringRef getAnnotation() const { 855 return llvm::StringRef(annotation, annotationLength); 856 } 857 unsigned getAnnotationLength() const { 858 return annotationLength; 859 } 860 void setAnnotation(ASTContext &C, llvm::StringRef S) { 861 annotationLength = S.size(); 862 this->annotation = new (C, 1) char [annotationLength]; 863 if (!S.empty()) 864 std::memcpy(this->annotation, S.data(), annotationLength); 865 } 866 867 868 869 static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; } 870}; 871 872class AnyX86InterruptAttr : public InheritableAttr { 873public: 874 static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 875 auto *A = new (Ctx) AnyX86InterruptAttr(Loc, Ctx, 0); 876 A->setImplicit(true); 877 return A; 878 } 879 880 AnyX86InterruptAttr(SourceRange R, ASTContext &Ctx 881 , unsigned SI 882 ) 883 : InheritableAttr(attr::AnyX86Interrupt, R, SI, false, false) 884 { 885 } 886 887 AnyX86InterruptAttr *clone(ASTContext &C) const; 888 void printPretty(raw_ostream &OS, 889 const PrintingPolicy &Policy) const; 890 const char *getSpelling() const; 891 892 893 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; } 894}; 895 896class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr { 897public: 898 static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 899 auto *A = new (Ctx) AnyX86NoCallerSavedRegistersAttr(Loc, Ctx, 0); 900 A->setImplicit(true); 901 return A; 902 } 903 904 AnyX86NoCallerSavedRegistersAttr(SourceRange R, ASTContext &Ctx 905 , unsigned SI 906 ) 907 : InheritableAttr(attr::AnyX86NoCallerSavedRegisters, R, SI, false, false) 908 { 909 } 910 911 AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const; 912 void printPretty(raw_ostream &OS, 913 const PrintingPolicy &Policy) const; 914 const char *getSpelling() const; 915 916 917 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; } 918}; 919 920class ArcWeakrefUnavailableAttr : public InheritableAttr { 921public: 922 static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 923 auto *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0); 924 A->setImplicit(true); 925 return A; 926 } 927 928 ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx 929 , unsigned SI 930 ) 931 : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, false, false) 932 { 933 } 934 935 ArcWeakrefUnavailableAttr *clone(ASTContext &C) const; 936 void printPretty(raw_ostream &OS, 937 const PrintingPolicy &Policy) const; 938 const char *getSpelling() const; 939 940 941 static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; } 942}; 943 944class ArgumentWithTypeTagAttr : public InheritableAttr { 945IdentifierInfo * argumentKind; 946 947unsigned argumentIdx; 948 949unsigned typeTagIdx; 950 951bool isPointer; 952 953public: 954 enum Spelling { 955 GNU_argument_with_type_tag = 0, 956 GNU_pointer_with_type_tag = 1 957 }; 958 959 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, unsigned ArgumentIdx, unsigned TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) { 960 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S); 961 A->setImplicit(true); 962 return A; 963 } 964 965 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx 966 , IdentifierInfo * ArgumentKind 967 , unsigned ArgumentIdx 968 , unsigned TypeTagIdx 969 , bool IsPointer 970 , unsigned SI 971 ) 972 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false) 973 , argumentKind(ArgumentKind) 974 , argumentIdx(ArgumentIdx) 975 , typeTagIdx(TypeTagIdx) 976 , isPointer(IsPointer) 977 { 978 } 979 980 ArgumentWithTypeTagAttr *clone(ASTContext &C) const; 981 void printPretty(raw_ostream &OS, 982 const PrintingPolicy &Policy) const; 983 const char *getSpelling() const; 984 Spelling getSemanticSpelling() const { 985 switch (SpellingListIndex) { 986 default: llvm_unreachable("Unknown spelling list index"); 987 case 0: return GNU_argument_with_type_tag; 988 case 1: return GNU_pointer_with_type_tag; 989 } 990 } 991 IdentifierInfo * getArgumentKind() const { 992 return argumentKind; 993 } 994 995 unsigned getArgumentIdx() const { 996 return argumentIdx; 997 } 998 999 unsigned getTypeTagIdx() const { 1000 return typeTagIdx; 1001 } 1002 1003 bool getIsPointer() const { 1004 return isPointer; 1005 } 1006 1007 1008 1009 static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; } 1010}; 1011 1012class AsmLabelAttr : public InheritableAttr { 1013unsigned labelLength; 1014char *label; 1015 1016public: 1017 static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) { 1018 auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0); 1019 A->setImplicit(true); 1020 return A; 1021 } 1022 1023 AsmLabelAttr(SourceRange R, ASTContext &Ctx 1024 , llvm::StringRef Label 1025 , unsigned SI 1026 ) 1027 : InheritableAttr(attr::AsmLabel, R, SI, false, false) 1028 , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength]) 1029 { 1030 if (!Label.empty()) 1031 std::memcpy(label, Label.data(), labelLength); 1032 } 1033 1034 AsmLabelAttr *clone(ASTContext &C) const; 1035 void printPretty(raw_ostream &OS, 1036 const PrintingPolicy &Policy) const; 1037 const char *getSpelling() const; 1038 llvm::StringRef getLabel() const { 1039 return llvm::StringRef(label, labelLength); 1040 } 1041 unsigned getLabelLength() const { 1042 return labelLength; 1043 } 1044 void setLabel(ASTContext &C, llvm::StringRef S) { 1045 labelLength = S.size(); 1046 this->label = new (C, 1) char [labelLength]; 1047 if (!S.empty()) 1048 std::memcpy(this->label, S.data(), labelLength); 1049 } 1050 1051 1052 1053 static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; } 1054}; 1055 1056class AssertCapabilityAttr : public InheritableAttr { 1057 unsigned args_Size; 1058 Expr * *args_; 1059 1060public: 1061 enum Spelling { 1062 GNU_assert_capability = 0, 1063 CXX11_clang_assert_capability = 1, 1064 GNU_assert_shared_capability = 2, 1065 CXX11_clang_assert_shared_capability = 3 1066 }; 1067 1068 static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 1069 auto *A = new (Ctx) AssertCapabilityAttr(Loc, Ctx, Args, ArgsSize, S); 1070 A->setImplicit(true); 1071 return A; 1072 } 1073 1074 AssertCapabilityAttr(SourceRange R, ASTContext &Ctx 1075 , Expr * *Args, unsigned ArgsSize 1076 , unsigned SI 1077 ) 1078 : InheritableAttr(attr::AssertCapability, R, SI, true, true) 1079 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 1080 { 1081 std::copy(Args, Args + args_Size, args_); 1082 } 1083 1084 AssertCapabilityAttr(SourceRange R, ASTContext &Ctx 1085 , unsigned SI 1086 ) 1087 : InheritableAttr(attr::AssertCapability, R, SI, true, true) 1088 , args_Size(0), args_(nullptr) 1089 { 1090 } 1091 1092 AssertCapabilityAttr *clone(ASTContext &C) const; 1093 void printPretty(raw_ostream &OS, 1094 const PrintingPolicy &Policy) const; 1095 const char *getSpelling() const; 1096 Spelling getSemanticSpelling() const { 1097 switch (SpellingListIndex) { 1098 default: llvm_unreachable("Unknown spelling list index"); 1099 case 0: return GNU_assert_capability; 1100 case 1: return CXX11_clang_assert_capability; 1101 case 2: return GNU_assert_shared_capability; 1102 case 3: return CXX11_clang_assert_shared_capability; 1103 } 1104 } 1105 bool isShared() const { return SpellingListIndex == 2 || 1106 SpellingListIndex == 3; } 1107 typedef Expr ** args_iterator; 1108 args_iterator args_begin() const { return args_; } 1109 args_iterator args_end() const { return args_ + args_Size; } 1110 unsigned args_size() const { return args_Size; } 1111 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 1112 1113 1114 1115 1116 static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; } 1117}; 1118 1119class AssertExclusiveLockAttr : public InheritableAttr { 1120 unsigned args_Size; 1121 Expr * *args_; 1122 1123public: 1124 static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 1125 auto *A = new (Ctx) AssertExclusiveLockAttr(Loc, Ctx, Args, ArgsSize, 0); 1126 A->setImplicit(true); 1127 return A; 1128 } 1129 1130 AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx 1131 , Expr * *Args, unsigned ArgsSize 1132 , unsigned SI 1133 ) 1134 : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true) 1135 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 1136 { 1137 std::copy(Args, Args + args_Size, args_); 1138 } 1139 1140 AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx 1141 , unsigned SI 1142 ) 1143 : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true) 1144 , args_Size(0), args_(nullptr) 1145 { 1146 } 1147 1148 AssertExclusiveLockAttr *clone(ASTContext &C) const; 1149 void printPretty(raw_ostream &OS, 1150 const PrintingPolicy &Policy) const; 1151 const char *getSpelling() const; 1152 typedef Expr ** args_iterator; 1153 args_iterator args_begin() const { return args_; } 1154 args_iterator args_end() const { return args_ + args_Size; } 1155 unsigned args_size() const { return args_Size; } 1156 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 1157 1158 1159 1160 1161 static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; } 1162}; 1163 1164class AssertSharedLockAttr : public InheritableAttr { 1165 unsigned args_Size; 1166 Expr * *args_; 1167 1168public: 1169 static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 1170 auto *A = new (Ctx) AssertSharedLockAttr(Loc, Ctx, Args, ArgsSize, 0); 1171 A->setImplicit(true); 1172 return A; 1173 } 1174 1175 AssertSharedLockAttr(SourceRange R, ASTContext &Ctx 1176 , Expr * *Args, unsigned ArgsSize 1177 , unsigned SI 1178 ) 1179 : InheritableAttr(attr::AssertSharedLock, R, SI, true, true) 1180 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 1181 { 1182 std::copy(Args, Args + args_Size, args_); 1183 } 1184 1185 AssertSharedLockAttr(SourceRange R, ASTContext &Ctx 1186 , unsigned SI 1187 ) 1188 : InheritableAttr(attr::AssertSharedLock, R, SI, true, true) 1189 , args_Size(0), args_(nullptr) 1190 { 1191 } 1192 1193 AssertSharedLockAttr *clone(ASTContext &C) const; 1194 void printPretty(raw_ostream &OS, 1195 const PrintingPolicy &Policy) const; 1196 const char *getSpelling() const; 1197 typedef Expr ** args_iterator; 1198 args_iterator args_begin() const { return args_; } 1199 args_iterator args_end() const { return args_ + args_Size; } 1200 unsigned args_size() const { return args_Size; } 1201 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 1202 1203 1204 1205 1206 static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; } 1207}; 1208 1209class AssumeAlignedAttr : public InheritableAttr { 1210Expr * alignment; 1211 1212Expr * offset; 1213 1214public: 1215 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Loc = SourceRange()) { 1216 auto *A = new (Ctx) AssumeAlignedAttr(Loc, Ctx, Alignment, Offset, 0); 1217 A->setImplicit(true); 1218 return A; 1219 } 1220 1221 AssumeAlignedAttr(SourceRange R, ASTContext &Ctx 1222 , Expr * Alignment 1223 , Expr * Offset 1224 , unsigned SI 1225 ) 1226 : InheritableAttr(attr::AssumeAligned, R, SI, false, false) 1227 , alignment(Alignment) 1228 , offset(Offset) 1229 { 1230 } 1231 1232 AssumeAlignedAttr(SourceRange R, ASTContext &Ctx 1233 , Expr * Alignment 1234 , unsigned SI 1235 ) 1236 : InheritableAttr(attr::AssumeAligned, R, SI, false, false) 1237 , alignment(Alignment) 1238 , offset() 1239 { 1240 } 1241 1242 AssumeAlignedAttr *clone(ASTContext &C) const; 1243 void printPretty(raw_ostream &OS, 1244 const PrintingPolicy &Policy) const; 1245 const char *getSpelling() const; 1246 Expr * getAlignment() const { 1247 return alignment; 1248 } 1249 1250 Expr * getOffset() const { 1251 return offset; 1252 } 1253 1254 1255 1256 static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; } 1257}; 1258 1259class AvailabilityAttr : public InheritableAttr { 1260IdentifierInfo * platform; 1261 1262VersionTuple introduced; 1263 1264 1265VersionTuple deprecated; 1266 1267 1268VersionTuple obsoleted; 1269 1270 1271bool unavailable; 1272 1273unsigned messageLength; 1274char *message; 1275 1276bool strict; 1277 1278unsigned replacementLength; 1279char *replacement; 1280 1281public: 1282 static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) { 1283 auto *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, Strict, Replacement, 0); 1284 A->setImplicit(true); 1285 return A; 1286 } 1287 1288 AvailabilityAttr(SourceRange R, ASTContext &Ctx 1289 , IdentifierInfo * Platform 1290 , VersionTuple Introduced 1291 , VersionTuple Deprecated 1292 , VersionTuple Obsoleted 1293 , bool Unavailable 1294 , llvm::StringRef Message 1295 , bool Strict 1296 , llvm::StringRef Replacement 1297 , unsigned SI 1298 ) 1299 : InheritableAttr(attr::Availability, R, SI, false, true) 1300 , platform(Platform) 1301 , introduced(Introduced) 1302 , deprecated(Deprecated) 1303 , obsoleted(Obsoleted) 1304 , unavailable(Unavailable) 1305 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 1306 , strict(Strict) 1307 , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength]) 1308 { 1309 if (!Message.empty()) 1310 std::memcpy(message, Message.data(), messageLength); 1311 if (!Replacement.empty()) 1312 std::memcpy(replacement, Replacement.data(), replacementLength); 1313 } 1314 1315 AvailabilityAttr *clone(ASTContext &C) const; 1316 void printPretty(raw_ostream &OS, 1317 const PrintingPolicy &Policy) const; 1318 const char *getSpelling() const; 1319 IdentifierInfo * getPlatform() const { 1320 return platform; 1321 } 1322 1323 VersionTuple getIntroduced() const { 1324 return introduced; 1325 } 1326 void setIntroduced(ASTContext &C, VersionTuple V) { 1327 introduced = V; 1328 } 1329 1330 VersionTuple getDeprecated() const { 1331 return deprecated; 1332 } 1333 void setDeprecated(ASTContext &C, VersionTuple V) { 1334 deprecated = V; 1335 } 1336 1337 VersionTuple getObsoleted() const { 1338 return obsoleted; 1339 } 1340 void setObsoleted(ASTContext &C, VersionTuple V) { 1341 obsoleted = V; 1342 } 1343 1344 bool getUnavailable() const { 1345 return unavailable; 1346 } 1347 1348 llvm::StringRef getMessage() const { 1349 return llvm::StringRef(message, messageLength); 1350 } 1351 unsigned getMessageLength() const { 1352 return messageLength; 1353 } 1354 void setMessage(ASTContext &C, llvm::StringRef S) { 1355 messageLength = S.size(); 1356 this->message = new (C, 1) char [messageLength]; 1357 if (!S.empty()) 1358 std::memcpy(this->message, S.data(), messageLength); 1359 } 1360 1361 bool getStrict() const { 1362 return strict; 1363 } 1364 1365 llvm::StringRef getReplacement() const { 1366 return llvm::StringRef(replacement, replacementLength); 1367 } 1368 unsigned getReplacementLength() const { 1369 return replacementLength; 1370 } 1371 void setReplacement(ASTContext &C, llvm::StringRef S) { 1372 replacementLength = S.size(); 1373 this->replacement = new (C, 1) char [replacementLength]; 1374 if (!S.empty()) 1375 std::memcpy(this->replacement, S.data(), replacementLength); 1376 } 1377 1378static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) { 1379 return llvm::StringSwitch<llvm::StringRef>(Platform) 1380 .Case("android", "Android") 1381 .Case("ios", "iOS") 1382 .Case("macos", "macOS") 1383 .Case("tvos", "tvOS") 1384 .Case("watchos", "watchOS") 1385 .Case("ios_app_extension", "iOS (App Extension)") 1386 .Case("macos_app_extension", "macOS (App Extension)") 1387 .Case("tvos_app_extension", "tvOS (App Extension)") 1388 .Case("watchos_app_extension", "watchOS (App Extension)") 1389 .Default(llvm::StringRef()); 1390} 1391static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) { 1392 return llvm::StringSwitch<llvm::StringRef>(Platform) 1393 .Case("ios", "iOS") 1394 .Case("macos", "macOS") 1395 .Case("tvos", "tvOS") 1396 .Case("watchos", "watchOS") 1397 .Case("ios_app_extension", "iOSApplicationExtension") 1398 .Case("macos_app_extension", "macOSApplicationExtension") 1399 .Case("tvos_app_extension", "tvOSApplicationExtension") 1400 .Case("watchos_app_extension", "watchOSApplicationExtension") 1401 .Default(Platform); 1402} 1403static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) { 1404 return llvm::StringSwitch<llvm::StringRef>(Platform) 1405 .Case("iOS", "ios") 1406 .Case("macOS", "macos") 1407 .Case("tvOS", "tvos") 1408 .Case("watchOS", "watchos") 1409 .Case("iOSApplicationExtension", "ios_app_extension") 1410 .Case("macOSApplicationExtension", "macos_app_extension") 1411 .Case("tvOSApplicationExtension", "tvos_app_extension") 1412 .Case("watchOSApplicationExtension", "watchos_app_extension") 1413 .Default(Platform); 1414} 1415 1416 static bool classof(const Attr *A) { return A->getKind() == attr::Availability; } 1417}; 1418 1419class BlocksAttr : public InheritableAttr { 1420public: 1421 enum BlockType { 1422 ByRef 1423 }; 1424private: 1425 BlockType type; 1426 1427public: 1428 static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Loc = SourceRange()) { 1429 auto *A = new (Ctx) BlocksAttr(Loc, Ctx, Type, 0); 1430 A->setImplicit(true); 1431 return A; 1432 } 1433 1434 BlocksAttr(SourceRange R, ASTContext &Ctx 1435 , BlockType Type 1436 , unsigned SI 1437 ) 1438 : InheritableAttr(attr::Blocks, R, SI, false, false) 1439 , type(Type) 1440 { 1441 } 1442 1443 BlocksAttr *clone(ASTContext &C) const; 1444 void printPretty(raw_ostream &OS, 1445 const PrintingPolicy &Policy) const; 1446 const char *getSpelling() const; 1447 BlockType getType() const { 1448 return type; 1449 } 1450 1451 static bool ConvertStrToBlockType(StringRef Val, BlockType &Out) { 1452 Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val) 1453 .Case("byref", BlocksAttr::ByRef) 1454 .Default(Optional<BlockType>()); 1455 if (R) { 1456 Out = *R; 1457 return true; 1458 } 1459 return false; 1460 } 1461 1462 static const char *ConvertBlockTypeToStr(BlockType Val) { 1463 switch(Val) { 1464 case BlocksAttr::ByRef: return "byref"; 1465 } 1466 llvm_unreachable("No enumerator with that value"); 1467 } 1468 1469 1470 static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; } 1471}; 1472 1473class C11NoReturnAttr : public InheritableAttr { 1474public: 1475 static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1476 auto *A = new (Ctx) C11NoReturnAttr(Loc, Ctx, 0); 1477 A->setImplicit(true); 1478 return A; 1479 } 1480 1481 C11NoReturnAttr(SourceRange R, ASTContext &Ctx 1482 , unsigned SI 1483 ) 1484 : InheritableAttr(attr::C11NoReturn, R, SI, false, false) 1485 { 1486 } 1487 1488 C11NoReturnAttr *clone(ASTContext &C) const; 1489 void printPretty(raw_ostream &OS, 1490 const PrintingPolicy &Policy) const; 1491 const char *getSpelling() const; 1492 1493 1494 static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; } 1495}; 1496 1497class CDeclAttr : public InheritableAttr { 1498public: 1499 static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1500 auto *A = new (Ctx) CDeclAttr(Loc, Ctx, 0); 1501 A->setImplicit(true); 1502 return A; 1503 } 1504 1505 CDeclAttr(SourceRange R, ASTContext &Ctx 1506 , unsigned SI 1507 ) 1508 : InheritableAttr(attr::CDecl, R, SI, false, false) 1509 { 1510 } 1511 1512 CDeclAttr *clone(ASTContext &C) const; 1513 void printPretty(raw_ostream &OS, 1514 const PrintingPolicy &Policy) const; 1515 const char *getSpelling() const; 1516 1517 1518 static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; } 1519}; 1520 1521class CFAuditedTransferAttr : public InheritableAttr { 1522public: 1523 static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1524 auto *A = new (Ctx) CFAuditedTransferAttr(Loc, Ctx, 0); 1525 A->setImplicit(true); 1526 return A; 1527 } 1528 1529 CFAuditedTransferAttr(SourceRange R, ASTContext &Ctx 1530 , unsigned SI 1531 ) 1532 : InheritableAttr(attr::CFAuditedTransfer, R, SI, false, false) 1533 { 1534 } 1535 1536 CFAuditedTransferAttr *clone(ASTContext &C) const; 1537 void printPretty(raw_ostream &OS, 1538 const PrintingPolicy &Policy) const; 1539 const char *getSpelling() const; 1540 1541 1542 static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; } 1543}; 1544 1545class CFConsumedAttr : public InheritableParamAttr { 1546public: 1547 static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1548 auto *A = new (Ctx) CFConsumedAttr(Loc, Ctx, 0); 1549 A->setImplicit(true); 1550 return A; 1551 } 1552 1553 CFConsumedAttr(SourceRange R, ASTContext &Ctx 1554 , unsigned SI 1555 ) 1556 : InheritableParamAttr(attr::CFConsumed, R, SI, false, false) 1557 { 1558 } 1559 1560 CFConsumedAttr *clone(ASTContext &C) const; 1561 void printPretty(raw_ostream &OS, 1562 const PrintingPolicy &Policy) const; 1563 const char *getSpelling() const; 1564 1565 1566 static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; } 1567}; 1568 1569class CFReturnsNotRetainedAttr : public InheritableAttr { 1570public: 1571 static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1572 auto *A = new (Ctx) CFReturnsNotRetainedAttr(Loc, Ctx, 0); 1573 A->setImplicit(true); 1574 return A; 1575 } 1576 1577 CFReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx 1578 , unsigned SI 1579 ) 1580 : InheritableAttr(attr::CFReturnsNotRetained, R, SI, false, false) 1581 { 1582 } 1583 1584 CFReturnsNotRetainedAttr *clone(ASTContext &C) const; 1585 void printPretty(raw_ostream &OS, 1586 const PrintingPolicy &Policy) const; 1587 const char *getSpelling() const; 1588 1589 1590 static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; } 1591}; 1592 1593class CFReturnsRetainedAttr : public InheritableAttr { 1594public: 1595 static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1596 auto *A = new (Ctx) CFReturnsRetainedAttr(Loc, Ctx, 0); 1597 A->setImplicit(true); 1598 return A; 1599 } 1600 1601 CFReturnsRetainedAttr(SourceRange R, ASTContext &Ctx 1602 , unsigned SI 1603 ) 1604 : InheritableAttr(attr::CFReturnsRetained, R, SI, false, false) 1605 { 1606 } 1607 1608 CFReturnsRetainedAttr *clone(ASTContext &C) const; 1609 void printPretty(raw_ostream &OS, 1610 const PrintingPolicy &Policy) const; 1611 const char *getSpelling() const; 1612 1613 1614 static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; } 1615}; 1616 1617class CFUnknownTransferAttr : public InheritableAttr { 1618public: 1619 static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1620 auto *A = new (Ctx) CFUnknownTransferAttr(Loc, Ctx, 0); 1621 A->setImplicit(true); 1622 return A; 1623 } 1624 1625 CFUnknownTransferAttr(SourceRange R, ASTContext &Ctx 1626 , unsigned SI 1627 ) 1628 : InheritableAttr(attr::CFUnknownTransfer, R, SI, false, false) 1629 { 1630 } 1631 1632 CFUnknownTransferAttr *clone(ASTContext &C) const; 1633 void printPretty(raw_ostream &OS, 1634 const PrintingPolicy &Policy) const; 1635 const char *getSpelling() const; 1636 1637 1638 static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; } 1639}; 1640 1641class CUDAConstantAttr : public InheritableAttr { 1642public: 1643 static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1644 auto *A = new (Ctx) CUDAConstantAttr(Loc, Ctx, 0); 1645 A->setImplicit(true); 1646 return A; 1647 } 1648 1649 CUDAConstantAttr(SourceRange R, ASTContext &Ctx 1650 , unsigned SI 1651 ) 1652 : InheritableAttr(attr::CUDAConstant, R, SI, false, false) 1653 { 1654 } 1655 1656 CUDAConstantAttr *clone(ASTContext &C) const; 1657 void printPretty(raw_ostream &OS, 1658 const PrintingPolicy &Policy) const; 1659 const char *getSpelling() const; 1660 1661 1662 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; } 1663}; 1664 1665class CUDADeviceAttr : public InheritableAttr { 1666public: 1667 static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1668 auto *A = new (Ctx) CUDADeviceAttr(Loc, Ctx, 0); 1669 A->setImplicit(true); 1670 return A; 1671 } 1672 1673 CUDADeviceAttr(SourceRange R, ASTContext &Ctx 1674 , unsigned SI 1675 ) 1676 : InheritableAttr(attr::CUDADevice, R, SI, false, false) 1677 { 1678 } 1679 1680 CUDADeviceAttr *clone(ASTContext &C) const; 1681 void printPretty(raw_ostream &OS, 1682 const PrintingPolicy &Policy) const; 1683 const char *getSpelling() const; 1684 1685 1686 static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; } 1687}; 1688 1689class CUDAGlobalAttr : public InheritableAttr { 1690public: 1691 static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1692 auto *A = new (Ctx) CUDAGlobalAttr(Loc, Ctx, 0); 1693 A->setImplicit(true); 1694 return A; 1695 } 1696 1697 CUDAGlobalAttr(SourceRange R, ASTContext &Ctx 1698 , unsigned SI 1699 ) 1700 : InheritableAttr(attr::CUDAGlobal, R, SI, false, false) 1701 { 1702 } 1703 1704 CUDAGlobalAttr *clone(ASTContext &C) const; 1705 void printPretty(raw_ostream &OS, 1706 const PrintingPolicy &Policy) const; 1707 const char *getSpelling() const; 1708 1709 1710 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; } 1711}; 1712 1713class CUDAHostAttr : public InheritableAttr { 1714public: 1715 static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1716 auto *A = new (Ctx) CUDAHostAttr(Loc, Ctx, 0); 1717 A->setImplicit(true); 1718 return A; 1719 } 1720 1721 CUDAHostAttr(SourceRange R, ASTContext &Ctx 1722 , unsigned SI 1723 ) 1724 : InheritableAttr(attr::CUDAHost, R, SI, false, false) 1725 { 1726 } 1727 1728 CUDAHostAttr *clone(ASTContext &C) const; 1729 void printPretty(raw_ostream &OS, 1730 const PrintingPolicy &Policy) const; 1731 const char *getSpelling() const; 1732 1733 1734 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; } 1735}; 1736 1737class CUDAInvalidTargetAttr : public InheritableAttr { 1738public: 1739 static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1740 auto *A = new (Ctx) CUDAInvalidTargetAttr(Loc, Ctx, 0); 1741 A->setImplicit(true); 1742 return A; 1743 } 1744 1745 CUDAInvalidTargetAttr(SourceRange R, ASTContext &Ctx 1746 , unsigned SI 1747 ) 1748 : InheritableAttr(attr::CUDAInvalidTarget, R, SI, false, false) 1749 { 1750 } 1751 1752 CUDAInvalidTargetAttr *clone(ASTContext &C) const; 1753 void printPretty(raw_ostream &OS, 1754 const PrintingPolicy &Policy) const; 1755 const char *getSpelling() const; 1756 1757 1758 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; } 1759}; 1760 1761class CUDALaunchBoundsAttr : public InheritableAttr { 1762Expr * maxThreads; 1763 1764Expr * minBlocks; 1765 1766public: 1767 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Loc = SourceRange()) { 1768 auto *A = new (Ctx) CUDALaunchBoundsAttr(Loc, Ctx, MaxThreads, MinBlocks, 0); 1769 A->setImplicit(true); 1770 return A; 1771 } 1772 1773 CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx 1774 , Expr * MaxThreads 1775 , Expr * MinBlocks 1776 , unsigned SI 1777 ) 1778 : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false) 1779 , maxThreads(MaxThreads) 1780 , minBlocks(MinBlocks) 1781 { 1782 } 1783 1784 CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx 1785 , Expr * MaxThreads 1786 , unsigned SI 1787 ) 1788 : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false) 1789 , maxThreads(MaxThreads) 1790 , minBlocks() 1791 { 1792 } 1793 1794 CUDALaunchBoundsAttr *clone(ASTContext &C) const; 1795 void printPretty(raw_ostream &OS, 1796 const PrintingPolicy &Policy) const; 1797 const char *getSpelling() const; 1798 Expr * getMaxThreads() const { 1799 return maxThreads; 1800 } 1801 1802 Expr * getMinBlocks() const { 1803 return minBlocks; 1804 } 1805 1806 1807 1808 static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; } 1809}; 1810 1811class CUDASharedAttr : public InheritableAttr { 1812public: 1813 static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1814 auto *A = new (Ctx) CUDASharedAttr(Loc, Ctx, 0); 1815 A->setImplicit(true); 1816 return A; 1817 } 1818 1819 CUDASharedAttr(SourceRange R, ASTContext &Ctx 1820 , unsigned SI 1821 ) 1822 : InheritableAttr(attr::CUDAShared, R, SI, false, false) 1823 { 1824 } 1825 1826 CUDASharedAttr *clone(ASTContext &C) const; 1827 void printPretty(raw_ostream &OS, 1828 const PrintingPolicy &Policy) const; 1829 const char *getSpelling() const; 1830 1831 1832 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; } 1833}; 1834 1835class CXX11NoReturnAttr : public InheritableAttr { 1836public: 1837 static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 1838 auto *A = new (Ctx) CXX11NoReturnAttr(Loc, Ctx, 0); 1839 A->setImplicit(true); 1840 return A; 1841 } 1842 1843 CXX11NoReturnAttr(SourceRange R, ASTContext &Ctx 1844 , unsigned SI 1845 ) 1846 : InheritableAttr(attr::CXX11NoReturn, R, SI, false, false) 1847 { 1848 } 1849 1850 CXX11NoReturnAttr *clone(ASTContext &C) const; 1851 void printPretty(raw_ostream &OS, 1852 const PrintingPolicy &Policy) const; 1853 const char *getSpelling() const; 1854 1855 1856 static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; } 1857}; 1858 1859class CallableWhenAttr : public InheritableAttr { 1860public: 1861 enum ConsumedState { 1862 Unknown, 1863 Consumed, 1864 Unconsumed 1865 }; 1866private: 1867 unsigned callableStates_Size; 1868 ConsumedState *callableStates_; 1869 1870public: 1871 static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Loc = SourceRange()) { 1872 auto *A = new (Ctx) CallableWhenAttr(Loc, Ctx, CallableStates, CallableStatesSize, 0); 1873 A->setImplicit(true); 1874 return A; 1875 } 1876 1877 CallableWhenAttr(SourceRange R, ASTContext &Ctx 1878 , ConsumedState *CallableStates, unsigned CallableStatesSize 1879 , unsigned SI 1880 ) 1881 : InheritableAttr(attr::CallableWhen, R, SI, false, false) 1882 , callableStates_Size(CallableStatesSize), callableStates_(new (Ctx, 16) ConsumedState[callableStates_Size]) 1883 { 1884 std::copy(CallableStates, CallableStates + callableStates_Size, callableStates_); 1885 } 1886 1887 CallableWhenAttr(SourceRange R, ASTContext &Ctx 1888 , unsigned SI 1889 ) 1890 : InheritableAttr(attr::CallableWhen, R, SI, false, false) 1891 , callableStates_Size(0), callableStates_(nullptr) 1892 { 1893 } 1894 1895 CallableWhenAttr *clone(ASTContext &C) const; 1896 void printPretty(raw_ostream &OS, 1897 const PrintingPolicy &Policy) const; 1898 const char *getSpelling() const; 1899 typedef ConsumedState* callableStates_iterator; 1900 callableStates_iterator callableStates_begin() const { return callableStates_; } 1901 callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; } 1902 unsigned callableStates_size() const { return callableStates_Size; } 1903 llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); } 1904 1905 1906 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { 1907 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) 1908 .Case("unknown", CallableWhenAttr::Unknown) 1909 .Case("consumed", CallableWhenAttr::Consumed) 1910 .Case("unconsumed", CallableWhenAttr::Unconsumed) 1911 .Default(Optional<ConsumedState>()); 1912 if (R) { 1913 Out = *R; 1914 return true; 1915 } 1916 return false; 1917 } 1918 1919 static const char *ConvertConsumedStateToStr(ConsumedState Val) { 1920 switch(Val) { 1921 case CallableWhenAttr::Unknown: return "unknown"; 1922 case CallableWhenAttr::Consumed: return "consumed"; 1923 case CallableWhenAttr::Unconsumed: return "unconsumed"; 1924 } 1925 llvm_unreachable("No enumerator with that value"); 1926 } 1927 1928 1929 static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; } 1930}; 1931 1932class CapabilityAttr : public InheritableAttr { 1933unsigned nameLength; 1934char *name; 1935 1936public: 1937 enum Spelling { 1938 GNU_capability = 0, 1939 CXX11_clang_capability = 1, 1940 GNU_shared_capability = 2, 1941 CXX11_clang_shared_capability = 3 1942 }; 1943 1944 static CapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) { 1945 auto *A = new (Ctx) CapabilityAttr(Loc, Ctx, Name, S); 1946 A->setImplicit(true); 1947 return A; 1948 } 1949 1950 CapabilityAttr(SourceRange R, ASTContext &Ctx 1951 , llvm::StringRef Name 1952 , unsigned SI 1953 ) 1954 : InheritableAttr(attr::Capability, R, SI, false, false) 1955 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) 1956 { 1957 if (!Name.empty()) 1958 std::memcpy(name, Name.data(), nameLength); 1959 } 1960 1961 CapabilityAttr *clone(ASTContext &C) const; 1962 void printPretty(raw_ostream &OS, 1963 const PrintingPolicy &Policy) const; 1964 const char *getSpelling() const; 1965 Spelling getSemanticSpelling() const { 1966 switch (SpellingListIndex) { 1967 default: llvm_unreachable("Unknown spelling list index"); 1968 case 0: return GNU_capability; 1969 case 1: return CXX11_clang_capability; 1970 case 2: return GNU_shared_capability; 1971 case 3: return CXX11_clang_shared_capability; 1972 } 1973 } 1974 bool isShared() const { return SpellingListIndex == 2 || 1975 SpellingListIndex == 3; } 1976 llvm::StringRef getName() const { 1977 return llvm::StringRef(name, nameLength); 1978 } 1979 unsigned getNameLength() const { 1980 return nameLength; 1981 } 1982 void setName(ASTContext &C, llvm::StringRef S) { 1983 nameLength = S.size(); 1984 this->name = new (C, 1) char [nameLength]; 1985 if (!S.empty()) 1986 std::memcpy(this->name, S.data(), nameLength); 1987 } 1988 1989 1990 bool isMutex() const { return getName().equals_lower("mutex"); } 1991 bool isRole() const { return getName().equals_lower("role"); } 1992 1993 1994 static bool classof(const Attr *A) { return A->getKind() == attr::Capability; } 1995}; 1996 1997class CapturedRecordAttr : public InheritableAttr { 1998public: 1999 static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2000 auto *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0); 2001 A->setImplicit(true); 2002 return A; 2003 } 2004 2005 CapturedRecordAttr(SourceRange R, ASTContext &Ctx 2006 , unsigned SI 2007 ) 2008 : InheritableAttr(attr::CapturedRecord, R, SI, false, false) 2009 { 2010 } 2011 2012 CapturedRecordAttr *clone(ASTContext &C) const; 2013 void printPretty(raw_ostream &OS, 2014 const PrintingPolicy &Policy) const; 2015 const char *getSpelling() const; 2016 2017 2018 static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; } 2019}; 2020 2021class CarriesDependencyAttr : public InheritableParamAttr { 2022public: 2023 static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2024 auto *A = new (Ctx) CarriesDependencyAttr(Loc, Ctx, 0); 2025 A->setImplicit(true); 2026 return A; 2027 } 2028 2029 CarriesDependencyAttr(SourceRange R, ASTContext &Ctx 2030 , unsigned SI 2031 ) 2032 : InheritableParamAttr(attr::CarriesDependency, R, SI, false, false) 2033 { 2034 } 2035 2036 CarriesDependencyAttr *clone(ASTContext &C) const; 2037 void printPretty(raw_ostream &OS, 2038 const PrintingPolicy &Policy) const; 2039 const char *getSpelling() const; 2040 2041 2042 static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; } 2043}; 2044 2045class CleanupAttr : public InheritableAttr { 2046FunctionDecl * functionDecl; 2047 2048public: 2049 static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Loc = SourceRange()) { 2050 auto *A = new (Ctx) CleanupAttr(Loc, Ctx, FunctionDecl, 0); 2051 A->setImplicit(true); 2052 return A; 2053 } 2054 2055 CleanupAttr(SourceRange R, ASTContext &Ctx 2056 , FunctionDecl * FunctionDecl 2057 , unsigned SI 2058 ) 2059 : InheritableAttr(attr::Cleanup, R, SI, false, false) 2060 , functionDecl(FunctionDecl) 2061 { 2062 } 2063 2064 CleanupAttr *clone(ASTContext &C) const; 2065 void printPretty(raw_ostream &OS, 2066 const PrintingPolicy &Policy) const; 2067 const char *getSpelling() const; 2068 FunctionDecl * getFunctionDecl() const { 2069 return functionDecl; 2070 } 2071 2072 2073 2074 static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; } 2075}; 2076 2077class ColdAttr : public InheritableAttr { 2078public: 2079 static ColdAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2080 auto *A = new (Ctx) ColdAttr(Loc, Ctx, 0); 2081 A->setImplicit(true); 2082 return A; 2083 } 2084 2085 ColdAttr(SourceRange R, ASTContext &Ctx 2086 , unsigned SI 2087 ) 2088 : InheritableAttr(attr::Cold, R, SI, false, false) 2089 { 2090 } 2091 2092 ColdAttr *clone(ASTContext &C) const; 2093 void printPretty(raw_ostream &OS, 2094 const PrintingPolicy &Policy) const; 2095 const char *getSpelling() const; 2096 2097 2098 static bool classof(const Attr *A) { return A->getKind() == attr::Cold; } 2099}; 2100 2101class CommonAttr : public InheritableAttr { 2102public: 2103 static CommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2104 auto *A = new (Ctx) CommonAttr(Loc, Ctx, 0); 2105 A->setImplicit(true); 2106 return A; 2107 } 2108 2109 CommonAttr(SourceRange R, ASTContext &Ctx 2110 , unsigned SI 2111 ) 2112 : InheritableAttr(attr::Common, R, SI, false, false) 2113 { 2114 } 2115 2116 CommonAttr *clone(ASTContext &C) const; 2117 void printPretty(raw_ostream &OS, 2118 const PrintingPolicy &Policy) const; 2119 const char *getSpelling() const; 2120 2121 2122 static bool classof(const Attr *A) { return A->getKind() == attr::Common; } 2123}; 2124 2125class ConstAttr : public InheritableAttr { 2126public: 2127 static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2128 auto *A = new (Ctx) ConstAttr(Loc, Ctx, 0); 2129 A->setImplicit(true); 2130 return A; 2131 } 2132 2133 ConstAttr(SourceRange R, ASTContext &Ctx 2134 , unsigned SI 2135 ) 2136 : InheritableAttr(attr::Const, R, SI, false, false) 2137 { 2138 } 2139 2140 ConstAttr *clone(ASTContext &C) const; 2141 void printPretty(raw_ostream &OS, 2142 const PrintingPolicy &Policy) const; 2143 const char *getSpelling() const; 2144 2145 2146 static bool classof(const Attr *A) { return A->getKind() == attr::Const; } 2147}; 2148 2149class ConstructorAttr : public InheritableAttr { 2150int priority; 2151 2152public: 2153 static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) { 2154 auto *A = new (Ctx) ConstructorAttr(Loc, Ctx, Priority, 0); 2155 A->setImplicit(true); 2156 return A; 2157 } 2158 2159 ConstructorAttr(SourceRange R, ASTContext &Ctx 2160 , int Priority 2161 , unsigned SI 2162 ) 2163 : InheritableAttr(attr::Constructor, R, SI, false, false) 2164 , priority(Priority) 2165 { 2166 } 2167 2168 ConstructorAttr(SourceRange R, ASTContext &Ctx 2169 , unsigned SI 2170 ) 2171 : InheritableAttr(attr::Constructor, R, SI, false, false) 2172 , priority() 2173 { 2174 } 2175 2176 ConstructorAttr *clone(ASTContext &C) const; 2177 void printPretty(raw_ostream &OS, 2178 const PrintingPolicy &Policy) const; 2179 const char *getSpelling() const; 2180 int getPriority() const { 2181 return priority; 2182 } 2183 2184 static const int DefaultPriority = 65535; 2185 2186 2187 2188 static bool classof(const Attr *A) { return A->getKind() == attr::Constructor; } 2189}; 2190 2191class ConsumableAttr : public InheritableAttr { 2192public: 2193 enum ConsumedState { 2194 Unknown, 2195 Consumed, 2196 Unconsumed 2197 }; 2198private: 2199 ConsumedState defaultState; 2200 2201public: 2202 static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumedState DefaultState, SourceRange Loc = SourceRange()) { 2203 auto *A = new (Ctx) ConsumableAttr(Loc, Ctx, DefaultState, 0); 2204 A->setImplicit(true); 2205 return A; 2206 } 2207 2208 ConsumableAttr(SourceRange R, ASTContext &Ctx 2209 , ConsumedState DefaultState 2210 , unsigned SI 2211 ) 2212 : InheritableAttr(attr::Consumable, R, SI, false, false) 2213 , defaultState(DefaultState) 2214 { 2215 } 2216 2217 ConsumableAttr *clone(ASTContext &C) const; 2218 void printPretty(raw_ostream &OS, 2219 const PrintingPolicy &Policy) const; 2220 const char *getSpelling() const; 2221 ConsumedState getDefaultState() const { 2222 return defaultState; 2223 } 2224 2225 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { 2226 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) 2227 .Case("unknown", ConsumableAttr::Unknown) 2228 .Case("consumed", ConsumableAttr::Consumed) 2229 .Case("unconsumed", ConsumableAttr::Unconsumed) 2230 .Default(Optional<ConsumedState>()); 2231 if (R) { 2232 Out = *R; 2233 return true; 2234 } 2235 return false; 2236 } 2237 2238 static const char *ConvertConsumedStateToStr(ConsumedState Val) { 2239 switch(Val) { 2240 case ConsumableAttr::Unknown: return "unknown"; 2241 case ConsumableAttr::Consumed: return "consumed"; 2242 case ConsumableAttr::Unconsumed: return "unconsumed"; 2243 } 2244 llvm_unreachable("No enumerator with that value"); 2245 } 2246 2247 2248 static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; } 2249}; 2250 2251class ConsumableAutoCastAttr : public InheritableAttr { 2252public: 2253 static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2254 auto *A = new (Ctx) ConsumableAutoCastAttr(Loc, Ctx, 0); 2255 A->setImplicit(true); 2256 return A; 2257 } 2258 2259 ConsumableAutoCastAttr(SourceRange R, ASTContext &Ctx 2260 , unsigned SI 2261 ) 2262 : InheritableAttr(attr::ConsumableAutoCast, R, SI, false, false) 2263 { 2264 } 2265 2266 ConsumableAutoCastAttr *clone(ASTContext &C) const; 2267 void printPretty(raw_ostream &OS, 2268 const PrintingPolicy &Policy) const; 2269 const char *getSpelling() const; 2270 2271 2272 static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableAutoCast; } 2273}; 2274 2275class ConsumableSetOnReadAttr : public InheritableAttr { 2276public: 2277 static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2278 auto *A = new (Ctx) ConsumableSetOnReadAttr(Loc, Ctx, 0); 2279 A->setImplicit(true); 2280 return A; 2281 } 2282 2283 ConsumableSetOnReadAttr(SourceRange R, ASTContext &Ctx 2284 , unsigned SI 2285 ) 2286 : InheritableAttr(attr::ConsumableSetOnRead, R, SI, false, false) 2287 { 2288 } 2289 2290 ConsumableSetOnReadAttr *clone(ASTContext &C) const; 2291 void printPretty(raw_ostream &OS, 2292 const PrintingPolicy &Policy) const; 2293 const char *getSpelling() const; 2294 2295 2296 static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableSetOnRead; } 2297}; 2298 2299class ConvergentAttr : public InheritableAttr { 2300public: 2301 static ConvergentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2302 auto *A = new (Ctx) ConvergentAttr(Loc, Ctx, 0); 2303 A->setImplicit(true); 2304 return A; 2305 } 2306 2307 ConvergentAttr(SourceRange R, ASTContext &Ctx 2308 , unsigned SI 2309 ) 2310 : InheritableAttr(attr::Convergent, R, SI, false, false) 2311 { 2312 } 2313 2314 ConvergentAttr *clone(ASTContext &C) const; 2315 void printPretty(raw_ostream &OS, 2316 const PrintingPolicy &Policy) const; 2317 const char *getSpelling() const; 2318 2319 2320 static bool classof(const Attr *A) { return A->getKind() == attr::Convergent; } 2321}; 2322 2323class DLLExportAttr : public InheritableAttr { 2324public: 2325 static DLLExportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2326 auto *A = new (Ctx) DLLExportAttr(Loc, Ctx, 0); 2327 A->setImplicit(true); 2328 return A; 2329 } 2330 2331 DLLExportAttr(SourceRange R, ASTContext &Ctx 2332 , unsigned SI 2333 ) 2334 : InheritableAttr(attr::DLLExport, R, SI, false, false) 2335 { 2336 } 2337 2338 DLLExportAttr *clone(ASTContext &C) const; 2339 void printPretty(raw_ostream &OS, 2340 const PrintingPolicy &Policy) const; 2341 const char *getSpelling() const; 2342 2343 2344 static bool classof(const Attr *A) { return A->getKind() == attr::DLLExport; } 2345}; 2346 2347class DLLImportAttr : public InheritableAttr { 2348public: 2349 static DLLImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2350 auto *A = new (Ctx) DLLImportAttr(Loc, Ctx, 0); 2351 A->setImplicit(true); 2352 return A; 2353 } 2354 2355 DLLImportAttr(SourceRange R, ASTContext &Ctx 2356 , unsigned SI 2357 ) 2358 : InheritableAttr(attr::DLLImport, R, SI, false, false) 2359 { 2360 } 2361 2362 DLLImportAttr *clone(ASTContext &C) const; 2363 void printPretty(raw_ostream &OS, 2364 const PrintingPolicy &Policy) const; 2365 const char *getSpelling() const; 2366 2367 2368 static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; } 2369}; 2370 2371class DeprecatedAttr : public InheritableAttr { 2372unsigned messageLength; 2373char *message; 2374 2375unsigned replacementLength; 2376char *replacement; 2377 2378public: 2379 static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) { 2380 auto *A = new (Ctx) DeprecatedAttr(Loc, Ctx, Message, Replacement, 0); 2381 A->setImplicit(true); 2382 return A; 2383 } 2384 2385 DeprecatedAttr(SourceRange R, ASTContext &Ctx 2386 , llvm::StringRef Message 2387 , llvm::StringRef Replacement 2388 , unsigned SI 2389 ) 2390 : InheritableAttr(attr::Deprecated, R, SI, false, false) 2391 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 2392 , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength]) 2393 { 2394 if (!Message.empty()) 2395 std::memcpy(message, Message.data(), messageLength); 2396 if (!Replacement.empty()) 2397 std::memcpy(replacement, Replacement.data(), replacementLength); 2398 } 2399 2400 DeprecatedAttr(SourceRange R, ASTContext &Ctx 2401 , unsigned SI 2402 ) 2403 : InheritableAttr(attr::Deprecated, R, SI, false, false) 2404 , messageLength(0),message(nullptr) 2405 , replacementLength(0),replacement(nullptr) 2406 { 2407 } 2408 2409 DeprecatedAttr *clone(ASTContext &C) const; 2410 void printPretty(raw_ostream &OS, 2411 const PrintingPolicy &Policy) const; 2412 const char *getSpelling() const; 2413 llvm::StringRef getMessage() const { 2414 return llvm::StringRef(message, messageLength); 2415 } 2416 unsigned getMessageLength() const { 2417 return messageLength; 2418 } 2419 void setMessage(ASTContext &C, llvm::StringRef S) { 2420 messageLength = S.size(); 2421 this->message = new (C, 1) char [messageLength]; 2422 if (!S.empty()) 2423 std::memcpy(this->message, S.data(), messageLength); 2424 } 2425 2426 llvm::StringRef getReplacement() const { 2427 return llvm::StringRef(replacement, replacementLength); 2428 } 2429 unsigned getReplacementLength() const { 2430 return replacementLength; 2431 } 2432 void setReplacement(ASTContext &C, llvm::StringRef S) { 2433 replacementLength = S.size(); 2434 this->replacement = new (C, 1) char [replacementLength]; 2435 if (!S.empty()) 2436 std::memcpy(this->replacement, S.data(), replacementLength); 2437 } 2438 2439 2440 2441 static bool classof(const Attr *A) { return A->getKind() == attr::Deprecated; } 2442}; 2443 2444class DestructorAttr : public InheritableAttr { 2445int priority; 2446 2447public: 2448 static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) { 2449 auto *A = new (Ctx) DestructorAttr(Loc, Ctx, Priority, 0); 2450 A->setImplicit(true); 2451 return A; 2452 } 2453 2454 DestructorAttr(SourceRange R, ASTContext &Ctx 2455 , int Priority 2456 , unsigned SI 2457 ) 2458 : InheritableAttr(attr::Destructor, R, SI, false, false) 2459 , priority(Priority) 2460 { 2461 } 2462 2463 DestructorAttr(SourceRange R, ASTContext &Ctx 2464 , unsigned SI 2465 ) 2466 : InheritableAttr(attr::Destructor, R, SI, false, false) 2467 , priority() 2468 { 2469 } 2470 2471 DestructorAttr *clone(ASTContext &C) const; 2472 void printPretty(raw_ostream &OS, 2473 const PrintingPolicy &Policy) const; 2474 const char *getSpelling() const; 2475 int getPriority() const { 2476 return priority; 2477 } 2478 2479 static const int DefaultPriority = 65535; 2480 2481 2482 2483 static bool classof(const Attr *A) { return A->getKind() == attr::Destructor; } 2484}; 2485 2486class DiagnoseIfAttr : public InheritableAttr { 2487Expr * cond; 2488 2489unsigned messageLength; 2490char *message; 2491 2492public: 2493 enum DiagnosticType { 2494 DT_Error, 2495 DT_Warning 2496 }; 2497private: 2498 DiagnosticType diagnosticType; 2499 2500bool argDependent; 2501 2502NamedDecl * parent; 2503 2504public: 2505 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, SourceRange Loc = SourceRange()) { 2506 auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, ArgDependent, Parent, 0); 2507 A->setImplicit(true); 2508 return A; 2509 } 2510 2511 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, SourceRange Loc = SourceRange()) { 2512 auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, 0); 2513 A->setImplicit(true); 2514 return A; 2515 } 2516 2517 DiagnoseIfAttr(SourceRange R, ASTContext &Ctx 2518 , Expr * Cond 2519 , llvm::StringRef Message 2520 , DiagnosticType DiagnosticType 2521 , bool ArgDependent 2522 , NamedDecl * Parent 2523 , unsigned SI 2524 ) 2525 : InheritableAttr(attr::DiagnoseIf, R, SI, true, true) 2526 , cond(Cond) 2527 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 2528 , diagnosticType(DiagnosticType) 2529 , argDependent(ArgDependent) 2530 , parent(Parent) 2531 { 2532 if (!Message.empty()) 2533 std::memcpy(message, Message.data(), messageLength); 2534 } 2535 2536 DiagnoseIfAttr(SourceRange R, ASTContext &Ctx 2537 , Expr * Cond 2538 , llvm::StringRef Message 2539 , DiagnosticType DiagnosticType 2540 , unsigned SI 2541 ) 2542 : InheritableAttr(attr::DiagnoseIf, R, SI, true, true) 2543 , cond(Cond) 2544 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 2545 , diagnosticType(DiagnosticType) 2546 , argDependent() 2547 , parent() 2548 { 2549 if (!Message.empty()) 2550 std::memcpy(message, Message.data(), messageLength); 2551 } 2552 2553 DiagnoseIfAttr *clone(ASTContext &C) const; 2554 void printPretty(raw_ostream &OS, 2555 const PrintingPolicy &Policy) const; 2556 const char *getSpelling() const; 2557 Expr * getCond() const { 2558 return cond; 2559 } 2560 2561 llvm::StringRef getMessage() const { 2562 return llvm::StringRef(message, messageLength); 2563 } 2564 unsigned getMessageLength() const { 2565 return messageLength; 2566 } 2567 void setMessage(ASTContext &C, llvm::StringRef S) { 2568 messageLength = S.size(); 2569 this->message = new (C, 1) char [messageLength]; 2570 if (!S.empty()) 2571 std::memcpy(this->message, S.data(), messageLength); 2572 } 2573 2574 DiagnosticType getDiagnosticType() const { 2575 return diagnosticType; 2576 } 2577 2578 static bool ConvertStrToDiagnosticType(StringRef Val, DiagnosticType &Out) { 2579 Optional<DiagnosticType> R = llvm::StringSwitch<Optional<DiagnosticType>>(Val) 2580 .Case("error", DiagnoseIfAttr::DT_Error) 2581 .Case("warning", DiagnoseIfAttr::DT_Warning) 2582 .Default(Optional<DiagnosticType>()); 2583 if (R) { 2584 Out = *R; 2585 return true; 2586 } 2587 return false; 2588 } 2589 2590 static const char *ConvertDiagnosticTypeToStr(DiagnosticType Val) { 2591 switch(Val) { 2592 case DiagnoseIfAttr::DT_Error: return "error"; 2593 case DiagnoseIfAttr::DT_Warning: return "warning"; 2594 } 2595 llvm_unreachable("No enumerator with that value"); 2596 } 2597 bool getArgDependent() const { 2598 return argDependent; 2599 } 2600 2601 NamedDecl * getParent() const { 2602 return parent; 2603 } 2604 2605 2606 bool isError() const { return diagnosticType == DT_Error; } 2607 bool isWarning() const { return diagnosticType == DT_Warning; } 2608 2609 2610 static bool classof(const Attr *A) { return A->getKind() == attr::DiagnoseIf; } 2611}; 2612 2613class DisableTailCallsAttr : public InheritableAttr { 2614public: 2615 static DisableTailCallsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2616 auto *A = new (Ctx) DisableTailCallsAttr(Loc, Ctx, 0); 2617 A->setImplicit(true); 2618 return A; 2619 } 2620 2621 DisableTailCallsAttr(SourceRange R, ASTContext &Ctx 2622 , unsigned SI 2623 ) 2624 : InheritableAttr(attr::DisableTailCalls, R, SI, false, false) 2625 { 2626 } 2627 2628 DisableTailCallsAttr *clone(ASTContext &C) const; 2629 void printPretty(raw_ostream &OS, 2630 const PrintingPolicy &Policy) const; 2631 const char *getSpelling() const; 2632 2633 2634 static bool classof(const Attr *A) { return A->getKind() == attr::DisableTailCalls; } 2635}; 2636 2637class EmptyBasesAttr : public InheritableAttr { 2638public: 2639 static EmptyBasesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2640 auto *A = new (Ctx) EmptyBasesAttr(Loc, Ctx, 0); 2641 A->setImplicit(true); 2642 return A; 2643 } 2644 2645 EmptyBasesAttr(SourceRange R, ASTContext &Ctx 2646 , unsigned SI 2647 ) 2648 : InheritableAttr(attr::EmptyBases, R, SI, false, false) 2649 { 2650 } 2651 2652 EmptyBasesAttr *clone(ASTContext &C) const; 2653 void printPretty(raw_ostream &OS, 2654 const PrintingPolicy &Policy) const; 2655 const char *getSpelling() const; 2656 2657 2658 static bool classof(const Attr *A) { return A->getKind() == attr::EmptyBases; } 2659}; 2660 2661class EnableIfAttr : public InheritableAttr { 2662Expr * cond; 2663 2664unsigned messageLength; 2665char *message; 2666 2667public: 2668 static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Loc = SourceRange()) { 2669 auto *A = new (Ctx) EnableIfAttr(Loc, Ctx, Cond, Message, 0); 2670 A->setImplicit(true); 2671 return A; 2672 } 2673 2674 EnableIfAttr(SourceRange R, ASTContext &Ctx 2675 , Expr * Cond 2676 , llvm::StringRef Message 2677 , unsigned SI 2678 ) 2679 : InheritableAttr(attr::EnableIf, R, SI, false, false) 2680 , cond(Cond) 2681 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 2682 { 2683 if (!Message.empty()) 2684 std::memcpy(message, Message.data(), messageLength); 2685 } 2686 2687 EnableIfAttr *clone(ASTContext &C) const; 2688 void printPretty(raw_ostream &OS, 2689 const PrintingPolicy &Policy) const; 2690 const char *getSpelling() const; 2691 Expr * getCond() const { 2692 return cond; 2693 } 2694 2695 llvm::StringRef getMessage() const { 2696 return llvm::StringRef(message, messageLength); 2697 } 2698 unsigned getMessageLength() const { 2699 return messageLength; 2700 } 2701 void setMessage(ASTContext &C, llvm::StringRef S) { 2702 messageLength = S.size(); 2703 this->message = new (C, 1) char [messageLength]; 2704 if (!S.empty()) 2705 std::memcpy(this->message, S.data(), messageLength); 2706 } 2707 2708 2709 2710 static bool classof(const Attr *A) { return A->getKind() == attr::EnableIf; } 2711}; 2712 2713class EnumExtensibilityAttr : public InheritableAttr { 2714public: 2715 enum Kind { 2716 Closed, 2717 Open 2718 }; 2719private: 2720 Kind extensibility; 2721 2722public: 2723 static EnumExtensibilityAttr *CreateImplicit(ASTContext &Ctx, Kind Extensibility, SourceRange Loc = SourceRange()) { 2724 auto *A = new (Ctx) EnumExtensibilityAttr(Loc, Ctx, Extensibility, 0); 2725 A->setImplicit(true); 2726 return A; 2727 } 2728 2729 EnumExtensibilityAttr(SourceRange R, ASTContext &Ctx 2730 , Kind Extensibility 2731 , unsigned SI 2732 ) 2733 : InheritableAttr(attr::EnumExtensibility, R, SI, false, false) 2734 , extensibility(Extensibility) 2735 { 2736 } 2737 2738 EnumExtensibilityAttr *clone(ASTContext &C) const; 2739 void printPretty(raw_ostream &OS, 2740 const PrintingPolicy &Policy) const; 2741 const char *getSpelling() const; 2742 Kind getExtensibility() const { 2743 return extensibility; 2744 } 2745 2746 static bool ConvertStrToKind(StringRef Val, Kind &Out) { 2747 Optional<Kind> R = llvm::StringSwitch<Optional<Kind>>(Val) 2748 .Case("closed", EnumExtensibilityAttr::Closed) 2749 .Case("open", EnumExtensibilityAttr::Open) 2750 .Default(Optional<Kind>()); 2751 if (R) { 2752 Out = *R; 2753 return true; 2754 } 2755 return false; 2756 } 2757 2758 static const char *ConvertKindToStr(Kind Val) { 2759 switch(Val) { 2760 case EnumExtensibilityAttr::Closed: return "closed"; 2761 case EnumExtensibilityAttr::Open: return "open"; 2762 } 2763 llvm_unreachable("No enumerator with that value"); 2764 } 2765 2766 2767 static bool classof(const Attr *A) { return A->getKind() == attr::EnumExtensibility; } 2768}; 2769 2770class ExclusiveTrylockFunctionAttr : public InheritableAttr { 2771Expr * successValue; 2772 2773 unsigned args_Size; 2774 Expr * *args_; 2775 2776public: 2777 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 2778 auto *A = new (Ctx) ExclusiveTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0); 2779 A->setImplicit(true); 2780 return A; 2781 } 2782 2783 ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx 2784 , Expr * SuccessValue 2785 , Expr * *Args, unsigned ArgsSize 2786 , unsigned SI 2787 ) 2788 : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true) 2789 , successValue(SuccessValue) 2790 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 2791 { 2792 std::copy(Args, Args + args_Size, args_); 2793 } 2794 2795 ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx 2796 , Expr * SuccessValue 2797 , unsigned SI 2798 ) 2799 : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true) 2800 , successValue(SuccessValue) 2801 , args_Size(0), args_(nullptr) 2802 { 2803 } 2804 2805 ExclusiveTrylockFunctionAttr *clone(ASTContext &C) const; 2806 void printPretty(raw_ostream &OS, 2807 const PrintingPolicy &Policy) const; 2808 const char *getSpelling() const; 2809 Expr * getSuccessValue() const { 2810 return successValue; 2811 } 2812 2813 typedef Expr ** args_iterator; 2814 args_iterator args_begin() const { return args_; } 2815 args_iterator args_end() const { return args_ + args_Size; } 2816 unsigned args_size() const { return args_Size; } 2817 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 2818 2819 2820 2821 2822 static bool classof(const Attr *A) { return A->getKind() == attr::ExclusiveTrylockFunction; } 2823}; 2824 2825class ExternalSourceSymbolAttr : public InheritableAttr { 2826unsigned languageLength; 2827char *language; 2828 2829unsigned definedInLength; 2830char *definedIn; 2831 2832bool generatedDeclaration; 2833 2834public: 2835 static ExternalSourceSymbolAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, SourceRange Loc = SourceRange()) { 2836 auto *A = new (Ctx) ExternalSourceSymbolAttr(Loc, Ctx, Language, DefinedIn, GeneratedDeclaration, 0); 2837 A->setImplicit(true); 2838 return A; 2839 } 2840 2841 ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx 2842 , llvm::StringRef Language 2843 , llvm::StringRef DefinedIn 2844 , bool GeneratedDeclaration 2845 , unsigned SI 2846 ) 2847 : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false) 2848 , languageLength(Language.size()),language(new (Ctx, 1) char[languageLength]) 2849 , definedInLength(DefinedIn.size()),definedIn(new (Ctx, 1) char[definedInLength]) 2850 , generatedDeclaration(GeneratedDeclaration) 2851 { 2852 if (!Language.empty()) 2853 std::memcpy(language, Language.data(), languageLength); 2854 if (!DefinedIn.empty()) 2855 std::memcpy(definedIn, DefinedIn.data(), definedInLength); 2856 } 2857 2858 ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx 2859 , unsigned SI 2860 ) 2861 : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false) 2862 , languageLength(0),language(nullptr) 2863 , definedInLength(0),definedIn(nullptr) 2864 , generatedDeclaration() 2865 { 2866 } 2867 2868 ExternalSourceSymbolAttr *clone(ASTContext &C) const; 2869 void printPretty(raw_ostream &OS, 2870 const PrintingPolicy &Policy) const; 2871 const char *getSpelling() const; 2872 llvm::StringRef getLanguage() const { 2873 return llvm::StringRef(language, languageLength); 2874 } 2875 unsigned getLanguageLength() const { 2876 return languageLength; 2877 } 2878 void setLanguage(ASTContext &C, llvm::StringRef S) { 2879 languageLength = S.size(); 2880 this->language = new (C, 1) char [languageLength]; 2881 if (!S.empty()) 2882 std::memcpy(this->language, S.data(), languageLength); 2883 } 2884 2885 llvm::StringRef getDefinedIn() const { 2886 return llvm::StringRef(definedIn, definedInLength); 2887 } 2888 unsigned getDefinedInLength() const { 2889 return definedInLength; 2890 } 2891 void setDefinedIn(ASTContext &C, llvm::StringRef S) { 2892 definedInLength = S.size(); 2893 this->definedIn = new (C, 1) char [definedInLength]; 2894 if (!S.empty()) 2895 std::memcpy(this->definedIn, S.data(), definedInLength); 2896 } 2897 2898 bool getGeneratedDeclaration() const { 2899 return generatedDeclaration; 2900 } 2901 2902 2903 2904 static bool classof(const Attr *A) { return A->getKind() == attr::ExternalSourceSymbol; } 2905}; 2906 2907class FallThroughAttr : public StmtAttr { 2908public: 2909 static FallThroughAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2910 auto *A = new (Ctx) FallThroughAttr(Loc, Ctx, 0); 2911 A->setImplicit(true); 2912 return A; 2913 } 2914 2915 FallThroughAttr(SourceRange R, ASTContext &Ctx 2916 , unsigned SI 2917 ) 2918 : StmtAttr(attr::FallThrough, R, SI, false, false) 2919 { 2920 } 2921 2922 FallThroughAttr *clone(ASTContext &C) const; 2923 void printPretty(raw_ostream &OS, 2924 const PrintingPolicy &Policy) const; 2925 const char *getSpelling() const; 2926 2927 2928 static bool classof(const Attr *A) { return A->getKind() == attr::FallThrough; } 2929}; 2930 2931class FastCallAttr : public InheritableAttr { 2932public: 2933 static FastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2934 auto *A = new (Ctx) FastCallAttr(Loc, Ctx, 0); 2935 A->setImplicit(true); 2936 return A; 2937 } 2938 2939 FastCallAttr(SourceRange R, ASTContext &Ctx 2940 , unsigned SI 2941 ) 2942 : InheritableAttr(attr::FastCall, R, SI, false, false) 2943 { 2944 } 2945 2946 FastCallAttr *clone(ASTContext &C) const; 2947 void printPretty(raw_ostream &OS, 2948 const PrintingPolicy &Policy) const; 2949 const char *getSpelling() const; 2950 2951 2952 static bool classof(const Attr *A) { return A->getKind() == attr::FastCall; } 2953}; 2954 2955class FinalAttr : public InheritableAttr { 2956public: 2957 enum Spelling { 2958 Keyword_final = 0, 2959 Keyword_sealed = 1 2960 }; 2961 2962 static FinalAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 2963 auto *A = new (Ctx) FinalAttr(Loc, Ctx, S); 2964 A->setImplicit(true); 2965 return A; 2966 } 2967 2968 FinalAttr(SourceRange R, ASTContext &Ctx 2969 , unsigned SI 2970 ) 2971 : InheritableAttr(attr::Final, R, SI, false, false) 2972 { 2973 } 2974 2975 FinalAttr *clone(ASTContext &C) const; 2976 void printPretty(raw_ostream &OS, 2977 const PrintingPolicy &Policy) const; 2978 const char *getSpelling() const; 2979 Spelling getSemanticSpelling() const { 2980 switch (SpellingListIndex) { 2981 default: llvm_unreachable("Unknown spelling list index"); 2982 case 0: return Keyword_final; 2983 case 1: return Keyword_sealed; 2984 } 2985 } 2986 bool isSpelledAsSealed() const { return SpellingListIndex == 1; } 2987 2988 2989 static bool classof(const Attr *A) { return A->getKind() == attr::Final; } 2990}; 2991 2992class FlagEnumAttr : public InheritableAttr { 2993public: 2994 static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 2995 auto *A = new (Ctx) FlagEnumAttr(Loc, Ctx, 0); 2996 A->setImplicit(true); 2997 return A; 2998 } 2999 3000 FlagEnumAttr(SourceRange R, ASTContext &Ctx 3001 , unsigned SI 3002 ) 3003 : InheritableAttr(attr::FlagEnum, R, SI, false, false) 3004 { 3005 } 3006 3007 FlagEnumAttr *clone(ASTContext &C) const; 3008 void printPretty(raw_ostream &OS, 3009 const PrintingPolicy &Policy) const; 3010 const char *getSpelling() const; 3011 3012 3013 static bool classof(const Attr *A) { return A->getKind() == attr::FlagEnum; } 3014}; 3015 3016class FlattenAttr : public InheritableAttr { 3017public: 3018 static FlattenAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3019 auto *A = new (Ctx) FlattenAttr(Loc, Ctx, 0); 3020 A->setImplicit(true); 3021 return A; 3022 } 3023 3024 FlattenAttr(SourceRange R, ASTContext &Ctx 3025 , unsigned SI 3026 ) 3027 : InheritableAttr(attr::Flatten, R, SI, false, false) 3028 { 3029 } 3030 3031 FlattenAttr *clone(ASTContext &C) const; 3032 void printPretty(raw_ostream &OS, 3033 const PrintingPolicy &Policy) const; 3034 const char *getSpelling() const; 3035 3036 3037 static bool classof(const Attr *A) { return A->getKind() == attr::Flatten; } 3038}; 3039 3040class FormatAttr : public InheritableAttr { 3041IdentifierInfo * type; 3042 3043int formatIdx; 3044 3045int firstArg; 3046 3047public: 3048 static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Loc = SourceRange()) { 3049 auto *A = new (Ctx) FormatAttr(Loc, Ctx, Type, FormatIdx, FirstArg, 0); 3050 A->setImplicit(true); 3051 return A; 3052 } 3053 3054 FormatAttr(SourceRange R, ASTContext &Ctx 3055 , IdentifierInfo * Type 3056 , int FormatIdx 3057 , int FirstArg 3058 , unsigned SI 3059 ) 3060 : InheritableAttr(attr::Format, R, SI, false, false) 3061 , type(Type) 3062 , formatIdx(FormatIdx) 3063 , firstArg(FirstArg) 3064 { 3065 } 3066 3067 FormatAttr *clone(ASTContext &C) const; 3068 void printPretty(raw_ostream &OS, 3069 const PrintingPolicy &Policy) const; 3070 const char *getSpelling() const; 3071 IdentifierInfo * getType() const { 3072 return type; 3073 } 3074 3075 int getFormatIdx() const { 3076 return formatIdx; 3077 } 3078 3079 int getFirstArg() const { 3080 return firstArg; 3081 } 3082 3083 3084 3085 static bool classof(const Attr *A) { return A->getKind() == attr::Format; } 3086}; 3087 3088class FormatArgAttr : public InheritableAttr { 3089int formatIdx; 3090 3091public: 3092 static FormatArgAttr *CreateImplicit(ASTContext &Ctx, int FormatIdx, SourceRange Loc = SourceRange()) { 3093 auto *A = new (Ctx) FormatArgAttr(Loc, Ctx, FormatIdx, 0); 3094 A->setImplicit(true); 3095 return A; 3096 } 3097 3098 FormatArgAttr(SourceRange R, ASTContext &Ctx 3099 , int FormatIdx 3100 , unsigned SI 3101 ) 3102 : InheritableAttr(attr::FormatArg, R, SI, false, false) 3103 , formatIdx(FormatIdx) 3104 { 3105 } 3106 3107 FormatArgAttr *clone(ASTContext &C) const; 3108 void printPretty(raw_ostream &OS, 3109 const PrintingPolicy &Policy) const; 3110 const char *getSpelling() const; 3111 int getFormatIdx() const { 3112 return formatIdx; 3113 } 3114 3115 3116 3117 static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; } 3118}; 3119 3120class GNUInlineAttr : public InheritableAttr { 3121public: 3122 static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3123 auto *A = new (Ctx) GNUInlineAttr(Loc, Ctx, 0); 3124 A->setImplicit(true); 3125 return A; 3126 } 3127 3128 GNUInlineAttr(SourceRange R, ASTContext &Ctx 3129 , unsigned SI 3130 ) 3131 : InheritableAttr(attr::GNUInline, R, SI, false, false) 3132 { 3133 } 3134 3135 GNUInlineAttr *clone(ASTContext &C) const; 3136 void printPretty(raw_ostream &OS, 3137 const PrintingPolicy &Policy) const; 3138 const char *getSpelling() const; 3139 3140 3141 static bool classof(const Attr *A) { return A->getKind() == attr::GNUInline; } 3142}; 3143 3144class GuardedByAttr : public InheritableAttr { 3145Expr * arg; 3146 3147public: 3148 static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) { 3149 auto *A = new (Ctx) GuardedByAttr(Loc, Ctx, Arg, 0); 3150 A->setImplicit(true); 3151 return A; 3152 } 3153 3154 GuardedByAttr(SourceRange R, ASTContext &Ctx 3155 , Expr * Arg 3156 , unsigned SI 3157 ) 3158 : InheritableAttr(attr::GuardedBy, R, SI, true, true) 3159 , arg(Arg) 3160 { 3161 } 3162 3163 GuardedByAttr *clone(ASTContext &C) const; 3164 void printPretty(raw_ostream &OS, 3165 const PrintingPolicy &Policy) const; 3166 const char *getSpelling() const; 3167 Expr * getArg() const { 3168 return arg; 3169 } 3170 3171 3172 3173 static bool classof(const Attr *A) { return A->getKind() == attr::GuardedBy; } 3174}; 3175 3176class GuardedVarAttr : public InheritableAttr { 3177public: 3178 static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3179 auto *A = new (Ctx) GuardedVarAttr(Loc, Ctx, 0); 3180 A->setImplicit(true); 3181 return A; 3182 } 3183 3184 GuardedVarAttr(SourceRange R, ASTContext &Ctx 3185 , unsigned SI 3186 ) 3187 : InheritableAttr(attr::GuardedVar, R, SI, false, false) 3188 { 3189 } 3190 3191 GuardedVarAttr *clone(ASTContext &C) const; 3192 void printPretty(raw_ostream &OS, 3193 const PrintingPolicy &Policy) const; 3194 const char *getSpelling() const; 3195 3196 3197 static bool classof(const Attr *A) { return A->getKind() == attr::GuardedVar; } 3198}; 3199 3200class HotAttr : public InheritableAttr { 3201public: 3202 static HotAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3203 auto *A = new (Ctx) HotAttr(Loc, Ctx, 0); 3204 A->setImplicit(true); 3205 return A; 3206 } 3207 3208 HotAttr(SourceRange R, ASTContext &Ctx 3209 , unsigned SI 3210 ) 3211 : InheritableAttr(attr::Hot, R, SI, false, false) 3212 { 3213 } 3214 3215 HotAttr *clone(ASTContext &C) const; 3216 void printPretty(raw_ostream &OS, 3217 const PrintingPolicy &Policy) const; 3218 const char *getSpelling() const; 3219 3220 3221 static bool classof(const Attr *A) { return A->getKind() == attr::Hot; } 3222}; 3223 3224class IBActionAttr : public InheritableAttr { 3225public: 3226 static IBActionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3227 auto *A = new (Ctx) IBActionAttr(Loc, Ctx, 0); 3228 A->setImplicit(true); 3229 return A; 3230 } 3231 3232 IBActionAttr(SourceRange R, ASTContext &Ctx 3233 , unsigned SI 3234 ) 3235 : InheritableAttr(attr::IBAction, R, SI, false, false) 3236 { 3237 } 3238 3239 IBActionAttr *clone(ASTContext &C) const; 3240 void printPretty(raw_ostream &OS, 3241 const PrintingPolicy &Policy) const; 3242 const char *getSpelling() const; 3243 3244 3245 static bool classof(const Attr *A) { return A->getKind() == attr::IBAction; } 3246}; 3247 3248class IBOutletAttr : public InheritableAttr { 3249public: 3250 static IBOutletAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3251 auto *A = new (Ctx) IBOutletAttr(Loc, Ctx, 0); 3252 A->setImplicit(true); 3253 return A; 3254 } 3255 3256 IBOutletAttr(SourceRange R, ASTContext &Ctx 3257 , unsigned SI 3258 ) 3259 : InheritableAttr(attr::IBOutlet, R, SI, false, false) 3260 { 3261 } 3262 3263 IBOutletAttr *clone(ASTContext &C) const; 3264 void printPretty(raw_ostream &OS, 3265 const PrintingPolicy &Policy) const; 3266 const char *getSpelling() const; 3267 3268 3269 static bool classof(const Attr *A) { return A->getKind() == attr::IBOutlet; } 3270}; 3271 3272class IBOutletCollectionAttr : public InheritableAttr { 3273TypeSourceInfo * interface_; 3274 3275public: 3276 static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Loc = SourceRange()) { 3277 auto *A = new (Ctx) IBOutletCollectionAttr(Loc, Ctx, Interface, 0); 3278 A->setImplicit(true); 3279 return A; 3280 } 3281 3282 IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx 3283 , TypeSourceInfo * Interface 3284 , unsigned SI 3285 ) 3286 : InheritableAttr(attr::IBOutletCollection, R, SI, false, false) 3287 , interface_(Interface) 3288 { 3289 } 3290 3291 IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx 3292 , unsigned SI 3293 ) 3294 : InheritableAttr(attr::IBOutletCollection, R, SI, false, false) 3295 , interface_() 3296 { 3297 } 3298 3299 IBOutletCollectionAttr *clone(ASTContext &C) const; 3300 void printPretty(raw_ostream &OS, 3301 const PrintingPolicy &Policy) const; 3302 const char *getSpelling() const; 3303 QualType getInterface() const { 3304 return interface_->getType(); 3305 } TypeSourceInfo * getInterfaceLoc() const { 3306 return interface_; 3307 } 3308 3309 3310 3311 static bool classof(const Attr *A) { return A->getKind() == attr::IBOutletCollection; } 3312}; 3313 3314class IFuncAttr : public Attr { 3315unsigned resolverLength; 3316char *resolver; 3317 3318public: 3319 static IFuncAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Resolver, SourceRange Loc = SourceRange()) { 3320 auto *A = new (Ctx) IFuncAttr(Loc, Ctx, Resolver, 0); 3321 A->setImplicit(true); 3322 return A; 3323 } 3324 3325 IFuncAttr(SourceRange R, ASTContext &Ctx 3326 , llvm::StringRef Resolver 3327 , unsigned SI 3328 ) 3329 : Attr(attr::IFunc, R, SI, false, false) 3330 , resolverLength(Resolver.size()),resolver(new (Ctx, 1) char[resolverLength]) 3331 { 3332 if (!Resolver.empty()) 3333 std::memcpy(resolver, Resolver.data(), resolverLength); 3334 } 3335 3336 IFuncAttr *clone(ASTContext &C) const; 3337 void printPretty(raw_ostream &OS, 3338 const PrintingPolicy &Policy) const; 3339 const char *getSpelling() const; 3340 llvm::StringRef getResolver() const { 3341 return llvm::StringRef(resolver, resolverLength); 3342 } 3343 unsigned getResolverLength() const { 3344 return resolverLength; 3345 } 3346 void setResolver(ASTContext &C, llvm::StringRef S) { 3347 resolverLength = S.size(); 3348 this->resolver = new (C, 1) char [resolverLength]; 3349 if (!S.empty()) 3350 std::memcpy(this->resolver, S.data(), resolverLength); 3351 } 3352 3353 3354 3355 static bool classof(const Attr *A) { return A->getKind() == attr::IFunc; } 3356}; 3357 3358class InitPriorityAttr : public InheritableAttr { 3359unsigned priority; 3360 3361public: 3362 static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, SourceRange Loc = SourceRange()) { 3363 auto *A = new (Ctx) InitPriorityAttr(Loc, Ctx, Priority, 0); 3364 A->setImplicit(true); 3365 return A; 3366 } 3367 3368 InitPriorityAttr(SourceRange R, ASTContext &Ctx 3369 , unsigned Priority 3370 , unsigned SI 3371 ) 3372 : InheritableAttr(attr::InitPriority, R, SI, false, false) 3373 , priority(Priority) 3374 { 3375 } 3376 3377 InitPriorityAttr *clone(ASTContext &C) const; 3378 void printPretty(raw_ostream &OS, 3379 const PrintingPolicy &Policy) const; 3380 const char *getSpelling() const; 3381 unsigned getPriority() const { 3382 return priority; 3383 } 3384 3385 3386 3387 static bool classof(const Attr *A) { return A->getKind() == attr::InitPriority; } 3388}; 3389 3390class InitSegAttr : public Attr { 3391unsigned sectionLength; 3392char *section; 3393 3394public: 3395 static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, SourceRange Loc = SourceRange()) { 3396 auto *A = new (Ctx) InitSegAttr(Loc, Ctx, Section, 0); 3397 A->setImplicit(true); 3398 return A; 3399 } 3400 3401 InitSegAttr(SourceRange R, ASTContext &Ctx 3402 , llvm::StringRef Section 3403 , unsigned SI 3404 ) 3405 : Attr(attr::InitSeg, R, SI, false, false) 3406 , sectionLength(Section.size()),section(new (Ctx, 1) char[sectionLength]) 3407 { 3408 if (!Section.empty()) 3409 std::memcpy(section, Section.data(), sectionLength); 3410 } 3411 3412 InitSegAttr *clone(ASTContext &C) const; 3413 void printPretty(raw_ostream &OS, 3414 const PrintingPolicy &Policy) const; 3415 const char *getSpelling() const; 3416 llvm::StringRef getSection() const { 3417 return llvm::StringRef(section, sectionLength); 3418 } 3419 unsigned getSectionLength() const { 3420 return sectionLength; 3421 } 3422 void setSection(ASTContext &C, llvm::StringRef S) { 3423 sectionLength = S.size(); 3424 this->section = new (C, 1) char [sectionLength]; 3425 if (!S.empty()) 3426 std::memcpy(this->section, S.data(), sectionLength); 3427 } 3428 3429 3430 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const { 3431 OS << '(' << getSection() << ')'; 3432 } 3433 3434 3435 static bool classof(const Attr *A) { return A->getKind() == attr::InitSeg; } 3436}; 3437 3438class IntelOclBiccAttr : public InheritableAttr { 3439public: 3440 static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3441 auto *A = new (Ctx) IntelOclBiccAttr(Loc, Ctx, 0); 3442 A->setImplicit(true); 3443 return A; 3444 } 3445 3446 IntelOclBiccAttr(SourceRange R, ASTContext &Ctx 3447 , unsigned SI 3448 ) 3449 : InheritableAttr(attr::IntelOclBicc, R, SI, false, false) 3450 { 3451 } 3452 3453 IntelOclBiccAttr *clone(ASTContext &C) const; 3454 void printPretty(raw_ostream &OS, 3455 const PrintingPolicy &Policy) const; 3456 const char *getSpelling() const; 3457 3458 3459 static bool classof(const Attr *A) { return A->getKind() == attr::IntelOclBicc; } 3460}; 3461 3462class InternalLinkageAttr : public InheritableAttr { 3463public: 3464 static InternalLinkageAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3465 auto *A = new (Ctx) InternalLinkageAttr(Loc, Ctx, 0); 3466 A->setImplicit(true); 3467 return A; 3468 } 3469 3470 InternalLinkageAttr(SourceRange R, ASTContext &Ctx 3471 , unsigned SI 3472 ) 3473 : InheritableAttr(attr::InternalLinkage, R, SI, false, false) 3474 { 3475 } 3476 3477 InternalLinkageAttr *clone(ASTContext &C) const; 3478 void printPretty(raw_ostream &OS, 3479 const PrintingPolicy &Policy) const; 3480 const char *getSpelling() const; 3481 3482 3483 static bool classof(const Attr *A) { return A->getKind() == attr::InternalLinkage; } 3484}; 3485 3486class LTOVisibilityPublicAttr : public InheritableAttr { 3487public: 3488 static LTOVisibilityPublicAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3489 auto *A = new (Ctx) LTOVisibilityPublicAttr(Loc, Ctx, 0); 3490 A->setImplicit(true); 3491 return A; 3492 } 3493 3494 LTOVisibilityPublicAttr(SourceRange R, ASTContext &Ctx 3495 , unsigned SI 3496 ) 3497 : InheritableAttr(attr::LTOVisibilityPublic, R, SI, false, false) 3498 { 3499 } 3500 3501 LTOVisibilityPublicAttr *clone(ASTContext &C) const; 3502 void printPretty(raw_ostream &OS, 3503 const PrintingPolicy &Policy) const; 3504 const char *getSpelling() const; 3505 3506 3507 static bool classof(const Attr *A) { return A->getKind() == attr::LTOVisibilityPublic; } 3508}; 3509 3510class LayoutVersionAttr : public InheritableAttr { 3511unsigned version; 3512 3513public: 3514 static LayoutVersionAttr *CreateImplicit(ASTContext &Ctx, unsigned Version, SourceRange Loc = SourceRange()) { 3515 auto *A = new (Ctx) LayoutVersionAttr(Loc, Ctx, Version, 0); 3516 A->setImplicit(true); 3517 return A; 3518 } 3519 3520 LayoutVersionAttr(SourceRange R, ASTContext &Ctx 3521 , unsigned Version 3522 , unsigned SI 3523 ) 3524 : InheritableAttr(attr::LayoutVersion, R, SI, false, false) 3525 , version(Version) 3526 { 3527 } 3528 3529 LayoutVersionAttr *clone(ASTContext &C) const; 3530 void printPretty(raw_ostream &OS, 3531 const PrintingPolicy &Policy) const; 3532 const char *getSpelling() const; 3533 unsigned getVersion() const { 3534 return version; 3535 } 3536 3537 3538 3539 static bool classof(const Attr *A) { return A->getKind() == attr::LayoutVersion; } 3540}; 3541 3542class LockReturnedAttr : public InheritableAttr { 3543Expr * arg; 3544 3545public: 3546 static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) { 3547 auto *A = new (Ctx) LockReturnedAttr(Loc, Ctx, Arg, 0); 3548 A->setImplicit(true); 3549 return A; 3550 } 3551 3552 LockReturnedAttr(SourceRange R, ASTContext &Ctx 3553 , Expr * Arg 3554 , unsigned SI 3555 ) 3556 : InheritableAttr(attr::LockReturned, R, SI, true, false) 3557 , arg(Arg) 3558 { 3559 } 3560 3561 LockReturnedAttr *clone(ASTContext &C) const; 3562 void printPretty(raw_ostream &OS, 3563 const PrintingPolicy &Policy) const; 3564 const char *getSpelling() const; 3565 Expr * getArg() const { 3566 return arg; 3567 } 3568 3569 3570 3571 static bool classof(const Attr *A) { return A->getKind() == attr::LockReturned; } 3572}; 3573 3574class LocksExcludedAttr : public InheritableAttr { 3575 unsigned args_Size; 3576 Expr * *args_; 3577 3578public: 3579 static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 3580 auto *A = new (Ctx) LocksExcludedAttr(Loc, Ctx, Args, ArgsSize, 0); 3581 A->setImplicit(true); 3582 return A; 3583 } 3584 3585 LocksExcludedAttr(SourceRange R, ASTContext &Ctx 3586 , Expr * *Args, unsigned ArgsSize 3587 , unsigned SI 3588 ) 3589 : InheritableAttr(attr::LocksExcluded, R, SI, true, true) 3590 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 3591 { 3592 std::copy(Args, Args + args_Size, args_); 3593 } 3594 3595 LocksExcludedAttr(SourceRange R, ASTContext &Ctx 3596 , unsigned SI 3597 ) 3598 : InheritableAttr(attr::LocksExcluded, R, SI, true, true) 3599 , args_Size(0), args_(nullptr) 3600 { 3601 } 3602 3603 LocksExcludedAttr *clone(ASTContext &C) const; 3604 void printPretty(raw_ostream &OS, 3605 const PrintingPolicy &Policy) const; 3606 const char *getSpelling() const; 3607 typedef Expr ** args_iterator; 3608 args_iterator args_begin() const { return args_; } 3609 args_iterator args_end() const { return args_ + args_Size; } 3610 unsigned args_size() const { return args_Size; } 3611 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 3612 3613 3614 3615 3616 static bool classof(const Attr *A) { return A->getKind() == attr::LocksExcluded; } 3617}; 3618 3619class LoopHintAttr : public Attr { 3620public: 3621 enum OptionType { 3622 Vectorize, 3623 VectorizeWidth, 3624 Interleave, 3625 InterleaveCount, 3626 Unroll, 3627 UnrollCount, 3628 Distribute 3629 }; 3630private: 3631 OptionType option; 3632 3633public: 3634 enum LoopHintState { 3635 Enable, 3636 Disable, 3637 Numeric, 3638 AssumeSafety, 3639 Full 3640 }; 3641private: 3642 LoopHintState state; 3643 3644Expr * value; 3645 3646public: 3647 enum Spelling { 3648 Pragma_clang_loop = 0, 3649 Pragma_unroll = 1, 3650 Pragma_nounroll = 2 3651 }; 3652 3653 static LoopHintAttr *CreateImplicit(ASTContext &Ctx, Spelling S, OptionType Option, LoopHintState State, Expr * Value, SourceRange Loc = SourceRange()) { 3654 auto *A = new (Ctx) LoopHintAttr(Loc, Ctx, Option, State, Value, S); 3655 A->setImplicit(true); 3656 return A; 3657 } 3658 3659 LoopHintAttr(SourceRange R, ASTContext &Ctx 3660 , OptionType Option 3661 , LoopHintState State 3662 , Expr * Value 3663 , unsigned SI 3664 ) 3665 : Attr(attr::LoopHint, R, SI, false, false) 3666 , option(Option) 3667 , state(State) 3668 , value(Value) 3669 { 3670 } 3671 3672 LoopHintAttr *clone(ASTContext &C) const; 3673 void printPretty(raw_ostream &OS, 3674 const PrintingPolicy &Policy) const; 3675 const char *getSpelling() const; 3676 Spelling getSemanticSpelling() const { 3677 switch (SpellingListIndex) { 3678 default: llvm_unreachable("Unknown spelling list index"); 3679 case 0: return Pragma_clang_loop; 3680 case 1: return Pragma_unroll; 3681 case 2: return Pragma_nounroll; 3682 } 3683 } 3684 OptionType getOption() const { 3685 return option; 3686 } 3687 3688 static bool ConvertStrToOptionType(StringRef Val, OptionType &Out) { 3689 Optional<OptionType> R = llvm::StringSwitch<Optional<OptionType>>(Val) 3690 .Case("vectorize", LoopHintAttr::Vectorize) 3691 .Case("vectorize_width", LoopHintAttr::VectorizeWidth) 3692 .Case("interleave", LoopHintAttr::Interleave) 3693 .Case("interleave_count", LoopHintAttr::InterleaveCount) 3694 .Case("unroll", LoopHintAttr::Unroll) 3695 .Case("unroll_count", LoopHintAttr::UnrollCount) 3696 .Case("distribute", LoopHintAttr::Distribute) 3697 .Default(Optional<OptionType>()); 3698 if (R) { 3699 Out = *R; 3700 return true; 3701 } 3702 return false; 3703 } 3704 3705 static const char *ConvertOptionTypeToStr(OptionType Val) { 3706 switch(Val) { 3707 case LoopHintAttr::Vectorize: return "vectorize"; 3708 case LoopHintAttr::VectorizeWidth: return "vectorize_width"; 3709 case LoopHintAttr::Interleave: return "interleave"; 3710 case LoopHintAttr::InterleaveCount: return "interleave_count"; 3711 case LoopHintAttr::Unroll: return "unroll"; 3712 case LoopHintAttr::UnrollCount: return "unroll_count"; 3713 case LoopHintAttr::Distribute: return "distribute"; 3714 } 3715 llvm_unreachable("No enumerator with that value"); 3716 } 3717 LoopHintState getState() const { 3718 return state; 3719 } 3720 3721 static bool ConvertStrToLoopHintState(StringRef Val, LoopHintState &Out) { 3722 Optional<LoopHintState> R = llvm::StringSwitch<Optional<LoopHintState>>(Val) 3723 .Case("enable", LoopHintAttr::Enable) 3724 .Case("disable", LoopHintAttr::Disable) 3725 .Case("numeric", LoopHintAttr::Numeric) 3726 .Case("assume_safety", LoopHintAttr::AssumeSafety) 3727 .Case("full", LoopHintAttr::Full) 3728 .Default(Optional<LoopHintState>()); 3729 if (R) { 3730 Out = *R; 3731 return true; 3732 } 3733 return false; 3734 } 3735 3736 static const char *ConvertLoopHintStateToStr(LoopHintState Val) { 3737 switch(Val) { 3738 case LoopHintAttr::Enable: return "enable"; 3739 case LoopHintAttr::Disable: return "disable"; 3740 case LoopHintAttr::Numeric: return "numeric"; 3741 case LoopHintAttr::AssumeSafety: return "assume_safety"; 3742 case LoopHintAttr::Full: return "full"; 3743 } 3744 llvm_unreachable("No enumerator with that value"); 3745 } 3746 Expr * getValue() const { 3747 return value; 3748 } 3749 3750 3751 static const char *getOptionName(int Option) { 3752 switch(Option) { 3753 case Vectorize: return "vectorize"; 3754 case VectorizeWidth: return "vectorize_width"; 3755 case Interleave: return "interleave"; 3756 case InterleaveCount: return "interleave_count"; 3757 case Unroll: return "unroll"; 3758 case UnrollCount: return "unroll_count"; 3759 case Distribute: return "distribute"; 3760 } 3761 llvm_unreachable("Unhandled LoopHint option."); 3762 } 3763 3764 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const { 3765 unsigned SpellingIndex = getSpellingListIndex(); 3766 // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or 3767 // "nounroll" is already emitted as the pragma name. 3768 if (SpellingIndex == Pragma_nounroll) 3769 return; 3770 else if (SpellingIndex == Pragma_unroll) { 3771 OS << getValueString(Policy); 3772 return; 3773 } 3774 3775 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling"); 3776 OS << getOptionName(option) << getValueString(Policy); 3777 } 3778 3779 // Return a string containing the loop hint argument including the 3780 // enclosing parentheses. 3781 std::string getValueString(const PrintingPolicy &Policy) const { 3782 std::string ValueName; 3783 llvm::raw_string_ostream OS(ValueName); 3784 OS << "("; 3785 if (state == Numeric) 3786 value->printPretty(OS, nullptr, Policy); 3787 else if (state == Enable) 3788 OS << "enable"; 3789 else if (state == Full) 3790 OS << "full"; 3791 else if (state == AssumeSafety) 3792 OS << "assume_safety"; 3793 else 3794 OS << "disable"; 3795 OS << ")"; 3796 return OS.str(); 3797 } 3798 3799 // Return a string suitable for identifying this attribute in diagnostics. 3800 std::string getDiagnosticName(const PrintingPolicy &Policy) const { 3801 unsigned SpellingIndex = getSpellingListIndex(); 3802 if (SpellingIndex == Pragma_nounroll) 3803 return "#pragma nounroll"; 3804 else if (SpellingIndex == Pragma_unroll) 3805 return "#pragma unroll" + (option == UnrollCount ? getValueString(Policy) : ""); 3806 3807 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling"); 3808 return getOptionName(option) + getValueString(Policy); 3809 } 3810 3811 3812 static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; } 3813}; 3814 3815class MSABIAttr : public InheritableAttr { 3816public: 3817 static MSABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3818 auto *A = new (Ctx) MSABIAttr(Loc, Ctx, 0); 3819 A->setImplicit(true); 3820 return A; 3821 } 3822 3823 MSABIAttr(SourceRange R, ASTContext &Ctx 3824 , unsigned SI 3825 ) 3826 : InheritableAttr(attr::MSABI, R, SI, false, false) 3827 { 3828 } 3829 3830 MSABIAttr *clone(ASTContext &C) const; 3831 void printPretty(raw_ostream &OS, 3832 const PrintingPolicy &Policy) const; 3833 const char *getSpelling() const; 3834 3835 3836 static bool classof(const Attr *A) { return A->getKind() == attr::MSABI; } 3837}; 3838 3839class MSInheritanceAttr : public InheritableAttr { 3840bool bestCase; 3841 3842public: 3843 enum Spelling { 3844 Keyword_single_inheritance = 0, 3845 Keyword_multiple_inheritance = 1, 3846 Keyword_virtual_inheritance = 2, 3847 Keyword_unspecified_inheritance = 3 3848 }; 3849 3850 static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool BestCase, SourceRange Loc = SourceRange()) { 3851 auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, BestCase, S); 3852 A->setImplicit(true); 3853 return A; 3854 } 3855 3856 MSInheritanceAttr(SourceRange R, ASTContext &Ctx 3857 , bool BestCase 3858 , unsigned SI 3859 ) 3860 : InheritableAttr(attr::MSInheritance, R, SI, false, false) 3861 , bestCase(BestCase) 3862 { 3863 } 3864 3865 MSInheritanceAttr(SourceRange R, ASTContext &Ctx 3866 , unsigned SI 3867 ) 3868 : InheritableAttr(attr::MSInheritance, R, SI, false, false) 3869 , bestCase() 3870 { 3871 } 3872 3873 MSInheritanceAttr *clone(ASTContext &C) const; 3874 void printPretty(raw_ostream &OS, 3875 const PrintingPolicy &Policy) const; 3876 const char *getSpelling() const; 3877 Spelling getSemanticSpelling() const { 3878 switch (SpellingListIndex) { 3879 default: llvm_unreachable("Unknown spelling list index"); 3880 case 0: return Keyword_single_inheritance; 3881 case 1: return Keyword_multiple_inheritance; 3882 case 2: return Keyword_virtual_inheritance; 3883 case 3: return Keyword_unspecified_inheritance; 3884 } 3885 } 3886 bool getBestCase() const { 3887 return bestCase; 3888 } 3889 3890 static const bool DefaultBestCase = true; 3891 3892 3893 static bool hasVBPtrOffsetField(Spelling Inheritance) { 3894 return Inheritance == Keyword_unspecified_inheritance; 3895 } 3896 3897 // Only member pointers to functions need a this adjustment, since it can be 3898 // combined with the field offset for data pointers. 3899 static bool hasNVOffsetField(bool IsMemberFunction, Spelling Inheritance) { 3900 return IsMemberFunction && Inheritance >= Keyword_multiple_inheritance; 3901 } 3902 3903 static bool hasVBTableOffsetField(Spelling Inheritance) { 3904 return Inheritance >= Keyword_virtual_inheritance; 3905 } 3906 3907 static bool hasOnlyOneField(bool IsMemberFunction, 3908 Spelling Inheritance) { 3909 if (IsMemberFunction) 3910 return Inheritance <= Keyword_single_inheritance; 3911 return Inheritance <= Keyword_multiple_inheritance; 3912 } 3913 3914 3915 static bool classof(const Attr *A) { return A->getKind() == attr::MSInheritance; } 3916}; 3917 3918class MSNoVTableAttr : public InheritableAttr { 3919public: 3920 static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3921 auto *A = new (Ctx) MSNoVTableAttr(Loc, Ctx, 0); 3922 A->setImplicit(true); 3923 return A; 3924 } 3925 3926 MSNoVTableAttr(SourceRange R, ASTContext &Ctx 3927 , unsigned SI 3928 ) 3929 : InheritableAttr(attr::MSNoVTable, R, SI, false, false) 3930 { 3931 } 3932 3933 MSNoVTableAttr *clone(ASTContext &C) const; 3934 void printPretty(raw_ostream &OS, 3935 const PrintingPolicy &Policy) const; 3936 const char *getSpelling() const; 3937 3938 3939 static bool classof(const Attr *A) { return A->getKind() == attr::MSNoVTable; } 3940}; 3941 3942class MSP430InterruptAttr : public InheritableAttr { 3943unsigned number; 3944 3945public: 3946 static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Loc = SourceRange()) { 3947 auto *A = new (Ctx) MSP430InterruptAttr(Loc, Ctx, Number, 0); 3948 A->setImplicit(true); 3949 return A; 3950 } 3951 3952 MSP430InterruptAttr(SourceRange R, ASTContext &Ctx 3953 , unsigned Number 3954 , unsigned SI 3955 ) 3956 : InheritableAttr(attr::MSP430Interrupt, R, SI, false, false) 3957 , number(Number) 3958 { 3959 } 3960 3961 MSP430InterruptAttr *clone(ASTContext &C) const; 3962 void printPretty(raw_ostream &OS, 3963 const PrintingPolicy &Policy) const; 3964 const char *getSpelling() const; 3965 unsigned getNumber() const { 3966 return number; 3967 } 3968 3969 3970 3971 static bool classof(const Attr *A) { return A->getKind() == attr::MSP430Interrupt; } 3972}; 3973 3974class MSStructAttr : public InheritableAttr { 3975public: 3976 static MSStructAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 3977 auto *A = new (Ctx) MSStructAttr(Loc, Ctx, 0); 3978 A->setImplicit(true); 3979 return A; 3980 } 3981 3982 MSStructAttr(SourceRange R, ASTContext &Ctx 3983 , unsigned SI 3984 ) 3985 : InheritableAttr(attr::MSStruct, R, SI, false, false) 3986 { 3987 } 3988 3989 MSStructAttr *clone(ASTContext &C) const; 3990 void printPretty(raw_ostream &OS, 3991 const PrintingPolicy &Policy) const; 3992 const char *getSpelling() const; 3993 3994 3995 static bool classof(const Attr *A) { return A->getKind() == attr::MSStruct; } 3996}; 3997 3998class MSVtorDispAttr : public InheritableAttr { 3999unsigned vdm; 4000 4001public: 4002 static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, SourceRange Loc = SourceRange()) { 4003 auto *A = new (Ctx) MSVtorDispAttr(Loc, Ctx, Vdm, 0); 4004 A->setImplicit(true); 4005 return A; 4006 } 4007 4008 MSVtorDispAttr(SourceRange R, ASTContext &Ctx 4009 , unsigned Vdm 4010 , unsigned SI 4011 ) 4012 : InheritableAttr(attr::MSVtorDisp, R, SI, false, false) 4013 , vdm(Vdm) 4014 { 4015 } 4016 4017 MSVtorDispAttr *clone(ASTContext &C) const; 4018 void printPretty(raw_ostream &OS, 4019 const PrintingPolicy &Policy) const; 4020 const char *getSpelling() const; 4021 unsigned getVdm() const { 4022 return vdm; 4023 } 4024 4025 4026 enum Mode { 4027 Never, 4028 ForVBaseOverride, 4029 ForVFTable 4030 }; 4031 4032 Mode getVtorDispMode() const { return Mode(vdm); } 4033 4034 4035 static bool classof(const Attr *A) { return A->getKind() == attr::MSVtorDisp; } 4036}; 4037 4038class MaxFieldAlignmentAttr : public InheritableAttr { 4039unsigned alignment; 4040 4041public: 4042 static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Loc = SourceRange()) { 4043 auto *A = new (Ctx) MaxFieldAlignmentAttr(Loc, Ctx, Alignment, 0); 4044 A->setImplicit(true); 4045 return A; 4046 } 4047 4048 MaxFieldAlignmentAttr(SourceRange R, ASTContext &Ctx 4049 , unsigned Alignment 4050 , unsigned SI 4051 ) 4052 : InheritableAttr(attr::MaxFieldAlignment, R, SI, false, false) 4053 , alignment(Alignment) 4054 { 4055 } 4056 4057 MaxFieldAlignmentAttr *clone(ASTContext &C) const; 4058 void printPretty(raw_ostream &OS, 4059 const PrintingPolicy &Policy) const; 4060 const char *getSpelling() const; 4061 unsigned getAlignment() const { 4062 return alignment; 4063 } 4064 4065 4066 4067 static bool classof(const Attr *A) { return A->getKind() == attr::MaxFieldAlignment; } 4068}; 4069 4070class MayAliasAttr : public InheritableAttr { 4071public: 4072 static MayAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4073 auto *A = new (Ctx) MayAliasAttr(Loc, Ctx, 0); 4074 A->setImplicit(true); 4075 return A; 4076 } 4077 4078 MayAliasAttr(SourceRange R, ASTContext &Ctx 4079 , unsigned SI 4080 ) 4081 : InheritableAttr(attr::MayAlias, R, SI, false, false) 4082 { 4083 } 4084 4085 MayAliasAttr *clone(ASTContext &C) const; 4086 void printPretty(raw_ostream &OS, 4087 const PrintingPolicy &Policy) const; 4088 const char *getSpelling() const; 4089 4090 4091 static bool classof(const Attr *A) { return A->getKind() == attr::MayAlias; } 4092}; 4093 4094class MicroMipsAttr : public InheritableAttr { 4095public: 4096 static MicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4097 auto *A = new (Ctx) MicroMipsAttr(Loc, Ctx, 0); 4098 A->setImplicit(true); 4099 return A; 4100 } 4101 4102 MicroMipsAttr(SourceRange R, ASTContext &Ctx 4103 , unsigned SI 4104 ) 4105 : InheritableAttr(attr::MicroMips, R, SI, false, false) 4106 { 4107 } 4108 4109 MicroMipsAttr *clone(ASTContext &C) const; 4110 void printPretty(raw_ostream &OS, 4111 const PrintingPolicy &Policy) const; 4112 const char *getSpelling() const; 4113 4114 4115 static bool classof(const Attr *A) { return A->getKind() == attr::MicroMips; } 4116}; 4117 4118class MinSizeAttr : public InheritableAttr { 4119public: 4120 static MinSizeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4121 auto *A = new (Ctx) MinSizeAttr(Loc, Ctx, 0); 4122 A->setImplicit(true); 4123 return A; 4124 } 4125 4126 MinSizeAttr(SourceRange R, ASTContext &Ctx 4127 , unsigned SI 4128 ) 4129 : InheritableAttr(attr::MinSize, R, SI, false, false) 4130 { 4131 } 4132 4133 MinSizeAttr *clone(ASTContext &C) const; 4134 void printPretty(raw_ostream &OS, 4135 const PrintingPolicy &Policy) const; 4136 const char *getSpelling() const; 4137 4138 4139 static bool classof(const Attr *A) { return A->getKind() == attr::MinSize; } 4140}; 4141 4142class Mips16Attr : public InheritableAttr { 4143public: 4144 static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4145 auto *A = new (Ctx) Mips16Attr(Loc, Ctx, 0); 4146 A->setImplicit(true); 4147 return A; 4148 } 4149 4150 Mips16Attr(SourceRange R, ASTContext &Ctx 4151 , unsigned SI 4152 ) 4153 : InheritableAttr(attr::Mips16, R, SI, false, false) 4154 { 4155 } 4156 4157 Mips16Attr *clone(ASTContext &C) const; 4158 void printPretty(raw_ostream &OS, 4159 const PrintingPolicy &Policy) const; 4160 const char *getSpelling() const; 4161 4162 4163 static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; } 4164}; 4165 4166class MipsInterruptAttr : public InheritableAttr { 4167public: 4168 enum InterruptType { 4169 sw0, 4170 sw1, 4171 hw0, 4172 hw1, 4173 hw2, 4174 hw3, 4175 hw4, 4176 hw5, 4177 eic 4178 }; 4179private: 4180 InterruptType interrupt; 4181 4182public: 4183 static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) { 4184 auto *A = new (Ctx) MipsInterruptAttr(Loc, Ctx, Interrupt, 0); 4185 A->setImplicit(true); 4186 return A; 4187 } 4188 4189 MipsInterruptAttr(SourceRange R, ASTContext &Ctx 4190 , InterruptType Interrupt 4191 , unsigned SI 4192 ) 4193 : InheritableAttr(attr::MipsInterrupt, R, SI, false, false) 4194 , interrupt(Interrupt) 4195 { 4196 } 4197 4198 MipsInterruptAttr *clone(ASTContext &C) const; 4199 void printPretty(raw_ostream &OS, 4200 const PrintingPolicy &Policy) const; 4201 const char *getSpelling() const; 4202 InterruptType getInterrupt() const { 4203 return interrupt; 4204 } 4205 4206 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) { 4207 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val) 4208 .Case("vector=sw0", MipsInterruptAttr::sw0) 4209 .Case("vector=sw1", MipsInterruptAttr::sw1) 4210 .Case("vector=hw0", MipsInterruptAttr::hw0) 4211 .Case("vector=hw1", MipsInterruptAttr::hw1) 4212 .Case("vector=hw2", MipsInterruptAttr::hw2) 4213 .Case("vector=hw3", MipsInterruptAttr::hw3) 4214 .Case("vector=hw4", MipsInterruptAttr::hw4) 4215 .Case("vector=hw5", MipsInterruptAttr::hw5) 4216 .Case("eic", MipsInterruptAttr::eic) 4217 .Case("", MipsInterruptAttr::eic) 4218 .Default(Optional<InterruptType>()); 4219 if (R) { 4220 Out = *R; 4221 return true; 4222 } 4223 return false; 4224 } 4225 4226 static const char *ConvertInterruptTypeToStr(InterruptType Val) { 4227 switch(Val) { 4228 case MipsInterruptAttr::sw0: return "vector=sw0"; 4229 case MipsInterruptAttr::sw1: return "vector=sw1"; 4230 case MipsInterruptAttr::hw0: return "vector=hw0"; 4231 case MipsInterruptAttr::hw1: return "vector=hw1"; 4232 case MipsInterruptAttr::hw2: return "vector=hw2"; 4233 case MipsInterruptAttr::hw3: return "vector=hw3"; 4234 case MipsInterruptAttr::hw4: return "vector=hw4"; 4235 case MipsInterruptAttr::hw5: return "vector=hw5"; 4236 case MipsInterruptAttr::eic: return "eic"; 4237 } 4238 llvm_unreachable("No enumerator with that value"); 4239 } 4240 4241 4242 static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; } 4243}; 4244 4245class MipsLongCallAttr : public InheritableAttr { 4246public: 4247 enum Spelling { 4248 GNU_long_call = 0, 4249 CXX11_gnu_long_call = 1, 4250 GNU_far = 2, 4251 CXX11_gnu_far = 3 4252 }; 4253 4254 static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 4255 auto *A = new (Ctx) MipsLongCallAttr(Loc, Ctx, S); 4256 A->setImplicit(true); 4257 return A; 4258 } 4259 4260 MipsLongCallAttr(SourceRange R, ASTContext &Ctx 4261 , unsigned SI 4262 ) 4263 : InheritableAttr(attr::MipsLongCall, R, SI, false, false) 4264 { 4265 } 4266 4267 MipsLongCallAttr *clone(ASTContext &C) const; 4268 void printPretty(raw_ostream &OS, 4269 const PrintingPolicy &Policy) const; 4270 const char *getSpelling() const; 4271 Spelling getSemanticSpelling() const { 4272 switch (SpellingListIndex) { 4273 default: llvm_unreachable("Unknown spelling list index"); 4274 case 0: return GNU_long_call; 4275 case 1: return CXX11_gnu_long_call; 4276 case 2: return GNU_far; 4277 case 3: return CXX11_gnu_far; 4278 } 4279 } 4280 4281 4282 static bool classof(const Attr *A) { return A->getKind() == attr::MipsLongCall; } 4283}; 4284 4285class MipsShortCallAttr : public InheritableAttr { 4286public: 4287 enum Spelling { 4288 GNU_short_call = 0, 4289 CXX11_gnu_short_call = 1, 4290 GNU_near = 2, 4291 CXX11_gnu_near = 3 4292 }; 4293 4294 static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 4295 auto *A = new (Ctx) MipsShortCallAttr(Loc, Ctx, S); 4296 A->setImplicit(true); 4297 return A; 4298 } 4299 4300 MipsShortCallAttr(SourceRange R, ASTContext &Ctx 4301 , unsigned SI 4302 ) 4303 : InheritableAttr(attr::MipsShortCall, R, SI, false, false) 4304 { 4305 } 4306 4307 MipsShortCallAttr *clone(ASTContext &C) const; 4308 void printPretty(raw_ostream &OS, 4309 const PrintingPolicy &Policy) const; 4310 const char *getSpelling() const; 4311 Spelling getSemanticSpelling() const { 4312 switch (SpellingListIndex) { 4313 default: llvm_unreachable("Unknown spelling list index"); 4314 case 0: return GNU_short_call; 4315 case 1: return CXX11_gnu_short_call; 4316 case 2: return GNU_near; 4317 case 3: return CXX11_gnu_near; 4318 } 4319 } 4320 4321 4322 static bool classof(const Attr *A) { return A->getKind() == attr::MipsShortCall; } 4323}; 4324 4325class ModeAttr : public Attr { 4326IdentifierInfo * mode; 4327 4328public: 4329 static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Loc = SourceRange()) { 4330 auto *A = new (Ctx) ModeAttr(Loc, Ctx, Mode, 0); 4331 A->setImplicit(true); 4332 return A; 4333 } 4334 4335 ModeAttr(SourceRange R, ASTContext &Ctx 4336 , IdentifierInfo * Mode 4337 , unsigned SI 4338 ) 4339 : Attr(attr::Mode, R, SI, false, false) 4340 , mode(Mode) 4341 { 4342 } 4343 4344 ModeAttr *clone(ASTContext &C) const; 4345 void printPretty(raw_ostream &OS, 4346 const PrintingPolicy &Policy) const; 4347 const char *getSpelling() const; 4348 IdentifierInfo * getMode() const { 4349 return mode; 4350 } 4351 4352 4353 4354 static bool classof(const Attr *A) { return A->getKind() == attr::Mode; } 4355}; 4356 4357class NSConsumedAttr : public InheritableParamAttr { 4358public: 4359 static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4360 auto *A = new (Ctx) NSConsumedAttr(Loc, Ctx, 0); 4361 A->setImplicit(true); 4362 return A; 4363 } 4364 4365 NSConsumedAttr(SourceRange R, ASTContext &Ctx 4366 , unsigned SI 4367 ) 4368 : InheritableParamAttr(attr::NSConsumed, R, SI, false, false) 4369 { 4370 } 4371 4372 NSConsumedAttr *clone(ASTContext &C) const; 4373 void printPretty(raw_ostream &OS, 4374 const PrintingPolicy &Policy) const; 4375 const char *getSpelling() const; 4376 4377 4378 static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; } 4379}; 4380 4381class NSConsumesSelfAttr : public InheritableAttr { 4382public: 4383 static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4384 auto *A = new (Ctx) NSConsumesSelfAttr(Loc, Ctx, 0); 4385 A->setImplicit(true); 4386 return A; 4387 } 4388 4389 NSConsumesSelfAttr(SourceRange R, ASTContext &Ctx 4390 , unsigned SI 4391 ) 4392 : InheritableAttr(attr::NSConsumesSelf, R, SI, false, false) 4393 { 4394 } 4395 4396 NSConsumesSelfAttr *clone(ASTContext &C) const; 4397 void printPretty(raw_ostream &OS, 4398 const PrintingPolicy &Policy) const; 4399 const char *getSpelling() const; 4400 4401 4402 static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; } 4403}; 4404 4405class NSReturnsAutoreleasedAttr : public InheritableAttr { 4406public: 4407 static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4408 auto *A = new (Ctx) NSReturnsAutoreleasedAttr(Loc, Ctx, 0); 4409 A->setImplicit(true); 4410 return A; 4411 } 4412 4413 NSReturnsAutoreleasedAttr(SourceRange R, ASTContext &Ctx 4414 , unsigned SI 4415 ) 4416 : InheritableAttr(attr::NSReturnsAutoreleased, R, SI, false, false) 4417 { 4418 } 4419 4420 NSReturnsAutoreleasedAttr *clone(ASTContext &C) const; 4421 void printPretty(raw_ostream &OS, 4422 const PrintingPolicy &Policy) const; 4423 const char *getSpelling() const; 4424 4425 4426 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; } 4427}; 4428 4429class NSReturnsNotRetainedAttr : public InheritableAttr { 4430public: 4431 static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4432 auto *A = new (Ctx) NSReturnsNotRetainedAttr(Loc, Ctx, 0); 4433 A->setImplicit(true); 4434 return A; 4435 } 4436 4437 NSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx 4438 , unsigned SI 4439 ) 4440 : InheritableAttr(attr::NSReturnsNotRetained, R, SI, false, false) 4441 { 4442 } 4443 4444 NSReturnsNotRetainedAttr *clone(ASTContext &C) const; 4445 void printPretty(raw_ostream &OS, 4446 const PrintingPolicy &Policy) const; 4447 const char *getSpelling() const; 4448 4449 4450 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; } 4451}; 4452 4453class NSReturnsRetainedAttr : public InheritableAttr { 4454public: 4455 static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4456 auto *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0); 4457 A->setImplicit(true); 4458 return A; 4459 } 4460 4461 NSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx 4462 , unsigned SI 4463 ) 4464 : InheritableAttr(attr::NSReturnsRetained, R, SI, false, false) 4465 { 4466 } 4467 4468 NSReturnsRetainedAttr *clone(ASTContext &C) const; 4469 void printPretty(raw_ostream &OS, 4470 const PrintingPolicy &Policy) const; 4471 const char *getSpelling() const; 4472 4473 4474 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; } 4475}; 4476 4477class NakedAttr : public InheritableAttr { 4478public: 4479 static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4480 auto *A = new (Ctx) NakedAttr(Loc, Ctx, 0); 4481 A->setImplicit(true); 4482 return A; 4483 } 4484 4485 NakedAttr(SourceRange R, ASTContext &Ctx 4486 , unsigned SI 4487 ) 4488 : InheritableAttr(attr::Naked, R, SI, false, false) 4489 { 4490 } 4491 4492 NakedAttr *clone(ASTContext &C) const; 4493 void printPretty(raw_ostream &OS, 4494 const PrintingPolicy &Policy) const; 4495 const char *getSpelling() const; 4496 4497 4498 static bool classof(const Attr *A) { return A->getKind() == attr::Naked; } 4499}; 4500 4501class NoAliasAttr : public InheritableAttr { 4502public: 4503 static NoAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4504 auto *A = new (Ctx) NoAliasAttr(Loc, Ctx, 0); 4505 A->setImplicit(true); 4506 return A; 4507 } 4508 4509 NoAliasAttr(SourceRange R, ASTContext &Ctx 4510 , unsigned SI 4511 ) 4512 : InheritableAttr(attr::NoAlias, R, SI, false, false) 4513 { 4514 } 4515 4516 NoAliasAttr *clone(ASTContext &C) const; 4517 void printPretty(raw_ostream &OS, 4518 const PrintingPolicy &Policy) const; 4519 const char *getSpelling() const; 4520 4521 4522 static bool classof(const Attr *A) { return A->getKind() == attr::NoAlias; } 4523}; 4524 4525class NoCommonAttr : public InheritableAttr { 4526public: 4527 static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4528 auto *A = new (Ctx) NoCommonAttr(Loc, Ctx, 0); 4529 A->setImplicit(true); 4530 return A; 4531 } 4532 4533 NoCommonAttr(SourceRange R, ASTContext &Ctx 4534 , unsigned SI 4535 ) 4536 : InheritableAttr(attr::NoCommon, R, SI, false, false) 4537 { 4538 } 4539 4540 NoCommonAttr *clone(ASTContext &C) const; 4541 void printPretty(raw_ostream &OS, 4542 const PrintingPolicy &Policy) const; 4543 const char *getSpelling() const; 4544 4545 4546 static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; } 4547}; 4548 4549class NoDebugAttr : public InheritableAttr { 4550public: 4551 static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4552 auto *A = new (Ctx) NoDebugAttr(Loc, Ctx, 0); 4553 A->setImplicit(true); 4554 return A; 4555 } 4556 4557 NoDebugAttr(SourceRange R, ASTContext &Ctx 4558 , unsigned SI 4559 ) 4560 : InheritableAttr(attr::NoDebug, R, SI, false, false) 4561 { 4562 } 4563 4564 NoDebugAttr *clone(ASTContext &C) const; 4565 void printPretty(raw_ostream &OS, 4566 const PrintingPolicy &Policy) const; 4567 const char *getSpelling() const; 4568 4569 4570 static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; } 4571}; 4572 4573class NoDuplicateAttr : public InheritableAttr { 4574public: 4575 static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4576 auto *A = new (Ctx) NoDuplicateAttr(Loc, Ctx, 0); 4577 A->setImplicit(true); 4578 return A; 4579 } 4580 4581 NoDuplicateAttr(SourceRange R, ASTContext &Ctx 4582 , unsigned SI 4583 ) 4584 : InheritableAttr(attr::NoDuplicate, R, SI, false, false) 4585 { 4586 } 4587 4588 NoDuplicateAttr *clone(ASTContext &C) const; 4589 void printPretty(raw_ostream &OS, 4590 const PrintingPolicy &Policy) const; 4591 const char *getSpelling() const; 4592 4593 4594 static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; } 4595}; 4596 4597class NoEscapeAttr : public Attr { 4598public: 4599 static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4600 auto *A = new (Ctx) NoEscapeAttr(Loc, Ctx, 0); 4601 A->setImplicit(true); 4602 return A; 4603 } 4604 4605 NoEscapeAttr(SourceRange R, ASTContext &Ctx 4606 , unsigned SI 4607 ) 4608 : Attr(attr::NoEscape, R, SI, false, false) 4609 { 4610 } 4611 4612 NoEscapeAttr *clone(ASTContext &C) const; 4613 void printPretty(raw_ostream &OS, 4614 const PrintingPolicy &Policy) const; 4615 const char *getSpelling() const; 4616 4617 4618 static bool classof(const Attr *A) { return A->getKind() == attr::NoEscape; } 4619}; 4620 4621class NoInlineAttr : public InheritableAttr { 4622public: 4623 static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4624 auto *A = new (Ctx) NoInlineAttr(Loc, Ctx, 0); 4625 A->setImplicit(true); 4626 return A; 4627 } 4628 4629 NoInlineAttr(SourceRange R, ASTContext &Ctx 4630 , unsigned SI 4631 ) 4632 : InheritableAttr(attr::NoInline, R, SI, false, false) 4633 { 4634 } 4635 4636 NoInlineAttr *clone(ASTContext &C) const; 4637 void printPretty(raw_ostream &OS, 4638 const PrintingPolicy &Policy) const; 4639 const char *getSpelling() const; 4640 4641 4642 static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; } 4643}; 4644 4645class NoInstrumentFunctionAttr : public InheritableAttr { 4646public: 4647 static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4648 auto *A = new (Ctx) NoInstrumentFunctionAttr(Loc, Ctx, 0); 4649 A->setImplicit(true); 4650 return A; 4651 } 4652 4653 NoInstrumentFunctionAttr(SourceRange R, ASTContext &Ctx 4654 , unsigned SI 4655 ) 4656 : InheritableAttr(attr::NoInstrumentFunction, R, SI, false, false) 4657 { 4658 } 4659 4660 NoInstrumentFunctionAttr *clone(ASTContext &C) const; 4661 void printPretty(raw_ostream &OS, 4662 const PrintingPolicy &Policy) const; 4663 const char *getSpelling() const; 4664 4665 4666 static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; } 4667}; 4668 4669class NoMicroMipsAttr : public InheritableAttr { 4670public: 4671 static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4672 auto *A = new (Ctx) NoMicroMipsAttr(Loc, Ctx, 0); 4673 A->setImplicit(true); 4674 return A; 4675 } 4676 4677 NoMicroMipsAttr(SourceRange R, ASTContext &Ctx 4678 , unsigned SI 4679 ) 4680 : InheritableAttr(attr::NoMicroMips, R, SI, false, false) 4681 { 4682 } 4683 4684 NoMicroMipsAttr *clone(ASTContext &C) const; 4685 void printPretty(raw_ostream &OS, 4686 const PrintingPolicy &Policy) const; 4687 const char *getSpelling() const; 4688 4689 4690 static bool classof(const Attr *A) { return A->getKind() == attr::NoMicroMips; } 4691}; 4692 4693class NoMips16Attr : public InheritableAttr { 4694public: 4695 static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4696 auto *A = new (Ctx) NoMips16Attr(Loc, Ctx, 0); 4697 A->setImplicit(true); 4698 return A; 4699 } 4700 4701 NoMips16Attr(SourceRange R, ASTContext &Ctx 4702 , unsigned SI 4703 ) 4704 : InheritableAttr(attr::NoMips16, R, SI, false, false) 4705 { 4706 } 4707 4708 NoMips16Attr *clone(ASTContext &C) const; 4709 void printPretty(raw_ostream &OS, 4710 const PrintingPolicy &Policy) const; 4711 const char *getSpelling() const; 4712 4713 4714 static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; } 4715}; 4716 4717class NoReturnAttr : public InheritableAttr { 4718public: 4719 static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4720 auto *A = new (Ctx) NoReturnAttr(Loc, Ctx, 0); 4721 A->setImplicit(true); 4722 return A; 4723 } 4724 4725 NoReturnAttr(SourceRange R, ASTContext &Ctx 4726 , unsigned SI 4727 ) 4728 : InheritableAttr(attr::NoReturn, R, SI, false, false) 4729 { 4730 } 4731 4732 NoReturnAttr *clone(ASTContext &C) const; 4733 void printPretty(raw_ostream &OS, 4734 const PrintingPolicy &Policy) const; 4735 const char *getSpelling() const; 4736 4737 4738 static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; } 4739}; 4740 4741class NoSanitizeAttr : public InheritableAttr { 4742 unsigned sanitizers_Size; 4743 StringRef *sanitizers_; 4744 4745public: 4746 static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Loc = SourceRange()) { 4747 auto *A = new (Ctx) NoSanitizeAttr(Loc, Ctx, Sanitizers, SanitizersSize, 0); 4748 A->setImplicit(true); 4749 return A; 4750 } 4751 4752 NoSanitizeAttr(SourceRange R, ASTContext &Ctx 4753 , StringRef *Sanitizers, unsigned SanitizersSize 4754 , unsigned SI 4755 ) 4756 : InheritableAttr(attr::NoSanitize, R, SI, false, false) 4757 , sanitizers_Size(SanitizersSize), sanitizers_(new (Ctx, 16) StringRef[sanitizers_Size]) 4758 { 4759 for (size_t I = 0, E = sanitizers_Size; I != E; 4760 ++I) { 4761 StringRef Ref = Sanitizers[I]; 4762 if (!Ref.empty()) { 4763 char *Mem = new (Ctx, 1) char[Ref.size()]; 4764 std::memcpy(Mem, Ref.data(), Ref.size()); 4765 sanitizers_[I] = StringRef(Mem, Ref.size()); 4766 } 4767 } 4768 } 4769 4770 NoSanitizeAttr(SourceRange R, ASTContext &Ctx 4771 , unsigned SI 4772 ) 4773 : InheritableAttr(attr::NoSanitize, R, SI, false, false) 4774 , sanitizers_Size(0), sanitizers_(nullptr) 4775 { 4776 } 4777 4778 NoSanitizeAttr *clone(ASTContext &C) const; 4779 void printPretty(raw_ostream &OS, 4780 const PrintingPolicy &Policy) const; 4781 const char *getSpelling() const; 4782 typedef StringRef* sanitizers_iterator; 4783 sanitizers_iterator sanitizers_begin() const { return sanitizers_; } 4784 sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; } 4785 unsigned sanitizers_size() const { return sanitizers_Size; } 4786 llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); } 4787 4788 4789 4790 SanitizerMask getMask() const { 4791 SanitizerMask Mask = 0; 4792 for (auto SanitizerName : sanitizers()) { 4793 SanitizerMask ParsedMask = 4794 parseSanitizerValue(SanitizerName, /*AllowGroups=*/true); 4795 Mask |= expandSanitizerGroups(ParsedMask); 4796 } 4797 return Mask; 4798 } 4799 4800 4801 static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; } 4802}; 4803 4804class NoSplitStackAttr : public InheritableAttr { 4805public: 4806 static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4807 auto *A = new (Ctx) NoSplitStackAttr(Loc, Ctx, 0); 4808 A->setImplicit(true); 4809 return A; 4810 } 4811 4812 NoSplitStackAttr(SourceRange R, ASTContext &Ctx 4813 , unsigned SI 4814 ) 4815 : InheritableAttr(attr::NoSplitStack, R, SI, false, false) 4816 { 4817 } 4818 4819 NoSplitStackAttr *clone(ASTContext &C) const; 4820 void printPretty(raw_ostream &OS, 4821 const PrintingPolicy &Policy) const; 4822 const char *getSpelling() const; 4823 4824 4825 static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; } 4826}; 4827 4828class NoThreadSafetyAnalysisAttr : public InheritableAttr { 4829public: 4830 static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4831 auto *A = new (Ctx) NoThreadSafetyAnalysisAttr(Loc, Ctx, 0); 4832 A->setImplicit(true); 4833 return A; 4834 } 4835 4836 NoThreadSafetyAnalysisAttr(SourceRange R, ASTContext &Ctx 4837 , unsigned SI 4838 ) 4839 : InheritableAttr(attr::NoThreadSafetyAnalysis, R, SI, false, false) 4840 { 4841 } 4842 4843 NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const; 4844 void printPretty(raw_ostream &OS, 4845 const PrintingPolicy &Policy) const; 4846 const char *getSpelling() const; 4847 4848 4849 static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; } 4850}; 4851 4852class NoThrowAttr : public InheritableAttr { 4853public: 4854 static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4855 auto *A = new (Ctx) NoThrowAttr(Loc, Ctx, 0); 4856 A->setImplicit(true); 4857 return A; 4858 } 4859 4860 NoThrowAttr(SourceRange R, ASTContext &Ctx 4861 , unsigned SI 4862 ) 4863 : InheritableAttr(attr::NoThrow, R, SI, false, false) 4864 { 4865 } 4866 4867 NoThrowAttr *clone(ASTContext &C) const; 4868 void printPretty(raw_ostream &OS, 4869 const PrintingPolicy &Policy) const; 4870 const char *getSpelling() const; 4871 4872 4873 static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; } 4874}; 4875 4876class NonNullAttr : public InheritableParamAttr { 4877 unsigned args_Size; 4878 unsigned *args_; 4879 4880public: 4881 static NonNullAttr *CreateImplicit(ASTContext &Ctx, unsigned *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 4882 auto *A = new (Ctx) NonNullAttr(Loc, Ctx, Args, ArgsSize, 0); 4883 A->setImplicit(true); 4884 return A; 4885 } 4886 4887 NonNullAttr(SourceRange R, ASTContext &Ctx 4888 , unsigned *Args, unsigned ArgsSize 4889 , unsigned SI 4890 ) 4891 : InheritableParamAttr(attr::NonNull, R, SI, false, true) 4892 , args_Size(ArgsSize), args_(new (Ctx, 16) unsigned[args_Size]) 4893 { 4894 std::copy(Args, Args + args_Size, args_); 4895 } 4896 4897 NonNullAttr(SourceRange R, ASTContext &Ctx 4898 , unsigned SI 4899 ) 4900 : InheritableParamAttr(attr::NonNull, R, SI, false, true) 4901 , args_Size(0), args_(nullptr) 4902 { 4903 } 4904 4905 NonNullAttr *clone(ASTContext &C) const; 4906 void printPretty(raw_ostream &OS, 4907 const PrintingPolicy &Policy) const; 4908 const char *getSpelling() const; 4909 typedef unsigned* args_iterator; 4910 args_iterator args_begin() const { return args_; } 4911 args_iterator args_end() const { return args_ + args_Size; } 4912 unsigned args_size() const { return args_Size; } 4913 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 4914 4915 4916bool isNonNull(unsigned idx) const { 4917 if (!args_size()) 4918 return true; 4919 for (const auto &V : args()) 4920 if (V == idx) 4921 return true; 4922 return false; 4923 } 4924 4925 static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; } 4926}; 4927 4928class NotTailCalledAttr : public InheritableAttr { 4929public: 4930 static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4931 auto *A = new (Ctx) NotTailCalledAttr(Loc, Ctx, 0); 4932 A->setImplicit(true); 4933 return A; 4934 } 4935 4936 NotTailCalledAttr(SourceRange R, ASTContext &Ctx 4937 , unsigned SI 4938 ) 4939 : InheritableAttr(attr::NotTailCalled, R, SI, false, false) 4940 { 4941 } 4942 4943 NotTailCalledAttr *clone(ASTContext &C) const; 4944 void printPretty(raw_ostream &OS, 4945 const PrintingPolicy &Policy) const; 4946 const char *getSpelling() const; 4947 4948 4949 static bool classof(const Attr *A) { return A->getKind() == attr::NotTailCalled; } 4950}; 4951 4952class OMPCaptureKindAttr : public Attr { 4953unsigned captureKind; 4954 4955public: 4956 static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKind, SourceRange Loc = SourceRange()) { 4957 auto *A = new (Ctx) OMPCaptureKindAttr(Loc, Ctx, CaptureKind, 0); 4958 A->setImplicit(true); 4959 return A; 4960 } 4961 4962 OMPCaptureKindAttr(SourceRange R, ASTContext &Ctx 4963 , unsigned CaptureKind 4964 , unsigned SI 4965 ) 4966 : Attr(attr::OMPCaptureKind, R, SI, false, false) 4967 , captureKind(CaptureKind) 4968 { 4969 } 4970 4971 OMPCaptureKindAttr *clone(ASTContext &C) const; 4972 void printPretty(raw_ostream &OS, 4973 const PrintingPolicy &Policy) const; 4974 const char *getSpelling() const; 4975 unsigned getCaptureKind() const { 4976 return captureKind; 4977 } 4978 4979 4980 4981 static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureKind; } 4982}; 4983 4984class OMPCaptureNoInitAttr : public InheritableAttr { 4985public: 4986 static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 4987 auto *A = new (Ctx) OMPCaptureNoInitAttr(Loc, Ctx, 0); 4988 A->setImplicit(true); 4989 return A; 4990 } 4991 4992 OMPCaptureNoInitAttr(SourceRange R, ASTContext &Ctx 4993 , unsigned SI 4994 ) 4995 : InheritableAttr(attr::OMPCaptureNoInit, R, SI, false, false) 4996 { 4997 } 4998 4999 OMPCaptureNoInitAttr *clone(ASTContext &C) const; 5000 void printPretty(raw_ostream &OS, 5001 const PrintingPolicy &Policy) const; 5002 const char *getSpelling() const; 5003 5004 5005 static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureNoInit; } 5006}; 5007 5008class OMPDeclareSimdDeclAttr : public Attr { 5009public: 5010 enum BranchStateTy { 5011 BS_Undefined, 5012 BS_Inbranch, 5013 BS_Notinbranch 5014 }; 5015private: 5016 BranchStateTy branchState; 5017 5018Expr * simdlen; 5019 5020 unsigned uniforms_Size; 5021 Expr * *uniforms_; 5022 5023 unsigned aligneds_Size; 5024 Expr * *aligneds_; 5025 5026 unsigned alignments_Size; 5027 Expr * *alignments_; 5028 5029 unsigned linears_Size; 5030 Expr * *linears_; 5031 5032 unsigned modifiers_Size; 5033 unsigned *modifiers_; 5034 5035 unsigned steps_Size; 5036 Expr * *steps_; 5037 5038public: 5039 static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Loc = SourceRange()) { 5040 auto *A = new (Ctx) OMPDeclareSimdDeclAttr(Loc, Ctx, BranchState, Simdlen, Uniforms, UniformsSize, Aligneds, AlignedsSize, Alignments, AlignmentsSize, Linears, LinearsSize, Modifiers, ModifiersSize, Steps, StepsSize, 0); 5041 A->setImplicit(true); 5042 return A; 5043 } 5044 5045 OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx 5046 , BranchStateTy BranchState 5047 , Expr * Simdlen 5048 , Expr * *Uniforms, unsigned UniformsSize 5049 , Expr * *Aligneds, unsigned AlignedsSize 5050 , Expr * *Alignments, unsigned AlignmentsSize 5051 , Expr * *Linears, unsigned LinearsSize 5052 , unsigned *Modifiers, unsigned ModifiersSize 5053 , Expr * *Steps, unsigned StepsSize 5054 , unsigned SI 5055 ) 5056 : Attr(attr::OMPDeclareSimdDecl, R, SI, false, false) 5057 , branchState(BranchState) 5058 , simdlen(Simdlen) 5059 , uniforms_Size(UniformsSize), uniforms_(new (Ctx, 16) Expr *[uniforms_Size]) 5060 , aligneds_Size(AlignedsSize), aligneds_(new (Ctx, 16) Expr *[aligneds_Size]) 5061 , alignments_Size(AlignmentsSize), alignments_(new (Ctx, 16) Expr *[alignments_Size]) 5062 , linears_Size(LinearsSize), linears_(new (Ctx, 16) Expr *[linears_Size]) 5063 , modifiers_Size(ModifiersSize), modifiers_(new (Ctx, 16) unsigned[modifiers_Size]) 5064 , steps_Size(StepsSize), steps_(new (Ctx, 16) Expr *[steps_Size]) 5065 { 5066 std::copy(Uniforms, Uniforms + uniforms_Size, uniforms_); 5067 std::copy(Aligneds, Aligneds + aligneds_Size, aligneds_); 5068 std::copy(Alignments, Alignments + alignments_Size, alignments_); 5069 std::copy(Linears, Linears + linears_Size, linears_); 5070 std::copy(Modifiers, Modifiers + modifiers_Size, modifiers_); 5071 std::copy(Steps, Steps + steps_Size, steps_); 5072 } 5073 5074 OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx 5075 , BranchStateTy BranchState 5076 , Expr * Simdlen 5077 , unsigned SI 5078 ) 5079 : Attr(attr::OMPDeclareSimdDecl, R, SI, false, false) 5080 , branchState(BranchState) 5081 , simdlen(Simdlen) 5082 , uniforms_Size(0), uniforms_(nullptr) 5083 , aligneds_Size(0), aligneds_(nullptr) 5084 , alignments_Size(0), alignments_(nullptr) 5085 , linears_Size(0), linears_(nullptr) 5086 , modifiers_Size(0), modifiers_(nullptr) 5087 , steps_Size(0), steps_(nullptr) 5088 { 5089 } 5090 5091 OMPDeclareSimdDeclAttr *clone(ASTContext &C) const; 5092 void printPretty(raw_ostream &OS, 5093 const PrintingPolicy &Policy) const; 5094 const char *getSpelling() const; 5095 BranchStateTy getBranchState() const { 5096 return branchState; 5097 } 5098 5099 static bool ConvertStrToBranchStateTy(StringRef Val, BranchStateTy &Out) { 5100 Optional<BranchStateTy> R = llvm::StringSwitch<Optional<BranchStateTy>>(Val) 5101 .Case("", OMPDeclareSimdDeclAttr::BS_Undefined) 5102 .Case("inbranch", OMPDeclareSimdDeclAttr::BS_Inbranch) 5103 .Case("notinbranch", OMPDeclareSimdDeclAttr::BS_Notinbranch) 5104 .Default(Optional<BranchStateTy>()); 5105 if (R) { 5106 Out = *R; 5107 return true; 5108 } 5109 return false; 5110 } 5111 5112 static const char *ConvertBranchStateTyToStr(BranchStateTy Val) { 5113 switch(Val) { 5114 case OMPDeclareSimdDeclAttr::BS_Undefined: return ""; 5115 case OMPDeclareSimdDeclAttr::BS_Inbranch: return "inbranch"; 5116 case OMPDeclareSimdDeclAttr::BS_Notinbranch: return "notinbranch"; 5117 } 5118 llvm_unreachable("No enumerator with that value"); 5119 } 5120 Expr * getSimdlen() const { 5121 return simdlen; 5122 } 5123 5124 typedef Expr ** uniforms_iterator; 5125 uniforms_iterator uniforms_begin() const { return uniforms_; } 5126 uniforms_iterator uniforms_end() const { return uniforms_ + uniforms_Size; } 5127 unsigned uniforms_size() const { return uniforms_Size; } 5128 llvm::iterator_range<uniforms_iterator> uniforms() const { return llvm::make_range(uniforms_begin(), uniforms_end()); } 5129 5130 5131 typedef Expr ** aligneds_iterator; 5132 aligneds_iterator aligneds_begin() const { return aligneds_; } 5133 aligneds_iterator aligneds_end() const { return aligneds_ + aligneds_Size; } 5134 unsigned aligneds_size() const { return aligneds_Size; } 5135 llvm::iterator_range<aligneds_iterator> aligneds() const { return llvm::make_range(aligneds_begin(), aligneds_end()); } 5136 5137 5138 typedef Expr ** alignments_iterator; 5139 alignments_iterator alignments_begin() const { return alignments_; } 5140 alignments_iterator alignments_end() const { return alignments_ + alignments_Size; } 5141 unsigned alignments_size() const { return alignments_Size; } 5142 llvm::iterator_range<alignments_iterator> alignments() const { return llvm::make_range(alignments_begin(), alignments_end()); } 5143 5144 5145 typedef Expr ** linears_iterator; 5146 linears_iterator linears_begin() const { return linears_; } 5147 linears_iterator linears_end() const { return linears_ + linears_Size; } 5148 unsigned linears_size() const { return linears_Size; } 5149 llvm::iterator_range<linears_iterator> linears() const { return llvm::make_range(linears_begin(), linears_end()); } 5150 5151 5152 typedef unsigned* modifiers_iterator; 5153 modifiers_iterator modifiers_begin() const { return modifiers_; } 5154 modifiers_iterator modifiers_end() const { return modifiers_ + modifiers_Size; } 5155 unsigned modifiers_size() const { return modifiers_Size; } 5156 llvm::iterator_range<modifiers_iterator> modifiers() const { return llvm::make_range(modifiers_begin(), modifiers_end()); } 5157 5158 5159 typedef Expr ** steps_iterator; 5160 steps_iterator steps_begin() const { return steps_; } 5161 steps_iterator steps_end() const { return steps_ + steps_Size; } 5162 unsigned steps_size() const { return steps_Size; } 5163 llvm::iterator_range<steps_iterator> steps() const { return llvm::make_range(steps_begin(), steps_end()); } 5164 5165 5166 5167 void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy) 5168 const { 5169 if (getBranchState() != BS_Undefined) 5170 OS << ConvertBranchStateTyToStr(getBranchState()) << " "; 5171 if (auto *E = getSimdlen()) { 5172 OS << "simdlen("; 5173 E->printPretty(OS, nullptr, Policy); 5174 OS << ") "; 5175 } 5176 if (uniforms_size() > 0) { 5177 OS << "uniform"; 5178 StringRef Sep = "("; 5179 for (auto *E : uniforms()) { 5180 OS << Sep; 5181 E->printPretty(OS, nullptr, Policy); 5182 Sep = ", "; 5183 } 5184 OS << ") "; 5185 } 5186 alignments_iterator NI = alignments_begin(); 5187 for (auto *E : aligneds()) { 5188 OS << "aligned("; 5189 E->printPretty(OS, nullptr, Policy); 5190 if (*NI) { 5191 OS << ": "; 5192 (*NI)->printPretty(OS, nullptr, Policy); 5193 } 5194 OS << ") "; 5195 ++NI; 5196 } 5197 steps_iterator I = steps_begin(); 5198 modifiers_iterator MI = modifiers_begin(); 5199 for (auto *E : linears()) { 5200 OS << "linear("; 5201 if (*MI != OMPC_LINEAR_unknown) 5202 OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "("; 5203 E->printPretty(OS, nullptr, Policy); 5204 if (*MI != OMPC_LINEAR_unknown) 5205 OS << ")"; 5206 if (*I) { 5207 OS << ": "; 5208 (*I)->printPretty(OS, nullptr, Policy); 5209 } 5210 OS << ") "; 5211 ++I; 5212 ++MI; 5213 } 5214 } 5215 5216 5217 static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareSimdDecl; } 5218}; 5219 5220class OMPDeclareTargetDeclAttr : public Attr { 5221public: 5222 enum MapTypeTy { 5223 MT_To, 5224 MT_Link 5225 }; 5226private: 5227 MapTypeTy mapType; 5228 5229public: 5230 static OMPDeclareTargetDeclAttr *CreateImplicit(ASTContext &Ctx, MapTypeTy MapType, SourceRange Loc = SourceRange()) { 5231 auto *A = new (Ctx) OMPDeclareTargetDeclAttr(Loc, Ctx, MapType, 0); 5232 A->setImplicit(true); 5233 return A; 5234 } 5235 5236 OMPDeclareTargetDeclAttr(SourceRange R, ASTContext &Ctx 5237 , MapTypeTy MapType 5238 , unsigned SI 5239 ) 5240 : Attr(attr::OMPDeclareTargetDecl, R, SI, false, false) 5241 , mapType(MapType) 5242 { 5243 } 5244 5245 OMPDeclareTargetDeclAttr *clone(ASTContext &C) const; 5246 void printPretty(raw_ostream &OS, 5247 const PrintingPolicy &Policy) const; 5248 const char *getSpelling() const; 5249 MapTypeTy getMapType() const { 5250 return mapType; 5251 } 5252 5253 static bool ConvertStrToMapTypeTy(StringRef Val, MapTypeTy &Out) { 5254 Optional<MapTypeTy> R = llvm::StringSwitch<Optional<MapTypeTy>>(Val) 5255 .Case("to", OMPDeclareTargetDeclAttr::MT_To) 5256 .Case("link", OMPDeclareTargetDeclAttr::MT_Link) 5257 .Default(Optional<MapTypeTy>()); 5258 if (R) { 5259 Out = *R; 5260 return true; 5261 } 5262 return false; 5263 } 5264 5265 static const char *ConvertMapTypeTyToStr(MapTypeTy Val) { 5266 switch(Val) { 5267 case OMPDeclareTargetDeclAttr::MT_To: return "to"; 5268 case OMPDeclareTargetDeclAttr::MT_Link: return "link"; 5269 } 5270 llvm_unreachable("No enumerator with that value"); 5271 } 5272 5273 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const { 5274 // Use fake syntax because it is for testing and debugging purpose only. 5275 if (getMapType() != MT_To) 5276 OS << ConvertMapTypeTyToStr(getMapType()) << " "; 5277 } 5278 5279 5280 static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareTargetDecl; } 5281}; 5282 5283class OMPThreadPrivateDeclAttr : public InheritableAttr { 5284public: 5285 static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5286 auto *A = new (Ctx) OMPThreadPrivateDeclAttr(Loc, Ctx, 0); 5287 A->setImplicit(true); 5288 return A; 5289 } 5290 5291 OMPThreadPrivateDeclAttr(SourceRange R, ASTContext &Ctx 5292 , unsigned SI 5293 ) 5294 : InheritableAttr(attr::OMPThreadPrivateDecl, R, SI, false, false) 5295 { 5296 } 5297 5298 OMPThreadPrivateDeclAttr *clone(ASTContext &C) const; 5299 void printPretty(raw_ostream &OS, 5300 const PrintingPolicy &Policy) const; 5301 const char *getSpelling() const; 5302 5303 5304 static bool classof(const Attr *A) { return A->getKind() == attr::OMPThreadPrivateDecl; } 5305}; 5306 5307class ObjCBoxableAttr : public Attr { 5308public: 5309 static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5310 auto *A = new (Ctx) ObjCBoxableAttr(Loc, Ctx, 0); 5311 A->setImplicit(true); 5312 return A; 5313 } 5314 5315 ObjCBoxableAttr(SourceRange R, ASTContext &Ctx 5316 , unsigned SI 5317 ) 5318 : Attr(attr::ObjCBoxable, R, SI, false, false) 5319 { 5320 } 5321 5322 ObjCBoxableAttr *clone(ASTContext &C) const; 5323 void printPretty(raw_ostream &OS, 5324 const PrintingPolicy &Policy) const; 5325 const char *getSpelling() const; 5326 5327 5328 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBoxable; } 5329}; 5330 5331class ObjCBridgeAttr : public InheritableAttr { 5332IdentifierInfo * bridgedType; 5333 5334public: 5335 static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) { 5336 auto *A = new (Ctx) ObjCBridgeAttr(Loc, Ctx, BridgedType, 0); 5337 A->setImplicit(true); 5338 return A; 5339 } 5340 5341 ObjCBridgeAttr(SourceRange R, ASTContext &Ctx 5342 , IdentifierInfo * BridgedType 5343 , unsigned SI 5344 ) 5345 : InheritableAttr(attr::ObjCBridge, R, SI, false, false) 5346 , bridgedType(BridgedType) 5347 { 5348 } 5349 5350 ObjCBridgeAttr *clone(ASTContext &C) const; 5351 void printPretty(raw_ostream &OS, 5352 const PrintingPolicy &Policy) const; 5353 const char *getSpelling() const; 5354 IdentifierInfo * getBridgedType() const { 5355 return bridgedType; 5356 } 5357 5358 5359 5360 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridge; } 5361}; 5362 5363class ObjCBridgeMutableAttr : public InheritableAttr { 5364IdentifierInfo * bridgedType; 5365 5366public: 5367 static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) { 5368 auto *A = new (Ctx) ObjCBridgeMutableAttr(Loc, Ctx, BridgedType, 0); 5369 A->setImplicit(true); 5370 return A; 5371 } 5372 5373 ObjCBridgeMutableAttr(SourceRange R, ASTContext &Ctx 5374 , IdentifierInfo * BridgedType 5375 , unsigned SI 5376 ) 5377 : InheritableAttr(attr::ObjCBridgeMutable, R, SI, false, false) 5378 , bridgedType(BridgedType) 5379 { 5380 } 5381 5382 ObjCBridgeMutableAttr *clone(ASTContext &C) const; 5383 void printPretty(raw_ostream &OS, 5384 const PrintingPolicy &Policy) const; 5385 const char *getSpelling() const; 5386 IdentifierInfo * getBridgedType() const { 5387 return bridgedType; 5388 } 5389 5390 5391 5392 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeMutable; } 5393}; 5394 5395class ObjCBridgeRelatedAttr : public InheritableAttr { 5396IdentifierInfo * relatedClass; 5397 5398IdentifierInfo * classMethod; 5399 5400IdentifierInfo * instanceMethod; 5401 5402public: 5403 static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Loc = SourceRange()) { 5404 auto *A = new (Ctx) ObjCBridgeRelatedAttr(Loc, Ctx, RelatedClass, ClassMethod, InstanceMethod, 0); 5405 A->setImplicit(true); 5406 return A; 5407 } 5408 5409 ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx 5410 , IdentifierInfo * RelatedClass 5411 , IdentifierInfo * ClassMethod 5412 , IdentifierInfo * InstanceMethod 5413 , unsigned SI 5414 ) 5415 : InheritableAttr(attr::ObjCBridgeRelated, R, SI, false, false) 5416 , relatedClass(RelatedClass) 5417 , classMethod(ClassMethod) 5418 , instanceMethod(InstanceMethod) 5419 { 5420 } 5421 5422 ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx 5423 , IdentifierInfo * RelatedClass 5424 , unsigned SI 5425 ) 5426 : InheritableAttr(attr::ObjCBridgeRelated, R, SI, false, false) 5427 , relatedClass(RelatedClass) 5428 , classMethod() 5429 , instanceMethod() 5430 { 5431 } 5432 5433 ObjCBridgeRelatedAttr *clone(ASTContext &C) const; 5434 void printPretty(raw_ostream &OS, 5435 const PrintingPolicy &Policy) const; 5436 const char *getSpelling() const; 5437 IdentifierInfo * getRelatedClass() const { 5438 return relatedClass; 5439 } 5440 5441 IdentifierInfo * getClassMethod() const { 5442 return classMethod; 5443 } 5444 5445 IdentifierInfo * getInstanceMethod() const { 5446 return instanceMethod; 5447 } 5448 5449 5450 5451 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeRelated; } 5452}; 5453 5454class ObjCDesignatedInitializerAttr : public Attr { 5455public: 5456 static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5457 auto *A = new (Ctx) ObjCDesignatedInitializerAttr(Loc, Ctx, 0); 5458 A->setImplicit(true); 5459 return A; 5460 } 5461 5462 ObjCDesignatedInitializerAttr(SourceRange R, ASTContext &Ctx 5463 , unsigned SI 5464 ) 5465 : Attr(attr::ObjCDesignatedInitializer, R, SI, false, false) 5466 { 5467 } 5468 5469 ObjCDesignatedInitializerAttr *clone(ASTContext &C) const; 5470 void printPretty(raw_ostream &OS, 5471 const PrintingPolicy &Policy) const; 5472 const char *getSpelling() const; 5473 5474 5475 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDesignatedInitializer; } 5476}; 5477 5478class ObjCExceptionAttr : public InheritableAttr { 5479public: 5480 static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5481 auto *A = new (Ctx) ObjCExceptionAttr(Loc, Ctx, 0); 5482 A->setImplicit(true); 5483 return A; 5484 } 5485 5486 ObjCExceptionAttr(SourceRange R, ASTContext &Ctx 5487 , unsigned SI 5488 ) 5489 : InheritableAttr(attr::ObjCException, R, SI, false, false) 5490 { 5491 } 5492 5493 ObjCExceptionAttr *clone(ASTContext &C) const; 5494 void printPretty(raw_ostream &OS, 5495 const PrintingPolicy &Policy) const; 5496 const char *getSpelling() const; 5497 5498 5499 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCException; } 5500}; 5501 5502class ObjCExplicitProtocolImplAttr : public InheritableAttr { 5503public: 5504 static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5505 auto *A = new (Ctx) ObjCExplicitProtocolImplAttr(Loc, Ctx, 0); 5506 A->setImplicit(true); 5507 return A; 5508 } 5509 5510 ObjCExplicitProtocolImplAttr(SourceRange R, ASTContext &Ctx 5511 , unsigned SI 5512 ) 5513 : InheritableAttr(attr::ObjCExplicitProtocolImpl, R, SI, false, false) 5514 { 5515 } 5516 5517 ObjCExplicitProtocolImplAttr *clone(ASTContext &C) const; 5518 void printPretty(raw_ostream &OS, 5519 const PrintingPolicy &Policy) const; 5520 const char *getSpelling() const; 5521 5522 5523 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExplicitProtocolImpl; } 5524}; 5525 5526class ObjCIndependentClassAttr : public InheritableAttr { 5527public: 5528 static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5529 auto *A = new (Ctx) ObjCIndependentClassAttr(Loc, Ctx, 0); 5530 A->setImplicit(true); 5531 return A; 5532 } 5533 5534 ObjCIndependentClassAttr(SourceRange R, ASTContext &Ctx 5535 , unsigned SI 5536 ) 5537 : InheritableAttr(attr::ObjCIndependentClass, R, SI, false, false) 5538 { 5539 } 5540 5541 ObjCIndependentClassAttr *clone(ASTContext &C) const; 5542 void printPretty(raw_ostream &OS, 5543 const PrintingPolicy &Policy) const; 5544 const char *getSpelling() const; 5545 5546 5547 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCIndependentClass; } 5548}; 5549 5550class ObjCMethodFamilyAttr : public InheritableAttr { 5551public: 5552 enum FamilyKind { 5553 OMF_None, 5554 OMF_alloc, 5555 OMF_copy, 5556 OMF_init, 5557 OMF_mutableCopy, 5558 OMF_new 5559 }; 5560private: 5561 FamilyKind family; 5562 5563public: 5564 static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, FamilyKind Family, SourceRange Loc = SourceRange()) { 5565 auto *A = new (Ctx) ObjCMethodFamilyAttr(Loc, Ctx, Family, 0); 5566 A->setImplicit(true); 5567 return A; 5568 } 5569 5570 ObjCMethodFamilyAttr(SourceRange R, ASTContext &Ctx 5571 , FamilyKind Family 5572 , unsigned SI 5573 ) 5574 : InheritableAttr(attr::ObjCMethodFamily, R, SI, false, false) 5575 , family(Family) 5576 { 5577 } 5578 5579 ObjCMethodFamilyAttr *clone(ASTContext &C) const; 5580 void printPretty(raw_ostream &OS, 5581 const PrintingPolicy &Policy) const; 5582 const char *getSpelling() const; 5583 FamilyKind getFamily() const { 5584 return family; 5585 } 5586 5587 static bool ConvertStrToFamilyKind(StringRef Val, FamilyKind &Out) { 5588 Optional<FamilyKind> R = llvm::StringSwitch<Optional<FamilyKind>>(Val) 5589 .Case("none", ObjCMethodFamilyAttr::OMF_None) 5590 .Case("alloc", ObjCMethodFamilyAttr::OMF_alloc) 5591 .Case("copy", ObjCMethodFamilyAttr::OMF_copy) 5592 .Case("init", ObjCMethodFamilyAttr::OMF_init) 5593 .Case("mutableCopy", ObjCMethodFamilyAttr::OMF_mutableCopy) 5594 .Case("new", ObjCMethodFamilyAttr::OMF_new) 5595 .Default(Optional<FamilyKind>()); 5596 if (R) { 5597 Out = *R; 5598 return true; 5599 } 5600 return false; 5601 } 5602 5603 static const char *ConvertFamilyKindToStr(FamilyKind Val) { 5604 switch(Val) { 5605 case ObjCMethodFamilyAttr::OMF_None: return "none"; 5606 case ObjCMethodFamilyAttr::OMF_alloc: return "alloc"; 5607 case ObjCMethodFamilyAttr::OMF_copy: return "copy"; 5608 case ObjCMethodFamilyAttr::OMF_init: return "init"; 5609 case ObjCMethodFamilyAttr::OMF_mutableCopy: return "mutableCopy"; 5610 case ObjCMethodFamilyAttr::OMF_new: return "new"; 5611 } 5612 llvm_unreachable("No enumerator with that value"); 5613 } 5614 5615 5616 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; } 5617}; 5618 5619class ObjCNSObjectAttr : public InheritableAttr { 5620public: 5621 static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5622 auto *A = new (Ctx) ObjCNSObjectAttr(Loc, Ctx, 0); 5623 A->setImplicit(true); 5624 return A; 5625 } 5626 5627 ObjCNSObjectAttr(SourceRange R, ASTContext &Ctx 5628 , unsigned SI 5629 ) 5630 : InheritableAttr(attr::ObjCNSObject, R, SI, false, false) 5631 { 5632 } 5633 5634 ObjCNSObjectAttr *clone(ASTContext &C) const; 5635 void printPretty(raw_ostream &OS, 5636 const PrintingPolicy &Policy) const; 5637 const char *getSpelling() const; 5638 5639 5640 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNSObject; } 5641}; 5642 5643class ObjCPreciseLifetimeAttr : public InheritableAttr { 5644public: 5645 static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5646 auto *A = new (Ctx) ObjCPreciseLifetimeAttr(Loc, Ctx, 0); 5647 A->setImplicit(true); 5648 return A; 5649 } 5650 5651 ObjCPreciseLifetimeAttr(SourceRange R, ASTContext &Ctx 5652 , unsigned SI 5653 ) 5654 : InheritableAttr(attr::ObjCPreciseLifetime, R, SI, false, false) 5655 { 5656 } 5657 5658 ObjCPreciseLifetimeAttr *clone(ASTContext &C) const; 5659 void printPretty(raw_ostream &OS, 5660 const PrintingPolicy &Policy) const; 5661 const char *getSpelling() const; 5662 5663 5664 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCPreciseLifetime; } 5665}; 5666 5667class ObjCRequiresPropertyDefsAttr : public InheritableAttr { 5668public: 5669 static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5670 auto *A = new (Ctx) ObjCRequiresPropertyDefsAttr(Loc, Ctx, 0); 5671 A->setImplicit(true); 5672 return A; 5673 } 5674 5675 ObjCRequiresPropertyDefsAttr(SourceRange R, ASTContext &Ctx 5676 , unsigned SI 5677 ) 5678 : InheritableAttr(attr::ObjCRequiresPropertyDefs, R, SI, false, false) 5679 { 5680 } 5681 5682 ObjCRequiresPropertyDefsAttr *clone(ASTContext &C) const; 5683 void printPretty(raw_ostream &OS, 5684 const PrintingPolicy &Policy) const; 5685 const char *getSpelling() const; 5686 5687 5688 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresPropertyDefs; } 5689}; 5690 5691class ObjCRequiresSuperAttr : public InheritableAttr { 5692public: 5693 static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5694 auto *A = new (Ctx) ObjCRequiresSuperAttr(Loc, Ctx, 0); 5695 A->setImplicit(true); 5696 return A; 5697 } 5698 5699 ObjCRequiresSuperAttr(SourceRange R, ASTContext &Ctx 5700 , unsigned SI 5701 ) 5702 : InheritableAttr(attr::ObjCRequiresSuper, R, SI, false, false) 5703 { 5704 } 5705 5706 ObjCRequiresSuperAttr *clone(ASTContext &C) const; 5707 void printPretty(raw_ostream &OS, 5708 const PrintingPolicy &Policy) const; 5709 const char *getSpelling() const; 5710 5711 5712 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresSuper; } 5713}; 5714 5715class ObjCReturnsInnerPointerAttr : public InheritableAttr { 5716public: 5717 static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5718 auto *A = new (Ctx) ObjCReturnsInnerPointerAttr(Loc, Ctx, 0); 5719 A->setImplicit(true); 5720 return A; 5721 } 5722 5723 ObjCReturnsInnerPointerAttr(SourceRange R, ASTContext &Ctx 5724 , unsigned SI 5725 ) 5726 : InheritableAttr(attr::ObjCReturnsInnerPointer, R, SI, false, false) 5727 { 5728 } 5729 5730 ObjCReturnsInnerPointerAttr *clone(ASTContext &C) const; 5731 void printPretty(raw_ostream &OS, 5732 const PrintingPolicy &Policy) const; 5733 const char *getSpelling() const; 5734 5735 5736 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCReturnsInnerPointer; } 5737}; 5738 5739class ObjCRootClassAttr : public InheritableAttr { 5740public: 5741 static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5742 auto *A = new (Ctx) ObjCRootClassAttr(Loc, Ctx, 0); 5743 A->setImplicit(true); 5744 return A; 5745 } 5746 5747 ObjCRootClassAttr(SourceRange R, ASTContext &Ctx 5748 , unsigned SI 5749 ) 5750 : InheritableAttr(attr::ObjCRootClass, R, SI, false, false) 5751 { 5752 } 5753 5754 ObjCRootClassAttr *clone(ASTContext &C) const; 5755 void printPretty(raw_ostream &OS, 5756 const PrintingPolicy &Policy) const; 5757 const char *getSpelling() const; 5758 5759 5760 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRootClass; } 5761}; 5762 5763class ObjCRuntimeNameAttr : public Attr { 5764unsigned metadataNameLength; 5765char *metadataName; 5766 5767public: 5768 static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Loc = SourceRange()) { 5769 auto *A = new (Ctx) ObjCRuntimeNameAttr(Loc, Ctx, MetadataName, 0); 5770 A->setImplicit(true); 5771 return A; 5772 } 5773 5774 ObjCRuntimeNameAttr(SourceRange R, ASTContext &Ctx 5775 , llvm::StringRef MetadataName 5776 , unsigned SI 5777 ) 5778 : Attr(attr::ObjCRuntimeName, R, SI, false, false) 5779 , metadataNameLength(MetadataName.size()),metadataName(new (Ctx, 1) char[metadataNameLength]) 5780 { 5781 if (!MetadataName.empty()) 5782 std::memcpy(metadataName, MetadataName.data(), metadataNameLength); 5783 } 5784 5785 ObjCRuntimeNameAttr *clone(ASTContext &C) const; 5786 void printPretty(raw_ostream &OS, 5787 const PrintingPolicy &Policy) const; 5788 const char *getSpelling() const; 5789 llvm::StringRef getMetadataName() const { 5790 return llvm::StringRef(metadataName, metadataNameLength); 5791 } 5792 unsigned getMetadataNameLength() const { 5793 return metadataNameLength; 5794 } 5795 void setMetadataName(ASTContext &C, llvm::StringRef S) { 5796 metadataNameLength = S.size(); 5797 this->metadataName = new (C, 1) char [metadataNameLength]; 5798 if (!S.empty()) 5799 std::memcpy(this->metadataName, S.data(), metadataNameLength); 5800 } 5801 5802 5803 5804 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeName; } 5805}; 5806 5807class ObjCRuntimeVisibleAttr : public Attr { 5808public: 5809 static ObjCRuntimeVisibleAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5810 auto *A = new (Ctx) ObjCRuntimeVisibleAttr(Loc, Ctx, 0); 5811 A->setImplicit(true); 5812 return A; 5813 } 5814 5815 ObjCRuntimeVisibleAttr(SourceRange R, ASTContext &Ctx 5816 , unsigned SI 5817 ) 5818 : Attr(attr::ObjCRuntimeVisible, R, SI, false, false) 5819 { 5820 } 5821 5822 ObjCRuntimeVisibleAttr *clone(ASTContext &C) const; 5823 void printPretty(raw_ostream &OS, 5824 const PrintingPolicy &Policy) const; 5825 const char *getSpelling() const; 5826 5827 5828 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeVisible; } 5829}; 5830 5831class ObjCSubclassingRestrictedAttr : public InheritableAttr { 5832public: 5833 static ObjCSubclassingRestrictedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5834 auto *A = new (Ctx) ObjCSubclassingRestrictedAttr(Loc, Ctx, 0); 5835 A->setImplicit(true); 5836 return A; 5837 } 5838 5839 ObjCSubclassingRestrictedAttr(SourceRange R, ASTContext &Ctx 5840 , unsigned SI 5841 ) 5842 : InheritableAttr(attr::ObjCSubclassingRestricted, R, SI, false, false) 5843 { 5844 } 5845 5846 ObjCSubclassingRestrictedAttr *clone(ASTContext &C) const; 5847 void printPretty(raw_ostream &OS, 5848 const PrintingPolicy &Policy) const; 5849 const char *getSpelling() const; 5850 5851 5852 static bool classof(const Attr *A) { return A->getKind() == attr::ObjCSubclassingRestricted; } 5853}; 5854 5855class OpenCLAccessAttr : public Attr { 5856public: 5857 enum Spelling { 5858 Keyword_read_only = 0, 5859 Keyword_write_only = 2, 5860 Keyword_read_write = 4 5861 }; 5862 5863 static OpenCLAccessAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 5864 auto *A = new (Ctx) OpenCLAccessAttr(Loc, Ctx, S); 5865 A->setImplicit(true); 5866 return A; 5867 } 5868 5869 OpenCLAccessAttr(SourceRange R, ASTContext &Ctx 5870 , unsigned SI 5871 ) 5872 : Attr(attr::OpenCLAccess, R, SI, false, false) 5873 { 5874 } 5875 5876 OpenCLAccessAttr *clone(ASTContext &C) const; 5877 void printPretty(raw_ostream &OS, 5878 const PrintingPolicy &Policy) const; 5879 const char *getSpelling() const; 5880 Spelling getSemanticSpelling() const { 5881 switch (SpellingListIndex) { 5882 default: llvm_unreachable("Unknown spelling list index"); 5883 case 0: return Keyword_read_only; 5884 case 1: return Keyword_read_only; 5885 case 2: return Keyword_write_only; 5886 case 3: return Keyword_write_only; 5887 case 4: return Keyword_read_write; 5888 case 5: return Keyword_read_write; 5889 } 5890 } 5891 bool isReadOnly() const { return SpellingListIndex == 0 || 5892 SpellingListIndex == 1; } 5893 bool isReadWrite() const { return SpellingListIndex == 4 || 5894 SpellingListIndex == 5; } 5895 bool isWriteOnly() const { return SpellingListIndex == 2 || 5896 SpellingListIndex == 3; } 5897 5898 5899 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLAccess; } 5900}; 5901 5902class OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr { 5903unsigned subGroupSize; 5904 5905public: 5906 static OpenCLIntelReqdSubGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned SubGroupSize, SourceRange Loc = SourceRange()) { 5907 auto *A = new (Ctx) OpenCLIntelReqdSubGroupSizeAttr(Loc, Ctx, SubGroupSize, 0); 5908 A->setImplicit(true); 5909 return A; 5910 } 5911 5912 OpenCLIntelReqdSubGroupSizeAttr(SourceRange R, ASTContext &Ctx 5913 , unsigned SubGroupSize 5914 , unsigned SI 5915 ) 5916 : InheritableAttr(attr::OpenCLIntelReqdSubGroupSize, R, SI, false, false) 5917 , subGroupSize(SubGroupSize) 5918 { 5919 } 5920 5921 OpenCLIntelReqdSubGroupSizeAttr *clone(ASTContext &C) const; 5922 void printPretty(raw_ostream &OS, 5923 const PrintingPolicy &Policy) const; 5924 const char *getSpelling() const; 5925 unsigned getSubGroupSize() const { 5926 return subGroupSize; 5927 } 5928 5929 5930 5931 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLIntelReqdSubGroupSize; } 5932}; 5933 5934class OpenCLKernelAttr : public InheritableAttr { 5935public: 5936 static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5937 auto *A = new (Ctx) OpenCLKernelAttr(Loc, Ctx, 0); 5938 A->setImplicit(true); 5939 return A; 5940 } 5941 5942 OpenCLKernelAttr(SourceRange R, ASTContext &Ctx 5943 , unsigned SI 5944 ) 5945 : InheritableAttr(attr::OpenCLKernel, R, SI, false, false) 5946 { 5947 } 5948 5949 OpenCLKernelAttr *clone(ASTContext &C) const; 5950 void printPretty(raw_ostream &OS, 5951 const PrintingPolicy &Policy) const; 5952 const char *getSpelling() const; 5953 5954 5955 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLKernel; } 5956}; 5957 5958class OpenCLUnrollHintAttr : public InheritableAttr { 5959unsigned unrollHint; 5960 5961public: 5962 static OpenCLUnrollHintAttr *CreateImplicit(ASTContext &Ctx, unsigned UnrollHint, SourceRange Loc = SourceRange()) { 5963 auto *A = new (Ctx) OpenCLUnrollHintAttr(Loc, Ctx, UnrollHint, 0); 5964 A->setImplicit(true); 5965 return A; 5966 } 5967 5968 OpenCLUnrollHintAttr(SourceRange R, ASTContext &Ctx 5969 , unsigned UnrollHint 5970 , unsigned SI 5971 ) 5972 : InheritableAttr(attr::OpenCLUnrollHint, R, SI, false, false) 5973 , unrollHint(UnrollHint) 5974 { 5975 } 5976 5977 OpenCLUnrollHintAttr *clone(ASTContext &C) const; 5978 void printPretty(raw_ostream &OS, 5979 const PrintingPolicy &Policy) const; 5980 const char *getSpelling() const; 5981 unsigned getUnrollHint() const { 5982 return unrollHint; 5983 } 5984 5985 5986 5987 static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLUnrollHint; } 5988}; 5989 5990class OptimizeNoneAttr : public InheritableAttr { 5991public: 5992 static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 5993 auto *A = new (Ctx) OptimizeNoneAttr(Loc, Ctx, 0); 5994 A->setImplicit(true); 5995 return A; 5996 } 5997 5998 OptimizeNoneAttr(SourceRange R, ASTContext &Ctx 5999 , unsigned SI 6000 ) 6001 : InheritableAttr(attr::OptimizeNone, R, SI, false, false) 6002 { 6003 } 6004 6005 OptimizeNoneAttr *clone(ASTContext &C) const; 6006 void printPretty(raw_ostream &OS, 6007 const PrintingPolicy &Policy) const; 6008 const char *getSpelling() const; 6009 6010 6011 static bool classof(const Attr *A) { return A->getKind() == attr::OptimizeNone; } 6012}; 6013 6014class OverloadableAttr : public Attr { 6015public: 6016 static OverloadableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6017 auto *A = new (Ctx) OverloadableAttr(Loc, Ctx, 0); 6018 A->setImplicit(true); 6019 return A; 6020 } 6021 6022 OverloadableAttr(SourceRange R, ASTContext &Ctx 6023 , unsigned SI 6024 ) 6025 : Attr(attr::Overloadable, R, SI, false, false) 6026 { 6027 } 6028 6029 OverloadableAttr *clone(ASTContext &C) const; 6030 void printPretty(raw_ostream &OS, 6031 const PrintingPolicy &Policy) const; 6032 const char *getSpelling() const; 6033 6034 6035 static bool classof(const Attr *A) { return A->getKind() == attr::Overloadable; } 6036}; 6037 6038class OverrideAttr : public InheritableAttr { 6039public: 6040 static OverrideAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6041 auto *A = new (Ctx) OverrideAttr(Loc, Ctx, 0); 6042 A->setImplicit(true); 6043 return A; 6044 } 6045 6046 OverrideAttr(SourceRange R, ASTContext &Ctx 6047 , unsigned SI 6048 ) 6049 : InheritableAttr(attr::Override, R, SI, false, false) 6050 { 6051 } 6052 6053 OverrideAttr *clone(ASTContext &C) const; 6054 void printPretty(raw_ostream &OS, 6055 const PrintingPolicy &Policy) const; 6056 const char *getSpelling() const; 6057 6058 6059 static bool classof(const Attr *A) { return A->getKind() == attr::Override; } 6060}; 6061 6062class OwnershipAttr : public InheritableAttr { 6063IdentifierInfo * module; 6064 6065 unsigned args_Size; 6066 unsigned *args_; 6067 6068public: 6069 enum Spelling { 6070 GNU_ownership_holds = 0, 6071 GNU_ownership_returns = 1, 6072 GNU_ownership_takes = 2 6073 }; 6074 6075 static OwnershipAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * Module, unsigned *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 6076 auto *A = new (Ctx) OwnershipAttr(Loc, Ctx, Module, Args, ArgsSize, S); 6077 A->setImplicit(true); 6078 return A; 6079 } 6080 6081 OwnershipAttr(SourceRange R, ASTContext &Ctx 6082 , IdentifierInfo * Module 6083 , unsigned *Args, unsigned ArgsSize 6084 , unsigned SI 6085 ) 6086 : InheritableAttr(attr::Ownership, R, SI, false, false) 6087 , module(Module) 6088 , args_Size(ArgsSize), args_(new (Ctx, 16) unsigned[args_Size]) 6089 { 6090 std::copy(Args, Args + args_Size, args_); 6091 } 6092 6093 OwnershipAttr(SourceRange R, ASTContext &Ctx 6094 , IdentifierInfo * Module 6095 , unsigned SI 6096 ) 6097 : InheritableAttr(attr::Ownership, R, SI, false, false) 6098 , module(Module) 6099 , args_Size(0), args_(nullptr) 6100 { 6101 } 6102 6103 OwnershipAttr *clone(ASTContext &C) const; 6104 void printPretty(raw_ostream &OS, 6105 const PrintingPolicy &Policy) const; 6106 const char *getSpelling() const; 6107 Spelling getSemanticSpelling() const { 6108 switch (SpellingListIndex) { 6109 default: llvm_unreachable("Unknown spelling list index"); 6110 case 0: return GNU_ownership_holds; 6111 case 1: return GNU_ownership_returns; 6112 case 2: return GNU_ownership_takes; 6113 } 6114 } 6115 bool isHolds() const { return SpellingListIndex == 0; } 6116 bool isReturns() const { return SpellingListIndex == 1; } 6117 bool isTakes() const { return SpellingListIndex == 2; } 6118 IdentifierInfo * getModule() const { 6119 return module; 6120 } 6121 6122 typedef unsigned* args_iterator; 6123 args_iterator args_begin() const { return args_; } 6124 args_iterator args_end() const { return args_ + args_Size; } 6125 unsigned args_size() const { return args_Size; } 6126 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 6127 6128 6129 6130 enum OwnershipKind { Holds, Returns, Takes }; 6131 OwnershipKind getOwnKind() const { 6132 return isHolds() ? Holds : 6133 isTakes() ? Takes : 6134 Returns; 6135 } 6136 6137 6138 static bool classof(const Attr *A) { return A->getKind() == attr::Ownership; } 6139}; 6140 6141class PackedAttr : public InheritableAttr { 6142public: 6143 static PackedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6144 auto *A = new (Ctx) PackedAttr(Loc, Ctx, 0); 6145 A->setImplicit(true); 6146 return A; 6147 } 6148 6149 PackedAttr(SourceRange R, ASTContext &Ctx 6150 , unsigned SI 6151 ) 6152 : InheritableAttr(attr::Packed, R, SI, false, false) 6153 { 6154 } 6155 6156 PackedAttr *clone(ASTContext &C) const; 6157 void printPretty(raw_ostream &OS, 6158 const PrintingPolicy &Policy) const; 6159 const char *getSpelling() const; 6160 6161 6162 static bool classof(const Attr *A) { return A->getKind() == attr::Packed; } 6163}; 6164 6165class ParamTypestateAttr : public InheritableAttr { 6166public: 6167 enum ConsumedState { 6168 Unknown, 6169 Consumed, 6170 Unconsumed 6171 }; 6172private: 6173 ConsumedState paramState; 6174 6175public: 6176 static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState ParamState, SourceRange Loc = SourceRange()) { 6177 auto *A = new (Ctx) ParamTypestateAttr(Loc, Ctx, ParamState, 0); 6178 A->setImplicit(true); 6179 return A; 6180 } 6181 6182 ParamTypestateAttr(SourceRange R, ASTContext &Ctx 6183 , ConsumedState ParamState 6184 , unsigned SI 6185 ) 6186 : InheritableAttr(attr::ParamTypestate, R, SI, false, false) 6187 , paramState(ParamState) 6188 { 6189 } 6190 6191 ParamTypestateAttr *clone(ASTContext &C) const; 6192 void printPretty(raw_ostream &OS, 6193 const PrintingPolicy &Policy) const; 6194 const char *getSpelling() const; 6195 ConsumedState getParamState() const { 6196 return paramState; 6197 } 6198 6199 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { 6200 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) 6201 .Case("unknown", ParamTypestateAttr::Unknown) 6202 .Case("consumed", ParamTypestateAttr::Consumed) 6203 .Case("unconsumed", ParamTypestateAttr::Unconsumed) 6204 .Default(Optional<ConsumedState>()); 6205 if (R) { 6206 Out = *R; 6207 return true; 6208 } 6209 return false; 6210 } 6211 6212 static const char *ConvertConsumedStateToStr(ConsumedState Val) { 6213 switch(Val) { 6214 case ParamTypestateAttr::Unknown: return "unknown"; 6215 case ParamTypestateAttr::Consumed: return "consumed"; 6216 case ParamTypestateAttr::Unconsumed: return "unconsumed"; 6217 } 6218 llvm_unreachable("No enumerator with that value"); 6219 } 6220 6221 6222 static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; } 6223}; 6224 6225class PascalAttr : public InheritableAttr { 6226public: 6227 static PascalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6228 auto *A = new (Ctx) PascalAttr(Loc, Ctx, 0); 6229 A->setImplicit(true); 6230 return A; 6231 } 6232 6233 PascalAttr(SourceRange R, ASTContext &Ctx 6234 , unsigned SI 6235 ) 6236 : InheritableAttr(attr::Pascal, R, SI, false, false) 6237 { 6238 } 6239 6240 PascalAttr *clone(ASTContext &C) const; 6241 void printPretty(raw_ostream &OS, 6242 const PrintingPolicy &Policy) const; 6243 const char *getSpelling() const; 6244 6245 6246 static bool classof(const Attr *A) { return A->getKind() == attr::Pascal; } 6247}; 6248 6249class PassObjectSizeAttr : public InheritableParamAttr { 6250int type; 6251 6252public: 6253 static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, int Type, SourceRange Loc = SourceRange()) { 6254 auto *A = new (Ctx) PassObjectSizeAttr(Loc, Ctx, Type, 0); 6255 A->setImplicit(true); 6256 return A; 6257 } 6258 6259 PassObjectSizeAttr(SourceRange R, ASTContext &Ctx 6260 , int Type 6261 , unsigned SI 6262 ) 6263 : InheritableParamAttr(attr::PassObjectSize, R, SI, false, false) 6264 , type(Type) 6265 { 6266 } 6267 6268 PassObjectSizeAttr *clone(ASTContext &C) const; 6269 void printPretty(raw_ostream &OS, 6270 const PrintingPolicy &Policy) const; 6271 const char *getSpelling() const; 6272 int getType() const { 6273 return type; 6274 } 6275 6276 6277 6278 static bool classof(const Attr *A) { return A->getKind() == attr::PassObjectSize; } 6279}; 6280 6281class PcsAttr : public InheritableAttr { 6282public: 6283 enum PCSType { 6284 AAPCS, 6285 AAPCS_VFP 6286 }; 6287private: 6288 PCSType pCS; 6289 6290public: 6291 static PcsAttr *CreateImplicit(ASTContext &Ctx, PCSType PCS, SourceRange Loc = SourceRange()) { 6292 auto *A = new (Ctx) PcsAttr(Loc, Ctx, PCS, 0); 6293 A->setImplicit(true); 6294 return A; 6295 } 6296 6297 PcsAttr(SourceRange R, ASTContext &Ctx 6298 , PCSType PCS 6299 , unsigned SI 6300 ) 6301 : InheritableAttr(attr::Pcs, R, SI, false, false) 6302 , pCS(PCS) 6303 { 6304 } 6305 6306 PcsAttr *clone(ASTContext &C) const; 6307 void printPretty(raw_ostream &OS, 6308 const PrintingPolicy &Policy) const; 6309 const char *getSpelling() const; 6310 PCSType getPCS() const { 6311 return pCS; 6312 } 6313 6314 static bool ConvertStrToPCSType(StringRef Val, PCSType &Out) { 6315 Optional<PCSType> R = llvm::StringSwitch<Optional<PCSType>>(Val) 6316 .Case("aapcs", PcsAttr::AAPCS) 6317 .Case("aapcs-vfp", PcsAttr::AAPCS_VFP) 6318 .Default(Optional<PCSType>()); 6319 if (R) { 6320 Out = *R; 6321 return true; 6322 } 6323 return false; 6324 } 6325 6326 static const char *ConvertPCSTypeToStr(PCSType Val) { 6327 switch(Val) { 6328 case PcsAttr::AAPCS: return "aapcs"; 6329 case PcsAttr::AAPCS_VFP: return "aapcs-vfp"; 6330 } 6331 llvm_unreachable("No enumerator with that value"); 6332 } 6333 6334 6335 static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; } 6336}; 6337 6338class PragmaClangBSSSectionAttr : public InheritableAttr { 6339unsigned nameLength; 6340char *name; 6341 6342public: 6343 static PragmaClangBSSSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) { 6344 auto *A = new (Ctx) PragmaClangBSSSectionAttr(Loc, Ctx, Name, 0); 6345 A->setImplicit(true); 6346 return A; 6347 } 6348 6349 PragmaClangBSSSectionAttr(SourceRange R, ASTContext &Ctx 6350 , llvm::StringRef Name 6351 , unsigned SI 6352 ) 6353 : InheritableAttr(attr::PragmaClangBSSSection, R, SI, false, false) 6354 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) 6355 { 6356 if (!Name.empty()) 6357 std::memcpy(name, Name.data(), nameLength); 6358 } 6359 6360 PragmaClangBSSSectionAttr *clone(ASTContext &C) const; 6361 void printPretty(raw_ostream &OS, 6362 const PrintingPolicy &Policy) const; 6363 const char *getSpelling() const; 6364 llvm::StringRef getName() const { 6365 return llvm::StringRef(name, nameLength); 6366 } 6367 unsigned getNameLength() const { 6368 return nameLength; 6369 } 6370 void setName(ASTContext &C, llvm::StringRef S) { 6371 nameLength = S.size(); 6372 this->name = new (C, 1) char [nameLength]; 6373 if (!S.empty()) 6374 std::memcpy(this->name, S.data(), nameLength); 6375 } 6376 6377 6378 6379 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangBSSSection; } 6380}; 6381 6382class PragmaClangDataSectionAttr : public InheritableAttr { 6383unsigned nameLength; 6384char *name; 6385 6386public: 6387 static PragmaClangDataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) { 6388 auto *A = new (Ctx) PragmaClangDataSectionAttr(Loc, Ctx, Name, 0); 6389 A->setImplicit(true); 6390 return A; 6391 } 6392 6393 PragmaClangDataSectionAttr(SourceRange R, ASTContext &Ctx 6394 , llvm::StringRef Name 6395 , unsigned SI 6396 ) 6397 : InheritableAttr(attr::PragmaClangDataSection, R, SI, false, false) 6398 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) 6399 { 6400 if (!Name.empty()) 6401 std::memcpy(name, Name.data(), nameLength); 6402 } 6403 6404 PragmaClangDataSectionAttr *clone(ASTContext &C) const; 6405 void printPretty(raw_ostream &OS, 6406 const PrintingPolicy &Policy) const; 6407 const char *getSpelling() const; 6408 llvm::StringRef getName() const { 6409 return llvm::StringRef(name, nameLength); 6410 } 6411 unsigned getNameLength() const { 6412 return nameLength; 6413 } 6414 void setName(ASTContext &C, llvm::StringRef S) { 6415 nameLength = S.size(); 6416 this->name = new (C, 1) char [nameLength]; 6417 if (!S.empty()) 6418 std::memcpy(this->name, S.data(), nameLength); 6419 } 6420 6421 6422 6423 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangDataSection; } 6424}; 6425 6426class PragmaClangRodataSectionAttr : public InheritableAttr { 6427unsigned nameLength; 6428char *name; 6429 6430public: 6431 static PragmaClangRodataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) { 6432 auto *A = new (Ctx) PragmaClangRodataSectionAttr(Loc, Ctx, Name, 0); 6433 A->setImplicit(true); 6434 return A; 6435 } 6436 6437 PragmaClangRodataSectionAttr(SourceRange R, ASTContext &Ctx 6438 , llvm::StringRef Name 6439 , unsigned SI 6440 ) 6441 : InheritableAttr(attr::PragmaClangRodataSection, R, SI, false, false) 6442 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) 6443 { 6444 if (!Name.empty()) 6445 std::memcpy(name, Name.data(), nameLength); 6446 } 6447 6448 PragmaClangRodataSectionAttr *clone(ASTContext &C) const; 6449 void printPretty(raw_ostream &OS, 6450 const PrintingPolicy &Policy) const; 6451 const char *getSpelling() const; 6452 llvm::StringRef getName() const { 6453 return llvm::StringRef(name, nameLength); 6454 } 6455 unsigned getNameLength() const { 6456 return nameLength; 6457 } 6458 void setName(ASTContext &C, llvm::StringRef S) { 6459 nameLength = S.size(); 6460 this->name = new (C, 1) char [nameLength]; 6461 if (!S.empty()) 6462 std::memcpy(this->name, S.data(), nameLength); 6463 } 6464 6465 6466 6467 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangRodataSection; } 6468}; 6469 6470class PragmaClangTextSectionAttr : public InheritableAttr { 6471unsigned nameLength; 6472char *name; 6473 6474public: 6475 static PragmaClangTextSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) { 6476 auto *A = new (Ctx) PragmaClangTextSectionAttr(Loc, Ctx, Name, 0); 6477 A->setImplicit(true); 6478 return A; 6479 } 6480 6481 PragmaClangTextSectionAttr(SourceRange R, ASTContext &Ctx 6482 , llvm::StringRef Name 6483 , unsigned SI 6484 ) 6485 : InheritableAttr(attr::PragmaClangTextSection, R, SI, false, false) 6486 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) 6487 { 6488 if (!Name.empty()) 6489 std::memcpy(name, Name.data(), nameLength); 6490 } 6491 6492 PragmaClangTextSectionAttr *clone(ASTContext &C) const; 6493 void printPretty(raw_ostream &OS, 6494 const PrintingPolicy &Policy) const; 6495 const char *getSpelling() const; 6496 llvm::StringRef getName() const { 6497 return llvm::StringRef(name, nameLength); 6498 } 6499 unsigned getNameLength() const { 6500 return nameLength; 6501 } 6502 void setName(ASTContext &C, llvm::StringRef S) { 6503 nameLength = S.size(); 6504 this->name = new (C, 1) char [nameLength]; 6505 if (!S.empty()) 6506 std::memcpy(this->name, S.data(), nameLength); 6507 } 6508 6509 6510 6511 static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangTextSection; } 6512}; 6513 6514class PreserveAllAttr : public InheritableAttr { 6515public: 6516 static PreserveAllAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6517 auto *A = new (Ctx) PreserveAllAttr(Loc, Ctx, 0); 6518 A->setImplicit(true); 6519 return A; 6520 } 6521 6522 PreserveAllAttr(SourceRange R, ASTContext &Ctx 6523 , unsigned SI 6524 ) 6525 : InheritableAttr(attr::PreserveAll, R, SI, false, false) 6526 { 6527 } 6528 6529 PreserveAllAttr *clone(ASTContext &C) const; 6530 void printPretty(raw_ostream &OS, 6531 const PrintingPolicy &Policy) const; 6532 const char *getSpelling() const; 6533 6534 6535 static bool classof(const Attr *A) { return A->getKind() == attr::PreserveAll; } 6536}; 6537 6538class PreserveMostAttr : public InheritableAttr { 6539public: 6540 static PreserveMostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6541 auto *A = new (Ctx) PreserveMostAttr(Loc, Ctx, 0); 6542 A->setImplicit(true); 6543 return A; 6544 } 6545 6546 PreserveMostAttr(SourceRange R, ASTContext &Ctx 6547 , unsigned SI 6548 ) 6549 : InheritableAttr(attr::PreserveMost, R, SI, false, false) 6550 { 6551 } 6552 6553 PreserveMostAttr *clone(ASTContext &C) const; 6554 void printPretty(raw_ostream &OS, 6555 const PrintingPolicy &Policy) const; 6556 const char *getSpelling() const; 6557 6558 6559 static bool classof(const Attr *A) { return A->getKind() == attr::PreserveMost; } 6560}; 6561 6562class PtGuardedByAttr : public InheritableAttr { 6563Expr * arg; 6564 6565public: 6566 static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) { 6567 auto *A = new (Ctx) PtGuardedByAttr(Loc, Ctx, Arg, 0); 6568 A->setImplicit(true); 6569 return A; 6570 } 6571 6572 PtGuardedByAttr(SourceRange R, ASTContext &Ctx 6573 , Expr * Arg 6574 , unsigned SI 6575 ) 6576 : InheritableAttr(attr::PtGuardedBy, R, SI, true, true) 6577 , arg(Arg) 6578 { 6579 } 6580 6581 PtGuardedByAttr *clone(ASTContext &C) const; 6582 void printPretty(raw_ostream &OS, 6583 const PrintingPolicy &Policy) const; 6584 const char *getSpelling() const; 6585 Expr * getArg() const { 6586 return arg; 6587 } 6588 6589 6590 6591 static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedBy; } 6592}; 6593 6594class PtGuardedVarAttr : public InheritableAttr { 6595public: 6596 static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6597 auto *A = new (Ctx) PtGuardedVarAttr(Loc, Ctx, 0); 6598 A->setImplicit(true); 6599 return A; 6600 } 6601 6602 PtGuardedVarAttr(SourceRange R, ASTContext &Ctx 6603 , unsigned SI 6604 ) 6605 : InheritableAttr(attr::PtGuardedVar, R, SI, false, false) 6606 { 6607 } 6608 6609 PtGuardedVarAttr *clone(ASTContext &C) const; 6610 void printPretty(raw_ostream &OS, 6611 const PrintingPolicy &Policy) const; 6612 const char *getSpelling() const; 6613 6614 6615 static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedVar; } 6616}; 6617 6618class PureAttr : public InheritableAttr { 6619public: 6620 static PureAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6621 auto *A = new (Ctx) PureAttr(Loc, Ctx, 0); 6622 A->setImplicit(true); 6623 return A; 6624 } 6625 6626 PureAttr(SourceRange R, ASTContext &Ctx 6627 , unsigned SI 6628 ) 6629 : InheritableAttr(attr::Pure, R, SI, false, false) 6630 { 6631 } 6632 6633 PureAttr *clone(ASTContext &C) const; 6634 void printPretty(raw_ostream &OS, 6635 const PrintingPolicy &Policy) const; 6636 const char *getSpelling() const; 6637 6638 6639 static bool classof(const Attr *A) { return A->getKind() == attr::Pure; } 6640}; 6641 6642class RegCallAttr : public InheritableAttr { 6643public: 6644 static RegCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6645 auto *A = new (Ctx) RegCallAttr(Loc, Ctx, 0); 6646 A->setImplicit(true); 6647 return A; 6648 } 6649 6650 RegCallAttr(SourceRange R, ASTContext &Ctx 6651 , unsigned SI 6652 ) 6653 : InheritableAttr(attr::RegCall, R, SI, false, false) 6654 { 6655 } 6656 6657 RegCallAttr *clone(ASTContext &C) const; 6658 void printPretty(raw_ostream &OS, 6659 const PrintingPolicy &Policy) const; 6660 const char *getSpelling() const; 6661 6662 6663 static bool classof(const Attr *A) { return A->getKind() == attr::RegCall; } 6664}; 6665 6666class ReleaseCapabilityAttr : public InheritableAttr { 6667 unsigned args_Size; 6668 Expr * *args_; 6669 6670public: 6671 enum Spelling { 6672 GNU_release_capability = 0, 6673 CXX11_clang_release_capability = 1, 6674 GNU_release_shared_capability = 2, 6675 CXX11_clang_release_shared_capability = 3, 6676 GNU_release_generic_capability = 4, 6677 CXX11_clang_release_generic_capability = 5, 6678 GNU_unlock_function = 6 6679 }; 6680 6681 static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 6682 auto *A = new (Ctx) ReleaseCapabilityAttr(Loc, Ctx, Args, ArgsSize, S); 6683 A->setImplicit(true); 6684 return A; 6685 } 6686 6687 ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx 6688 , Expr * *Args, unsigned ArgsSize 6689 , unsigned SI 6690 ) 6691 : InheritableAttr(attr::ReleaseCapability, R, SI, true, true) 6692 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 6693 { 6694 std::copy(Args, Args + args_Size, args_); 6695 } 6696 6697 ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx 6698 , unsigned SI 6699 ) 6700 : InheritableAttr(attr::ReleaseCapability, R, SI, true, true) 6701 , args_Size(0), args_(nullptr) 6702 { 6703 } 6704 6705 ReleaseCapabilityAttr *clone(ASTContext &C) const; 6706 void printPretty(raw_ostream &OS, 6707 const PrintingPolicy &Policy) const; 6708 const char *getSpelling() const; 6709 Spelling getSemanticSpelling() const { 6710 switch (SpellingListIndex) { 6711 default: llvm_unreachable("Unknown spelling list index"); 6712 case 0: return GNU_release_capability; 6713 case 1: return CXX11_clang_release_capability; 6714 case 2: return GNU_release_shared_capability; 6715 case 3: return CXX11_clang_release_shared_capability; 6716 case 4: return GNU_release_generic_capability; 6717 case 5: return CXX11_clang_release_generic_capability; 6718 case 6: return GNU_unlock_function; 6719 } 6720 } 6721 bool isShared() const { return SpellingListIndex == 2 || 6722 SpellingListIndex == 3; } 6723 bool isGeneric() const { return SpellingListIndex == 4 || 6724 SpellingListIndex == 5 || 6725 SpellingListIndex == 6; } 6726 typedef Expr ** args_iterator; 6727 args_iterator args_begin() const { return args_; } 6728 args_iterator args_end() const { return args_ + args_Size; } 6729 unsigned args_size() const { return args_Size; } 6730 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 6731 6732 6733 6734 6735 static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseCapability; } 6736}; 6737 6738class RenderScriptKernelAttr : public Attr { 6739public: 6740 static RenderScriptKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6741 auto *A = new (Ctx) RenderScriptKernelAttr(Loc, Ctx, 0); 6742 A->setImplicit(true); 6743 return A; 6744 } 6745 6746 RenderScriptKernelAttr(SourceRange R, ASTContext &Ctx 6747 , unsigned SI 6748 ) 6749 : Attr(attr::RenderScriptKernel, R, SI, false, false) 6750 { 6751 } 6752 6753 RenderScriptKernelAttr *clone(ASTContext &C) const; 6754 void printPretty(raw_ostream &OS, 6755 const PrintingPolicy &Policy) const; 6756 const char *getSpelling() const; 6757 6758 6759 static bool classof(const Attr *A) { return A->getKind() == attr::RenderScriptKernel; } 6760}; 6761 6762class ReqdWorkGroupSizeAttr : public InheritableAttr { 6763unsigned xDim; 6764 6765unsigned yDim; 6766 6767unsigned zDim; 6768 6769public: 6770 static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) { 6771 auto *A = new (Ctx) ReqdWorkGroupSizeAttr(Loc, Ctx, XDim, YDim, ZDim, 0); 6772 A->setImplicit(true); 6773 return A; 6774 } 6775 6776 ReqdWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx 6777 , unsigned XDim 6778 , unsigned YDim 6779 , unsigned ZDim 6780 , unsigned SI 6781 ) 6782 : InheritableAttr(attr::ReqdWorkGroupSize, R, SI, false, false) 6783 , xDim(XDim) 6784 , yDim(YDim) 6785 , zDim(ZDim) 6786 { 6787 } 6788 6789 ReqdWorkGroupSizeAttr *clone(ASTContext &C) const; 6790 void printPretty(raw_ostream &OS, 6791 const PrintingPolicy &Policy) const; 6792 const char *getSpelling() const; 6793 unsigned getXDim() const { 6794 return xDim; 6795 } 6796 6797 unsigned getYDim() const { 6798 return yDim; 6799 } 6800 6801 unsigned getZDim() const { 6802 return zDim; 6803 } 6804 6805 6806 6807 static bool classof(const Attr *A) { return A->getKind() == attr::ReqdWorkGroupSize; } 6808}; 6809 6810class RequireConstantInitAttr : public InheritableAttr { 6811public: 6812 static RequireConstantInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 6813 auto *A = new (Ctx) RequireConstantInitAttr(Loc, Ctx, 0); 6814 A->setImplicit(true); 6815 return A; 6816 } 6817 6818 RequireConstantInitAttr(SourceRange R, ASTContext &Ctx 6819 , unsigned SI 6820 ) 6821 : InheritableAttr(attr::RequireConstantInit, R, SI, false, false) 6822 { 6823 } 6824 6825 RequireConstantInitAttr *clone(ASTContext &C) const; 6826 void printPretty(raw_ostream &OS, 6827 const PrintingPolicy &Policy) const; 6828 const char *getSpelling() const; 6829 6830 6831 static bool classof(const Attr *A) { return A->getKind() == attr::RequireConstantInit; } 6832}; 6833 6834class RequiresCapabilityAttr : public InheritableAttr { 6835 unsigned args_Size; 6836 Expr * *args_; 6837 6838public: 6839 enum Spelling { 6840 GNU_requires_capability = 0, 6841 CXX11_clang_requires_capability = 1, 6842 GNU_exclusive_locks_required = 2, 6843 GNU_requires_shared_capability = 3, 6844 CXX11_clang_requires_shared_capability = 4, 6845 GNU_shared_locks_required = 5 6846 }; 6847 6848 static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 6849 auto *A = new (Ctx) RequiresCapabilityAttr(Loc, Ctx, Args, ArgsSize, S); 6850 A->setImplicit(true); 6851 return A; 6852 } 6853 6854 RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx 6855 , Expr * *Args, unsigned ArgsSize 6856 , unsigned SI 6857 ) 6858 : InheritableAttr(attr::RequiresCapability, R, SI, true, true) 6859 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 6860 { 6861 std::copy(Args, Args + args_Size, args_); 6862 } 6863 6864 RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx 6865 , unsigned SI 6866 ) 6867 : InheritableAttr(attr::RequiresCapability, R, SI, true, true) 6868 , args_Size(0), args_(nullptr) 6869 { 6870 } 6871 6872 RequiresCapabilityAttr *clone(ASTContext &C) const; 6873 void printPretty(raw_ostream &OS, 6874 const PrintingPolicy &Policy) const; 6875 const char *getSpelling() const; 6876 Spelling getSemanticSpelling() const { 6877 switch (SpellingListIndex) { 6878 default: llvm_unreachable("Unknown spelling list index"); 6879 case 0: return GNU_requires_capability; 6880 case 1: return CXX11_clang_requires_capability; 6881 case 2: return GNU_exclusive_locks_required; 6882 case 3: return GNU_requires_shared_capability; 6883 case 4: return CXX11_clang_requires_shared_capability; 6884 case 5: return GNU_shared_locks_required; 6885 } 6886 } 6887 bool isShared() const { return SpellingListIndex == 3 || 6888 SpellingListIndex == 5 || 6889 SpellingListIndex == 4; } 6890 typedef Expr ** args_iterator; 6891 args_iterator args_begin() const { return args_; } 6892 args_iterator args_end() const { return args_ + args_Size; } 6893 unsigned args_size() const { return args_Size; } 6894 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 6895 6896 6897 6898 6899 static bool classof(const Attr *A) { return A->getKind() == attr::RequiresCapability; } 6900}; 6901 6902class RestrictAttr : public InheritableAttr { 6903public: 6904 enum Spelling { 6905 Declspec_restrict = 0, 6906 GNU_malloc = 1, 6907 CXX11_gnu_malloc = 2 6908 }; 6909 6910 static RestrictAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 6911 auto *A = new (Ctx) RestrictAttr(Loc, Ctx, S); 6912 A->setImplicit(true); 6913 return A; 6914 } 6915 6916 RestrictAttr(SourceRange R, ASTContext &Ctx 6917 , unsigned SI 6918 ) 6919 : InheritableAttr(attr::Restrict, R, SI, false, false) 6920 { 6921 } 6922 6923 RestrictAttr *clone(ASTContext &C) const; 6924 void printPretty(raw_ostream &OS, 6925 const PrintingPolicy &Policy) const; 6926 const char *getSpelling() const; 6927 Spelling getSemanticSpelling() const { 6928 switch (SpellingListIndex) { 6929 default: llvm_unreachable("Unknown spelling list index"); 6930 case 0: return Declspec_restrict; 6931 case 1: return GNU_malloc; 6932 case 2: return CXX11_gnu_malloc; 6933 } 6934 } 6935 6936 6937 static bool classof(const Attr *A) { return A->getKind() == attr::Restrict; } 6938}; 6939 6940class ReturnTypestateAttr : public InheritableAttr { 6941public: 6942 enum ConsumedState { 6943 Unknown, 6944 Consumed, 6945 Unconsumed 6946 }; 6947private: 6948 ConsumedState state; 6949 6950public: 6951 static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState State, SourceRange Loc = SourceRange()) { 6952 auto *A = new (Ctx) ReturnTypestateAttr(Loc, Ctx, State, 0); 6953 A->setImplicit(true); 6954 return A; 6955 } 6956 6957 ReturnTypestateAttr(SourceRange R, ASTContext &Ctx 6958 , ConsumedState State 6959 , unsigned SI 6960 ) 6961 : InheritableAttr(attr::ReturnTypestate, R, SI, false, false) 6962 , state(State) 6963 { 6964 } 6965 6966 ReturnTypestateAttr *clone(ASTContext &C) const; 6967 void printPretty(raw_ostream &OS, 6968 const PrintingPolicy &Policy) const; 6969 const char *getSpelling() const; 6970 ConsumedState getState() const { 6971 return state; 6972 } 6973 6974 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { 6975 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) 6976 .Case("unknown", ReturnTypestateAttr::Unknown) 6977 .Case("consumed", ReturnTypestateAttr::Consumed) 6978 .Case("unconsumed", ReturnTypestateAttr::Unconsumed) 6979 .Default(Optional<ConsumedState>()); 6980 if (R) { 6981 Out = *R; 6982 return true; 6983 } 6984 return false; 6985 } 6986 6987 static const char *ConvertConsumedStateToStr(ConsumedState Val) { 6988 switch(Val) { 6989 case ReturnTypestateAttr::Unknown: return "unknown"; 6990 case ReturnTypestateAttr::Consumed: return "consumed"; 6991 case ReturnTypestateAttr::Unconsumed: return "unconsumed"; 6992 } 6993 llvm_unreachable("No enumerator with that value"); 6994 } 6995 6996 6997 static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; } 6998}; 6999 7000class ReturnsNonNullAttr : public InheritableAttr { 7001public: 7002 static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7003 auto *A = new (Ctx) ReturnsNonNullAttr(Loc, Ctx, 0); 7004 A->setImplicit(true); 7005 return A; 7006 } 7007 7008 ReturnsNonNullAttr(SourceRange R, ASTContext &Ctx 7009 , unsigned SI 7010 ) 7011 : InheritableAttr(attr::ReturnsNonNull, R, SI, false, false) 7012 { 7013 } 7014 7015 ReturnsNonNullAttr *clone(ASTContext &C) const; 7016 void printPretty(raw_ostream &OS, 7017 const PrintingPolicy &Policy) const; 7018 const char *getSpelling() const; 7019 7020 7021 static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsNonNull; } 7022}; 7023 7024class ReturnsTwiceAttr : public InheritableAttr { 7025public: 7026 static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7027 auto *A = new (Ctx) ReturnsTwiceAttr(Loc, Ctx, 0); 7028 A->setImplicit(true); 7029 return A; 7030 } 7031 7032 ReturnsTwiceAttr(SourceRange R, ASTContext &Ctx 7033 , unsigned SI 7034 ) 7035 : InheritableAttr(attr::ReturnsTwice, R, SI, false, false) 7036 { 7037 } 7038 7039 ReturnsTwiceAttr *clone(ASTContext &C) const; 7040 void printPretty(raw_ostream &OS, 7041 const PrintingPolicy &Policy) const; 7042 const char *getSpelling() const; 7043 7044 7045 static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsTwice; } 7046}; 7047 7048class ScopedLockableAttr : public InheritableAttr { 7049public: 7050 static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7051 auto *A = new (Ctx) ScopedLockableAttr(Loc, Ctx, 0); 7052 A->setImplicit(true); 7053 return A; 7054 } 7055 7056 ScopedLockableAttr(SourceRange R, ASTContext &Ctx 7057 , unsigned SI 7058 ) 7059 : InheritableAttr(attr::ScopedLockable, R, SI, false, false) 7060 { 7061 } 7062 7063 ScopedLockableAttr *clone(ASTContext &C) const; 7064 void printPretty(raw_ostream &OS, 7065 const PrintingPolicy &Policy) const; 7066 const char *getSpelling() const; 7067 7068 7069 static bool classof(const Attr *A) { return A->getKind() == attr::ScopedLockable; } 7070}; 7071 7072class SectionAttr : public InheritableAttr { 7073unsigned nameLength; 7074char *name; 7075 7076public: 7077 enum Spelling { 7078 GNU_section = 0, 7079 CXX11_gnu_section = 1, 7080 Declspec_allocate = 2 7081 }; 7082 7083 static SectionAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) { 7084 auto *A = new (Ctx) SectionAttr(Loc, Ctx, Name, S); 7085 A->setImplicit(true); 7086 return A; 7087 } 7088 7089 SectionAttr(SourceRange R, ASTContext &Ctx 7090 , llvm::StringRef Name 7091 , unsigned SI 7092 ) 7093 : InheritableAttr(attr::Section, R, SI, false, false) 7094 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) 7095 { 7096 if (!Name.empty()) 7097 std::memcpy(name, Name.data(), nameLength); 7098 } 7099 7100 SectionAttr *clone(ASTContext &C) const; 7101 void printPretty(raw_ostream &OS, 7102 const PrintingPolicy &Policy) const; 7103 const char *getSpelling() const; 7104 Spelling getSemanticSpelling() const { 7105 switch (SpellingListIndex) { 7106 default: llvm_unreachable("Unknown spelling list index"); 7107 case 0: return GNU_section; 7108 case 1: return CXX11_gnu_section; 7109 case 2: return Declspec_allocate; 7110 } 7111 } 7112 llvm::StringRef getName() const { 7113 return llvm::StringRef(name, nameLength); 7114 } 7115 unsigned getNameLength() const { 7116 return nameLength; 7117 } 7118 void setName(ASTContext &C, llvm::StringRef S) { 7119 nameLength = S.size(); 7120 this->name = new (C, 1) char [nameLength]; 7121 if (!S.empty()) 7122 std::memcpy(this->name, S.data(), nameLength); 7123 } 7124 7125 7126 7127 static bool classof(const Attr *A) { return A->getKind() == attr::Section; } 7128}; 7129 7130class SelectAnyAttr : public InheritableAttr { 7131public: 7132 static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7133 auto *A = new (Ctx) SelectAnyAttr(Loc, Ctx, 0); 7134 A->setImplicit(true); 7135 return A; 7136 } 7137 7138 SelectAnyAttr(SourceRange R, ASTContext &Ctx 7139 , unsigned SI 7140 ) 7141 : InheritableAttr(attr::SelectAny, R, SI, false, false) 7142 { 7143 } 7144 7145 SelectAnyAttr *clone(ASTContext &C) const; 7146 void printPretty(raw_ostream &OS, 7147 const PrintingPolicy &Policy) const; 7148 const char *getSpelling() const; 7149 7150 7151 static bool classof(const Attr *A) { return A->getKind() == attr::SelectAny; } 7152}; 7153 7154class SentinelAttr : public InheritableAttr { 7155int sentinel; 7156 7157int nullPos; 7158 7159public: 7160 static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Loc = SourceRange()) { 7161 auto *A = new (Ctx) SentinelAttr(Loc, Ctx, Sentinel, NullPos, 0); 7162 A->setImplicit(true); 7163 return A; 7164 } 7165 7166 SentinelAttr(SourceRange R, ASTContext &Ctx 7167 , int Sentinel 7168 , int NullPos 7169 , unsigned SI 7170 ) 7171 : InheritableAttr(attr::Sentinel, R, SI, false, false) 7172 , sentinel(Sentinel) 7173 , nullPos(NullPos) 7174 { 7175 } 7176 7177 SentinelAttr(SourceRange R, ASTContext &Ctx 7178 , unsigned SI 7179 ) 7180 : InheritableAttr(attr::Sentinel, R, SI, false, false) 7181 , sentinel() 7182 , nullPos() 7183 { 7184 } 7185 7186 SentinelAttr *clone(ASTContext &C) const; 7187 void printPretty(raw_ostream &OS, 7188 const PrintingPolicy &Policy) const; 7189 const char *getSpelling() const; 7190 int getSentinel() const { 7191 return sentinel; 7192 } 7193 7194 static const int DefaultSentinel = 0; 7195 7196 int getNullPos() const { 7197 return nullPos; 7198 } 7199 7200 static const int DefaultNullPos = 0; 7201 7202 7203 7204 static bool classof(const Attr *A) { return A->getKind() == attr::Sentinel; } 7205}; 7206 7207class SetTypestateAttr : public InheritableAttr { 7208public: 7209 enum ConsumedState { 7210 Unknown, 7211 Consumed, 7212 Unconsumed 7213 }; 7214private: 7215 ConsumedState newState; 7216 7217public: 7218 static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState NewState, SourceRange Loc = SourceRange()) { 7219 auto *A = new (Ctx) SetTypestateAttr(Loc, Ctx, NewState, 0); 7220 A->setImplicit(true); 7221 return A; 7222 } 7223 7224 SetTypestateAttr(SourceRange R, ASTContext &Ctx 7225 , ConsumedState NewState 7226 , unsigned SI 7227 ) 7228 : InheritableAttr(attr::SetTypestate, R, SI, false, false) 7229 , newState(NewState) 7230 { 7231 } 7232 7233 SetTypestateAttr *clone(ASTContext &C) const; 7234 void printPretty(raw_ostream &OS, 7235 const PrintingPolicy &Policy) const; 7236 const char *getSpelling() const; 7237 ConsumedState getNewState() const { 7238 return newState; 7239 } 7240 7241 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { 7242 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) 7243 .Case("unknown", SetTypestateAttr::Unknown) 7244 .Case("consumed", SetTypestateAttr::Consumed) 7245 .Case("unconsumed", SetTypestateAttr::Unconsumed) 7246 .Default(Optional<ConsumedState>()); 7247 if (R) { 7248 Out = *R; 7249 return true; 7250 } 7251 return false; 7252 } 7253 7254 static const char *ConvertConsumedStateToStr(ConsumedState Val) { 7255 switch(Val) { 7256 case SetTypestateAttr::Unknown: return "unknown"; 7257 case SetTypestateAttr::Consumed: return "consumed"; 7258 case SetTypestateAttr::Unconsumed: return "unconsumed"; 7259 } 7260 llvm_unreachable("No enumerator with that value"); 7261 } 7262 7263 7264 static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; } 7265}; 7266 7267class SharedTrylockFunctionAttr : public InheritableAttr { 7268Expr * successValue; 7269 7270 unsigned args_Size; 7271 Expr * *args_; 7272 7273public: 7274 static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 7275 auto *A = new (Ctx) SharedTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0); 7276 A->setImplicit(true); 7277 return A; 7278 } 7279 7280 SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx 7281 , Expr * SuccessValue 7282 , Expr * *Args, unsigned ArgsSize 7283 , unsigned SI 7284 ) 7285 : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true) 7286 , successValue(SuccessValue) 7287 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 7288 { 7289 std::copy(Args, Args + args_Size, args_); 7290 } 7291 7292 SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx 7293 , Expr * SuccessValue 7294 , unsigned SI 7295 ) 7296 : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true) 7297 , successValue(SuccessValue) 7298 , args_Size(0), args_(nullptr) 7299 { 7300 } 7301 7302 SharedTrylockFunctionAttr *clone(ASTContext &C) const; 7303 void printPretty(raw_ostream &OS, 7304 const PrintingPolicy &Policy) const; 7305 const char *getSpelling() const; 7306 Expr * getSuccessValue() const { 7307 return successValue; 7308 } 7309 7310 typedef Expr ** args_iterator; 7311 args_iterator args_begin() const { return args_; } 7312 args_iterator args_end() const { return args_ + args_Size; } 7313 unsigned args_size() const { return args_Size; } 7314 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 7315 7316 7317 7318 7319 static bool classof(const Attr *A) { return A->getKind() == attr::SharedTrylockFunction; } 7320}; 7321 7322class StdCallAttr : public InheritableAttr { 7323public: 7324 static StdCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7325 auto *A = new (Ctx) StdCallAttr(Loc, Ctx, 0); 7326 A->setImplicit(true); 7327 return A; 7328 } 7329 7330 StdCallAttr(SourceRange R, ASTContext &Ctx 7331 , unsigned SI 7332 ) 7333 : InheritableAttr(attr::StdCall, R, SI, false, false) 7334 { 7335 } 7336 7337 StdCallAttr *clone(ASTContext &C) const; 7338 void printPretty(raw_ostream &OS, 7339 const PrintingPolicy &Policy) const; 7340 const char *getSpelling() const; 7341 7342 7343 static bool classof(const Attr *A) { return A->getKind() == attr::StdCall; } 7344}; 7345 7346class SuppressAttr : public StmtAttr { 7347 unsigned diagnosticIdentifiers_Size; 7348 StringRef *diagnosticIdentifiers_; 7349 7350public: 7351 static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Loc = SourceRange()) { 7352 auto *A = new (Ctx) SuppressAttr(Loc, Ctx, DiagnosticIdentifiers, DiagnosticIdentifiersSize, 0); 7353 A->setImplicit(true); 7354 return A; 7355 } 7356 7357 SuppressAttr(SourceRange R, ASTContext &Ctx 7358 , StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize 7359 , unsigned SI 7360 ) 7361 : StmtAttr(attr::Suppress, R, SI, false, false) 7362 , diagnosticIdentifiers_Size(DiagnosticIdentifiersSize), diagnosticIdentifiers_(new (Ctx, 16) StringRef[diagnosticIdentifiers_Size]) 7363 { 7364 for (size_t I = 0, E = diagnosticIdentifiers_Size; I != E; 7365 ++I) { 7366 StringRef Ref = DiagnosticIdentifiers[I]; 7367 if (!Ref.empty()) { 7368 char *Mem = new (Ctx, 1) char[Ref.size()]; 7369 std::memcpy(Mem, Ref.data(), Ref.size()); 7370 diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size()); 7371 } 7372 } 7373 } 7374 7375 SuppressAttr(SourceRange R, ASTContext &Ctx 7376 , unsigned SI 7377 ) 7378 : StmtAttr(attr::Suppress, R, SI, false, false) 7379 , diagnosticIdentifiers_Size(0), diagnosticIdentifiers_(nullptr) 7380 { 7381 } 7382 7383 SuppressAttr *clone(ASTContext &C) const; 7384 void printPretty(raw_ostream &OS, 7385 const PrintingPolicy &Policy) const; 7386 const char *getSpelling() const; 7387 typedef StringRef* diagnosticIdentifiers_iterator; 7388 diagnosticIdentifiers_iterator diagnosticIdentifiers_begin() const { return diagnosticIdentifiers_; } 7389 diagnosticIdentifiers_iterator diagnosticIdentifiers_end() const { return diagnosticIdentifiers_ + diagnosticIdentifiers_Size; } 7390 unsigned diagnosticIdentifiers_size() const { return diagnosticIdentifiers_Size; } 7391 llvm::iterator_range<diagnosticIdentifiers_iterator> diagnosticIdentifiers() const { return llvm::make_range(diagnosticIdentifiers_begin(), diagnosticIdentifiers_end()); } 7392 7393 7394 7395 7396 static bool classof(const Attr *A) { return A->getKind() == attr::Suppress; } 7397}; 7398 7399class SwiftCallAttr : public InheritableAttr { 7400public: 7401 static SwiftCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7402 auto *A = new (Ctx) SwiftCallAttr(Loc, Ctx, 0); 7403 A->setImplicit(true); 7404 return A; 7405 } 7406 7407 SwiftCallAttr(SourceRange R, ASTContext &Ctx 7408 , unsigned SI 7409 ) 7410 : InheritableAttr(attr::SwiftCall, R, SI, false, false) 7411 { 7412 } 7413 7414 SwiftCallAttr *clone(ASTContext &C) const; 7415 void printPretty(raw_ostream &OS, 7416 const PrintingPolicy &Policy) const; 7417 const char *getSpelling() const; 7418 7419 7420 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftCall; } 7421}; 7422 7423class SwiftContextAttr : public ParameterABIAttr { 7424public: 7425 static SwiftContextAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7426 auto *A = new (Ctx) SwiftContextAttr(Loc, Ctx, 0); 7427 A->setImplicit(true); 7428 return A; 7429 } 7430 7431 SwiftContextAttr(SourceRange R, ASTContext &Ctx 7432 , unsigned SI 7433 ) 7434 : ParameterABIAttr(attr::SwiftContext, R, SI, false, false) 7435 { 7436 } 7437 7438 SwiftContextAttr *clone(ASTContext &C) const; 7439 void printPretty(raw_ostream &OS, 7440 const PrintingPolicy &Policy) const; 7441 const char *getSpelling() const; 7442 7443 7444 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftContext; } 7445}; 7446 7447class SwiftErrorResultAttr : public ParameterABIAttr { 7448public: 7449 static SwiftErrorResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7450 auto *A = new (Ctx) SwiftErrorResultAttr(Loc, Ctx, 0); 7451 A->setImplicit(true); 7452 return A; 7453 } 7454 7455 SwiftErrorResultAttr(SourceRange R, ASTContext &Ctx 7456 , unsigned SI 7457 ) 7458 : ParameterABIAttr(attr::SwiftErrorResult, R, SI, false, false) 7459 { 7460 } 7461 7462 SwiftErrorResultAttr *clone(ASTContext &C) const; 7463 void printPretty(raw_ostream &OS, 7464 const PrintingPolicy &Policy) const; 7465 const char *getSpelling() const; 7466 7467 7468 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftErrorResult; } 7469}; 7470 7471class SwiftIndirectResultAttr : public ParameterABIAttr { 7472public: 7473 static SwiftIndirectResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7474 auto *A = new (Ctx) SwiftIndirectResultAttr(Loc, Ctx, 0); 7475 A->setImplicit(true); 7476 return A; 7477 } 7478 7479 SwiftIndirectResultAttr(SourceRange R, ASTContext &Ctx 7480 , unsigned SI 7481 ) 7482 : ParameterABIAttr(attr::SwiftIndirectResult, R, SI, false, false) 7483 { 7484 } 7485 7486 SwiftIndirectResultAttr *clone(ASTContext &C) const; 7487 void printPretty(raw_ostream &OS, 7488 const PrintingPolicy &Policy) const; 7489 const char *getSpelling() const; 7490 7491 7492 static bool classof(const Attr *A) { return A->getKind() == attr::SwiftIndirectResult; } 7493}; 7494 7495class SysVABIAttr : public InheritableAttr { 7496public: 7497 static SysVABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7498 auto *A = new (Ctx) SysVABIAttr(Loc, Ctx, 0); 7499 A->setImplicit(true); 7500 return A; 7501 } 7502 7503 SysVABIAttr(SourceRange R, ASTContext &Ctx 7504 , unsigned SI 7505 ) 7506 : InheritableAttr(attr::SysVABI, R, SI, false, false) 7507 { 7508 } 7509 7510 SysVABIAttr *clone(ASTContext &C) const; 7511 void printPretty(raw_ostream &OS, 7512 const PrintingPolicy &Policy) const; 7513 const char *getSpelling() const; 7514 7515 7516 static bool classof(const Attr *A) { return A->getKind() == attr::SysVABI; } 7517}; 7518 7519class TLSModelAttr : public InheritableAttr { 7520unsigned modelLength; 7521char *model; 7522 7523public: 7524 static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, SourceRange Loc = SourceRange()) { 7525 auto *A = new (Ctx) TLSModelAttr(Loc, Ctx, Model, 0); 7526 A->setImplicit(true); 7527 return A; 7528 } 7529 7530 TLSModelAttr(SourceRange R, ASTContext &Ctx 7531 , llvm::StringRef Model 7532 , unsigned SI 7533 ) 7534 : InheritableAttr(attr::TLSModel, R, SI, false, false) 7535 , modelLength(Model.size()),model(new (Ctx, 1) char[modelLength]) 7536 { 7537 if (!Model.empty()) 7538 std::memcpy(model, Model.data(), modelLength); 7539 } 7540 7541 TLSModelAttr *clone(ASTContext &C) const; 7542 void printPretty(raw_ostream &OS, 7543 const PrintingPolicy &Policy) const; 7544 const char *getSpelling() const; 7545 llvm::StringRef getModel() const { 7546 return llvm::StringRef(model, modelLength); 7547 } 7548 unsigned getModelLength() const { 7549 return modelLength; 7550 } 7551 void setModel(ASTContext &C, llvm::StringRef S) { 7552 modelLength = S.size(); 7553 this->model = new (C, 1) char [modelLength]; 7554 if (!S.empty()) 7555 std::memcpy(this->model, S.data(), modelLength); 7556 } 7557 7558 7559 7560 static bool classof(const Attr *A) { return A->getKind() == attr::TLSModel; } 7561}; 7562 7563class TargetAttr : public InheritableAttr { 7564unsigned featuresStrLength; 7565char *featuresStr; 7566 7567public: 7568 static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef FeaturesStr, SourceRange Loc = SourceRange()) { 7569 auto *A = new (Ctx) TargetAttr(Loc, Ctx, FeaturesStr, 0); 7570 A->setImplicit(true); 7571 return A; 7572 } 7573 7574 TargetAttr(SourceRange R, ASTContext &Ctx 7575 , llvm::StringRef FeaturesStr 7576 , unsigned SI 7577 ) 7578 : InheritableAttr(attr::Target, R, SI, false, false) 7579 , featuresStrLength(FeaturesStr.size()),featuresStr(new (Ctx, 1) char[featuresStrLength]) 7580 { 7581 if (!FeaturesStr.empty()) 7582 std::memcpy(featuresStr, FeaturesStr.data(), featuresStrLength); 7583 } 7584 7585 TargetAttr *clone(ASTContext &C) const; 7586 void printPretty(raw_ostream &OS, 7587 const PrintingPolicy &Policy) const; 7588 const char *getSpelling() const; 7589 llvm::StringRef getFeaturesStr() const { 7590 return llvm::StringRef(featuresStr, featuresStrLength); 7591 } 7592 unsigned getFeaturesStrLength() const { 7593 return featuresStrLength; 7594 } 7595 void setFeaturesStr(ASTContext &C, llvm::StringRef S) { 7596 featuresStrLength = S.size(); 7597 this->featuresStr = new (C, 1) char [featuresStrLength]; 7598 if (!S.empty()) 7599 std::memcpy(this->featuresStr, S.data(), featuresStrLength); 7600 } 7601 7602 7603 struct ParsedTargetAttr { 7604 std::vector<std::string> Features; 7605 StringRef Architecture; 7606 bool DuplicateArchitecture = false; 7607 }; 7608 ParsedTargetAttr parse() const { 7609 return parse(getFeaturesStr()); 7610 } 7611 static ParsedTargetAttr parse(StringRef Features) { 7612 ParsedTargetAttr Ret; 7613 SmallVector<StringRef, 1> AttrFeatures; 7614 Features.split(AttrFeatures, ","); 7615 7616 // Grab the various features and prepend a "+" to turn on the feature to 7617 // the backend and add them to our existing set of features. 7618 for (auto &Feature : AttrFeatures) { 7619 // Go ahead and trim whitespace rather than either erroring or 7620 // accepting it weirdly. 7621 Feature = Feature.trim(); 7622 7623 // We don't support cpu tuning this way currently. 7624 // TODO: Support the fpmath option. It will require checking 7625 // overall feature validity for the function with the rest of the 7626 // attributes on the function. 7627 if (Feature.startswith("fpmath=") || Feature.startswith("tune=")) 7628 continue; 7629 7630 // While we're here iterating check for a different target cpu. 7631 if (Feature.startswith("arch=")) { 7632 if (!Ret.Architecture.empty()) 7633 Ret.DuplicateArchitecture = true; 7634 else 7635 Ret.Architecture = Feature.split("=").second.trim(); 7636 } else if (Feature.startswith("no-")) 7637 Ret.Features.push_back("-" + Feature.split("-").second.str()); 7638 else 7639 Ret.Features.push_back("+" + Feature.str()); 7640 } 7641 return Ret; 7642 } 7643 7644 7645 static bool classof(const Attr *A) { return A->getKind() == attr::Target; } 7646}; 7647 7648class TestTypestateAttr : public InheritableAttr { 7649public: 7650 enum ConsumedState { 7651 Consumed, 7652 Unconsumed 7653 }; 7654private: 7655 ConsumedState testState; 7656 7657public: 7658 static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState TestState, SourceRange Loc = SourceRange()) { 7659 auto *A = new (Ctx) TestTypestateAttr(Loc, Ctx, TestState, 0); 7660 A->setImplicit(true); 7661 return A; 7662 } 7663 7664 TestTypestateAttr(SourceRange R, ASTContext &Ctx 7665 , ConsumedState TestState 7666 , unsigned SI 7667 ) 7668 : InheritableAttr(attr::TestTypestate, R, SI, false, false) 7669 , testState(TestState) 7670 { 7671 } 7672 7673 TestTypestateAttr *clone(ASTContext &C) const; 7674 void printPretty(raw_ostream &OS, 7675 const PrintingPolicy &Policy) const; 7676 const char *getSpelling() const; 7677 ConsumedState getTestState() const { 7678 return testState; 7679 } 7680 7681 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { 7682 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) 7683 .Case("consumed", TestTypestateAttr::Consumed) 7684 .Case("unconsumed", TestTypestateAttr::Unconsumed) 7685 .Default(Optional<ConsumedState>()); 7686 if (R) { 7687 Out = *R; 7688 return true; 7689 } 7690 return false; 7691 } 7692 7693 static const char *ConvertConsumedStateToStr(ConsumedState Val) { 7694 switch(Val) { 7695 case TestTypestateAttr::Consumed: return "consumed"; 7696 case TestTypestateAttr::Unconsumed: return "unconsumed"; 7697 } 7698 llvm_unreachable("No enumerator with that value"); 7699 } 7700 7701 7702 static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; } 7703}; 7704 7705class ThisCallAttr : public InheritableAttr { 7706public: 7707 static ThisCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7708 auto *A = new (Ctx) ThisCallAttr(Loc, Ctx, 0); 7709 A->setImplicit(true); 7710 return A; 7711 } 7712 7713 ThisCallAttr(SourceRange R, ASTContext &Ctx 7714 , unsigned SI 7715 ) 7716 : InheritableAttr(attr::ThisCall, R, SI, false, false) 7717 { 7718 } 7719 7720 ThisCallAttr *clone(ASTContext &C) const; 7721 void printPretty(raw_ostream &OS, 7722 const PrintingPolicy &Policy) const; 7723 const char *getSpelling() const; 7724 7725 7726 static bool classof(const Attr *A) { return A->getKind() == attr::ThisCall; } 7727}; 7728 7729class ThreadAttr : public Attr { 7730public: 7731 static ThreadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7732 auto *A = new (Ctx) ThreadAttr(Loc, Ctx, 0); 7733 A->setImplicit(true); 7734 return A; 7735 } 7736 7737 ThreadAttr(SourceRange R, ASTContext &Ctx 7738 , unsigned SI 7739 ) 7740 : Attr(attr::Thread, R, SI, false, false) 7741 { 7742 } 7743 7744 ThreadAttr *clone(ASTContext &C) const; 7745 void printPretty(raw_ostream &OS, 7746 const PrintingPolicy &Policy) const; 7747 const char *getSpelling() const; 7748 7749 7750 static bool classof(const Attr *A) { return A->getKind() == attr::Thread; } 7751}; 7752 7753class TransparentUnionAttr : public InheritableAttr { 7754public: 7755 static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 7756 auto *A = new (Ctx) TransparentUnionAttr(Loc, Ctx, 0); 7757 A->setImplicit(true); 7758 return A; 7759 } 7760 7761 TransparentUnionAttr(SourceRange R, ASTContext &Ctx 7762 , unsigned SI 7763 ) 7764 : InheritableAttr(attr::TransparentUnion, R, SI, false, false) 7765 { 7766 } 7767 7768 TransparentUnionAttr *clone(ASTContext &C) const; 7769 void printPretty(raw_ostream &OS, 7770 const PrintingPolicy &Policy) const; 7771 const char *getSpelling() const; 7772 7773 7774 static bool classof(const Attr *A) { return A->getKind() == attr::TransparentUnion; } 7775}; 7776 7777class TryAcquireCapabilityAttr : public InheritableAttr { 7778Expr * successValue; 7779 7780 unsigned args_Size; 7781 Expr * *args_; 7782 7783public: 7784 enum Spelling { 7785 GNU_try_acquire_capability = 0, 7786 CXX11_clang_try_acquire_capability = 1, 7787 GNU_try_acquire_shared_capability = 2, 7788 CXX11_clang_try_acquire_shared_capability = 3 7789 }; 7790 7791 static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { 7792 auto *A = new (Ctx) TryAcquireCapabilityAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, S); 7793 A->setImplicit(true); 7794 return A; 7795 } 7796 7797 TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx 7798 , Expr * SuccessValue 7799 , Expr * *Args, unsigned ArgsSize 7800 , unsigned SI 7801 ) 7802 : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true) 7803 , successValue(SuccessValue) 7804 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) 7805 { 7806 std::copy(Args, Args + args_Size, args_); 7807 } 7808 7809 TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx 7810 , Expr * SuccessValue 7811 , unsigned SI 7812 ) 7813 : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true) 7814 , successValue(SuccessValue) 7815 , args_Size(0), args_(nullptr) 7816 { 7817 } 7818 7819 TryAcquireCapabilityAttr *clone(ASTContext &C) const; 7820 void printPretty(raw_ostream &OS, 7821 const PrintingPolicy &Policy) const; 7822 const char *getSpelling() const; 7823 Spelling getSemanticSpelling() const { 7824 switch (SpellingListIndex) { 7825 default: llvm_unreachable("Unknown spelling list index"); 7826 case 0: return GNU_try_acquire_capability; 7827 case 1: return CXX11_clang_try_acquire_capability; 7828 case 2: return GNU_try_acquire_shared_capability; 7829 case 3: return CXX11_clang_try_acquire_shared_capability; 7830 } 7831 } 7832 bool isShared() const { return SpellingListIndex == 2 || 7833 SpellingListIndex == 3; } 7834 Expr * getSuccessValue() const { 7835 return successValue; 7836 } 7837 7838 typedef Expr ** args_iterator; 7839 args_iterator args_begin() const { return args_; } 7840 args_iterator args_end() const { return args_ + args_Size; } 7841 unsigned args_size() const { return args_Size; } 7842 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } 7843 7844 7845 7846 7847 static bool classof(const Attr *A) { return A->getKind() == attr::TryAcquireCapability; } 7848}; 7849 7850class TypeTagForDatatypeAttr : public InheritableAttr { 7851IdentifierInfo * argumentKind; 7852 7853TypeSourceInfo * matchingCType; 7854 7855bool layoutCompatible; 7856 7857bool mustBeNull; 7858 7859public: 7860 static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Loc = SourceRange()) { 7861 auto *A = new (Ctx) TypeTagForDatatypeAttr(Loc, Ctx, ArgumentKind, MatchingCType, LayoutCompatible, MustBeNull, 0); 7862 A->setImplicit(true); 7863 return A; 7864 } 7865 7866 TypeTagForDatatypeAttr(SourceRange R, ASTContext &Ctx 7867 , IdentifierInfo * ArgumentKind 7868 , TypeSourceInfo * MatchingCType 7869 , bool LayoutCompatible 7870 , bool MustBeNull 7871 , unsigned SI 7872 ) 7873 : InheritableAttr(attr::TypeTagForDatatype, R, SI, false, false) 7874 , argumentKind(ArgumentKind) 7875 , matchingCType(MatchingCType) 7876 , layoutCompatible(LayoutCompatible) 7877 , mustBeNull(MustBeNull) 7878 { 7879 } 7880 7881 TypeTagForDatatypeAttr *clone(ASTContext &C) const; 7882 void printPretty(raw_ostream &OS, 7883 const PrintingPolicy &Policy) const; 7884 const char *getSpelling() const; 7885 IdentifierInfo * getArgumentKind() const { 7886 return argumentKind; 7887 } 7888 7889 QualType getMatchingCType() const { 7890 return matchingCType->getType(); 7891 } TypeSourceInfo * getMatchingCTypeLoc() const { 7892 return matchingCType; 7893 } 7894 7895 bool getLayoutCompatible() const { 7896 return layoutCompatible; 7897 } 7898 7899 bool getMustBeNull() const { 7900 return mustBeNull; 7901 } 7902 7903 7904 7905 static bool classof(const Attr *A) { return A->getKind() == attr::TypeTagForDatatype; } 7906}; 7907 7908class TypeVisibilityAttr : public InheritableAttr { 7909public: 7910 enum VisibilityType { 7911 Default, 7912 Hidden, 7913 Protected 7914 }; 7915private: 7916 VisibilityType visibility; 7917 7918public: 7919 static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) { 7920 auto *A = new (Ctx) TypeVisibilityAttr(Loc, Ctx, Visibility, 0); 7921 A->setImplicit(true); 7922 return A; 7923 } 7924 7925 TypeVisibilityAttr(SourceRange R, ASTContext &Ctx 7926 , VisibilityType Visibility 7927 , unsigned SI 7928 ) 7929 : InheritableAttr(attr::TypeVisibility, R, SI, false, false) 7930 , visibility(Visibility) 7931 { 7932 } 7933 7934 TypeVisibilityAttr *clone(ASTContext &C) const; 7935 void printPretty(raw_ostream &OS, 7936 const PrintingPolicy &Policy) const; 7937 const char *getSpelling() const; 7938 VisibilityType getVisibility() const { 7939 return visibility; 7940 } 7941 7942 static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) { 7943 Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val) 7944 .Case("default", TypeVisibilityAttr::Default) 7945 .Case("hidden", TypeVisibilityAttr::Hidden) 7946 .Case("internal", TypeVisibilityAttr::Hidden) 7947 .Case("protected", TypeVisibilityAttr::Protected) 7948 .Default(Optional<VisibilityType>()); 7949 if (R) { 7950 Out = *R; 7951 return true; 7952 } 7953 return false; 7954 } 7955 7956 static const char *ConvertVisibilityTypeToStr(VisibilityType Val) { 7957 switch(Val) { 7958 case TypeVisibilityAttr::Default: return "default"; 7959 case TypeVisibilityAttr::Hidden: return "hidden"; 7960 case TypeVisibilityAttr::Protected: return "protected"; 7961 } 7962 llvm_unreachable("No enumerator with that value"); 7963 } 7964 7965 7966 static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; } 7967}; 7968 7969class UnavailableAttr : public InheritableAttr { 7970unsigned messageLength; 7971char *message; 7972 7973public: 7974 enum ImplicitReason { 7975 IR_None, 7976 IR_ARCForbiddenType, 7977 IR_ForbiddenWeak, 7978 IR_ARCForbiddenConversion, 7979 IR_ARCInitReturnsUnrelated, 7980 IR_ARCFieldWithOwnership 7981 }; 7982private: 7983 ImplicitReason implicitReason; 7984 7985public: 7986 static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, ImplicitReason ImplicitReason, SourceRange Loc = SourceRange()) { 7987 auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, ImplicitReason, 0); 7988 A->setImplicit(true); 7989 return A; 7990 } 7991 7992 static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Loc = SourceRange()) { 7993 auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, 0); 7994 A->setImplicit(true); 7995 return A; 7996 } 7997 7998 UnavailableAttr(SourceRange R, ASTContext &Ctx 7999 , llvm::StringRef Message 8000 , ImplicitReason ImplicitReason 8001 , unsigned SI 8002 ) 8003 : InheritableAttr(attr::Unavailable, R, SI, false, false) 8004 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 8005 , implicitReason(ImplicitReason) 8006 { 8007 if (!Message.empty()) 8008 std::memcpy(message, Message.data(), messageLength); 8009 } 8010 8011 UnavailableAttr(SourceRange R, ASTContext &Ctx 8012 , llvm::StringRef Message 8013 , unsigned SI 8014 ) 8015 : InheritableAttr(attr::Unavailable, R, SI, false, false) 8016 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) 8017 , implicitReason(ImplicitReason(0)) 8018 { 8019 if (!Message.empty()) 8020 std::memcpy(message, Message.data(), messageLength); 8021 } 8022 8023 UnavailableAttr(SourceRange R, ASTContext &Ctx 8024 , unsigned SI 8025 ) 8026 : InheritableAttr(attr::Unavailable, R, SI, false, false) 8027 , messageLength(0),message(nullptr) 8028 , implicitReason(ImplicitReason(0)) 8029 { 8030 } 8031 8032 UnavailableAttr *clone(ASTContext &C) const; 8033 void printPretty(raw_ostream &OS, 8034 const PrintingPolicy &Policy) const; 8035 const char *getSpelling() const; 8036 llvm::StringRef getMessage() const { 8037 return llvm::StringRef(message, messageLength); 8038 } 8039 unsigned getMessageLength() const { 8040 return messageLength; 8041 } 8042 void setMessage(ASTContext &C, llvm::StringRef S) { 8043 messageLength = S.size(); 8044 this->message = new (C, 1) char [messageLength]; 8045 if (!S.empty()) 8046 std::memcpy(this->message, S.data(), messageLength); 8047 } 8048 8049 ImplicitReason getImplicitReason() const { 8050 return implicitReason; 8051 } 8052 8053 8054 8055 static bool classof(const Attr *A) { return A->getKind() == attr::Unavailable; } 8056}; 8057 8058class UnusedAttr : public InheritableAttr { 8059public: 8060 enum Spelling { 8061 CXX11_maybe_unused = 0, 8062 GNU_unused = 1, 8063 CXX11_gnu_unused = 2, 8064 C2x_maybe_unused = 3 8065 }; 8066 8067 static UnusedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 8068 auto *A = new (Ctx) UnusedAttr(Loc, Ctx, S); 8069 A->setImplicit(true); 8070 return A; 8071 } 8072 8073 UnusedAttr(SourceRange R, ASTContext &Ctx 8074 , unsigned SI 8075 ) 8076 : InheritableAttr(attr::Unused, R, SI, false, false) 8077 { 8078 } 8079 8080 UnusedAttr *clone(ASTContext &C) const; 8081 void printPretty(raw_ostream &OS, 8082 const PrintingPolicy &Policy) const; 8083 const char *getSpelling() const; 8084 Spelling getSemanticSpelling() const { 8085 switch (SpellingListIndex) { 8086 default: llvm_unreachable("Unknown spelling list index"); 8087 case 0: return CXX11_maybe_unused; 8088 case 1: return GNU_unused; 8089 case 2: return CXX11_gnu_unused; 8090 case 3: return C2x_maybe_unused; 8091 } 8092 } 8093 8094 8095 static bool classof(const Attr *A) { return A->getKind() == attr::Unused; } 8096}; 8097 8098class UsedAttr : public InheritableAttr { 8099public: 8100 static UsedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8101 auto *A = new (Ctx) UsedAttr(Loc, Ctx, 0); 8102 A->setImplicit(true); 8103 return A; 8104 } 8105 8106 UsedAttr(SourceRange R, ASTContext &Ctx 8107 , unsigned SI 8108 ) 8109 : InheritableAttr(attr::Used, R, SI, false, false) 8110 { 8111 } 8112 8113 UsedAttr *clone(ASTContext &C) const; 8114 void printPretty(raw_ostream &OS, 8115 const PrintingPolicy &Policy) const; 8116 const char *getSpelling() const; 8117 8118 8119 static bool classof(const Attr *A) { return A->getKind() == attr::Used; } 8120}; 8121 8122class UuidAttr : public InheritableAttr { 8123unsigned guidLength; 8124char *guid; 8125 8126public: 8127 static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Loc = SourceRange()) { 8128 auto *A = new (Ctx) UuidAttr(Loc, Ctx, Guid, 0); 8129 A->setImplicit(true); 8130 return A; 8131 } 8132 8133 UuidAttr(SourceRange R, ASTContext &Ctx 8134 , llvm::StringRef Guid 8135 , unsigned SI 8136 ) 8137 : InheritableAttr(attr::Uuid, R, SI, false, false) 8138 , guidLength(Guid.size()),guid(new (Ctx, 1) char[guidLength]) 8139 { 8140 if (!Guid.empty()) 8141 std::memcpy(guid, Guid.data(), guidLength); 8142 } 8143 8144 UuidAttr *clone(ASTContext &C) const; 8145 void printPretty(raw_ostream &OS, 8146 const PrintingPolicy &Policy) const; 8147 const char *getSpelling() const; 8148 llvm::StringRef getGuid() const { 8149 return llvm::StringRef(guid, guidLength); 8150 } 8151 unsigned getGuidLength() const { 8152 return guidLength; 8153 } 8154 void setGuid(ASTContext &C, llvm::StringRef S) { 8155 guidLength = S.size(); 8156 this->guid = new (C, 1) char [guidLength]; 8157 if (!S.empty()) 8158 std::memcpy(this->guid, S.data(), guidLength); 8159 } 8160 8161 8162 8163 static bool classof(const Attr *A) { return A->getKind() == attr::Uuid; } 8164}; 8165 8166class VecReturnAttr : public InheritableAttr { 8167public: 8168 static VecReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8169 auto *A = new (Ctx) VecReturnAttr(Loc, Ctx, 0); 8170 A->setImplicit(true); 8171 return A; 8172 } 8173 8174 VecReturnAttr(SourceRange R, ASTContext &Ctx 8175 , unsigned SI 8176 ) 8177 : InheritableAttr(attr::VecReturn, R, SI, false, false) 8178 { 8179 } 8180 8181 VecReturnAttr *clone(ASTContext &C) const; 8182 void printPretty(raw_ostream &OS, 8183 const PrintingPolicy &Policy) const; 8184 const char *getSpelling() const; 8185 8186 8187 static bool classof(const Attr *A) { return A->getKind() == attr::VecReturn; } 8188}; 8189 8190class VecTypeHintAttr : public InheritableAttr { 8191TypeSourceInfo * typeHint; 8192 8193public: 8194 static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Loc = SourceRange()) { 8195 auto *A = new (Ctx) VecTypeHintAttr(Loc, Ctx, TypeHint, 0); 8196 A->setImplicit(true); 8197 return A; 8198 } 8199 8200 VecTypeHintAttr(SourceRange R, ASTContext &Ctx 8201 , TypeSourceInfo * TypeHint 8202 , unsigned SI 8203 ) 8204 : InheritableAttr(attr::VecTypeHint, R, SI, false, false) 8205 , typeHint(TypeHint) 8206 { 8207 } 8208 8209 VecTypeHintAttr *clone(ASTContext &C) const; 8210 void printPretty(raw_ostream &OS, 8211 const PrintingPolicy &Policy) const; 8212 const char *getSpelling() const; 8213 QualType getTypeHint() const { 8214 return typeHint->getType(); 8215 } TypeSourceInfo * getTypeHintLoc() const { 8216 return typeHint; 8217 } 8218 8219 8220 8221 static bool classof(const Attr *A) { return A->getKind() == attr::VecTypeHint; } 8222}; 8223 8224class VectorCallAttr : public InheritableAttr { 8225public: 8226 static VectorCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8227 auto *A = new (Ctx) VectorCallAttr(Loc, Ctx, 0); 8228 A->setImplicit(true); 8229 return A; 8230 } 8231 8232 VectorCallAttr(SourceRange R, ASTContext &Ctx 8233 , unsigned SI 8234 ) 8235 : InheritableAttr(attr::VectorCall, R, SI, false, false) 8236 { 8237 } 8238 8239 VectorCallAttr *clone(ASTContext &C) const; 8240 void printPretty(raw_ostream &OS, 8241 const PrintingPolicy &Policy) const; 8242 const char *getSpelling() const; 8243 8244 8245 static bool classof(const Attr *A) { return A->getKind() == attr::VectorCall; } 8246}; 8247 8248class VisibilityAttr : public InheritableAttr { 8249public: 8250 enum VisibilityType { 8251 Default, 8252 Hidden, 8253 Protected 8254 }; 8255private: 8256 VisibilityType visibility; 8257 8258public: 8259 static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) { 8260 auto *A = new (Ctx) VisibilityAttr(Loc, Ctx, Visibility, 0); 8261 A->setImplicit(true); 8262 return A; 8263 } 8264 8265 VisibilityAttr(SourceRange R, ASTContext &Ctx 8266 , VisibilityType Visibility 8267 , unsigned SI 8268 ) 8269 : InheritableAttr(attr::Visibility, R, SI, false, false) 8270 , visibility(Visibility) 8271 { 8272 } 8273 8274 VisibilityAttr *clone(ASTContext &C) const; 8275 void printPretty(raw_ostream &OS, 8276 const PrintingPolicy &Policy) const; 8277 const char *getSpelling() const; 8278 VisibilityType getVisibility() const { 8279 return visibility; 8280 } 8281 8282 static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) { 8283 Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val) 8284 .Case("default", VisibilityAttr::Default) 8285 .Case("hidden", VisibilityAttr::Hidden) 8286 .Case("internal", VisibilityAttr::Hidden) 8287 .Case("protected", VisibilityAttr::Protected) 8288 .Default(Optional<VisibilityType>()); 8289 if (R) { 8290 Out = *R; 8291 return true; 8292 } 8293 return false; 8294 } 8295 8296 static const char *ConvertVisibilityTypeToStr(VisibilityType Val) { 8297 switch(Val) { 8298 case VisibilityAttr::Default: return "default"; 8299 case VisibilityAttr::Hidden: return "hidden"; 8300 case VisibilityAttr::Protected: return "protected"; 8301 } 8302 llvm_unreachable("No enumerator with that value"); 8303 } 8304 8305 8306 static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; } 8307}; 8308 8309class WarnUnusedAttr : public InheritableAttr { 8310public: 8311 static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8312 auto *A = new (Ctx) WarnUnusedAttr(Loc, Ctx, 0); 8313 A->setImplicit(true); 8314 return A; 8315 } 8316 8317 WarnUnusedAttr(SourceRange R, ASTContext &Ctx 8318 , unsigned SI 8319 ) 8320 : InheritableAttr(attr::WarnUnused, R, SI, false, false) 8321 { 8322 } 8323 8324 WarnUnusedAttr *clone(ASTContext &C) const; 8325 void printPretty(raw_ostream &OS, 8326 const PrintingPolicy &Policy) const; 8327 const char *getSpelling() const; 8328 8329 8330 static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnused; } 8331}; 8332 8333class WarnUnusedResultAttr : public InheritableAttr { 8334public: 8335 enum Spelling { 8336 CXX11_nodiscard = 0, 8337 C2x_nodiscard = 1, 8338 CXX11_clang_warn_unused_result = 2, 8339 GNU_warn_unused_result = 3, 8340 CXX11_gnu_warn_unused_result = 4 8341 }; 8342 8343 static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 8344 auto *A = new (Ctx) WarnUnusedResultAttr(Loc, Ctx, S); 8345 A->setImplicit(true); 8346 return A; 8347 } 8348 8349 WarnUnusedResultAttr(SourceRange R, ASTContext &Ctx 8350 , unsigned SI 8351 ) 8352 : InheritableAttr(attr::WarnUnusedResult, R, SI, false, false) 8353 { 8354 } 8355 8356 WarnUnusedResultAttr *clone(ASTContext &C) const; 8357 void printPretty(raw_ostream &OS, 8358 const PrintingPolicy &Policy) const; 8359 const char *getSpelling() const; 8360 Spelling getSemanticSpelling() const { 8361 switch (SpellingListIndex) { 8362 default: llvm_unreachable("Unknown spelling list index"); 8363 case 0: return CXX11_nodiscard; 8364 case 1: return C2x_nodiscard; 8365 case 2: return CXX11_clang_warn_unused_result; 8366 case 3: return GNU_warn_unused_result; 8367 case 4: return CXX11_gnu_warn_unused_result; 8368 } 8369 } 8370 8371 8372 static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnusedResult; } 8373}; 8374 8375class WeakAttr : public InheritableAttr { 8376public: 8377 static WeakAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8378 auto *A = new (Ctx) WeakAttr(Loc, Ctx, 0); 8379 A->setImplicit(true); 8380 return A; 8381 } 8382 8383 WeakAttr(SourceRange R, ASTContext &Ctx 8384 , unsigned SI 8385 ) 8386 : InheritableAttr(attr::Weak, R, SI, false, false) 8387 { 8388 } 8389 8390 WeakAttr *clone(ASTContext &C) const; 8391 void printPretty(raw_ostream &OS, 8392 const PrintingPolicy &Policy) const; 8393 const char *getSpelling() const; 8394 8395 8396 static bool classof(const Attr *A) { return A->getKind() == attr::Weak; } 8397}; 8398 8399class WeakImportAttr : public InheritableAttr { 8400public: 8401 static WeakImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8402 auto *A = new (Ctx) WeakImportAttr(Loc, Ctx, 0); 8403 A->setImplicit(true); 8404 return A; 8405 } 8406 8407 WeakImportAttr(SourceRange R, ASTContext &Ctx 8408 , unsigned SI 8409 ) 8410 : InheritableAttr(attr::WeakImport, R, SI, false, false) 8411 { 8412 } 8413 8414 WeakImportAttr *clone(ASTContext &C) const; 8415 void printPretty(raw_ostream &OS, 8416 const PrintingPolicy &Policy) const; 8417 const char *getSpelling() const; 8418 8419 8420 static bool classof(const Attr *A) { return A->getKind() == attr::WeakImport; } 8421}; 8422 8423class WeakRefAttr : public InheritableAttr { 8424unsigned aliaseeLength; 8425char *aliasee; 8426 8427public: 8428 static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) { 8429 auto *A = new (Ctx) WeakRefAttr(Loc, Ctx, Aliasee, 0); 8430 A->setImplicit(true); 8431 return A; 8432 } 8433 8434 WeakRefAttr(SourceRange R, ASTContext &Ctx 8435 , llvm::StringRef Aliasee 8436 , unsigned SI 8437 ) 8438 : InheritableAttr(attr::WeakRef, R, SI, false, false) 8439 , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength]) 8440 { 8441 if (!Aliasee.empty()) 8442 std::memcpy(aliasee, Aliasee.data(), aliaseeLength); 8443 } 8444 8445 WeakRefAttr(SourceRange R, ASTContext &Ctx 8446 , unsigned SI 8447 ) 8448 : InheritableAttr(attr::WeakRef, R, SI, false, false) 8449 , aliaseeLength(0),aliasee(nullptr) 8450 { 8451 } 8452 8453 WeakRefAttr *clone(ASTContext &C) const; 8454 void printPretty(raw_ostream &OS, 8455 const PrintingPolicy &Policy) const; 8456 const char *getSpelling() const; 8457 llvm::StringRef getAliasee() const { 8458 return llvm::StringRef(aliasee, aliaseeLength); 8459 } 8460 unsigned getAliaseeLength() const { 8461 return aliaseeLength; 8462 } 8463 void setAliasee(ASTContext &C, llvm::StringRef S) { 8464 aliaseeLength = S.size(); 8465 this->aliasee = new (C, 1) char [aliaseeLength]; 8466 if (!S.empty()) 8467 std::memcpy(this->aliasee, S.data(), aliaseeLength); 8468 } 8469 8470 8471 8472 static bool classof(const Attr *A) { return A->getKind() == attr::WeakRef; } 8473}; 8474 8475class WorkGroupSizeHintAttr : public InheritableAttr { 8476unsigned xDim; 8477 8478unsigned yDim; 8479 8480unsigned zDim; 8481 8482public: 8483 static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) { 8484 auto *A = new (Ctx) WorkGroupSizeHintAttr(Loc, Ctx, XDim, YDim, ZDim, 0); 8485 A->setImplicit(true); 8486 return A; 8487 } 8488 8489 WorkGroupSizeHintAttr(SourceRange R, ASTContext &Ctx 8490 , unsigned XDim 8491 , unsigned YDim 8492 , unsigned ZDim 8493 , unsigned SI 8494 ) 8495 : InheritableAttr(attr::WorkGroupSizeHint, R, SI, false, false) 8496 , xDim(XDim) 8497 , yDim(YDim) 8498 , zDim(ZDim) 8499 { 8500 } 8501 8502 WorkGroupSizeHintAttr *clone(ASTContext &C) const; 8503 void printPretty(raw_ostream &OS, 8504 const PrintingPolicy &Policy) const; 8505 const char *getSpelling() const; 8506 unsigned getXDim() const { 8507 return xDim; 8508 } 8509 8510 unsigned getYDim() const { 8511 return yDim; 8512 } 8513 8514 unsigned getZDim() const { 8515 return zDim; 8516 } 8517 8518 8519 8520 static bool classof(const Attr *A) { return A->getKind() == attr::WorkGroupSizeHint; } 8521}; 8522 8523class X86ForceAlignArgPointerAttr : public InheritableAttr { 8524public: 8525 static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { 8526 auto *A = new (Ctx) X86ForceAlignArgPointerAttr(Loc, Ctx, 0); 8527 A->setImplicit(true); 8528 return A; 8529 } 8530 8531 X86ForceAlignArgPointerAttr(SourceRange R, ASTContext &Ctx 8532 , unsigned SI 8533 ) 8534 : InheritableAttr(attr::X86ForceAlignArgPointer, R, SI, false, false) 8535 { 8536 } 8537 8538 X86ForceAlignArgPointerAttr *clone(ASTContext &C) const; 8539 void printPretty(raw_ostream &OS, 8540 const PrintingPolicy &Policy) const; 8541 const char *getSpelling() const; 8542 8543 8544 static bool classof(const Attr *A) { return A->getKind() == attr::X86ForceAlignArgPointer; } 8545}; 8546 8547class XRayInstrumentAttr : public InheritableAttr { 8548public: 8549 enum Spelling { 8550 GNU_xray_always_instrument = 0, 8551 CXX11_clang_xray_always_instrument = 1, 8552 GNU_xray_never_instrument = 2, 8553 CXX11_clang_xray_never_instrument = 3 8554 }; 8555 8556 static XRayInstrumentAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { 8557 auto *A = new (Ctx) XRayInstrumentAttr(Loc, Ctx, S); 8558 A->setImplicit(true); 8559 return A; 8560 } 8561 8562 XRayInstrumentAttr(SourceRange R, ASTContext &Ctx 8563 , unsigned SI 8564 ) 8565 : InheritableAttr(attr::XRayInstrument, R, SI, false, false) 8566 { 8567 } 8568 8569 XRayInstrumentAttr *clone(ASTContext &C) const; 8570 void printPretty(raw_ostream &OS, 8571 const PrintingPolicy &Policy) const; 8572 const char *getSpelling() const; 8573 Spelling getSemanticSpelling() const { 8574 switch (SpellingListIndex) { 8575 default: llvm_unreachable("Unknown spelling list index"); 8576 case 0: return GNU_xray_always_instrument; 8577 case 1: return CXX11_clang_xray_always_instrument; 8578 case 2: return GNU_xray_never_instrument; 8579 case 3: return CXX11_clang_xray_never_instrument; 8580 } 8581 } 8582 bool alwaysXRayInstrument() const { return SpellingListIndex == 0 || 8583 SpellingListIndex == 1; } 8584 bool neverXRayInstrument() const { return SpellingListIndex == 2 || 8585 SpellingListIndex == 3; } 8586 8587 8588 static bool classof(const Attr *A) { return A->getKind() == attr::XRayInstrument; } 8589}; 8590 8591class XRayLogArgsAttr : public InheritableAttr { 8592unsigned argumentCount; 8593 8594public: 8595 static XRayLogArgsAttr *CreateImplicit(ASTContext &Ctx, unsigned ArgumentCount, SourceRange Loc = SourceRange()) { 8596 auto *A = new (Ctx) XRayLogArgsAttr(Loc, Ctx, ArgumentCount, 0); 8597 A->setImplicit(true); 8598 return A; 8599 } 8600 8601 XRayLogArgsAttr(SourceRange R, ASTContext &Ctx 8602 , unsigned ArgumentCount 8603 , unsigned SI 8604 ) 8605 : InheritableAttr(attr::XRayLogArgs, R, SI, false, false) 8606 , argumentCount(ArgumentCount) 8607 { 8608 } 8609 8610 XRayLogArgsAttr *clone(ASTContext &C) const; 8611 void printPretty(raw_ostream &OS, 8612 const PrintingPolicy &Policy) const; 8613 const char *getSpelling() const; 8614 unsigned getArgumentCount() const { 8615 return argumentCount; 8616 } 8617 8618 8619 8620 static bool classof(const Attr *A) { return A->getKind() == attr::XRayLogArgs; } 8621}; 8622 8623#endif // LLVM_CLANG_ATTR_CLASSES_INC 8624