LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/AST - Attrs.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 930 1019 91.3 %
Date: 2018-07-13 00:08:38 Functions: 121 124 97.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13