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: 928 1017 91.2 %
Date: 2018-06-17 00:07:59 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        4952 :   AbiTagAttr(SourceRange R, ASTContext &Ctx
     303             :               , StringRef *Tags, unsigned TagsSize
     304             :               , unsigned SI
     305             :              )
     306        4952 :     : Attr(attr::AbiTag, R, SI, false)
     307       14917 :               , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size])
     308             :   {
     309        9965 :     for (size_t I = 0, E = tags_Size; I != E;
     310             :          ++I) {
     311        5013 :       StringRef Ref = Tags[I];
     312        5013 :       if (!Ref.empty()) {
     313             :         char *Mem = new (Ctx, 1) char[Ref.size()];
     314        5013 :         std::memcpy(Mem, Ref.data(), Ref.size());
     315        5013 :         tags_[I] = StringRef(Mem, Ref.size());
     316             :       }
     317             :     }
     318        4952 :   }
     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      166396 :   tags_iterator tags_end() const { return tags_ + tags_Size; }
     335             :   unsigned tags_size() const { return tags_Size; }
     336      166126 :   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       11894 :   AliasAttr(SourceRange R, ASTContext &Ctx
     514             :               , llvm::StringRef Aliasee
     515             :               , unsigned SI
     516             :              )
     517       11894 :     : Attr(attr::Alias, R, SI, false)
     518       23788 :               , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
     519             :   {
     520       11894 :       if (!Aliasee.empty())
     521       23788 :         std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
     522       11894 :   }
     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         656 :     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         292 :     : Attr(attr::AlignValue, R, SI, false)
     585         292 :               , 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       15062 :     : InheritableAttr(attr::Aligned, R, SI, false, false)
     629       15062 :               , isalignmentExpr(IsAlignmentExpr)
     630             :   {
     631         462 :     if (isalignmentExpr)
     632       15062 :        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           5 :   bool isC11() const { return SpellingListIndex == 4; }
     662       17965 :   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       83405 :   static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
     775       83405 :     auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S);
     776             :     A->setImplicit(true);
     777       83405 :     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          46 :   static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) {
    1094          92 :     auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0);
    1095             :     A->setImplicit(true);
    1096          46 :     return A;
    1097             :   }
    1098             : 
    1099        5456 :   AsmLabelAttr(SourceRange R, ASTContext &Ctx
    1100             :               , llvm::StringRef Label
    1101             :               , unsigned SI
    1102             :              )
    1103        5456 :     : InheritableAttr(attr::AsmLabel, R, SI, false, false)
    1104       10912 :               , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
    1105             :   {
    1106        5456 :       if (!Label.empty())
    1107       10896 :         std::memcpy(label, Label.data(), labelLength);
    1108        5456 :   }
    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         800 :     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        1002 :   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        1002 :     : InheritableAttr(attr::Availability, R, SI, false, true)
    1376             :               , platform(Platform)
    1377             :               , introduced(Introduced)
    1378             :               , deprecated(Deprecated)
    1379             :               , obsoleted(Obsoleted)
    1380             :               , unavailable(Unavailable)
    1381        1002 :               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
    1382             :               , strict(Strict)
    1383        3006 :               , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
    1384             :   {
    1385        1002 :       if (!Message.empty())
    1386          40 :         std::memcpy(message, Message.data(), messageLength);
    1387        1002 :       if (!Replacement.empty())
    1388          16 :         std::memcpy(replacement, Replacement.data(), replacementLength);
    1389        1002 :   }
    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        3843 :     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        1798 :     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        3660 : static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
    1455        3660 :     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        3660 :              .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         511 : static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) {
    1480         511 :     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         511 :              .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      289457 :   static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    2076      289457 :     auto *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0);
    2077             :     A->setImplicit(true);
    2078      289457 :     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      145902 :   static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    2204      145902 :     auto *A = new (Ctx) ConstAttr(Loc, Ctx, 0);
    2205             :     A->setImplicit(true);
    2206      145902 :     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         185 :   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        1206 :   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        6377 :   DeprecatedAttr(SourceRange R, ASTContext &Ctx
    2469             :               , llvm::StringRef Message
    2470             :               , llvm::StringRef Replacement
    2471             :               , unsigned SI
    2472             :              )
    2473        6377 :     : InheritableAttr(attr::Deprecated, R, SI, false, false)
    2474        6377 :               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
    2475       19131 :               , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
    2476             :   {
    2477        6377 :       if (!Message.empty())
    2478         638 :         std::memcpy(message, Message.data(), messageLength);
    2479        6377 :       if (!Replacement.empty())
    2480         136 :         std::memcpy(replacement, Replacement.data(), replacementLength);
    2481        6377 :   }
    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        3045 :     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        2881 :     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        1921 :   static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Loc = SourceRange()) {
    3132        1921 :     auto *A = new (Ctx) FormatAttr(Loc, Ctx, Type, FormatIdx, FirstArg, 0);
    3133             :     A->setImplicit(true);
    3134        1921 :     return A;
    3135             :   }
    3136             : 
    3137             :   FormatAttr(SourceRange R, ASTContext &Ctx
    3138             :               , IdentifierInfo * Type
    3139             :               , int FormatIdx
    3140             :               , int FirstArg
    3141             :               , unsigned SI
    3142             :              )
    3143       19771 :     : InheritableAttr(attr::Format, R, SI, false, false)
    3144             :               , type(Type)
    3145             :               , formatIdx(FormatIdx)
    3146       19771 :               , 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         654 :     : InheritableAttr(attr::FormatArg, R, SI, false, false)
    3186         654 :               , 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          22 :     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         216 :   static LoopHintAttr *CreateImplicit(ASTContext &Ctx, Spelling S, OptionType Option, LoopHintState State, Expr * Value, SourceRange Loc = SourceRange()) {
    3737         216 :     auto *A = new (Ctx) LoopHintAttr(Loc, Ctx, Option, State, Value, S);
    3738             :     A->setImplicit(true);
    3739         216 :     return A;
    3740             :   }
    3741             : 
    3742             :   LoopHintAttr(SourceRange R, ASTContext &Ctx
    3743             :               , OptionType Option
    3744             :               , LoopHintState State
    3745             :               , Expr * Value
    3746             :               , unsigned SI
    3747             :              )
    3748         234 :     : Attr(attr::LoopHint, R, SI, false)
    3749             :               , option(Option)
    3750             :               , state(State)
    3751         234 :               , 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         321 :   static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Loc = SourceRange()) {
    4132         321 :     auto *A = new (Ctx) MaxFieldAlignmentAttr(Loc, Ctx, Alignment, 0);
    4133             :     A->setImplicit(true);
    4134         321 :     return A;
    4135             :   }
    4136             : 
    4137             :   MaxFieldAlignmentAttr(SourceRange R, ASTContext &Ctx
    4138             :               , unsigned Alignment
    4139             :               , unsigned SI
    4140             :              )
    4141         322 :     : InheritableAttr(attr::MaxFieldAlignment, R, SI, false, false)
    4142         322 :               , 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 Mips16Attr : public InheritableAttr {
    4232             : public:
    4233             :   static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4234             :     auto *A = new (Ctx) Mips16Attr(Loc, Ctx, 0);
    4235             :     A->setImplicit(true);
    4236             :     return A;
    4237             :   }
    4238             : 
    4239             :   Mips16Attr(SourceRange R, ASTContext &Ctx
    4240             :               , unsigned SI
    4241             :              )
    4242             :     : InheritableAttr(attr::Mips16, R, SI, false, false)
    4243             :   {
    4244             :   }
    4245             : 
    4246             :   Mips16Attr *clone(ASTContext &C) const;
    4247             :   void printPretty(raw_ostream &OS,
    4248             :                    const PrintingPolicy &Policy) const;
    4249             :   const char *getSpelling() const;
    4250             : 
    4251             : 
    4252             :   static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; }
    4253             : };
    4254             : 
    4255             : class MipsInterruptAttr : public InheritableAttr {
    4256             : public:
    4257             :   enum InterruptType {
    4258             :     sw0,
    4259             :     sw1,
    4260             :     hw0,
    4261             :     hw1,
    4262             :     hw2,
    4263             :     hw3,
    4264             :     hw4,
    4265             :     hw5,
    4266             :     eic
    4267             :   };
    4268             : private:
    4269             :   InterruptType interrupt;
    4270             : 
    4271             : public:
    4272             :   static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
    4273             :     auto *A = new (Ctx) MipsInterruptAttr(Loc, Ctx, Interrupt, 0);
    4274             :     A->setImplicit(true);
    4275             :     return A;
    4276             :   }
    4277             : 
    4278             :   MipsInterruptAttr(SourceRange R, ASTContext &Ctx
    4279             :               , InterruptType Interrupt
    4280             :               , unsigned SI
    4281             :              )
    4282          20 :     : InheritableAttr(attr::MipsInterrupt, R, SI, false, false)
    4283          20 :               , interrupt(Interrupt)
    4284             :   {
    4285             :   }
    4286             : 
    4287             :   MipsInterruptAttr *clone(ASTContext &C) const;
    4288             :   void printPretty(raw_ostream &OS,
    4289             :                    const PrintingPolicy &Policy) const;
    4290             :   const char *getSpelling() const;
    4291             :   InterruptType getInterrupt() const {
    4292             :     return interrupt;
    4293             :   }
    4294             : 
    4295          21 :   static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
    4296          21 :     Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
    4297          21 :       .Case("vector=sw0", MipsInterruptAttr::sw0)
    4298          21 :       .Case("vector=sw1", MipsInterruptAttr::sw1)
    4299          21 :       .Case("vector=hw0", MipsInterruptAttr::hw0)
    4300          21 :       .Case("vector=hw1", MipsInterruptAttr::hw1)
    4301          21 :       .Case("vector=hw2", MipsInterruptAttr::hw2)
    4302          21 :       .Case("vector=hw3", MipsInterruptAttr::hw3)
    4303          21 :       .Case("vector=hw4", MipsInterruptAttr::hw4)
    4304          21 :       .Case("vector=hw5", MipsInterruptAttr::hw5)
    4305          21 :       .Case("eic", MipsInterruptAttr::eic)
    4306          21 :       .Case("", MipsInterruptAttr::eic)
    4307             :       .Default(Optional<InterruptType>());
    4308          21 :     if (R) {
    4309          20 :       Out = *R;
    4310          20 :       return true;
    4311             :     }
    4312             :     return false;
    4313             :   }
    4314             : 
    4315           0 :   static const char *ConvertInterruptTypeToStr(InterruptType Val) {
    4316           0 :     switch(Val) {
    4317             :     case MipsInterruptAttr::sw0: return "vector=sw0";
    4318           0 :     case MipsInterruptAttr::sw1: return "vector=sw1";
    4319           0 :     case MipsInterruptAttr::hw0: return "vector=hw0";
    4320           0 :     case MipsInterruptAttr::hw1: return "vector=hw1";
    4321           0 :     case MipsInterruptAttr::hw2: return "vector=hw2";
    4322           0 :     case MipsInterruptAttr::hw3: return "vector=hw3";
    4323           0 :     case MipsInterruptAttr::hw4: return "vector=hw4";
    4324           0 :     case MipsInterruptAttr::hw5: return "vector=hw5";
    4325           0 :     case MipsInterruptAttr::eic: return "eic";
    4326             :     }
    4327           0 :     llvm_unreachable("No enumerator with that value");
    4328             :   }
    4329             : 
    4330             : 
    4331             :   static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; }
    4332             : };
    4333             : 
    4334             : class MipsLongCallAttr : public InheritableAttr {
    4335             : public:
    4336             :   enum Spelling {
    4337             :     GNU_long_call = 0,
    4338             :     CXX11_gnu_long_call = 1,
    4339             :     GNU_far = 2,
    4340             :     CXX11_gnu_far = 3
    4341             :   };
    4342             : 
    4343             :   static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    4344             :     auto *A = new (Ctx) MipsLongCallAttr(Loc, Ctx, S);
    4345             :     A->setImplicit(true);
    4346             :     return A;
    4347             :   }
    4348             : 
    4349             :   MipsLongCallAttr(SourceRange R, ASTContext &Ctx
    4350             :               , unsigned SI
    4351             :              )
    4352             :     : InheritableAttr(attr::MipsLongCall, R, SI, false, false)
    4353             :   {
    4354             :   }
    4355             : 
    4356             :   MipsLongCallAttr *clone(ASTContext &C) const;
    4357             :   void printPretty(raw_ostream &OS,
    4358             :                    const PrintingPolicy &Policy) const;
    4359             :   const char *getSpelling() const;
    4360             :   Spelling getSemanticSpelling() const {
    4361             :   switch (SpellingListIndex) {
    4362             :     default: llvm_unreachable("Unknown spelling list index");
    4363             :     case 0: return GNU_long_call;
    4364             :     case 1: return CXX11_gnu_long_call;
    4365             :     case 2: return GNU_far;
    4366             :     case 3: return CXX11_gnu_far;
    4367             :   }
    4368             :   }
    4369             : 
    4370             : 
    4371             :   static bool classof(const Attr *A) { return A->getKind() == attr::MipsLongCall; }
    4372             : };
    4373             : 
    4374             : class MipsShortCallAttr : public InheritableAttr {
    4375             : public:
    4376             :   enum Spelling {
    4377             :     GNU_short_call = 0,
    4378             :     CXX11_gnu_short_call = 1,
    4379             :     GNU_near = 2,
    4380             :     CXX11_gnu_near = 3
    4381             :   };
    4382             : 
    4383             :   static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    4384             :     auto *A = new (Ctx) MipsShortCallAttr(Loc, Ctx, S);
    4385             :     A->setImplicit(true);
    4386             :     return A;
    4387             :   }
    4388             : 
    4389             :   MipsShortCallAttr(SourceRange R, ASTContext &Ctx
    4390             :               , unsigned SI
    4391             :              )
    4392             :     : InheritableAttr(attr::MipsShortCall, R, SI, false, false)
    4393             :   {
    4394             :   }
    4395             : 
    4396             :   MipsShortCallAttr *clone(ASTContext &C) const;
    4397             :   void printPretty(raw_ostream &OS,
    4398             :                    const PrintingPolicy &Policy) const;
    4399             :   const char *getSpelling() const;
    4400             :   Spelling getSemanticSpelling() const {
    4401             :   switch (SpellingListIndex) {
    4402             :     default: llvm_unreachable("Unknown spelling list index");
    4403             :     case 0: return GNU_short_call;
    4404             :     case 1: return CXX11_gnu_short_call;
    4405             :     case 2: return GNU_near;
    4406             :     case 3: return CXX11_gnu_near;
    4407             :   }
    4408             :   }
    4409             : 
    4410             : 
    4411             :   static bool classof(const Attr *A) { return A->getKind() == attr::MipsShortCall; }
    4412             : };
    4413             : 
    4414             : class ModeAttr : public Attr {
    4415             : IdentifierInfo * mode;
    4416             : 
    4417             : public:
    4418             :   static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Loc = SourceRange()) {
    4419             :     auto *A = new (Ctx) ModeAttr(Loc, Ctx, Mode, 0);
    4420             :     A->setImplicit(true);
    4421             :     return A;
    4422             :   }
    4423             : 
    4424             :   ModeAttr(SourceRange R, ASTContext &Ctx
    4425             :               , IdentifierInfo * Mode
    4426             :               , unsigned SI
    4427             :              )
    4428        3079 :     : Attr(attr::Mode, R, SI, false)
    4429        3079 :               , mode(Mode)
    4430             :   {
    4431             :   }
    4432             : 
    4433             :   ModeAttr *clone(ASTContext &C) const;
    4434             :   void printPretty(raw_ostream &OS,
    4435             :                    const PrintingPolicy &Policy) const;
    4436             :   const char *getSpelling() const;
    4437             :   IdentifierInfo * getMode() const {
    4438             :     return mode;
    4439             :   }
    4440             : 
    4441             : 
    4442             : 
    4443             :   static bool classof(const Attr *A) { return A->getKind() == attr::Mode; }
    4444             : };
    4445             : 
    4446             : class NSConsumedAttr : public InheritableParamAttr {
    4447             : public:
    4448         153 :   static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4449         153 :     auto *A = new (Ctx) NSConsumedAttr(Loc, Ctx, 0);
    4450             :     A->setImplicit(true);
    4451         153 :     return A;
    4452             :   }
    4453             : 
    4454             :   NSConsumedAttr(SourceRange R, ASTContext &Ctx
    4455             :               , unsigned SI
    4456             :              )
    4457             :     : InheritableParamAttr(attr::NSConsumed, R, SI, false, false)
    4458             :   {
    4459             :   }
    4460             : 
    4461             :   NSConsumedAttr *clone(ASTContext &C) const;
    4462             :   void printPretty(raw_ostream &OS,
    4463             :                    const PrintingPolicy &Policy) const;
    4464             :   const char *getSpelling() const;
    4465             : 
    4466             : 
    4467          89 :   static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; }
    4468             : };
    4469             : 
    4470             : class NSConsumesSelfAttr : public InheritableAttr {
    4471             : public:
    4472         495 :   static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4473         495 :     auto *A = new (Ctx) NSConsumesSelfAttr(Loc, Ctx, 0);
    4474             :     A->setImplicit(true);
    4475         495 :     return A;
    4476             :   }
    4477             : 
    4478             :   NSConsumesSelfAttr(SourceRange R, ASTContext &Ctx
    4479             :               , unsigned SI
    4480             :              )
    4481             :     : InheritableAttr(attr::NSConsumesSelf, R, SI, false, false)
    4482             :   {
    4483             :   }
    4484             : 
    4485             :   NSConsumesSelfAttr *clone(ASTContext &C) const;
    4486             :   void printPretty(raw_ostream &OS,
    4487             :                    const PrintingPolicy &Policy) const;
    4488             :   const char *getSpelling() const;
    4489             : 
    4490             : 
    4491             :   static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; }
    4492             : };
    4493             : 
    4494             : class NSReturnsAutoreleasedAttr : public InheritableAttr {
    4495             : public:
    4496             :   static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4497             :     auto *A = new (Ctx) NSReturnsAutoreleasedAttr(Loc, Ctx, 0);
    4498             :     A->setImplicit(true);
    4499             :     return A;
    4500             :   }
    4501             : 
    4502             :   NSReturnsAutoreleasedAttr(SourceRange R, ASTContext &Ctx
    4503             :               , unsigned SI
    4504             :              )
    4505             :     : InheritableAttr(attr::NSReturnsAutoreleased, R, SI, false, false)
    4506             :   {
    4507             :   }
    4508             : 
    4509             :   NSReturnsAutoreleasedAttr *clone(ASTContext &C) const;
    4510             :   void printPretty(raw_ostream &OS,
    4511             :                    const PrintingPolicy &Policy) const;
    4512             :   const char *getSpelling() const;
    4513             : 
    4514             : 
    4515             :   static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; }
    4516             : };
    4517             : 
    4518             : class NSReturnsNotRetainedAttr : public InheritableAttr {
    4519             : public:
    4520           3 :   static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4521           3 :     auto *A = new (Ctx) NSReturnsNotRetainedAttr(Loc, Ctx, 0);
    4522             :     A->setImplicit(true);
    4523           3 :     return A;
    4524             :   }
    4525             : 
    4526             :   NSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
    4527             :               , unsigned SI
    4528             :              )
    4529             :     : InheritableAttr(attr::NSReturnsNotRetained, R, SI, false, false)
    4530             :   {
    4531             :   }
    4532             : 
    4533             :   NSReturnsNotRetainedAttr *clone(ASTContext &C) const;
    4534             :   void printPretty(raw_ostream &OS,
    4535             :                    const PrintingPolicy &Policy) const;
    4536             :   const char *getSpelling() const;
    4537             : 
    4538             : 
    4539             :   static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; }
    4540             : };
    4541             : 
    4542             : class NSReturnsRetainedAttr : public InheritableAttr {
    4543             : public:
    4544         877 :   static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4545         877 :     auto *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0);
    4546             :     A->setImplicit(true);
    4547         877 :     return A;
    4548             :   }
    4549             : 
    4550             :   NSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
    4551             :               , unsigned SI
    4552             :              )
    4553             :     : InheritableAttr(attr::NSReturnsRetained, R, SI, false, false)
    4554             :   {
    4555             :   }
    4556             : 
    4557             :   NSReturnsRetainedAttr *clone(ASTContext &C) const;
    4558             :   void printPretty(raw_ostream &OS,
    4559             :                    const PrintingPolicy &Policy) const;
    4560             :   const char *getSpelling() const;
    4561             : 
    4562             : 
    4563             :   static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; }
    4564             : };
    4565             : 
    4566             : class NakedAttr : public InheritableAttr {
    4567             : public:
    4568             :   static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4569             :     auto *A = new (Ctx) NakedAttr(Loc, Ctx, 0);
    4570             :     A->setImplicit(true);
    4571             :     return A;
    4572             :   }
    4573             : 
    4574             :   NakedAttr(SourceRange R, ASTContext &Ctx
    4575             :               , unsigned SI
    4576             :              )
    4577             :     : InheritableAttr(attr::Naked, R, SI, false, false)
    4578             :   {
    4579             :   }
    4580             : 
    4581             :   NakedAttr *clone(ASTContext &C) const;
    4582             :   void printPretty(raw_ostream &OS,
    4583             :                    const PrintingPolicy &Policy) const;
    4584             :   const char *getSpelling() const;
    4585             : 
    4586             : 
    4587             :   static bool classof(const Attr *A) { return A->getKind() == attr::Naked; }
    4588             : };
    4589             : 
    4590             : class NoAliasAttr : public InheritableAttr {
    4591             : public:
    4592             :   static NoAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4593             :     auto *A = new (Ctx) NoAliasAttr(Loc, Ctx, 0);
    4594             :     A->setImplicit(true);
    4595             :     return A;
    4596             :   }
    4597             : 
    4598             :   NoAliasAttr(SourceRange R, ASTContext &Ctx
    4599             :               , unsigned SI
    4600             :              )
    4601             :     : InheritableAttr(attr::NoAlias, R, SI, false, false)
    4602             :   {
    4603             :   }
    4604             : 
    4605             :   NoAliasAttr *clone(ASTContext &C) const;
    4606             :   void printPretty(raw_ostream &OS,
    4607             :                    const PrintingPolicy &Policy) const;
    4608             :   const char *getSpelling() const;
    4609             : 
    4610             : 
    4611             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoAlias; }
    4612             : };
    4613             : 
    4614             : class NoCommonAttr : public InheritableAttr {
    4615             : public:
    4616             :   static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4617             :     auto *A = new (Ctx) NoCommonAttr(Loc, Ctx, 0);
    4618             :     A->setImplicit(true);
    4619             :     return A;
    4620             :   }
    4621             : 
    4622             :   NoCommonAttr(SourceRange R, ASTContext &Ctx
    4623             :               , unsigned SI
    4624             :              )
    4625             :     : InheritableAttr(attr::NoCommon, R, SI, false, false)
    4626             :   {
    4627             :   }
    4628             : 
    4629             :   NoCommonAttr *clone(ASTContext &C) const;
    4630             :   void printPretty(raw_ostream &OS,
    4631             :                    const PrintingPolicy &Policy) const;
    4632             :   const char *getSpelling() const;
    4633             : 
    4634             : 
    4635             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; }
    4636             : };
    4637             : 
    4638             : class NoDebugAttr : public InheritableAttr {
    4639             : public:
    4640             :   static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4641             :     auto *A = new (Ctx) NoDebugAttr(Loc, Ctx, 0);
    4642             :     A->setImplicit(true);
    4643             :     return A;
    4644             :   }
    4645             : 
    4646             :   NoDebugAttr(SourceRange R, ASTContext &Ctx
    4647             :               , unsigned SI
    4648             :              )
    4649             :     : InheritableAttr(attr::NoDebug, R, SI, false, false)
    4650             :   {
    4651             :   }
    4652             : 
    4653             :   NoDebugAttr *clone(ASTContext &C) const;
    4654             :   void printPretty(raw_ostream &OS,
    4655             :                    const PrintingPolicy &Policy) const;
    4656             :   const char *getSpelling() const;
    4657             : 
    4658             : 
    4659             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; }
    4660             : };
    4661             : 
    4662             : class NoDuplicateAttr : public InheritableAttr {
    4663             : public:
    4664             :   static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4665             :     auto *A = new (Ctx) NoDuplicateAttr(Loc, Ctx, 0);
    4666             :     A->setImplicit(true);
    4667             :     return A;
    4668             :   }
    4669             : 
    4670             :   NoDuplicateAttr(SourceRange R, ASTContext &Ctx
    4671             :               , unsigned SI
    4672             :              )
    4673             :     : InheritableAttr(attr::NoDuplicate, R, SI, false, false)
    4674             :   {
    4675             :   }
    4676             : 
    4677             :   NoDuplicateAttr *clone(ASTContext &C) const;
    4678             :   void printPretty(raw_ostream &OS,
    4679             :                    const PrintingPolicy &Policy) const;
    4680             :   const char *getSpelling() const;
    4681             : 
    4682             : 
    4683             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; }
    4684             : };
    4685             : 
    4686             : class NoEscapeAttr : public Attr {
    4687             : public:
    4688             :   static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4689             :     auto *A = new (Ctx) NoEscapeAttr(Loc, Ctx, 0);
    4690             :     A->setImplicit(true);
    4691             :     return A;
    4692             :   }
    4693             : 
    4694             :   NoEscapeAttr(SourceRange R, ASTContext &Ctx
    4695             :               , unsigned SI
    4696             :              )
    4697             :     : Attr(attr::NoEscape, R, SI, false)
    4698             :   {
    4699             :   }
    4700             : 
    4701             :   NoEscapeAttr *clone(ASTContext &C) const;
    4702             :   void printPretty(raw_ostream &OS,
    4703             :                    const PrintingPolicy &Policy) const;
    4704             :   const char *getSpelling() const;
    4705             : 
    4706             : 
    4707             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoEscape; }
    4708             : };
    4709             : 
    4710             : class NoInlineAttr : public InheritableAttr {
    4711             : public:
    4712          22 :   static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4713          22 :     auto *A = new (Ctx) NoInlineAttr(Loc, Ctx, 0);
    4714             :     A->setImplicit(true);
    4715          22 :     return A;
    4716             :   }
    4717             : 
    4718             :   NoInlineAttr(SourceRange R, ASTContext &Ctx
    4719             :               , unsigned SI
    4720             :              )
    4721             :     : InheritableAttr(attr::NoInline, R, SI, false, false)
    4722             :   {
    4723             :   }
    4724             : 
    4725             :   NoInlineAttr *clone(ASTContext &C) const;
    4726             :   void printPretty(raw_ostream &OS,
    4727             :                    const PrintingPolicy &Policy) const;
    4728             :   const char *getSpelling() const;
    4729             : 
    4730             : 
    4731             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; }
    4732             : };
    4733             : 
    4734             : class NoInstrumentFunctionAttr : public InheritableAttr {
    4735             : public:
    4736             :   static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4737             :     auto *A = new (Ctx) NoInstrumentFunctionAttr(Loc, Ctx, 0);
    4738             :     A->setImplicit(true);
    4739             :     return A;
    4740             :   }
    4741             : 
    4742             :   NoInstrumentFunctionAttr(SourceRange R, ASTContext &Ctx
    4743             :               , unsigned SI
    4744             :              )
    4745             :     : InheritableAttr(attr::NoInstrumentFunction, R, SI, false, false)
    4746             :   {
    4747             :   }
    4748             : 
    4749             :   NoInstrumentFunctionAttr *clone(ASTContext &C) const;
    4750             :   void printPretty(raw_ostream &OS,
    4751             :                    const PrintingPolicy &Policy) const;
    4752             :   const char *getSpelling() const;
    4753             : 
    4754             : 
    4755             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; }
    4756             : };
    4757             : 
    4758             : class NoMicroMipsAttr : public InheritableAttr {
    4759             : public:
    4760             :   static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4761             :     auto *A = new (Ctx) NoMicroMipsAttr(Loc, Ctx, 0);
    4762             :     A->setImplicit(true);
    4763             :     return A;
    4764             :   }
    4765             : 
    4766             :   NoMicroMipsAttr(SourceRange R, ASTContext &Ctx
    4767             :               , unsigned SI
    4768             :              )
    4769             :     : InheritableAttr(attr::NoMicroMips, R, SI, false, false)
    4770             :   {
    4771             :   }
    4772             : 
    4773             :   NoMicroMipsAttr *clone(ASTContext &C) const;
    4774             :   void printPretty(raw_ostream &OS,
    4775             :                    const PrintingPolicy &Policy) const;
    4776             :   const char *getSpelling() const;
    4777             : 
    4778             : 
    4779             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoMicroMips; }
    4780             : };
    4781             : 
    4782             : class NoMips16Attr : public InheritableAttr {
    4783             : public:
    4784             :   static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4785             :     auto *A = new (Ctx) NoMips16Attr(Loc, Ctx, 0);
    4786             :     A->setImplicit(true);
    4787             :     return A;
    4788             :   }
    4789             : 
    4790             :   NoMips16Attr(SourceRange R, ASTContext &Ctx
    4791             :               , unsigned SI
    4792             :              )
    4793             :     : InheritableAttr(attr::NoMips16, R, SI, false, false)
    4794             :   {
    4795             :   }
    4796             : 
    4797             :   NoMips16Attr *clone(ASTContext &C) const;
    4798             :   void printPretty(raw_ostream &OS,
    4799             :                    const PrintingPolicy &Policy) const;
    4800             :   const char *getSpelling() const;
    4801             : 
    4802             : 
    4803             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; }
    4804             : };
    4805             : 
    4806             : class NoReturnAttr : public InheritableAttr {
    4807             : public:
    4808             :   static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4809             :     auto *A = new (Ctx) NoReturnAttr(Loc, Ctx, 0);
    4810             :     A->setImplicit(true);
    4811             :     return A;
    4812             :   }
    4813             : 
    4814             :   NoReturnAttr(SourceRange R, ASTContext &Ctx
    4815             :               , unsigned SI
    4816             :              )
    4817             :     : InheritableAttr(attr::NoReturn, R, SI, false, false)
    4818             :   {
    4819             :   }
    4820             : 
    4821             :   NoReturnAttr *clone(ASTContext &C) const;
    4822             :   void printPretty(raw_ostream &OS,
    4823             :                    const PrintingPolicy &Policy) const;
    4824             :   const char *getSpelling() const;
    4825             : 
    4826             : 
    4827             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; }
    4828             : };
    4829             : 
    4830             : class NoSanitizeAttr : public InheritableAttr {
    4831             :   unsigned sanitizers_Size;
    4832             :   StringRef *sanitizers_;
    4833             : 
    4834             : public:
    4835             :   static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Loc = SourceRange()) {
    4836             :     auto *A = new (Ctx) NoSanitizeAttr(Loc, Ctx, Sanitizers, SanitizersSize, 0);
    4837             :     A->setImplicit(true);
    4838             :     return A;
    4839             :   }
    4840             : 
    4841         185 :   NoSanitizeAttr(SourceRange R, ASTContext &Ctx
    4842             :               , StringRef *Sanitizers, unsigned SanitizersSize
    4843             :               , unsigned SI
    4844             :              )
    4845         185 :     : InheritableAttr(attr::NoSanitize, R, SI, false, false)
    4846         564 :               , sanitizers_Size(SanitizersSize), sanitizers_(new (Ctx, 16) StringRef[sanitizers_Size])
    4847             :   {
    4848         379 :     for (size_t I = 0, E = sanitizers_Size; I != E;
    4849             :          ++I) {
    4850         194 :       StringRef Ref = Sanitizers[I];
    4851         194 :       if (!Ref.empty()) {
    4852             :         char *Mem = new (Ctx, 1) char[Ref.size()];
    4853         194 :         std::memcpy(Mem, Ref.data(), Ref.size());
    4854         194 :         sanitizers_[I] = StringRef(Mem, Ref.size());
    4855             :       }
    4856             :     }
    4857         185 :   }
    4858             : 
    4859             :   NoSanitizeAttr(SourceRange R, ASTContext &Ctx
    4860             :               , unsigned SI
    4861             :              )
    4862             :     : InheritableAttr(attr::NoSanitize, R, SI, false, false)
    4863             :               , sanitizers_Size(0), sanitizers_(nullptr)
    4864             :   {
    4865             :   }
    4866             : 
    4867             :   NoSanitizeAttr *clone(ASTContext &C) const;
    4868             :   void printPretty(raw_ostream &OS,
    4869             :                    const PrintingPolicy &Policy) const;
    4870             :   const char *getSpelling() const;
    4871             :   typedef StringRef* sanitizers_iterator;
    4872             :   sanitizers_iterator sanitizers_begin() const { return sanitizers_; }
    4873         129 :   sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; }
    4874             :   unsigned sanitizers_size() const { return sanitizers_Size; }
    4875         129 :   llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); }
    4876             : 
    4877             : 
    4878             : 
    4879         118 :     SanitizerMask getMask() const {
    4880             :       SanitizerMask Mask = 0;
    4881         354 :       for (auto SanitizerName : sanitizers()) {
    4882             :         SanitizerMask ParsedMask =
    4883         118 :             parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
    4884         118 :         Mask |= expandSanitizerGroups(ParsedMask);
    4885             :       }
    4886         118 :       return Mask;
    4887             :     }
    4888             :   
    4889             : 
    4890             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; }
    4891             : };
    4892             : 
    4893             : class NoSplitStackAttr : public InheritableAttr {
    4894             : public:
    4895             :   static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4896             :     auto *A = new (Ctx) NoSplitStackAttr(Loc, Ctx, 0);
    4897             :     A->setImplicit(true);
    4898             :     return A;
    4899             :   }
    4900             : 
    4901             :   NoSplitStackAttr(SourceRange R, ASTContext &Ctx
    4902             :               , unsigned SI
    4903             :              )
    4904             :     : InheritableAttr(attr::NoSplitStack, R, SI, false, false)
    4905             :   {
    4906             :   }
    4907             : 
    4908             :   NoSplitStackAttr *clone(ASTContext &C) const;
    4909             :   void printPretty(raw_ostream &OS,
    4910             :                    const PrintingPolicy &Policy) const;
    4911             :   const char *getSpelling() const;
    4912             : 
    4913             : 
    4914             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; }
    4915             : };
    4916             : 
    4917             : class NoStackProtectorAttr : public InheritableAttr {
    4918             : public:
    4919             :   static NoStackProtectorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4920             :     auto *A = new (Ctx) NoStackProtectorAttr(Loc, Ctx, 0);
    4921             :     A->setImplicit(true);
    4922             :     return A;
    4923             :   }
    4924             : 
    4925             :   NoStackProtectorAttr(SourceRange R, ASTContext &Ctx
    4926             :               , unsigned SI
    4927             :              )
    4928             :     : InheritableAttr(attr::NoStackProtector, R, SI, false, false)
    4929             :   {
    4930             :   }
    4931             : 
    4932             :   NoStackProtectorAttr *clone(ASTContext &C) const;
    4933             :   void printPretty(raw_ostream &OS,
    4934             :                    const PrintingPolicy &Policy) const;
    4935             :   const char *getSpelling() const;
    4936             : 
    4937             : 
    4938             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoStackProtector; }
    4939             : };
    4940             : 
    4941             : class NoThreadSafetyAnalysisAttr : public InheritableAttr {
    4942             : public:
    4943             :   static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4944             :     auto *A = new (Ctx) NoThreadSafetyAnalysisAttr(Loc, Ctx, 0);
    4945             :     A->setImplicit(true);
    4946             :     return A;
    4947             :   }
    4948             : 
    4949             :   NoThreadSafetyAnalysisAttr(SourceRange R, ASTContext &Ctx
    4950             :               , unsigned SI
    4951             :              )
    4952             :     : InheritableAttr(attr::NoThreadSafetyAnalysis, R, SI, false, false)
    4953             :   {
    4954             :   }
    4955             : 
    4956             :   NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const;
    4957             :   void printPretty(raw_ostream &OS,
    4958             :                    const PrintingPolicy &Policy) const;
    4959             :   const char *getSpelling() const;
    4960             : 
    4961             : 
    4962             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; }
    4963             : };
    4964             : 
    4965             : class NoThrowAttr : public InheritableAttr {
    4966             : public:
    4967      233164 :   static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    4968      233164 :     auto *A = new (Ctx) NoThrowAttr(Loc, Ctx, 0);
    4969             :     A->setImplicit(true);
    4970      233164 :     return A;
    4971             :   }
    4972             : 
    4973             :   NoThrowAttr(SourceRange R, ASTContext &Ctx
    4974             :               , unsigned SI
    4975             :              )
    4976             :     : InheritableAttr(attr::NoThrow, R, SI, false, false)
    4977             :   {
    4978             :   }
    4979             : 
    4980             :   NoThrowAttr *clone(ASTContext &C) const;
    4981             :   void printPretty(raw_ostream &OS,
    4982             :                    const PrintingPolicy &Policy) const;
    4983             :   const char *getSpelling() const;
    4984             : 
    4985             : 
    4986             :   static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; }
    4987             : };
    4988             : 
    4989             : class NonNullAttr : public InheritableParamAttr {
    4990             :   unsigned args_Size;
    4991             :   ParamIdx *args_;
    4992             : 
    4993             : public:
    4994             :   static NonNullAttr *CreateImplicit(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
    4995             :     auto *A = new (Ctx) NonNullAttr(Loc, Ctx, Args, ArgsSize, 0);
    4996             :     A->setImplicit(true);
    4997             :     return A;
    4998             :   }
    4999             : 
    5000      124171 :   NonNullAttr(SourceRange R, ASTContext &Ctx
    5001             :               , ParamIdx *Args, unsigned ArgsSize
    5002             :               , unsigned SI
    5003             :              )
    5004      124171 :     : InheritableParamAttr(attr::NonNull, R, SI, false, true)
    5005      425968 :               , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[args_Size])
    5006             :   {
    5007      124171 :     std::copy(Args, Args + args_Size, args_);
    5008      124171 :   }
    5009             : 
    5010             :   NonNullAttr(SourceRange R, ASTContext &Ctx
    5011             :               , unsigned SI
    5012             :              )
    5013             :     : InheritableParamAttr(attr::NonNull, R, SI, false, true)
    5014             :               , args_Size(0), args_(nullptr)
    5015             :   {
    5016             :   }
    5017             : 
    5018             :   NonNullAttr *clone(ASTContext &C) const;
    5019             :   void printPretty(raw_ostream &OS,
    5020             :                    const PrintingPolicy &Policy) const;
    5021             :   const char *getSpelling() const;
    5022             :   typedef ParamIdx* args_iterator;
    5023             :   args_iterator args_begin() const { return args_; }
    5024        6069 :   args_iterator args_end() const { return args_ + args_Size; }
    5025             :   unsigned args_size() const { return args_Size; }
    5026        6042 :   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
    5027             : 
    5028             : 
    5029             : 
    5030          33 :     bool isNonNull(unsigned IdxAST) const {
    5031          33 :       if (!args_size())
    5032             :         return true;
    5033          27 :       return args_end() != std::find_if(
    5034             :           args_begin(), args_end(),
    5035          27 :           [=](const ParamIdx &Idx) { return Idx.getASTIndex() == IdxAST; });
    5036             :     }
    5037             :   
    5038             : 
    5039          12 :   static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
    5040             : };
    5041             : 
    5042             : class NotTailCalledAttr : public InheritableAttr {
    5043             : public:
    5044             :   static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5045             :     auto *A = new (Ctx) NotTailCalledAttr(Loc, Ctx, 0);
    5046             :     A->setImplicit(true);
    5047             :     return A;
    5048             :   }
    5049             : 
    5050             :   NotTailCalledAttr(SourceRange R, ASTContext &Ctx
    5051             :               , unsigned SI
    5052             :              )
    5053             :     : InheritableAttr(attr::NotTailCalled, R, SI, false, false)
    5054             :   {
    5055             :   }
    5056             : 
    5057             :   NotTailCalledAttr *clone(ASTContext &C) const;
    5058             :   void printPretty(raw_ostream &OS,
    5059             :                    const PrintingPolicy &Policy) const;
    5060             :   const char *getSpelling() const;
    5061             : 
    5062             : 
    5063           2 :   static bool classof(const Attr *A) { return A->getKind() == attr::NotTailCalled; }
    5064             : };
    5065             : 
    5066             : class OMPCaptureKindAttr : public Attr {
    5067             : unsigned captureKind;
    5068             : 
    5069             : public:
    5070      173690 :   static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKind, SourceRange Loc = SourceRange()) {
    5071      173690 :     auto *A = new (Ctx) OMPCaptureKindAttr(Loc, Ctx, CaptureKind, 0);
    5072             :     A->setImplicit(true);
    5073      173690 :     return A;
    5074             :   }
    5075             : 
    5076             :   OMPCaptureKindAttr(SourceRange R, ASTContext &Ctx
    5077             :               , unsigned CaptureKind
    5078             :               , unsigned SI
    5079             :              )
    5080      178300 :     : Attr(attr::OMPCaptureKind, R, SI, false)
    5081      178300 :               , captureKind(CaptureKind)
    5082             :   {
    5083             :   }
    5084             : 
    5085             :   OMPCaptureKindAttr *clone(ASTContext &C) const;
    5086             :   void printPretty(raw_ostream &OS,
    5087             :                    const PrintingPolicy &Policy) const;
    5088             :   const char *getSpelling() const;
    5089             :   unsigned getCaptureKind() const {
    5090             :     return captureKind;
    5091             :   }
    5092             : 
    5093             : 
    5094             : 
    5095             :   static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureKind; }
    5096             : };
    5097             : 
    5098             : class OMPCaptureNoInitAttr : public InheritableAttr {
    5099             : public:
    5100          70 :   static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5101          70 :     auto *A = new (Ctx) OMPCaptureNoInitAttr(Loc, Ctx, 0);
    5102             :     A->setImplicit(true);
    5103          70 :     return A;
    5104             :   }
    5105             : 
    5106             :   OMPCaptureNoInitAttr(SourceRange R, ASTContext &Ctx
    5107             :               , unsigned SI
    5108             :              )
    5109             :     : InheritableAttr(attr::OMPCaptureNoInit, R, SI, false, false)
    5110             :   {
    5111             :   }
    5112             : 
    5113             :   OMPCaptureNoInitAttr *clone(ASTContext &C) const;
    5114             :   void printPretty(raw_ostream &OS,
    5115             :                    const PrintingPolicy &Policy) const;
    5116             :   const char *getSpelling() const;
    5117             : 
    5118             : 
    5119             :   static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureNoInit; }
    5120             : };
    5121             : 
    5122             : class OMPDeclareSimdDeclAttr : public Attr {
    5123             : public:
    5124             :   enum BranchStateTy {
    5125             :     BS_Undefined,
    5126             :     BS_Inbranch,
    5127             :     BS_Notinbranch
    5128             :   };
    5129             : private:
    5130             :   BranchStateTy branchState;
    5131             : 
    5132             : Expr * simdlen;
    5133             : 
    5134             :   unsigned uniforms_Size;
    5135             :   Expr * *uniforms_;
    5136             : 
    5137             :   unsigned aligneds_Size;
    5138             :   Expr * *aligneds_;
    5139             : 
    5140             :   unsigned alignments_Size;
    5141             :   Expr * *alignments_;
    5142             : 
    5143             :   unsigned linears_Size;
    5144             :   Expr * *linears_;
    5145             : 
    5146             :   unsigned modifiers_Size;
    5147             :   unsigned *modifiers_;
    5148             : 
    5149             :   unsigned steps_Size;
    5150             :   Expr * *steps_;
    5151             : 
    5152             : public:
    5153         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()) {
    5154         612 :     auto *A = new (Ctx) OMPDeclareSimdDeclAttr(Loc, Ctx, BranchState, Simdlen, Uniforms, UniformsSize, Aligneds, AlignedsSize, Alignments, AlignmentsSize, Linears, LinearsSize, Modifiers, ModifiersSize, Steps, StepsSize, 0);
    5155             :     A->setImplicit(true);
    5156         306 :     return A;
    5157             :   }
    5158             : 
    5159         430 :   OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx
    5160             :               , BranchStateTy BranchState
    5161             :               , Expr * Simdlen
    5162             :               , Expr * *Uniforms, unsigned UniformsSize
    5163             :               , Expr * *Aligneds, unsigned AlignedsSize
    5164             :               , Expr * *Alignments, unsigned AlignmentsSize
    5165             :               , Expr * *Linears, unsigned LinearsSize
    5166             :               , unsigned *Modifiers, unsigned ModifiersSize
    5167             :               , Expr * *Steps, unsigned StepsSize
    5168             :               , unsigned SI
    5169             :              )
    5170         430 :     : Attr(attr::OMPDeclareSimdDecl, R, SI, false)
    5171             :               , branchState(BranchState)
    5172             :               , simdlen(Simdlen)
    5173         430 :               , uniforms_Size(UniformsSize), uniforms_(new (Ctx, 16) Expr *[uniforms_Size])
    5174         430 :               , aligneds_Size(AlignedsSize), aligneds_(new (Ctx, 16) Expr *[aligneds_Size])
    5175         430 :               , alignments_Size(AlignmentsSize), alignments_(new (Ctx, 16) Expr *[alignments_Size])
    5176         430 :               , linears_Size(LinearsSize), linears_(new (Ctx, 16) Expr *[linears_Size])
    5177         430 :               , modifiers_Size(ModifiersSize), modifiers_(new (Ctx, 16) unsigned[modifiers_Size])
    5178        3010 :               , steps_Size(StepsSize), steps_(new (Ctx, 16) Expr *[steps_Size])
    5179             :   {
    5180         430 :     std::copy(Uniforms, Uniforms + uniforms_Size, uniforms_);
    5181         430 :     std::copy(Aligneds, Aligneds + aligneds_Size, aligneds_);
    5182         430 :     std::copy(Alignments, Alignments + alignments_Size, alignments_);
    5183         430 :     std::copy(Linears, Linears + linears_Size, linears_);
    5184         430 :     std::copy(Modifiers, Modifiers + modifiers_Size, modifiers_);
    5185         430 :     std::copy(Steps, Steps + steps_Size, steps_);
    5186         430 :   }
    5187             : 
    5188             :   OMPDeclareSimdDeclAttr(SourceRange R, ASTContext &Ctx
    5189             :               , BranchStateTy BranchState
    5190             :               , Expr * Simdlen
    5191             :               , unsigned SI
    5192             :              )
    5193             :     : Attr(attr::OMPDeclareSimdDecl, R, SI, false)
    5194             :               , branchState(BranchState)
    5195             :               , simdlen(Simdlen)
    5196             :               , uniforms_Size(0), uniforms_(nullptr)
    5197             :               , aligneds_Size(0), aligneds_(nullptr)
    5198             :               , alignments_Size(0), alignments_(nullptr)
    5199             :               , linears_Size(0), linears_(nullptr)
    5200             :               , modifiers_Size(0), modifiers_(nullptr)
    5201             :               , steps_Size(0), steps_(nullptr)
    5202             :   {
    5203             :   }
    5204             : 
    5205             :   OMPDeclareSimdDeclAttr *clone(ASTContext &C) const;
    5206             :   void printPretty(raw_ostream &OS,
    5207             :                    const PrintingPolicy &Policy) const;
    5208             :   const char *getSpelling() const;
    5209             :   BranchStateTy getBranchState() const {
    5210             :     return branchState;
    5211             :   }
    5212             : 
    5213         448 :   static bool ConvertStrToBranchStateTy(StringRef Val, BranchStateTy &Out) {
    5214         448 :     Optional<BranchStateTy> R = llvm::StringSwitch<Optional<BranchStateTy>>(Val)
    5215         448 :       .Case("", OMPDeclareSimdDeclAttr::BS_Undefined)
    5216         448 :       .Case("inbranch", OMPDeclareSimdDeclAttr::BS_Inbranch)
    5217         448 :       .Case("notinbranch", OMPDeclareSimdDeclAttr::BS_Notinbranch)
    5218             :       .Default(Optional<BranchStateTy>());
    5219         448 :     if (R) {
    5220          82 :       Out = *R;
    5221          82 :       return true;
    5222             :     }
    5223             :     return false;
    5224             :   }
    5225             : 
    5226             :   static const char *ConvertBranchStateTyToStr(BranchStateTy Val) {
    5227          20 :     switch(Val) {
    5228             :     case OMPDeclareSimdDeclAttr::BS_Undefined: return "";
    5229          10 :     case OMPDeclareSimdDeclAttr::BS_Inbranch: return "inbranch";
    5230          10 :     case OMPDeclareSimdDeclAttr::BS_Notinbranch: return "notinbranch";
    5231             :     }
    5232           0 :     llvm_unreachable("No enumerator with that value");
    5233             :   }
    5234             :   Expr * getSimdlen() const {
    5235             :     return simdlen;
    5236             :   }
    5237             : 
    5238             :   typedef Expr ** uniforms_iterator;
    5239             :   uniforms_iterator uniforms_begin() const { return uniforms_; }
    5240         278 :   uniforms_iterator uniforms_end() const { return uniforms_ + uniforms_Size; }
    5241             :   unsigned uniforms_size() const { return uniforms_Size; }
    5242         274 :   llvm::iterator_range<uniforms_iterator> uniforms() const { return llvm::make_range(uniforms_begin(), uniforms_end()); }
    5243             : 
    5244             : 
    5245             :   typedef Expr ** aligneds_iterator;
    5246             :   aligneds_iterator aligneds_begin() const { return aligneds_; }
    5247         398 :   aligneds_iterator aligneds_end() const { return aligneds_ + aligneds_Size; }
    5248             :   unsigned aligneds_size() const { return aligneds_Size; }
    5249         394 :   llvm::iterator_range<aligneds_iterator> aligneds() const { return llvm::make_range(aligneds_begin(), aligneds_end()); }
    5250             : 
    5251             : 
    5252             :   typedef Expr ** alignments_iterator;
    5253             :   alignments_iterator alignments_begin() const { return alignments_; }
    5254         128 :   alignments_iterator alignments_end() const { return alignments_ + alignments_Size; }
    5255             :   unsigned alignments_size() const { return alignments_Size; }
    5256         124 :   llvm::iterator_range<alignments_iterator> alignments() const { return llvm::make_range(alignments_begin(), alignments_end()); }
    5257             : 
    5258             : 
    5259             :   typedef Expr ** linears_iterator;
    5260             :   linears_iterator linears_begin() const { return linears_; }
    5261         398 :   linears_iterator linears_end() const { return linears_ + linears_Size; }
    5262             :   unsigned linears_size() const { return linears_Size; }
    5263         394 :   llvm::iterator_range<linears_iterator> linears() const { return llvm::make_range(linears_begin(), linears_end()); }
    5264             : 
    5265             : 
    5266             :   typedef unsigned* modifiers_iterator;
    5267             :   modifiers_iterator modifiers_begin() const { return modifiers_; }
    5268         186 :   modifiers_iterator modifiers_end() const { return modifiers_ + modifiers_Size; }
    5269             :   unsigned modifiers_size() const { return modifiers_Size; }
    5270         128 :   llvm::iterator_range<modifiers_iterator> modifiers() const { return llvm::make_range(modifiers_begin(), modifiers_end()); }
    5271             : 
    5272             : 
    5273             :   typedef Expr ** steps_iterator;
    5274             :   steps_iterator steps_begin() const { return steps_; }
    5275         128 :   steps_iterator steps_end() const { return steps_ + steps_Size; }
    5276             :   unsigned steps_size() const { return steps_Size; }
    5277         124 :   llvm::iterator_range<steps_iterator> steps() const { return llvm::make_range(steps_begin(), steps_end()); }
    5278             : 
    5279             : 
    5280             : 
    5281          92 :     void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
    5282             :         const {
    5283          92 :       if (getBranchState() != BS_Undefined)
    5284          32 :         OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
    5285          92 :       if (auto *E = getSimdlen()) {
    5286          28 :         OS << " simdlen(";
    5287          28 :         E->printPretty(OS, nullptr, Policy);
    5288          28 :         OS << ")";
    5289             :       }
    5290          92 :       if (uniforms_size() > 0) {
    5291          20 :         OS << " uniform";
    5292             :         StringRef Sep = "(";
    5293          92 :         for (auto *E : uniforms()) {
    5294          36 :           OS << Sep;
    5295          36 :           E->printPretty(OS, nullptr, Policy);
    5296          36 :           Sep = ", ";
    5297             :         }
    5298          20 :         OS << ")";
    5299             :       }
    5300          92 :       alignments_iterator NI = alignments_begin();
    5301         220 :       for (auto *E : aligneds()) {
    5302          64 :         OS << " aligned(";
    5303          64 :         E->printPretty(OS, nullptr, Policy);
    5304          64 :         if (*NI) {
    5305          28 :           OS << ": ";
    5306          28 :           (*NI)->printPretty(OS, nullptr, Policy);
    5307             :         }
    5308          64 :         OS << ")";
    5309          64 :         ++NI;
    5310             :       }
    5311          92 :       steps_iterator I = steps_begin();
    5312          92 :       modifiers_iterator MI = modifiers_begin();
    5313         196 :       for (auto *E : linears()) {
    5314          52 :         OS << " linear(";
    5315          52 :         if (*MI != OMPC_LINEAR_unknown)
    5316          52 :           OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
    5317          52 :         E->printPretty(OS, nullptr, Policy);
    5318          52 :         if (*MI != OMPC_LINEAR_unknown)
    5319          52 :           OS << ")";
    5320          52 :         if (*I) {
    5321          44 :           OS << ": ";
    5322          44 :           (*I)->printPretty(OS, nullptr, Policy);
    5323             :         }
    5324          52 :         OS << ")";
    5325          52 :         ++I;
    5326          52 :         ++MI;
    5327             :       }
    5328          92 :     }
    5329             :   
    5330             : 
    5331             :   static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareSimdDecl; }
    5332             : };
    5333             : 
    5334             : class OMPDeclareTargetDeclAttr : public Attr {
    5335             : public:
    5336             :   enum MapTypeTy {
    5337             :     MT_To,
    5338             :     MT_Link
    5339             :   };
    5340             : private:
    5341             :   MapTypeTy mapType;
    5342             : 
    5343             : public:
    5344         276 :   static OMPDeclareTargetDeclAttr *CreateImplicit(ASTContext &Ctx, MapTypeTy MapType, SourceRange Loc = SourceRange()) {
    5345         276 :     auto *A = new (Ctx) OMPDeclareTargetDeclAttr(Loc, Ctx, MapType, 0);
    5346             :     A->setImplicit(true);
    5347         276 :     return A;
    5348             :   }
    5349             : 
    5350             :   OMPDeclareTargetDeclAttr(SourceRange R, ASTContext &Ctx
    5351             :               , MapTypeTy MapType
    5352             :               , unsigned SI
    5353             :              )
    5354         368 :     : Attr(attr::OMPDeclareTargetDecl, R, SI, false)
    5355         368 :               , mapType(MapType)
    5356             :   {
    5357             :   }
    5358             : 
    5359             :   OMPDeclareTargetDeclAttr *clone(ASTContext &C) const;
    5360             :   void printPretty(raw_ostream &OS,
    5361             :                    const PrintingPolicy &Policy) const;
    5362             :   const char *getSpelling() const;
    5363             :   MapTypeTy getMapType() const {
    5364             :     return mapType;
    5365             :   }
    5366             : 
    5367          48 :   static bool ConvertStrToMapTypeTy(StringRef Val, MapTypeTy &Out) {
    5368          48 :     Optional<MapTypeTy> R = llvm::StringSwitch<Optional<MapTypeTy>>(Val)
    5369          48 :       .Case("to", OMPDeclareTargetDeclAttr::MT_To)
    5370          48 :       .Case("link", OMPDeclareTargetDeclAttr::MT_Link)
    5371             :       .Default(Optional<MapTypeTy>());
    5372          48 :     if (R) {
    5373          46 :       Out = *R;
    5374          46 :       return true;
    5375             :     }
    5376             :     return false;
    5377             :   }
    5378             : 
    5379             :   static const char *ConvertMapTypeTyToStr(MapTypeTy Val) {
    5380          12 :     switch(Val) {
    5381             :     case OMPDeclareTargetDeclAttr::MT_To: return "to";
    5382          12 :     case OMPDeclareTargetDeclAttr::MT_Link: return "link";
    5383             :     }
    5384           0 :     llvm_unreachable("No enumerator with that value");
    5385             :   }
    5386             : 
    5387          96 :     void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5388             :       // Use fake syntax because it is for testing and debugging purpose only.
    5389          96 :       if (getMapType() != MT_To)
    5390          24 :         OS << ' ' << ConvertMapTypeTyToStr(getMapType());
    5391          96 :     }
    5392             :   
    5393             : 
    5394             :   static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareTargetDecl; }
    5395             : };
    5396             : 
    5397             : class OMPReferencedVarAttr : public Attr {
    5398             : Expr * ref;
    5399             : 
    5400             : public:
    5401      101207 :   static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, SourceRange Loc = SourceRange()) {
    5402      101207 :     auto *A = new (Ctx) OMPReferencedVarAttr(Loc, Ctx, Ref, 0);
    5403             :     A->setImplicit(true);
    5404      101207 :     return A;
    5405             :   }
    5406             : 
    5407             :   OMPReferencedVarAttr(SourceRange R, ASTContext &Ctx
    5408             :               , Expr * Ref
    5409             :               , unsigned SI
    5410             :              )
    5411      109301 :     : Attr(attr::OMPReferencedVar, R, SI, false)
    5412      109301 :               , ref(Ref)
    5413             :   {
    5414             :   }
    5415             : 
    5416             :   OMPReferencedVarAttr *clone(ASTContext &C) const;
    5417             :   void printPretty(raw_ostream &OS,
    5418             :                    const PrintingPolicy &Policy) const;
    5419             :   const char *getSpelling() const;
    5420             :   Expr * getRef() const {
    5421             :     return ref;
    5422             :   }
    5423             : 
    5424             : 
    5425             : 
    5426             :   static bool classof(const Attr *A) { return A->getKind() == attr::OMPReferencedVar; }
    5427             : };
    5428             : 
    5429             : class OMPThreadPrivateDeclAttr : public InheritableAttr {
    5430             : public:
    5431        1621 :   static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5432        1621 :     auto *A = new (Ctx) OMPThreadPrivateDeclAttr(Loc, Ctx, 0);
    5433             :     A->setImplicit(true);
    5434        1621 :     return A;
    5435             :   }
    5436             : 
    5437             :   OMPThreadPrivateDeclAttr(SourceRange R, ASTContext &Ctx
    5438             :               , unsigned SI
    5439             :              )
    5440             :     : InheritableAttr(attr::OMPThreadPrivateDecl, R, SI, false, false)
    5441             :   {
    5442             :   }
    5443             : 
    5444             :   OMPThreadPrivateDeclAttr *clone(ASTContext &C) const;
    5445             :   void printPretty(raw_ostream &OS,
    5446             :                    const PrintingPolicy &Policy) const;
    5447             :   const char *getSpelling() const;
    5448             : 
    5449             : 
    5450             :   static bool classof(const Attr *A) { return A->getKind() == attr::OMPThreadPrivateDecl; }
    5451             : };
    5452             : 
    5453             : class ObjCBoxableAttr : public Attr {
    5454             : public:
    5455             :   static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5456             :     auto *A = new (Ctx) ObjCBoxableAttr(Loc, Ctx, 0);
    5457             :     A->setImplicit(true);
    5458             :     return A;
    5459             :   }
    5460             : 
    5461             :   ObjCBoxableAttr(SourceRange R, ASTContext &Ctx
    5462             :               , unsigned SI
    5463             :              )
    5464             :     : Attr(attr::ObjCBoxable, R, SI, false)
    5465             :   {
    5466             :   }
    5467             : 
    5468             :   ObjCBoxableAttr *clone(ASTContext &C) const;
    5469             :   void printPretty(raw_ostream &OS,
    5470             :                    const PrintingPolicy &Policy) const;
    5471             :   const char *getSpelling() const;
    5472             : 
    5473             : 
    5474             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBoxable; }
    5475             : };
    5476             : 
    5477             : class ObjCBridgeAttr : public InheritableAttr {
    5478             : IdentifierInfo * bridgedType;
    5479             : 
    5480             : public:
    5481             :   static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
    5482             :     auto *A = new (Ctx) ObjCBridgeAttr(Loc, Ctx, BridgedType, 0);
    5483             :     A->setImplicit(true);
    5484             :     return A;
    5485             :   }
    5486             : 
    5487             :   ObjCBridgeAttr(SourceRange R, ASTContext &Ctx
    5488             :               , IdentifierInfo * BridgedType
    5489             :               , unsigned SI
    5490             :              )
    5491          49 :     : InheritableAttr(attr::ObjCBridge, R, SI, false, false)
    5492          49 :               , bridgedType(BridgedType)
    5493             :   {
    5494             :   }
    5495             : 
    5496             :   ObjCBridgeAttr *clone(ASTContext &C) const;
    5497             :   void printPretty(raw_ostream &OS,
    5498             :                    const PrintingPolicy &Policy) const;
    5499             :   const char *getSpelling() const;
    5500             :   IdentifierInfo * getBridgedType() const {
    5501             :     return bridgedType;
    5502             :   }
    5503             : 
    5504             : 
    5505             : 
    5506             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridge; }
    5507             : };
    5508             : 
    5509             : class ObjCBridgeMutableAttr : public InheritableAttr {
    5510             : IdentifierInfo * bridgedType;
    5511             : 
    5512             : public:
    5513             :   static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
    5514             :     auto *A = new (Ctx) ObjCBridgeMutableAttr(Loc, Ctx, BridgedType, 0);
    5515             :     A->setImplicit(true);
    5516             :     return A;
    5517             :   }
    5518             : 
    5519             :   ObjCBridgeMutableAttr(SourceRange R, ASTContext &Ctx
    5520             :               , IdentifierInfo * BridgedType
    5521             :               , unsigned SI
    5522             :              )
    5523           6 :     : InheritableAttr(attr::ObjCBridgeMutable, R, SI, false, false)
    5524           6 :               , bridgedType(BridgedType)
    5525             :   {
    5526             :   }
    5527             : 
    5528             :   ObjCBridgeMutableAttr *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::ObjCBridgeMutable; }
    5539             : };
    5540             : 
    5541             : class ObjCBridgeRelatedAttr : public InheritableAttr {
    5542             : IdentifierInfo * relatedClass;
    5543             : 
    5544             : IdentifierInfo * classMethod;
    5545             : 
    5546             : IdentifierInfo * instanceMethod;
    5547             : 
    5548             : public:
    5549             :   static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Loc = SourceRange()) {
    5550             :     auto *A = new (Ctx) ObjCBridgeRelatedAttr(Loc, Ctx, RelatedClass, ClassMethod, InstanceMethod, 0);
    5551             :     A->setImplicit(true);
    5552             :     return A;
    5553             :   }
    5554             : 
    5555             :   ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx
    5556             :               , IdentifierInfo * RelatedClass
    5557             :               , IdentifierInfo * ClassMethod
    5558             :               , IdentifierInfo * InstanceMethod
    5559             :               , unsigned SI
    5560             :              )
    5561          26 :     : InheritableAttr(attr::ObjCBridgeRelated, R, SI, false, false)
    5562             :               , relatedClass(RelatedClass)
    5563             :               , classMethod(ClassMethod)
    5564          26 :               , instanceMethod(InstanceMethod)
    5565             :   {
    5566             :   }
    5567             : 
    5568             :   ObjCBridgeRelatedAttr *clone(ASTContext &C) const;
    5569             :   void printPretty(raw_ostream &OS,
    5570             :                    const PrintingPolicy &Policy) const;
    5571             :   const char *getSpelling() const;
    5572             :   IdentifierInfo * getRelatedClass() const {
    5573             :     return relatedClass;
    5574             :   }
    5575             : 
    5576             :   IdentifierInfo * getClassMethod() const {
    5577             :     return classMethod;
    5578             :   }
    5579             : 
    5580             :   IdentifierInfo * getInstanceMethod() const {
    5581             :     return instanceMethod;
    5582             :   }
    5583             : 
    5584             : 
    5585             : 
    5586             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeRelated; }
    5587             : };
    5588             : 
    5589             : class ObjCDesignatedInitializerAttr : public Attr {
    5590             : public:
    5591             :   static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5592             :     auto *A = new (Ctx) ObjCDesignatedInitializerAttr(Loc, Ctx, 0);
    5593             :     A->setImplicit(true);
    5594             :     return A;
    5595             :   }
    5596             : 
    5597             :   ObjCDesignatedInitializerAttr(SourceRange R, ASTContext &Ctx
    5598             :               , unsigned SI
    5599             :              )
    5600             :     : Attr(attr::ObjCDesignatedInitializer, R, SI, false)
    5601             :   {
    5602             :   }
    5603             : 
    5604             :   ObjCDesignatedInitializerAttr *clone(ASTContext &C) const;
    5605             :   void printPretty(raw_ostream &OS,
    5606             :                    const PrintingPolicy &Policy) const;
    5607             :   const char *getSpelling() const;
    5608             : 
    5609             : 
    5610             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDesignatedInitializer; }
    5611             : };
    5612             : 
    5613             : class ObjCExceptionAttr : public InheritableAttr {
    5614             : public:
    5615             :   static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5616             :     auto *A = new (Ctx) ObjCExceptionAttr(Loc, Ctx, 0);
    5617             :     A->setImplicit(true);
    5618             :     return A;
    5619             :   }
    5620             : 
    5621             :   ObjCExceptionAttr(SourceRange R, ASTContext &Ctx
    5622             :               , unsigned SI
    5623             :              )
    5624             :     : InheritableAttr(attr::ObjCException, R, SI, false, false)
    5625             :   {
    5626             :   }
    5627             : 
    5628             :   ObjCExceptionAttr *clone(ASTContext &C) const;
    5629             :   void printPretty(raw_ostream &OS,
    5630             :                    const PrintingPolicy &Policy) const;
    5631             :   const char *getSpelling() const;
    5632             : 
    5633             : 
    5634             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCException; }
    5635             : };
    5636             : 
    5637             : class ObjCExplicitProtocolImplAttr : public InheritableAttr {
    5638             : public:
    5639             :   static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5640             :     auto *A = new (Ctx) ObjCExplicitProtocolImplAttr(Loc, Ctx, 0);
    5641             :     A->setImplicit(true);
    5642             :     return A;
    5643             :   }
    5644             : 
    5645             :   ObjCExplicitProtocolImplAttr(SourceRange R, ASTContext &Ctx
    5646             :               , unsigned SI
    5647             :              )
    5648             :     : InheritableAttr(attr::ObjCExplicitProtocolImpl, R, SI, false, false)
    5649             :   {
    5650             :   }
    5651             : 
    5652             :   ObjCExplicitProtocolImplAttr *clone(ASTContext &C) const;
    5653             :   void printPretty(raw_ostream &OS,
    5654             :                    const PrintingPolicy &Policy) const;
    5655             :   const char *getSpelling() const;
    5656             : 
    5657             : 
    5658             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExplicitProtocolImpl; }
    5659             : };
    5660             : 
    5661             : class ObjCIndependentClassAttr : public InheritableAttr {
    5662             : public:
    5663             :   static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5664             :     auto *A = new (Ctx) ObjCIndependentClassAttr(Loc, Ctx, 0);
    5665             :     A->setImplicit(true);
    5666             :     return A;
    5667             :   }
    5668             : 
    5669             :   ObjCIndependentClassAttr(SourceRange R, ASTContext &Ctx
    5670             :               , unsigned SI
    5671             :              )
    5672             :     : InheritableAttr(attr::ObjCIndependentClass, R, SI, false, false)
    5673             :   {
    5674             :   }
    5675             : 
    5676             :   ObjCIndependentClassAttr *clone(ASTContext &C) const;
    5677             :   void printPretty(raw_ostream &OS,
    5678             :                    const PrintingPolicy &Policy) const;
    5679             :   const char *getSpelling() const;
    5680             : 
    5681             : 
    5682             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCIndependentClass; }
    5683             : };
    5684             : 
    5685             : class ObjCMethodFamilyAttr : public InheritableAttr {
    5686             : public:
    5687             :   enum FamilyKind {
    5688             :     OMF_None,
    5689             :     OMF_alloc,
    5690             :     OMF_copy,
    5691             :     OMF_init,
    5692             :     OMF_mutableCopy,
    5693             :     OMF_new
    5694             :   };
    5695             : private:
    5696             :   FamilyKind family;
    5697             : 
    5698             : public:
    5699             :   static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, FamilyKind Family, SourceRange Loc = SourceRange()) {
    5700             :     auto *A = new (Ctx) ObjCMethodFamilyAttr(Loc, Ctx, Family, 0);
    5701             :     A->setImplicit(true);
    5702             :     return A;
    5703             :   }
    5704             : 
    5705             :   ObjCMethodFamilyAttr(SourceRange R, ASTContext &Ctx
    5706             :               , FamilyKind Family
    5707             :               , unsigned SI
    5708             :              )
    5709          20 :     : InheritableAttr(attr::ObjCMethodFamily, R, SI, false, false)
    5710          20 :               , family(Family)
    5711             :   {
    5712             :   }
    5713             : 
    5714             :   ObjCMethodFamilyAttr *clone(ASTContext &C) const;
    5715             :   void printPretty(raw_ostream &OS,
    5716             :                    const PrintingPolicy &Policy) const;
    5717             :   const char *getSpelling() const;
    5718             :   FamilyKind getFamily() const {
    5719             :     return family;
    5720             :   }
    5721             : 
    5722          11 :   static bool ConvertStrToFamilyKind(StringRef Val, FamilyKind &Out) {
    5723          11 :     Optional<FamilyKind> R = llvm::StringSwitch<Optional<FamilyKind>>(Val)
    5724          11 :       .Case("none", ObjCMethodFamilyAttr::OMF_None)
    5725          11 :       .Case("alloc", ObjCMethodFamilyAttr::OMF_alloc)
    5726          11 :       .Case("copy", ObjCMethodFamilyAttr::OMF_copy)
    5727          11 :       .Case("init", ObjCMethodFamilyAttr::OMF_init)
    5728          11 :       .Case("mutableCopy", ObjCMethodFamilyAttr::OMF_mutableCopy)
    5729          11 :       .Case("new", ObjCMethodFamilyAttr::OMF_new)
    5730             :       .Default(Optional<FamilyKind>());
    5731          11 :     if (R) {
    5732          11 :       Out = *R;
    5733          11 :       return true;
    5734             :     }
    5735             :     return false;
    5736             :   }
    5737             : 
    5738             :   static const char *ConvertFamilyKindToStr(FamilyKind Val) {
    5739           0 :     switch(Val) {
    5740             :     case ObjCMethodFamilyAttr::OMF_None: return "none";
    5741           0 :     case ObjCMethodFamilyAttr::OMF_alloc: return "alloc";
    5742           0 :     case ObjCMethodFamilyAttr::OMF_copy: return "copy";
    5743           0 :     case ObjCMethodFamilyAttr::OMF_init: return "init";
    5744           0 :     case ObjCMethodFamilyAttr::OMF_mutableCopy: return "mutableCopy";
    5745           0 :     case ObjCMethodFamilyAttr::OMF_new: return "new";
    5746             :     }
    5747           0 :     llvm_unreachable("No enumerator with that value");
    5748             :   }
    5749             : 
    5750             : 
    5751             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; }
    5752             : };
    5753             : 
    5754             : class ObjCNSObjectAttr : public InheritableAttr {
    5755             : public:
    5756             :   static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5757             :     auto *A = new (Ctx) ObjCNSObjectAttr(Loc, Ctx, 0);
    5758             :     A->setImplicit(true);
    5759             :     return A;
    5760             :   }
    5761             : 
    5762             :   ObjCNSObjectAttr(SourceRange R, ASTContext &Ctx
    5763             :               , unsigned SI
    5764             :              )
    5765             :     : InheritableAttr(attr::ObjCNSObject, R, SI, false, false)
    5766             :   {
    5767             :   }
    5768             : 
    5769             :   ObjCNSObjectAttr *clone(ASTContext &C) const;
    5770             :   void printPretty(raw_ostream &OS,
    5771             :                    const PrintingPolicy &Policy) const;
    5772             :   const char *getSpelling() const;
    5773             : 
    5774             : 
    5775             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNSObject; }
    5776             : };
    5777             : 
    5778             : class ObjCPreciseLifetimeAttr : public InheritableAttr {
    5779             : public:
    5780             :   static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5781             :     auto *A = new (Ctx) ObjCPreciseLifetimeAttr(Loc, Ctx, 0);
    5782             :     A->setImplicit(true);
    5783             :     return A;
    5784             :   }
    5785             : 
    5786             :   ObjCPreciseLifetimeAttr(SourceRange R, ASTContext &Ctx
    5787             :               , unsigned SI
    5788             :              )
    5789             :     : InheritableAttr(attr::ObjCPreciseLifetime, R, SI, false, false)
    5790             :   {
    5791             :   }
    5792             : 
    5793             :   ObjCPreciseLifetimeAttr *clone(ASTContext &C) const;
    5794             :   void printPretty(raw_ostream &OS,
    5795             :                    const PrintingPolicy &Policy) const;
    5796             :   const char *getSpelling() const;
    5797             : 
    5798             : 
    5799             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCPreciseLifetime; }
    5800             : };
    5801             : 
    5802             : class ObjCRequiresPropertyDefsAttr : public InheritableAttr {
    5803             : public:
    5804             :   static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5805             :     auto *A = new (Ctx) ObjCRequiresPropertyDefsAttr(Loc, Ctx, 0);
    5806             :     A->setImplicit(true);
    5807             :     return A;
    5808             :   }
    5809             : 
    5810             :   ObjCRequiresPropertyDefsAttr(SourceRange R, ASTContext &Ctx
    5811             :               , unsigned SI
    5812             :              )
    5813             :     : InheritableAttr(attr::ObjCRequiresPropertyDefs, R, SI, false, false)
    5814             :   {
    5815             :   }
    5816             : 
    5817             :   ObjCRequiresPropertyDefsAttr *clone(ASTContext &C) const;
    5818             :   void printPretty(raw_ostream &OS,
    5819             :                    const PrintingPolicy &Policy) const;
    5820             :   const char *getSpelling() const;
    5821             : 
    5822             : 
    5823             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresPropertyDefs; }
    5824             : };
    5825             : 
    5826             : class ObjCRequiresSuperAttr : public InheritableAttr {
    5827             : public:
    5828          80 :   static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5829          80 :     auto *A = new (Ctx) ObjCRequiresSuperAttr(Loc, Ctx, 0);
    5830             :     A->setImplicit(true);
    5831          80 :     return A;
    5832             :   }
    5833             : 
    5834             :   ObjCRequiresSuperAttr(SourceRange R, ASTContext &Ctx
    5835             :               , unsigned SI
    5836             :              )
    5837             :     : InheritableAttr(attr::ObjCRequiresSuper, R, SI, false, false)
    5838             :   {
    5839             :   }
    5840             : 
    5841             :   ObjCRequiresSuperAttr *clone(ASTContext &C) const;
    5842             :   void printPretty(raw_ostream &OS,
    5843             :                    const PrintingPolicy &Policy) const;
    5844             :   const char *getSpelling() const;
    5845             : 
    5846             : 
    5847             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresSuper; }
    5848             : };
    5849             : 
    5850             : class ObjCReturnsInnerPointerAttr : public InheritableAttr {
    5851             : public:
    5852          11 :   static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5853          11 :     auto *A = new (Ctx) ObjCReturnsInnerPointerAttr(Loc, Ctx, 0);
    5854             :     A->setImplicit(true);
    5855          11 :     return A;
    5856             :   }
    5857             : 
    5858             :   ObjCReturnsInnerPointerAttr(SourceRange R, ASTContext &Ctx
    5859             :               , unsigned SI
    5860             :              )
    5861             :     : InheritableAttr(attr::ObjCReturnsInnerPointer, R, SI, false, false)
    5862             :   {
    5863             :   }
    5864             : 
    5865             :   ObjCReturnsInnerPointerAttr *clone(ASTContext &C) const;
    5866             :   void printPretty(raw_ostream &OS,
    5867             :                    const PrintingPolicy &Policy) const;
    5868             :   const char *getSpelling() const;
    5869             : 
    5870             : 
    5871             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCReturnsInnerPointer; }
    5872             : };
    5873             : 
    5874             : class ObjCRootClassAttr : public InheritableAttr {
    5875             : public:
    5876             :   static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5877             :     auto *A = new (Ctx) ObjCRootClassAttr(Loc, Ctx, 0);
    5878             :     A->setImplicit(true);
    5879             :     return A;
    5880             :   }
    5881             : 
    5882             :   ObjCRootClassAttr(SourceRange R, ASTContext &Ctx
    5883             :               , unsigned SI
    5884             :              )
    5885             :     : InheritableAttr(attr::ObjCRootClass, R, SI, false, false)
    5886             :   {
    5887             :   }
    5888             : 
    5889             :   ObjCRootClassAttr *clone(ASTContext &C) const;
    5890             :   void printPretty(raw_ostream &OS,
    5891             :                    const PrintingPolicy &Policy) const;
    5892             :   const char *getSpelling() const;
    5893             : 
    5894             : 
    5895             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRootClass; }
    5896             : };
    5897             : 
    5898             : class ObjCRuntimeNameAttr : public Attr {
    5899             : unsigned metadataNameLength;
    5900             : char *metadataName;
    5901             : 
    5902             : public:
    5903             :   static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Loc = SourceRange()) {
    5904             :     auto *A = new (Ctx) ObjCRuntimeNameAttr(Loc, Ctx, MetadataName, 0);
    5905             :     A->setImplicit(true);
    5906             :     return A;
    5907             :   }
    5908             : 
    5909          28 :   ObjCRuntimeNameAttr(SourceRange R, ASTContext &Ctx
    5910             :               , llvm::StringRef MetadataName
    5911             :               , unsigned SI
    5912             :              )
    5913          28 :     : Attr(attr::ObjCRuntimeName, R, SI, false)
    5914          56 :               , metadataNameLength(MetadataName.size()),metadataName(new (Ctx, 1) char[metadataNameLength])
    5915             :   {
    5916          28 :       if (!MetadataName.empty())
    5917          56 :         std::memcpy(metadataName, MetadataName.data(), metadataNameLength);
    5918          28 :   }
    5919             : 
    5920             :   ObjCRuntimeNameAttr *clone(ASTContext &C) const;
    5921             :   void printPretty(raw_ostream &OS,
    5922             :                    const PrintingPolicy &Policy) const;
    5923             :   const char *getSpelling() const;
    5924             :   llvm::StringRef getMetadataName() const {
    5925         182 :     return llvm::StringRef(metadataName, metadataNameLength);
    5926             :   }
    5927             :   unsigned getMetadataNameLength() const {
    5928             :     return metadataNameLength;
    5929             :   }
    5930             :   void setMetadataName(ASTContext &C, llvm::StringRef S) {
    5931             :     metadataNameLength = S.size();
    5932             :     this->metadataName = new (C, 1) char [metadataNameLength];
    5933             :     if (!S.empty())
    5934             :       std::memcpy(this->metadataName, S.data(), metadataNameLength);
    5935             :   }
    5936             : 
    5937             : 
    5938             : 
    5939             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeName; }
    5940             : };
    5941             : 
    5942             : class ObjCRuntimeVisibleAttr : public Attr {
    5943             : public:
    5944             :   static ObjCRuntimeVisibleAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5945             :     auto *A = new (Ctx) ObjCRuntimeVisibleAttr(Loc, Ctx, 0);
    5946             :     A->setImplicit(true);
    5947             :     return A;
    5948             :   }
    5949             : 
    5950             :   ObjCRuntimeVisibleAttr(SourceRange R, ASTContext &Ctx
    5951             :               , unsigned SI
    5952             :              )
    5953             :     : Attr(attr::ObjCRuntimeVisible, R, SI, false)
    5954             :   {
    5955             :   }
    5956             : 
    5957             :   ObjCRuntimeVisibleAttr *clone(ASTContext &C) const;
    5958             :   void printPretty(raw_ostream &OS,
    5959             :                    const PrintingPolicy &Policy) const;
    5960             :   const char *getSpelling() const;
    5961             : 
    5962             : 
    5963             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeVisible; }
    5964             : };
    5965             : 
    5966             : class ObjCSubclassingRestrictedAttr : public InheritableAttr {
    5967             : public:
    5968             :   static ObjCSubclassingRestrictedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    5969             :     auto *A = new (Ctx) ObjCSubclassingRestrictedAttr(Loc, Ctx, 0);
    5970             :     A->setImplicit(true);
    5971             :     return A;
    5972             :   }
    5973             : 
    5974             :   ObjCSubclassingRestrictedAttr(SourceRange R, ASTContext &Ctx
    5975             :               , unsigned SI
    5976             :              )
    5977             :     : InheritableAttr(attr::ObjCSubclassingRestricted, R, SI, false, false)
    5978             :   {
    5979             :   }
    5980             : 
    5981             :   ObjCSubclassingRestrictedAttr *clone(ASTContext &C) const;
    5982             :   void printPretty(raw_ostream &OS,
    5983             :                    const PrintingPolicy &Policy) const;
    5984             :   const char *getSpelling() const;
    5985             : 
    5986             : 
    5987             :   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCSubclassingRestricted; }
    5988             : };
    5989             : 
    5990             : class OpenCLAccessAttr : public Attr {
    5991             : public:
    5992             :   enum Spelling {
    5993             :     Keyword_read_only = 0,
    5994             :     Keyword_write_only = 2,
    5995             :     Keyword_read_write = 4
    5996             :   };
    5997             : 
    5998             :   static OpenCLAccessAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    5999             :     auto *A = new (Ctx) OpenCLAccessAttr(Loc, Ctx, S);
    6000             :     A->setImplicit(true);
    6001             :     return A;
    6002             :   }
    6003             : 
    6004             :   OpenCLAccessAttr(SourceRange R, ASTContext &Ctx
    6005             :               , unsigned SI
    6006             :              )
    6007             :     : Attr(attr::OpenCLAccess, R, SI, false)
    6008             :   {
    6009             :   }
    6010             : 
    6011             :   OpenCLAccessAttr *clone(ASTContext &C) const;
    6012             :   void printPretty(raw_ostream &OS,
    6013             :                    const PrintingPolicy &Policy) const;
    6014             :   const char *getSpelling() const;
    6015             :   Spelling getSemanticSpelling() const {
    6016             :   switch (SpellingListIndex) {
    6017             :     default: llvm_unreachable("Unknown spelling list index");
    6018             :     case 0: return Keyword_read_only;
    6019             :     case 1: return Keyword_read_only;
    6020             :     case 2: return Keyword_write_only;
    6021             :     case 3: return Keyword_write_only;
    6022             :     case 4: return Keyword_read_write;
    6023             :     case 5: return Keyword_read_write;
    6024             :   }
    6025             :   }
    6026          27 :   bool isReadOnly() const { return SpellingListIndex == 0 ||
    6027             :     SpellingListIndex == 1; }
    6028          12 :   bool isReadWrite() const { return SpellingListIndex == 4 ||
    6029             :     SpellingListIndex == 5; }
    6030          44 :   bool isWriteOnly() const { return SpellingListIndex == 2 ||
    6031             :     SpellingListIndex == 3; }
    6032             : 
    6033             : 
    6034             :   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLAccess; }
    6035             : };
    6036             : 
    6037             : class OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
    6038             : unsigned subGroupSize;
    6039             : 
    6040             : public:
    6041             :   static OpenCLIntelReqdSubGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned SubGroupSize, SourceRange Loc = SourceRange()) {
    6042             :     auto *A = new (Ctx) OpenCLIntelReqdSubGroupSizeAttr(Loc, Ctx, SubGroupSize, 0);
    6043             :     A->setImplicit(true);
    6044             :     return A;
    6045             :   }
    6046             : 
    6047             :   OpenCLIntelReqdSubGroupSizeAttr(SourceRange R, ASTContext &Ctx
    6048             :               , unsigned SubGroupSize
    6049             :               , unsigned SI
    6050             :              )
    6051           5 :     : InheritableAttr(attr::OpenCLIntelReqdSubGroupSize, R, SI, false, false)
    6052           5 :               , subGroupSize(SubGroupSize)
    6053             :   {
    6054             :   }
    6055             : 
    6056             :   OpenCLIntelReqdSubGroupSizeAttr *clone(ASTContext &C) const;
    6057             :   void printPretty(raw_ostream &OS,
    6058             :                    const PrintingPolicy &Policy) const;
    6059             :   const char *getSpelling() const;
    6060             :   unsigned getSubGroupSize() const {
    6061             :     return subGroupSize;
    6062             :   }
    6063             : 
    6064             : 
    6065             : 
    6066             :   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLIntelReqdSubGroupSize; }
    6067             : };
    6068             : 
    6069             : class OpenCLKernelAttr : public InheritableAttr {
    6070             : public:
    6071             :   static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6072             :     auto *A = new (Ctx) OpenCLKernelAttr(Loc, Ctx, 0);
    6073             :     A->setImplicit(true);
    6074             :     return A;
    6075             :   }
    6076             : 
    6077             :   OpenCLKernelAttr(SourceRange R, ASTContext &Ctx
    6078             :               , unsigned SI
    6079             :              )
    6080             :     : InheritableAttr(attr::OpenCLKernel, R, SI, false, false)
    6081             :   {
    6082             :   }
    6083             : 
    6084             :   OpenCLKernelAttr *clone(ASTContext &C) const;
    6085             :   void printPretty(raw_ostream &OS,
    6086             :                    const PrintingPolicy &Policy) const;
    6087             :   const char *getSpelling() const;
    6088             : 
    6089             : 
    6090             :   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLKernel; }
    6091             : };
    6092             : 
    6093             : class OpenCLUnrollHintAttr : public InheritableAttr {
    6094             : unsigned unrollHint;
    6095             : 
    6096             : public:
    6097          18 :   static OpenCLUnrollHintAttr *CreateImplicit(ASTContext &Ctx, unsigned UnrollHint, SourceRange Loc = SourceRange()) {
    6098          18 :     auto *A = new (Ctx) OpenCLUnrollHintAttr(Loc, Ctx, UnrollHint, 0);
    6099             :     A->setImplicit(true);
    6100          18 :     return A;
    6101             :   }
    6102             : 
    6103             :   OpenCLUnrollHintAttr(SourceRange R, ASTContext &Ctx
    6104             :               , unsigned UnrollHint
    6105             :               , unsigned SI
    6106             :              )
    6107          18 :     : InheritableAttr(attr::OpenCLUnrollHint, R, SI, false, false)
    6108          18 :               , unrollHint(UnrollHint)
    6109             :   {
    6110             :   }
    6111             : 
    6112             :   OpenCLUnrollHintAttr *clone(ASTContext &C) const;
    6113             :   void printPretty(raw_ostream &OS,
    6114             :                    const PrintingPolicy &Policy) const;
    6115             :   const char *getSpelling() const;
    6116             :   unsigned getUnrollHint() const {
    6117             :     return unrollHint;
    6118             :   }
    6119             : 
    6120             : 
    6121             : 
    6122             :   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLUnrollHint; }
    6123             : };
    6124             : 
    6125             : class OptimizeNoneAttr : public InheritableAttr {
    6126             : public:
    6127          22 :   static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6128          22 :     auto *A = new (Ctx) OptimizeNoneAttr(Loc, Ctx, 0);
    6129             :     A->setImplicit(true);
    6130          22 :     return A;
    6131             :   }
    6132             : 
    6133             :   OptimizeNoneAttr(SourceRange R, ASTContext &Ctx
    6134             :               , unsigned SI
    6135             :              )
    6136             :     : InheritableAttr(attr::OptimizeNone, R, SI, false, false)
    6137             :   {
    6138             :   }
    6139             : 
    6140             :   OptimizeNoneAttr *clone(ASTContext &C) const;
    6141             :   void printPretty(raw_ostream &OS,
    6142             :                    const PrintingPolicy &Policy) const;
    6143             :   const char *getSpelling() const;
    6144             : 
    6145             : 
    6146             :   static bool classof(const Attr *A) { return A->getKind() == attr::OptimizeNone; }
    6147             : };
    6148             : 
    6149             : class OverloadableAttr : public Attr {
    6150             : public:
    6151          18 :   static OverloadableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6152          18 :     auto *A = new (Ctx) OverloadableAttr(Loc, Ctx, 0);
    6153             :     A->setImplicit(true);
    6154          18 :     return A;
    6155             :   }
    6156             : 
    6157             :   OverloadableAttr(SourceRange R, ASTContext &Ctx
    6158             :               , unsigned SI
    6159             :              )
    6160             :     : Attr(attr::Overloadable, R, SI, false)
    6161             :   {
    6162             :   }
    6163             : 
    6164             :   OverloadableAttr *clone(ASTContext &C) const;
    6165             :   void printPretty(raw_ostream &OS,
    6166             :                    const PrintingPolicy &Policy) const;
    6167             :   const char *getSpelling() const;
    6168             : 
    6169             : 
    6170           4 :   static bool classof(const Attr *A) { return A->getKind() == attr::Overloadable; }
    6171             : };
    6172             : 
    6173             : class OverrideAttr : public InheritableAttr {
    6174             : public:
    6175             :   static OverrideAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6176             :     auto *A = new (Ctx) OverrideAttr(Loc, Ctx, 0);
    6177             :     A->setImplicit(true);
    6178             :     return A;
    6179             :   }
    6180             : 
    6181             :   OverrideAttr(SourceRange R, ASTContext &Ctx
    6182             :               , unsigned SI
    6183             :              )
    6184             :     : InheritableAttr(attr::Override, R, SI, false, false)
    6185             :   {
    6186             :   }
    6187             : 
    6188             :   OverrideAttr *clone(ASTContext &C) const;
    6189             :   void printPretty(raw_ostream &OS,
    6190             :                    const PrintingPolicy &Policy) const;
    6191             :   const char *getSpelling() const;
    6192             : 
    6193             : 
    6194           8 :   static bool classof(const Attr *A) { return A->getKind() == attr::Override; }
    6195             : };
    6196             : 
    6197             : class OwnershipAttr : public InheritableAttr {
    6198             : IdentifierInfo * module;
    6199             : 
    6200             :   unsigned args_Size;
    6201             :   ParamIdx *args_;
    6202             : 
    6203             : public:
    6204             :   enum Spelling {
    6205             :     GNU_ownership_holds = 0,
    6206             :     CXX11_clang_ownership_holds = 1,
    6207             :     C2x_clang_ownership_holds = 2,
    6208             :     GNU_ownership_returns = 3,
    6209             :     CXX11_clang_ownership_returns = 4,
    6210             :     C2x_clang_ownership_returns = 5,
    6211             :     GNU_ownership_takes = 6,
    6212             :     CXX11_clang_ownership_takes = 7,
    6213             :     C2x_clang_ownership_takes = 8
    6214             :   };
    6215             : 
    6216             :   static OwnershipAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * Module, ParamIdx *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
    6217             :     auto *A = new (Ctx) OwnershipAttr(Loc, Ctx, Module, Args, ArgsSize, S);
    6218             :     A->setImplicit(true);
    6219             :     return A;
    6220             :   }
    6221             : 
    6222          90 :   OwnershipAttr(SourceRange R, ASTContext &Ctx
    6223             :               , IdentifierInfo * Module
    6224             :               , ParamIdx *Args, unsigned ArgsSize
    6225             :               , unsigned SI
    6226             :              )
    6227          90 :     : InheritableAttr(attr::Ownership, R, SI, false, false)
    6228             :               , module(Module)
    6229         229 :               , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[args_Size])
    6230             :   {
    6231          90 :     std::copy(Args, Args + args_Size, args_);
    6232          90 :   }
    6233             : 
    6234             :   OwnershipAttr(SourceRange R, ASTContext &Ctx
    6235             :               , IdentifierInfo * Module
    6236             :               , unsigned SI
    6237             :              )
    6238             :     : InheritableAttr(attr::Ownership, R, SI, false, false)
    6239             :               , module(Module)
    6240             :               , args_Size(0), args_(nullptr)
    6241             :   {
    6242             :   }
    6243             : 
    6244             :   OwnershipAttr *clone(ASTContext &C) const;
    6245             :   void printPretty(raw_ostream &OS,
    6246             :                    const PrintingPolicy &Policy) const;
    6247             :   const char *getSpelling() const;
    6248             :   Spelling getSemanticSpelling() const {
    6249             :   switch (SpellingListIndex) {
    6250             :     default: llvm_unreachable("Unknown spelling list index");
    6251             :     case 0: return GNU_ownership_holds;
    6252             :     case 1: return CXX11_clang_ownership_holds;
    6253             :     case 2: return C2x_clang_ownership_holds;
    6254             :     case 3: return GNU_ownership_returns;
    6255             :     case 4: return CXX11_clang_ownership_returns;
    6256             :     case 5: return C2x_clang_ownership_returns;
    6257             :     case 6: return GNU_ownership_takes;
    6258             :     case 7: return CXX11_clang_ownership_takes;
    6259             :     case 8: return C2x_clang_ownership_takes;
    6260             :   }
    6261             :   }
    6262         142 :   bool isHolds() const { return SpellingListIndex == 0 ||
    6263         142 :     SpellingListIndex == 1 ||
    6264             :     SpellingListIndex == 2; }
    6265             :   bool isReturns() const { return SpellingListIndex == 3 ||
    6266             :     SpellingListIndex == 4 ||
    6267             :     SpellingListIndex == 5; }
    6268             :   bool isTakes() const { return SpellingListIndex == 6 ||
    6269          93 :     SpellingListIndex == 7 ||
    6270             :     SpellingListIndex == 8; }
    6271             :   IdentifierInfo * getModule() const {
    6272             :     return module;
    6273             :   }
    6274             : 
    6275             :   typedef ParamIdx* args_iterator;
    6276             :   args_iterator args_begin() const { return args_; }
    6277          53 :   args_iterator args_end() const { return args_ + args_Size; }
    6278             :   unsigned args_size() const { return args_Size; }
    6279          29 :   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
    6280             : 
    6281             : 
    6282             : 
    6283             :     enum OwnershipKind { Holds, Returns, Takes };
    6284             :     OwnershipKind getOwnKind() const {
    6285         144 :       return isHolds() ? Holds :
    6286          93 :              isTakes() ? Takes :
    6287             :              Returns;
    6288             :     }
    6289             :   
    6290             : 
    6291             :   static bool classof(const Attr *A) { return A->getKind() == attr::Ownership; }
    6292             : };
    6293             : 
    6294             : class PackedAttr : public InheritableAttr {
    6295             : public:
    6296        1317 :   static PackedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6297        1317 :     auto *A = new (Ctx) PackedAttr(Loc, Ctx, 0);
    6298             :     A->setImplicit(true);
    6299        1317 :     return A;
    6300             :   }
    6301             : 
    6302             :   PackedAttr(SourceRange R, ASTContext &Ctx
    6303             :               , unsigned SI
    6304             :              )
    6305             :     : InheritableAttr(attr::Packed, R, SI, false, false)
    6306             :   {
    6307             :   }
    6308             : 
    6309             :   PackedAttr *clone(ASTContext &C) const;
    6310             :   void printPretty(raw_ostream &OS,
    6311             :                    const PrintingPolicy &Policy) const;
    6312             :   const char *getSpelling() const;
    6313             : 
    6314             : 
    6315             :   static bool classof(const Attr *A) { return A->getKind() == attr::Packed; }
    6316             : };
    6317             : 
    6318             : class ParamTypestateAttr : public InheritableAttr {
    6319             : public:
    6320             :   enum ConsumedState {
    6321             :     Unknown,
    6322             :     Consumed,
    6323             :     Unconsumed
    6324             :   };
    6325             : private:
    6326             :   ConsumedState paramState;
    6327             : 
    6328             : public:
    6329             :   static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState ParamState, SourceRange Loc = SourceRange()) {
    6330             :     auto *A = new (Ctx) ParamTypestateAttr(Loc, Ctx, ParamState, 0);
    6331             :     A->setImplicit(true);
    6332             :     return A;
    6333             :   }
    6334             : 
    6335             :   ParamTypestateAttr(SourceRange R, ASTContext &Ctx
    6336             :               , ConsumedState ParamState
    6337             :               , unsigned SI
    6338             :              )
    6339           7 :     : InheritableAttr(attr::ParamTypestate, R, SI, false, false)
    6340           7 :               , paramState(ParamState)
    6341             :   {
    6342             :   }
    6343             : 
    6344             :   ParamTypestateAttr *clone(ASTContext &C) const;
    6345             :   void printPretty(raw_ostream &OS,
    6346             :                    const PrintingPolicy &Policy) const;
    6347             :   const char *getSpelling() const;
    6348             :   ConsumedState getParamState() const {
    6349             :     return paramState;
    6350             :   }
    6351             : 
    6352           7 :   static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
    6353           7 :     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    6354           7 :       .Case("unknown", ParamTypestateAttr::Unknown)
    6355           7 :       .Case("consumed", ParamTypestateAttr::Consumed)
    6356           7 :       .Case("unconsumed", ParamTypestateAttr::Unconsumed)
    6357             :       .Default(Optional<ConsumedState>());
    6358           7 :     if (R) {
    6359           7 :       Out = *R;
    6360           7 :       return true;
    6361             :     }
    6362             :     return false;
    6363             :   }
    6364             : 
    6365             :   static const char *ConvertConsumedStateToStr(ConsumedState Val) {
    6366           0 :     switch(Val) {
    6367             :     case ParamTypestateAttr::Unknown: return "unknown";
    6368           0 :     case ParamTypestateAttr::Consumed: return "consumed";
    6369           0 :     case ParamTypestateAttr::Unconsumed: return "unconsumed";
    6370             :     }
    6371           0 :     llvm_unreachable("No enumerator with that value");
    6372             :   }
    6373             : 
    6374             : 
    6375             :   static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; }
    6376             : };
    6377             : 
    6378             : class PascalAttr : public InheritableAttr {
    6379             : public:
    6380             :   static PascalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6381             :     auto *A = new (Ctx) PascalAttr(Loc, Ctx, 0);
    6382             :     A->setImplicit(true);
    6383             :     return A;
    6384             :   }
    6385             : 
    6386             :   PascalAttr(SourceRange R, ASTContext &Ctx
    6387             :               , unsigned SI
    6388             :              )
    6389             :     : InheritableAttr(attr::Pascal, R, SI, false, false)
    6390             :   {
    6391             :   }
    6392             : 
    6393             :   PascalAttr *clone(ASTContext &C) const;
    6394             :   void printPretty(raw_ostream &OS,
    6395             :                    const PrintingPolicy &Policy) const;
    6396             :   const char *getSpelling() const;
    6397             : 
    6398             : 
    6399             :   static bool classof(const Attr *A) { return A->getKind() == attr::Pascal; }
    6400             : };
    6401             : 
    6402             : class PassObjectSizeAttr : public InheritableParamAttr {
    6403             : int type;
    6404             : 
    6405             : public:
    6406             :   static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, int Type, SourceRange Loc = SourceRange()) {
    6407             :     auto *A = new (Ctx) PassObjectSizeAttr(Loc, Ctx, Type, 0);
    6408             :     A->setImplicit(true);
    6409             :     return A;
    6410             :   }
    6411             : 
    6412             :   PassObjectSizeAttr(SourceRange R, ASTContext &Ctx
    6413             :               , int Type
    6414             :               , unsigned SI
    6415             :              )
    6416         139 :     : InheritableParamAttr(attr::PassObjectSize, R, SI, false, false)
    6417         139 :               , type(Type)
    6418             :   {
    6419             :   }
    6420             : 
    6421             :   PassObjectSizeAttr *clone(ASTContext &C) const;
    6422             :   void printPretty(raw_ostream &OS,
    6423             :                    const PrintingPolicy &Policy) const;
    6424             :   const char *getSpelling() const;
    6425             :   int getType() const {
    6426             :     return type;
    6427             :   }
    6428             : 
    6429             : 
    6430             : 
    6431             :   static bool classof(const Attr *A) { return A->getKind() == attr::PassObjectSize; }
    6432             : };
    6433             : 
    6434             : class PcsAttr : public InheritableAttr {
    6435             : public:
    6436             :   enum PCSType {
    6437             :     AAPCS,
    6438             :     AAPCS_VFP
    6439             :   };
    6440             : private:
    6441             :   PCSType pCS;
    6442             : 
    6443             : public:
    6444             :   static PcsAttr *CreateImplicit(ASTContext &Ctx, PCSType PCS, SourceRange Loc = SourceRange()) {
    6445             :     auto *A = new (Ctx) PcsAttr(Loc, Ctx, PCS, 0);
    6446             :     A->setImplicit(true);
    6447             :     return A;
    6448             :   }
    6449             : 
    6450             :   PcsAttr(SourceRange R, ASTContext &Ctx
    6451             :               , PCSType PCS
    6452             :               , unsigned SI
    6453             :              )
    6454           0 :     : InheritableAttr(attr::Pcs, R, SI, false, false)
    6455           0 :               , pCS(PCS)
    6456             :   {
    6457             :   }
    6458             : 
    6459             :   PcsAttr *clone(ASTContext &C) const;
    6460             :   void printPretty(raw_ostream &OS,
    6461             :                    const PrintingPolicy &Policy) const;
    6462             :   const char *getSpelling() const;
    6463             :   PCSType getPCS() const {
    6464             :     return pCS;
    6465             :   }
    6466             : 
    6467             :   static bool ConvertStrToPCSType(StringRef Val, PCSType &Out) {
    6468             :     Optional<PCSType> R = llvm::StringSwitch<Optional<PCSType>>(Val)
    6469             :       .Case("aapcs", PcsAttr::AAPCS)
    6470             :       .Case("aapcs-vfp", PcsAttr::AAPCS_VFP)
    6471             :       .Default(Optional<PCSType>());
    6472             :     if (R) {
    6473             :       Out = *R;
    6474             :       return true;
    6475             :     }
    6476             :     return false;
    6477             :   }
    6478             : 
    6479             :   static const char *ConvertPCSTypeToStr(PCSType Val) {
    6480           0 :     switch(Val) {
    6481             :     case PcsAttr::AAPCS: return "aapcs";
    6482           0 :     case PcsAttr::AAPCS_VFP: return "aapcs-vfp";
    6483             :     }
    6484           0 :     llvm_unreachable("No enumerator with that value");
    6485             :   }
    6486             : 
    6487             : 
    6488             :   static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; }
    6489             : };
    6490             : 
    6491             : class PragmaClangBSSSectionAttr : public InheritableAttr {
    6492             : unsigned nameLength;
    6493             : char *name;
    6494             : 
    6495             : public:
    6496          22 :   static PragmaClangBSSSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
    6497          44 :     auto *A = new (Ctx) PragmaClangBSSSectionAttr(Loc, Ctx, Name, 0);
    6498             :     A->setImplicit(true);
    6499          22 :     return A;
    6500             :   }
    6501             : 
    6502          27 :   PragmaClangBSSSectionAttr(SourceRange R, ASTContext &Ctx
    6503             :               , llvm::StringRef Name
    6504             :               , unsigned SI
    6505             :              )
    6506          27 :     : InheritableAttr(attr::PragmaClangBSSSection, R, SI, false, false)
    6507          54 :               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
    6508             :   {
    6509          27 :       if (!Name.empty())
    6510          54 :         std::memcpy(name, Name.data(), nameLength);
    6511          27 :   }
    6512             : 
    6513             :   PragmaClangBSSSectionAttr *clone(ASTContext &C) const;
    6514             :   void printPretty(raw_ostream &OS,
    6515             :                    const PrintingPolicy &Policy) const;
    6516             :   const char *getSpelling() const;
    6517             :   llvm::StringRef getName() const {
    6518          23 :     return llvm::StringRef(name, nameLength);
    6519             :   }
    6520             :   unsigned getNameLength() const {
    6521             :     return nameLength;
    6522             :   }
    6523             :   void setName(ASTContext &C, llvm::StringRef S) {
    6524             :     nameLength = S.size();
    6525             :     this->name = new (C, 1) char [nameLength];
    6526             :     if (!S.empty())
    6527             :       std::memcpy(this->name, S.data(), nameLength);
    6528             :   }
    6529             : 
    6530             : 
    6531             : 
    6532             :   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangBSSSection; }
    6533             : };
    6534             : 
    6535             : class PragmaClangDataSectionAttr : public InheritableAttr {
    6536             : unsigned nameLength;
    6537             : char *name;
    6538             : 
    6539             : public:
    6540          10 :   static PragmaClangDataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
    6541          20 :     auto *A = new (Ctx) PragmaClangDataSectionAttr(Loc, Ctx, Name, 0);
    6542             :     A->setImplicit(true);
    6543          10 :     return A;
    6544             :   }
    6545             : 
    6546          10 :   PragmaClangDataSectionAttr(SourceRange R, ASTContext &Ctx
    6547             :               , llvm::StringRef Name
    6548             :               , unsigned SI
    6549             :              )
    6550          10 :     : InheritableAttr(attr::PragmaClangDataSection, R, SI, false, false)
    6551          20 :               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
    6552             :   {
    6553          10 :       if (!Name.empty())
    6554          20 :         std::memcpy(name, Name.data(), nameLength);
    6555          10 :   }
    6556             : 
    6557             :   PragmaClangDataSectionAttr *clone(ASTContext &C) const;
    6558             :   void printPretty(raw_ostream &OS,
    6559             :                    const PrintingPolicy &Policy) const;
    6560             :   const char *getSpelling() const;
    6561             :   llvm::StringRef getName() const {
    6562          10 :     return llvm::StringRef(name, nameLength);
    6563             :   }
    6564             :   unsigned getNameLength() const {
    6565             :     return nameLength;
    6566             :   }
    6567             :   void setName(ASTContext &C, llvm::StringRef S) {
    6568             :     nameLength = S.size();
    6569             :     this->name = new (C, 1) char [nameLength];
    6570             :     if (!S.empty())
    6571             :       std::memcpy(this->name, S.data(), nameLength);
    6572             :   }
    6573             : 
    6574             : 
    6575             : 
    6576             :   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangDataSection; }
    6577             : };
    6578             : 
    6579             : class PragmaClangRodataSectionAttr : public InheritableAttr {
    6580             : unsigned nameLength;
    6581             : char *name;
    6582             : 
    6583             : public:
    6584          17 :   static PragmaClangRodataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
    6585          34 :     auto *A = new (Ctx) PragmaClangRodataSectionAttr(Loc, Ctx, Name, 0);
    6586             :     A->setImplicit(true);
    6587          17 :     return A;
    6588             :   }
    6589             : 
    6590          19 :   PragmaClangRodataSectionAttr(SourceRange R, ASTContext &Ctx
    6591             :               , llvm::StringRef Name
    6592             :               , unsigned SI
    6593             :              )
    6594          19 :     : InheritableAttr(attr::PragmaClangRodataSection, R, SI, false, false)
    6595          38 :               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
    6596             :   {
    6597          19 :       if (!Name.empty())
    6598          38 :         std::memcpy(name, Name.data(), nameLength);
    6599          19 :   }
    6600             : 
    6601             :   PragmaClangRodataSectionAttr *clone(ASTContext &C) const;
    6602             :   void printPretty(raw_ostream &OS,
    6603             :                    const PrintingPolicy &Policy) const;
    6604             :   const char *getSpelling() const;
    6605             :   llvm::StringRef getName() const {
    6606          18 :     return llvm::StringRef(name, nameLength);
    6607             :   }
    6608             :   unsigned getNameLength() const {
    6609             :     return nameLength;
    6610             :   }
    6611             :   void setName(ASTContext &C, llvm::StringRef S) {
    6612             :     nameLength = S.size();
    6613             :     this->name = new (C, 1) char [nameLength];
    6614             :     if (!S.empty())
    6615             :       std::memcpy(this->name, S.data(), nameLength);
    6616             :   }
    6617             : 
    6618             : 
    6619             : 
    6620             :   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangRodataSection; }
    6621             : };
    6622             : 
    6623             : class PragmaClangTextSectionAttr : public InheritableAttr {
    6624             : unsigned nameLength;
    6625             : char *name;
    6626             : 
    6627             : public:
    6628           2 :   static PragmaClangTextSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
    6629           4 :     auto *A = new (Ctx) PragmaClangTextSectionAttr(Loc, Ctx, Name, 0);
    6630             :     A->setImplicit(true);
    6631           2 :     return A;
    6632             :   }
    6633             : 
    6634           2 :   PragmaClangTextSectionAttr(SourceRange R, ASTContext &Ctx
    6635             :               , llvm::StringRef Name
    6636             :               , unsigned SI
    6637             :              )
    6638           2 :     : InheritableAttr(attr::PragmaClangTextSection, R, SI, false, false)
    6639           4 :               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
    6640             :   {
    6641           2 :       if (!Name.empty())
    6642           4 :         std::memcpy(name, Name.data(), nameLength);
    6643           2 :   }
    6644             : 
    6645             :   PragmaClangTextSectionAttr *clone(ASTContext &C) const;
    6646             :   void printPretty(raw_ostream &OS,
    6647             :                    const PrintingPolicy &Policy) const;
    6648             :   const char *getSpelling() const;
    6649             :   llvm::StringRef getName() const {
    6650           2 :     return llvm::StringRef(name, nameLength);
    6651             :   }
    6652             :   unsigned getNameLength() const {
    6653             :     return nameLength;
    6654             :   }
    6655             :   void setName(ASTContext &C, llvm::StringRef S) {
    6656             :     nameLength = S.size();
    6657             :     this->name = new (C, 1) char [nameLength];
    6658             :     if (!S.empty())
    6659             :       std::memcpy(this->name, S.data(), nameLength);
    6660             :   }
    6661             : 
    6662             : 
    6663             : 
    6664             :   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangTextSection; }
    6665             : };
    6666             : 
    6667             : class PreserveAllAttr : public InheritableAttr {
    6668             : public:
    6669             :   static PreserveAllAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6670             :     auto *A = new (Ctx) PreserveAllAttr(Loc, Ctx, 0);
    6671             :     A->setImplicit(true);
    6672             :     return A;
    6673             :   }
    6674             : 
    6675             :   PreserveAllAttr(SourceRange R, ASTContext &Ctx
    6676             :               , unsigned SI
    6677             :              )
    6678             :     : InheritableAttr(attr::PreserveAll, R, SI, false, false)
    6679             :   {
    6680             :   }
    6681             : 
    6682             :   PreserveAllAttr *clone(ASTContext &C) const;
    6683             :   void printPretty(raw_ostream &OS,
    6684             :                    const PrintingPolicy &Policy) const;
    6685             :   const char *getSpelling() const;
    6686             : 
    6687             : 
    6688             :   static bool classof(const Attr *A) { return A->getKind() == attr::PreserveAll; }
    6689             : };
    6690             : 
    6691             : class PreserveMostAttr : public InheritableAttr {
    6692             : public:
    6693             :   static PreserveMostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6694             :     auto *A = new (Ctx) PreserveMostAttr(Loc, Ctx, 0);
    6695             :     A->setImplicit(true);
    6696             :     return A;
    6697             :   }
    6698             : 
    6699             :   PreserveMostAttr(SourceRange R, ASTContext &Ctx
    6700             :               , unsigned SI
    6701             :              )
    6702             :     : InheritableAttr(attr::PreserveMost, R, SI, false, false)
    6703             :   {
    6704             :   }
    6705             : 
    6706             :   PreserveMostAttr *clone(ASTContext &C) const;
    6707             :   void printPretty(raw_ostream &OS,
    6708             :                    const PrintingPolicy &Policy) const;
    6709             :   const char *getSpelling() const;
    6710             : 
    6711             : 
    6712             :   static bool classof(const Attr *A) { return A->getKind() == attr::PreserveMost; }
    6713             : };
    6714             : 
    6715             : class PtGuardedByAttr : public InheritableAttr {
    6716             : Expr * arg;
    6717             : 
    6718             : public:
    6719             :   static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
    6720             :     auto *A = new (Ctx) PtGuardedByAttr(Loc, Ctx, Arg, 0);
    6721             :     A->setImplicit(true);
    6722             :     return A;
    6723             :   }
    6724             : 
    6725             :   PtGuardedByAttr(SourceRange R, ASTContext &Ctx
    6726             :               , Expr * Arg
    6727             :               , unsigned SI
    6728             :              )
    6729         121 :     : InheritableAttr(attr::PtGuardedBy, R, SI, true, true)
    6730         121 :               , arg(Arg)
    6731             :   {
    6732             :   }
    6733             : 
    6734             :   PtGuardedByAttr *clone(ASTContext &C) const;
    6735             :   void printPretty(raw_ostream &OS,
    6736             :                    const PrintingPolicy &Policy) const;
    6737             :   const char *getSpelling() const;
    6738             :   Expr * getArg() const {
    6739             :     return arg;
    6740             :   }
    6741             : 
    6742             : 
    6743             : 
    6744             :   static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedBy; }
    6745             : };
    6746             : 
    6747             : class PtGuardedVarAttr : public InheritableAttr {
    6748             : public:
    6749             :   static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6750             :     auto *A = new (Ctx) PtGuardedVarAttr(Loc, Ctx, 0);
    6751             :     A->setImplicit(true);
    6752             :     return A;
    6753             :   }
    6754             : 
    6755             :   PtGuardedVarAttr(SourceRange R, ASTContext &Ctx
    6756             :               , unsigned SI
    6757             :              )
    6758             :     : InheritableAttr(attr::PtGuardedVar, R, SI, false, false)
    6759             :   {
    6760             :   }
    6761             : 
    6762             :   PtGuardedVarAttr *clone(ASTContext &C) const;
    6763             :   void printPretty(raw_ostream &OS,
    6764             :                    const PrintingPolicy &Policy) const;
    6765             :   const char *getSpelling() const;
    6766             : 
    6767             : 
    6768             :   static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedVar; }
    6769             : };
    6770             : 
    6771             : class PureAttr : public InheritableAttr {
    6772             : public:
    6773        2870 :   static PureAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6774        2870 :     auto *A = new (Ctx) PureAttr(Loc, Ctx, 0);
    6775             :     A->setImplicit(true);
    6776        2870 :     return A;
    6777             :   }
    6778             : 
    6779             :   PureAttr(SourceRange R, ASTContext &Ctx
    6780             :               , unsigned SI
    6781             :              )
    6782             :     : InheritableAttr(attr::Pure, R, SI, false, false)
    6783             :   {
    6784             :   }
    6785             : 
    6786             :   PureAttr *clone(ASTContext &C) const;
    6787             :   void printPretty(raw_ostream &OS,
    6788             :                    const PrintingPolicy &Policy) const;
    6789             :   const char *getSpelling() const;
    6790             : 
    6791             : 
    6792             :   static bool classof(const Attr *A) { return A->getKind() == attr::Pure; }
    6793             : };
    6794             : 
    6795             : class RegCallAttr : public InheritableAttr {
    6796             : public:
    6797             :   static RegCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6798             :     auto *A = new (Ctx) RegCallAttr(Loc, Ctx, 0);
    6799             :     A->setImplicit(true);
    6800             :     return A;
    6801             :   }
    6802             : 
    6803             :   RegCallAttr(SourceRange R, ASTContext &Ctx
    6804             :               , unsigned SI
    6805             :              )
    6806             :     : InheritableAttr(attr::RegCall, R, SI, false, false)
    6807             :   {
    6808             :   }
    6809             : 
    6810             :   RegCallAttr *clone(ASTContext &C) const;
    6811             :   void printPretty(raw_ostream &OS,
    6812             :                    const PrintingPolicy &Policy) const;
    6813             :   const char *getSpelling() const;
    6814             : 
    6815             : 
    6816             :   static bool classof(const Attr *A) { return A->getKind() == attr::RegCall; }
    6817             : };
    6818             : 
    6819             : class ReleaseCapabilityAttr : public InheritableAttr {
    6820             :   unsigned args_Size;
    6821             :   Expr * *args_;
    6822             : 
    6823             : public:
    6824             :   enum Spelling {
    6825             :     GNU_release_capability = 0,
    6826             :     CXX11_clang_release_capability = 1,
    6827             :     GNU_release_shared_capability = 2,
    6828             :     CXX11_clang_release_shared_capability = 3,
    6829             :     GNU_release_generic_capability = 4,
    6830             :     CXX11_clang_release_generic_capability = 5,
    6831             :     GNU_unlock_function = 6,
    6832             :     CXX11_clang_unlock_function = 7
    6833             :   };
    6834             : 
    6835             :   static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
    6836             :     auto *A = new (Ctx) ReleaseCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
    6837             :     A->setImplicit(true);
    6838             :     return A;
    6839             :   }
    6840             : 
    6841         339 :   ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
    6842             :               , Expr * *Args, unsigned ArgsSize
    6843             :               , unsigned SI
    6844             :              )
    6845         339 :     : InheritableAttr(attr::ReleaseCapability, R, SI, true, true)
    6846         678 :               , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
    6847             :   {
    6848         339 :     std::copy(Args, Args + args_Size, args_);
    6849         339 :   }
    6850             : 
    6851             :   ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
    6852             :               , unsigned SI
    6853             :              )
    6854             :     : InheritableAttr(attr::ReleaseCapability, R, SI, true, true)
    6855             :               , args_Size(0), args_(nullptr)
    6856             :   {
    6857             :   }
    6858             : 
    6859             :   ReleaseCapabilityAttr *clone(ASTContext &C) const;
    6860             :   void printPretty(raw_ostream &OS,
    6861             :                    const PrintingPolicy &Policy) const;
    6862             :   const char *getSpelling() const;
    6863             :   Spelling getSemanticSpelling() const {
    6864             :   switch (SpellingListIndex) {
    6865             :     default: llvm_unreachable("Unknown spelling list index");
    6866             :     case 0: return GNU_release_capability;
    6867             :     case 1: return CXX11_clang_release_capability;
    6868             :     case 2: return GNU_release_shared_capability;
    6869             :     case 3: return CXX11_clang_release_shared_capability;
    6870             :     case 4: return GNU_release_generic_capability;
    6871             :     case 5: return CXX11_clang_release_generic_capability;
    6872             :     case 6: return GNU_unlock_function;
    6873             :     case 7: return CXX11_clang_unlock_function;
    6874             :   }
    6875             :   }
    6876           4 :   bool isShared() const { return SpellingListIndex == 2 ||
    6877             :     SpellingListIndex == 3; }
    6878        1566 :   bool isGeneric() const { return SpellingListIndex == 4 ||
    6879             :     SpellingListIndex == 5 ||
    6880        1566 :     SpellingListIndex == 6 ||
    6881             :     SpellingListIndex == 7; }
    6882             :   typedef Expr ** args_iterator;
    6883             :   args_iterator args_begin() const { return args_; }
    6884        2117 :   args_iterator args_end() const { return args_ + args_Size; }
    6885             :   unsigned args_size() const { return args_Size; }
    6886        2112 :   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
    6887             : 
    6888             : 
    6889             : 
    6890             : 
    6891             :   static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseCapability; }
    6892             : };
    6893             : 
    6894             : class RenderScriptKernelAttr : public Attr {
    6895             : public:
    6896             :   static RenderScriptKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6897             :     auto *A = new (Ctx) RenderScriptKernelAttr(Loc, Ctx, 0);
    6898             :     A->setImplicit(true);
    6899             :     return A;
    6900             :   }
    6901             : 
    6902             :   RenderScriptKernelAttr(SourceRange R, ASTContext &Ctx
    6903             :               , unsigned SI
    6904             :              )
    6905             :     : Attr(attr::RenderScriptKernel, R, SI, false)
    6906             :   {
    6907             :   }
    6908             : 
    6909             :   RenderScriptKernelAttr *clone(ASTContext &C) const;
    6910             :   void printPretty(raw_ostream &OS,
    6911             :                    const PrintingPolicy &Policy) const;
    6912             :   const char *getSpelling() const;
    6913             : 
    6914             : 
    6915             :   static bool classof(const Attr *A) { return A->getKind() == attr::RenderScriptKernel; }
    6916             : };
    6917             : 
    6918             : class ReqdWorkGroupSizeAttr : public InheritableAttr {
    6919             : unsigned xDim;
    6920             : 
    6921             : unsigned yDim;
    6922             : 
    6923             : unsigned zDim;
    6924             : 
    6925             : public:
    6926             :   static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
    6927             :     auto *A = new (Ctx) ReqdWorkGroupSizeAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
    6928             :     A->setImplicit(true);
    6929             :     return A;
    6930             :   }
    6931             : 
    6932             :   ReqdWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
    6933             :               , unsigned XDim
    6934             :               , unsigned YDim
    6935             :               , unsigned ZDim
    6936             :               , unsigned SI
    6937             :              )
    6938           9 :     : InheritableAttr(attr::ReqdWorkGroupSize, R, SI, false, false)
    6939             :               , xDim(XDim)
    6940             :               , yDim(YDim)
    6941           9 :               , zDim(ZDim)
    6942             :   {
    6943             :   }
    6944             : 
    6945             :   ReqdWorkGroupSizeAttr *clone(ASTContext &C) const;
    6946             :   void printPretty(raw_ostream &OS,
    6947             :                    const PrintingPolicy &Policy) const;
    6948             :   const char *getSpelling() const;
    6949             :   unsigned getXDim() const {
    6950             :     return xDim;
    6951             :   }
    6952             : 
    6953             :   unsigned getYDim() const {
    6954             :     return yDim;
    6955             :   }
    6956             : 
    6957             :   unsigned getZDim() const {
    6958             :     return zDim;
    6959             :   }
    6960             : 
    6961             : 
    6962             : 
    6963             :   static bool classof(const Attr *A) { return A->getKind() == attr::ReqdWorkGroupSize; }
    6964             : };
    6965             : 
    6966             : class RequireConstantInitAttr : public InheritableAttr {
    6967             : public:
    6968             :   static RequireConstantInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    6969             :     auto *A = new (Ctx) RequireConstantInitAttr(Loc, Ctx, 0);
    6970             :     A->setImplicit(true);
    6971             :     return A;
    6972             :   }
    6973             : 
    6974             :   RequireConstantInitAttr(SourceRange R, ASTContext &Ctx
    6975             :               , unsigned SI
    6976             :              )
    6977             :     : InheritableAttr(attr::RequireConstantInit, R, SI, false, false)
    6978             :   {
    6979             :   }
    6980             : 
    6981             :   RequireConstantInitAttr *clone(ASTContext &C) const;
    6982             :   void printPretty(raw_ostream &OS,
    6983             :                    const PrintingPolicy &Policy) const;
    6984             :   const char *getSpelling() const;
    6985             : 
    6986             : 
    6987             :   static bool classof(const Attr *A) { return A->getKind() == attr::RequireConstantInit; }
    6988             : };
    6989             : 
    6990             : class RequiresCapabilityAttr : public InheritableAttr {
    6991             :   unsigned args_Size;
    6992             :   Expr * *args_;
    6993             : 
    6994             : public:
    6995             :   enum Spelling {
    6996             :     GNU_requires_capability = 0,
    6997             :     CXX11_clang_requires_capability = 1,
    6998             :     GNU_exclusive_locks_required = 2,
    6999             :     CXX11_clang_exclusive_locks_required = 3,
    7000             :     GNU_requires_shared_capability = 4,
    7001             :     CXX11_clang_requires_shared_capability = 5,
    7002             :     GNU_shared_locks_required = 6,
    7003             :     CXX11_clang_shared_locks_required = 7
    7004             :   };
    7005             : 
    7006             :   static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
    7007             :     auto *A = new (Ctx) RequiresCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
    7008             :     A->setImplicit(true);
    7009             :     return A;
    7010             :   }
    7011             : 
    7012         881 :   RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
    7013             :               , Expr * *Args, unsigned ArgsSize
    7014             :               , unsigned SI
    7015             :              )
    7016         881 :     : InheritableAttr(attr::RequiresCapability, R, SI, true, true)
    7017        1762 :               , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
    7018             :   {
    7019         881 :     std::copy(Args, Args + args_Size, args_);
    7020         881 :   }
    7021             : 
    7022             :   RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
    7023             :               , unsigned SI
    7024             :              )
    7025             :     : InheritableAttr(attr::RequiresCapability, R, SI, true, true)
    7026             :               , args_Size(0), args_(nullptr)
    7027             :   {
    7028             :   }
    7029             : 
    7030             :   RequiresCapabilityAttr *clone(ASTContext &C) const;
    7031             :   void printPretty(raw_ostream &OS,
    7032             :                    const PrintingPolicy &Policy) const;
    7033             :   const char *getSpelling() const;
    7034             :   Spelling getSemanticSpelling() const {
    7035             :   switch (SpellingListIndex) {
    7036             :     default: llvm_unreachable("Unknown spelling list index");
    7037             :     case 0: return GNU_requires_capability;
    7038             :     case 1: return CXX11_clang_requires_capability;
    7039             :     case 2: return GNU_exclusive_locks_required;
    7040             :     case 3: return CXX11_clang_exclusive_locks_required;
    7041             :     case 4: return GNU_requires_shared_capability;
    7042             :     case 5: return CXX11_clang_requires_shared_capability;
    7043             :     case 6: return GNU_shared_locks_required;
    7044             :     case 7: return CXX11_clang_shared_locks_required;
    7045             :   }
    7046             :   }
    7047         999 :   bool isShared() const { return SpellingListIndex == 4 ||
    7048             :     SpellingListIndex == 5 ||
    7049         999 :     SpellingListIndex == 6 ||
    7050             :     SpellingListIndex == 7; }
    7051             :   typedef Expr ** args_iterator;
    7052             :   args_iterator args_begin() const { return args_; }
    7053        1996 :   args_iterator args_end() const { return args_ + args_Size; }
    7054             :   unsigned args_size() const { return args_Size; }
    7055        1918 :   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
    7056             : 
    7057             : 
    7058             : 
    7059             : 
    7060             :   static bool classof(const Attr *A) { return A->getKind() == attr::RequiresCapability; }
    7061             : };
    7062             : 
    7063             : class RestrictAttr : public InheritableAttr {
    7064             : public:
    7065             :   enum Spelling {
    7066             :     Declspec_restrict = 0,
    7067             :     GNU_malloc = 1,
    7068             :     CXX11_gnu_malloc = 2
    7069             :   };
    7070             : 
    7071             :   static RestrictAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    7072             :     auto *A = new (Ctx) RestrictAttr(Loc, Ctx, S);
    7073             :     A->setImplicit(true);
    7074             :     return A;
    7075             :   }
    7076             : 
    7077             :   RestrictAttr(SourceRange R, ASTContext &Ctx
    7078             :               , unsigned SI
    7079             :              )
    7080             :     : InheritableAttr(attr::Restrict, R, SI, false, false)
    7081             :   {
    7082             :   }
    7083             : 
    7084             :   RestrictAttr *clone(ASTContext &C) const;
    7085             :   void printPretty(raw_ostream &OS,
    7086             :                    const PrintingPolicy &Policy) const;
    7087             :   const char *getSpelling() const;
    7088             :   Spelling getSemanticSpelling() const {
    7089             :   switch (SpellingListIndex) {
    7090             :     default: llvm_unreachable("Unknown spelling list index");
    7091             :     case 0: return Declspec_restrict;
    7092             :     case 1: return GNU_malloc;
    7093             :     case 2: return CXX11_gnu_malloc;
    7094             :   }
    7095             :   }
    7096             : 
    7097             : 
    7098             :   static bool classof(const Attr *A) { return A->getKind() == attr::Restrict; }
    7099             : };
    7100             : 
    7101             : class ReturnTypestateAttr : public InheritableAttr {
    7102             : public:
    7103             :   enum ConsumedState {
    7104             :     Unknown,
    7105             :     Consumed,
    7106             :     Unconsumed
    7107             :   };
    7108             : private:
    7109             :   ConsumedState state;
    7110             : 
    7111             : public:
    7112             :   static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState State, SourceRange Loc = SourceRange()) {
    7113             :     auto *A = new (Ctx) ReturnTypestateAttr(Loc, Ctx, State, 0);
    7114             :     A->setImplicit(true);
    7115             :     return A;
    7116             :   }
    7117             : 
    7118             :   ReturnTypestateAttr(SourceRange R, ASTContext &Ctx
    7119             :               , ConsumedState State
    7120             :               , unsigned SI
    7121             :              )
    7122          16 :     : InheritableAttr(attr::ReturnTypestate, R, SI, false, false)
    7123          16 :               , state(State)
    7124             :   {
    7125             :   }
    7126             : 
    7127             :   ReturnTypestateAttr *clone(ASTContext &C) const;
    7128             :   void printPretty(raw_ostream &OS,
    7129             :                    const PrintingPolicy &Policy) const;
    7130             :   const char *getSpelling() const;
    7131             :   ConsumedState getState() const {
    7132             :     return state;
    7133             :   }
    7134             : 
    7135          11 :   static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
    7136          11 :     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    7137          11 :       .Case("unknown", ReturnTypestateAttr::Unknown)
    7138          11 :       .Case("consumed", ReturnTypestateAttr::Consumed)
    7139          11 :       .Case("unconsumed", ReturnTypestateAttr::Unconsumed)
    7140             :       .Default(Optional<ConsumedState>());
    7141          11 :     if (R) {
    7142          10 :       Out = *R;
    7143          10 :       return true;
    7144             :     }
    7145             :     return false;
    7146             :   }
    7147             : 
    7148             :   static const char *ConvertConsumedStateToStr(ConsumedState Val) {
    7149           0 :     switch(Val) {
    7150             :     case ReturnTypestateAttr::Unknown: return "unknown";
    7151           0 :     case ReturnTypestateAttr::Consumed: return "consumed";
    7152           0 :     case ReturnTypestateAttr::Unconsumed: return "unconsumed";
    7153             :     }
    7154           0 :     llvm_unreachable("No enumerator with that value");
    7155             :   }
    7156             : 
    7157             : 
    7158             :   static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; }
    7159             : };
    7160             : 
    7161             : class ReturnsNonNullAttr : public InheritableAttr {
    7162             : public:
    7163             :   static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7164             :     auto *A = new (Ctx) ReturnsNonNullAttr(Loc, Ctx, 0);
    7165             :     A->setImplicit(true);
    7166             :     return A;
    7167             :   }
    7168             : 
    7169             :   ReturnsNonNullAttr(SourceRange R, ASTContext &Ctx
    7170             :               , unsigned SI
    7171             :              )
    7172             :     : InheritableAttr(attr::ReturnsNonNull, R, SI, false, false)
    7173             :   {
    7174             :   }
    7175             : 
    7176             :   ReturnsNonNullAttr *clone(ASTContext &C) const;
    7177             :   void printPretty(raw_ostream &OS,
    7178             :                    const PrintingPolicy &Policy) const;
    7179             :   const char *getSpelling() const;
    7180             : 
    7181             : 
    7182             :   static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsNonNull; }
    7183             : };
    7184             : 
    7185             : class ReturnsTwiceAttr : public InheritableAttr {
    7186             : public:
    7187         218 :   static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7188         218 :     auto *A = new (Ctx) ReturnsTwiceAttr(Loc, Ctx, 0);
    7189             :     A->setImplicit(true);
    7190         218 :     return A;
    7191             :   }
    7192             : 
    7193             :   ReturnsTwiceAttr(SourceRange R, ASTContext &Ctx
    7194             :               , unsigned SI
    7195             :              )
    7196             :     : InheritableAttr(attr::ReturnsTwice, R, SI, false, false)
    7197             :   {
    7198             :   }
    7199             : 
    7200             :   ReturnsTwiceAttr *clone(ASTContext &C) const;
    7201             :   void printPretty(raw_ostream &OS,
    7202             :                    const PrintingPolicy &Policy) const;
    7203             :   const char *getSpelling() const;
    7204             : 
    7205             : 
    7206             :   static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsTwice; }
    7207             : };
    7208             : 
    7209             : class ScopedLockableAttr : public InheritableAttr {
    7210             : public:
    7211             :   static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7212             :     auto *A = new (Ctx) ScopedLockableAttr(Loc, Ctx, 0);
    7213             :     A->setImplicit(true);
    7214             :     return A;
    7215             :   }
    7216             : 
    7217             :   ScopedLockableAttr(SourceRange R, ASTContext &Ctx
    7218             :               , unsigned SI
    7219             :              )
    7220             :     : InheritableAttr(attr::ScopedLockable, R, SI, false, false)
    7221             :   {
    7222             :   }
    7223             : 
    7224             :   ScopedLockableAttr *clone(ASTContext &C) const;
    7225             :   void printPretty(raw_ostream &OS,
    7226             :                    const PrintingPolicy &Policy) const;
    7227             :   const char *getSpelling() const;
    7228             : 
    7229             : 
    7230             :   static bool classof(const Attr *A) { return A->getKind() == attr::ScopedLockable; }
    7231             : };
    7232             : 
    7233             : class SectionAttr : public InheritableAttr {
    7234             : unsigned nameLength;
    7235             : char *name;
    7236             : 
    7237             : public:
    7238             :   enum Spelling {
    7239             :     GNU_section = 0,
    7240             :     CXX11_gnu_section = 1,
    7241             :     Declspec_allocate = 2
    7242             :   };
    7243             : 
    7244          27 :   static SectionAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
    7245          54 :     auto *A = new (Ctx) SectionAttr(Loc, Ctx, Name, S);
    7246             :     A->setImplicit(true);
    7247          27 :     return A;
    7248             :   }
    7249             : 
    7250          95 :   SectionAttr(SourceRange R, ASTContext &Ctx
    7251             :               , llvm::StringRef Name
    7252             :               , unsigned SI
    7253             :              )
    7254          95 :     : InheritableAttr(attr::Section, R, SI, false, false)
    7255         190 :               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
    7256             :   {
    7257          95 :       if (!Name.empty())
    7258         190 :         std::memcpy(name, Name.data(), nameLength);
    7259          95 :   }
    7260             : 
    7261             :   SectionAttr *clone(ASTContext &C) const;
    7262             :   void printPretty(raw_ostream &OS,
    7263             :                    const PrintingPolicy &Policy) const;
    7264             :   const char *getSpelling() const;
    7265             :   Spelling getSemanticSpelling() const {
    7266             :   switch (SpellingListIndex) {
    7267             :     default: llvm_unreachable("Unknown spelling list index");
    7268             :     case 0: return GNU_section;
    7269             :     case 1: return CXX11_gnu_section;
    7270             :     case 2: return Declspec_allocate;
    7271             :   }
    7272             :   }
    7273             :   llvm::StringRef getName() const {
    7274         169 :     return llvm::StringRef(name, nameLength);
    7275             :   }
    7276             :   unsigned getNameLength() const {
    7277             :     return nameLength;
    7278             :   }
    7279             :   void setName(ASTContext &C, llvm::StringRef S) {
    7280             :     nameLength = S.size();
    7281             :     this->name = new (C, 1) char [nameLength];
    7282             :     if (!S.empty())
    7283             :       std::memcpy(this->name, S.data(), nameLength);
    7284             :   }
    7285             : 
    7286             : 
    7287             : 
    7288           3 :   static bool classof(const Attr *A) { return A->getKind() == attr::Section; }
    7289             : };
    7290             : 
    7291             : class SelectAnyAttr : public InheritableAttr {
    7292             : public:
    7293             :   static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7294             :     auto *A = new (Ctx) SelectAnyAttr(Loc, Ctx, 0);
    7295             :     A->setImplicit(true);
    7296             :     return A;
    7297             :   }
    7298             : 
    7299             :   SelectAnyAttr(SourceRange R, ASTContext &Ctx
    7300             :               , unsigned SI
    7301             :              )
    7302             :     : InheritableAttr(attr::SelectAny, R, SI, false, false)
    7303             :   {
    7304             :   }
    7305             : 
    7306             :   SelectAnyAttr *clone(ASTContext &C) const;
    7307             :   void printPretty(raw_ostream &OS,
    7308             :                    const PrintingPolicy &Policy) const;
    7309             :   const char *getSpelling() const;
    7310             : 
    7311             : 
    7312          16 :   static bool classof(const Attr *A) { return A->getKind() == attr::SelectAny; }
    7313             : };
    7314             : 
    7315             : class SentinelAttr : public InheritableAttr {
    7316             : int sentinel;
    7317             : 
    7318             : int nullPos;
    7319             : 
    7320             : public:
    7321             :   static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Loc = SourceRange()) {
    7322             :     auto *A = new (Ctx) SentinelAttr(Loc, Ctx, Sentinel, NullPos, 0);
    7323             :     A->setImplicit(true);
    7324             :     return A;
    7325             :   }
    7326             : 
    7327             :   SentinelAttr(SourceRange R, ASTContext &Ctx
    7328             :               , int Sentinel
    7329             :               , int NullPos
    7330             :               , unsigned SI
    7331             :              )
    7332         199 :     : InheritableAttr(attr::Sentinel, R, SI, false, false)
    7333             :               , sentinel(Sentinel)
    7334         199 :               , nullPos(NullPos)
    7335             :   {
    7336             :   }
    7337             : 
    7338             :   SentinelAttr(SourceRange R, ASTContext &Ctx
    7339             :               , unsigned SI
    7340             :              )
    7341             :     : InheritableAttr(attr::Sentinel, R, SI, false, false)
    7342             :               , sentinel()
    7343             :               , nullPos()
    7344             :   {
    7345             :   }
    7346             : 
    7347             :   SentinelAttr *clone(ASTContext &C) const;
    7348             :   void printPretty(raw_ostream &OS,
    7349             :                    const PrintingPolicy &Policy) const;
    7350             :   const char *getSpelling() const;
    7351             :   int getSentinel() const {
    7352             :     return sentinel;
    7353             :   }
    7354             : 
    7355             :   static const int DefaultSentinel = 0;
    7356             : 
    7357             :   int getNullPos() const {
    7358             :     return nullPos;
    7359             :   }
    7360             : 
    7361             :   static const int DefaultNullPos = 0;
    7362             : 
    7363             : 
    7364             : 
    7365             :   static bool classof(const Attr *A) { return A->getKind() == attr::Sentinel; }
    7366             : };
    7367             : 
    7368             : class SetTypestateAttr : public InheritableAttr {
    7369             : public:
    7370             :   enum ConsumedState {
    7371             :     Unknown,
    7372             :     Consumed,
    7373             :     Unconsumed
    7374             :   };
    7375             : private:
    7376             :   ConsumedState newState;
    7377             : 
    7378             : public:
    7379             :   static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState NewState, SourceRange Loc = SourceRange()) {
    7380             :     auto *A = new (Ctx) SetTypestateAttr(Loc, Ctx, NewState, 0);
    7381             :     A->setImplicit(true);
    7382             :     return A;
    7383             :   }
    7384             : 
    7385             :   SetTypestateAttr(SourceRange R, ASTContext &Ctx
    7386             :               , ConsumedState NewState
    7387             :               , unsigned SI
    7388             :              )
    7389          17 :     : InheritableAttr(attr::SetTypestate, R, SI, false, false)
    7390          17 :               , newState(NewState)
    7391             :   {
    7392             :   }
    7393             : 
    7394             :   SetTypestateAttr *clone(ASTContext &C) const;
    7395             :   void printPretty(raw_ostream &OS,
    7396             :                    const PrintingPolicy &Policy) const;
    7397             :   const char *getSpelling() const;
    7398             :   ConsumedState getNewState() const {
    7399             :     return newState;
    7400             :   }
    7401             : 
    7402           9 :   static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
    7403           9 :     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    7404           9 :       .Case("unknown", SetTypestateAttr::Unknown)
    7405           9 :       .Case("consumed", SetTypestateAttr::Consumed)
    7406           9 :       .Case("unconsumed", SetTypestateAttr::Unconsumed)
    7407             :       .Default(Optional<ConsumedState>());
    7408           9 :     if (R) {
    7409           9 :       Out = *R;
    7410           9 :       return true;
    7411             :     }
    7412             :     return false;
    7413             :   }
    7414             : 
    7415             :   static const char *ConvertConsumedStateToStr(ConsumedState Val) {
    7416           0 :     switch(Val) {
    7417             :     case SetTypestateAttr::Unknown: return "unknown";
    7418           0 :     case SetTypestateAttr::Consumed: return "consumed";
    7419           0 :     case SetTypestateAttr::Unconsumed: return "unconsumed";
    7420             :     }
    7421           0 :     llvm_unreachable("No enumerator with that value");
    7422             :   }
    7423             : 
    7424             : 
    7425             :   static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; }
    7426             : };
    7427             : 
    7428             : class SharedTrylockFunctionAttr : public InheritableAttr {
    7429             : Expr * successValue;
    7430             : 
    7431             :   unsigned args_Size;
    7432             :   Expr * *args_;
    7433             : 
    7434             : public:
    7435             :   static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
    7436             :     auto *A = new (Ctx) SharedTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
    7437             :     A->setImplicit(true);
    7438             :     return A;
    7439             :   }
    7440             : 
    7441          73 :   SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
    7442             :               , Expr * SuccessValue
    7443             :               , Expr * *Args, unsigned ArgsSize
    7444             :               , unsigned SI
    7445             :              )
    7446          73 :     : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true)
    7447             :               , successValue(SuccessValue)
    7448         146 :               , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
    7449             :   {
    7450          73 :     std::copy(Args, Args + args_Size, args_);
    7451          73 :   }
    7452             : 
    7453             :   SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
    7454             :               , Expr * SuccessValue
    7455             :               , unsigned SI
    7456             :              )
    7457             :     : InheritableAttr(attr::SharedTrylockFunction, R, SI, true, true)
    7458             :               , successValue(SuccessValue)
    7459             :               , args_Size(0), args_(nullptr)
    7460             :   {
    7461             :   }
    7462             : 
    7463             :   SharedTrylockFunctionAttr *clone(ASTContext &C) const;
    7464             :   void printPretty(raw_ostream &OS,
    7465             :                    const PrintingPolicy &Policy) const;
    7466             :   const char *getSpelling() const;
    7467             :   Expr * getSuccessValue() const {
    7468             :     return successValue;
    7469             :   }
    7470             : 
    7471             :   typedef Expr ** args_iterator;
    7472             :   args_iterator args_begin() const { return args_; }
    7473          25 :   args_iterator args_end() const { return args_ + args_Size; }
    7474             :   unsigned args_size() const { return args_Size; }
    7475          25 :   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
    7476             : 
    7477             : 
    7478             : 
    7479             : 
    7480             :   static bool classof(const Attr *A) { return A->getKind() == attr::SharedTrylockFunction; }
    7481             : };
    7482             : 
    7483             : class StdCallAttr : public InheritableAttr {
    7484             : public:
    7485             :   static StdCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7486             :     auto *A = new (Ctx) StdCallAttr(Loc, Ctx, 0);
    7487             :     A->setImplicit(true);
    7488             :     return A;
    7489             :   }
    7490             : 
    7491             :   StdCallAttr(SourceRange R, ASTContext &Ctx
    7492             :               , unsigned SI
    7493             :              )
    7494             :     : InheritableAttr(attr::StdCall, R, SI, false, false)
    7495             :   {
    7496             :   }
    7497             : 
    7498             :   StdCallAttr *clone(ASTContext &C) const;
    7499             :   void printPretty(raw_ostream &OS,
    7500             :                    const PrintingPolicy &Policy) const;
    7501             :   const char *getSpelling() const;
    7502             : 
    7503             : 
    7504             :   static bool classof(const Attr *A) { return A->getKind() == attr::StdCall; }
    7505             : };
    7506             : 
    7507             : class SuppressAttr : public StmtAttr {
    7508             :   unsigned diagnosticIdentifiers_Size;
    7509             :   StringRef *diagnosticIdentifiers_;
    7510             : 
    7511             : public:
    7512             :   static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Loc = SourceRange()) {
    7513             :     auto *A = new (Ctx) SuppressAttr(Loc, Ctx, DiagnosticIdentifiers, DiagnosticIdentifiersSize, 0);
    7514             :     A->setImplicit(true);
    7515             :     return A;
    7516             :   }
    7517             : 
    7518           8 :   SuppressAttr(SourceRange R, ASTContext &Ctx
    7519             :               , StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize
    7520             :               , unsigned SI
    7521             :              )
    7522           8 :     : StmtAttr(attr::Suppress, R, SI, false)
    7523          25 :               , diagnosticIdentifiers_Size(DiagnosticIdentifiersSize), diagnosticIdentifiers_(new (Ctx, 16) StringRef[diagnosticIdentifiers_Size])
    7524             :   {
    7525          17 :     for (size_t I = 0, E = diagnosticIdentifiers_Size; I != E;
    7526             :          ++I) {
    7527           9 :       StringRef Ref = DiagnosticIdentifiers[I];
    7528           9 :       if (!Ref.empty()) {
    7529             :         char *Mem = new (Ctx, 1) char[Ref.size()];
    7530           9 :         std::memcpy(Mem, Ref.data(), Ref.size());
    7531           9 :         diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size());
    7532             :       }
    7533             :     }
    7534           8 :   }
    7535             : 
    7536             :   SuppressAttr(SourceRange R, ASTContext &Ctx
    7537             :               , unsigned SI
    7538             :              )
    7539             :     : StmtAttr(attr::Suppress, R, SI, false)
    7540             :               , diagnosticIdentifiers_Size(0), diagnosticIdentifiers_(nullptr)
    7541             :   {
    7542             :   }
    7543             : 
    7544             :   SuppressAttr *clone(ASTContext &C) const;
    7545             :   void printPretty(raw_ostream &OS,
    7546             :                    const PrintingPolicy &Policy) const;
    7547             :   const char *getSpelling() const;
    7548             :   typedef StringRef* diagnosticIdentifiers_iterator;
    7549             :   diagnosticIdentifiers_iterator diagnosticIdentifiers_begin() const { return diagnosticIdentifiers_; }
    7550           3 :   diagnosticIdentifiers_iterator diagnosticIdentifiers_end() const { return diagnosticIdentifiers_ + diagnosticIdentifiers_Size; }
    7551             :   unsigned diagnosticIdentifiers_size() const { return diagnosticIdentifiers_Size; }
    7552           3 :   llvm::iterator_range<diagnosticIdentifiers_iterator> diagnosticIdentifiers() const { return llvm::make_range(diagnosticIdentifiers_begin(), diagnosticIdentifiers_end()); }
    7553             : 
    7554             : 
    7555             : 
    7556             : 
    7557             :   static bool classof(const Attr *A) { return A->getKind() == attr::Suppress; }
    7558             : };
    7559             : 
    7560             : class SwiftCallAttr : public InheritableAttr {
    7561             : public:
    7562             :   static SwiftCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7563             :     auto *A = new (Ctx) SwiftCallAttr(Loc, Ctx, 0);
    7564             :     A->setImplicit(true);
    7565             :     return A;
    7566             :   }
    7567             : 
    7568             :   SwiftCallAttr(SourceRange R, ASTContext &Ctx
    7569             :               , unsigned SI
    7570             :              )
    7571             :     : InheritableAttr(attr::SwiftCall, R, SI, false, false)
    7572             :   {
    7573             :   }
    7574             : 
    7575             :   SwiftCallAttr *clone(ASTContext &C) const;
    7576             :   void printPretty(raw_ostream &OS,
    7577             :                    const PrintingPolicy &Policy) const;
    7578             :   const char *getSpelling() const;
    7579             : 
    7580             : 
    7581             :   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftCall; }
    7582             : };
    7583             : 
    7584             : class SwiftContextAttr : public ParameterABIAttr {
    7585             : public:
    7586             :   static SwiftContextAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7587             :     auto *A = new (Ctx) SwiftContextAttr(Loc, Ctx, 0);
    7588             :     A->setImplicit(true);
    7589             :     return A;
    7590             :   }
    7591             : 
    7592             :   SwiftContextAttr(SourceRange R, ASTContext &Ctx
    7593             :               , unsigned SI
    7594             :              )
    7595             :     : ParameterABIAttr(attr::SwiftContext, R, SI, false, false)
    7596             :   {
    7597             :   }
    7598             : 
    7599             :   SwiftContextAttr *clone(ASTContext &C) const;
    7600             :   void printPretty(raw_ostream &OS,
    7601             :                    const PrintingPolicy &Policy) const;
    7602             :   const char *getSpelling() const;
    7603             : 
    7604             : 
    7605             :   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftContext; }
    7606             : };
    7607             : 
    7608             : class SwiftErrorResultAttr : public ParameterABIAttr {
    7609             : public:
    7610             :   static SwiftErrorResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7611             :     auto *A = new (Ctx) SwiftErrorResultAttr(Loc, Ctx, 0);
    7612             :     A->setImplicit(true);
    7613             :     return A;
    7614             :   }
    7615             : 
    7616             :   SwiftErrorResultAttr(SourceRange R, ASTContext &Ctx
    7617             :               , unsigned SI
    7618             :              )
    7619             :     : ParameterABIAttr(attr::SwiftErrorResult, R, SI, false, false)
    7620             :   {
    7621             :   }
    7622             : 
    7623             :   SwiftErrorResultAttr *clone(ASTContext &C) const;
    7624             :   void printPretty(raw_ostream &OS,
    7625             :                    const PrintingPolicy &Policy) const;
    7626             :   const char *getSpelling() const;
    7627             : 
    7628             : 
    7629             :   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftErrorResult; }
    7630             : };
    7631             : 
    7632             : class SwiftIndirectResultAttr : public ParameterABIAttr {
    7633             : public:
    7634             :   static SwiftIndirectResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7635             :     auto *A = new (Ctx) SwiftIndirectResultAttr(Loc, Ctx, 0);
    7636             :     A->setImplicit(true);
    7637             :     return A;
    7638             :   }
    7639             : 
    7640             :   SwiftIndirectResultAttr(SourceRange R, ASTContext &Ctx
    7641             :               , unsigned SI
    7642             :              )
    7643             :     : ParameterABIAttr(attr::SwiftIndirectResult, R, SI, false, false)
    7644             :   {
    7645             :   }
    7646             : 
    7647             :   SwiftIndirectResultAttr *clone(ASTContext &C) const;
    7648             :   void printPretty(raw_ostream &OS,
    7649             :                    const PrintingPolicy &Policy) const;
    7650             :   const char *getSpelling() const;
    7651             : 
    7652             : 
    7653             :   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftIndirectResult; }
    7654             : };
    7655             : 
    7656             : class SysVABIAttr : public InheritableAttr {
    7657             : public:
    7658             :   static SysVABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7659             :     auto *A = new (Ctx) SysVABIAttr(Loc, Ctx, 0);
    7660             :     A->setImplicit(true);
    7661             :     return A;
    7662             :   }
    7663             : 
    7664             :   SysVABIAttr(SourceRange R, ASTContext &Ctx
    7665             :               , unsigned SI
    7666             :              )
    7667             :     : InheritableAttr(attr::SysVABI, R, SI, false, false)
    7668             :   {
    7669             :   }
    7670             : 
    7671             :   SysVABIAttr *clone(ASTContext &C) const;
    7672             :   void printPretty(raw_ostream &OS,
    7673             :                    const PrintingPolicy &Policy) const;
    7674             :   const char *getSpelling() const;
    7675             : 
    7676             : 
    7677             :   static bool classof(const Attr *A) { return A->getKind() == attr::SysVABI; }
    7678             : };
    7679             : 
    7680             : class TLSModelAttr : public InheritableAttr {
    7681             : unsigned modelLength;
    7682             : char *model;
    7683             : 
    7684             : public:
    7685             :   static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, SourceRange Loc = SourceRange()) {
    7686             :     auto *A = new (Ctx) TLSModelAttr(Loc, Ctx, Model, 0);
    7687             :     A->setImplicit(true);
    7688             :     return A;
    7689             :   }
    7690             : 
    7691          17 :   TLSModelAttr(SourceRange R, ASTContext &Ctx
    7692             :               , llvm::StringRef Model
    7693             :               , unsigned SI
    7694             :              )
    7695          17 :     : InheritableAttr(attr::TLSModel, R, SI, false, false)
    7696          34 :               , modelLength(Model.size()),model(new (Ctx, 1) char[modelLength])
    7697             :   {
    7698          17 :       if (!Model.empty())
    7699          34 :         std::memcpy(model, Model.data(), modelLength);
    7700          17 :   }
    7701             : 
    7702             :   TLSModelAttr *clone(ASTContext &C) const;
    7703             :   void printPretty(raw_ostream &OS,
    7704             :                    const PrintingPolicy &Policy) const;
    7705             :   const char *getSpelling() const;
    7706             :   llvm::StringRef getModel() const {
    7707          15 :     return llvm::StringRef(model, modelLength);
    7708             :   }
    7709             :   unsigned getModelLength() const {
    7710             :     return modelLength;
    7711             :   }
    7712             :   void setModel(ASTContext &C, llvm::StringRef S) {
    7713             :     modelLength = S.size();
    7714             :     this->model = new (C, 1) char [modelLength];
    7715             :     if (!S.empty())
    7716             :       std::memcpy(this->model, S.data(), modelLength);
    7717             :   }
    7718             : 
    7719             : 
    7720             : 
    7721             :   static bool classof(const Attr *A) { return A->getKind() == attr::TLSModel; }
    7722             : };
    7723             : 
    7724             : class TargetAttr : public InheritableAttr {
    7725             : unsigned featuresStrLength;
    7726             : char *featuresStr;
    7727             : 
    7728             : public:
    7729             :   static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef FeaturesStr, SourceRange Loc = SourceRange()) {
    7730             :     auto *A = new (Ctx) TargetAttr(Loc, Ctx, FeaturesStr, 0);
    7731             :     A->setImplicit(true);
    7732             :     return A;
    7733             :   }
    7734             : 
    7735      493905 :   TargetAttr(SourceRange R, ASTContext &Ctx
    7736             :               , llvm::StringRef FeaturesStr
    7737             :               , unsigned SI
    7738             :              )
    7739      493905 :     : InheritableAttr(attr::Target, R, SI, false, false)
    7740      987810 :               , featuresStrLength(FeaturesStr.size()),featuresStr(new (Ctx, 1) char[featuresStrLength])
    7741             :   {
    7742      493905 :       if (!FeaturesStr.empty())
    7743      987810 :         std::memcpy(featuresStr, FeaturesStr.data(), featuresStrLength);
    7744      493905 :   }
    7745             : 
    7746             :   TargetAttr *clone(ASTContext &C) const;
    7747             :   void printPretty(raw_ostream &OS,
    7748             :                    const PrintingPolicy &Policy) const;
    7749             :   const char *getSpelling() const;
    7750             :   llvm::StringRef getFeaturesStr() const {
    7751       65469 :     return llvm::StringRef(featuresStr, featuresStrLength);
    7752             :   }
    7753             :   unsigned getFeaturesStrLength() const {
    7754             :     return featuresStrLength;
    7755             :   }
    7756             :   void setFeaturesStr(ASTContext &C, llvm::StringRef S) {
    7757             :     featuresStrLength = S.size();
    7758             :     this->featuresStr = new (C, 1) char [featuresStrLength];
    7759             :     if (!S.empty())
    7760             :       std::memcpy(this->featuresStr, S.data(), featuresStrLength);
    7761             :   }
    7762             : 
    7763             : 
    7764     1087862 :     struct ParsedTargetAttr {
    7765             :       std::vector<std::string> Features;
    7766             :       StringRef Architecture;
    7767             :       bool DuplicateArchitecture = false;
    7768         198 :       bool operator ==(const ParsedTargetAttr &Other) const {
    7769         198 :         return DuplicateArchitecture == Other.DuplicateArchitecture &&
    7770         240 :                Architecture == Other.Architecture && Features == Other.Features;
    7771             :       }
    7772             :     };
    7773             :     ParsedTargetAttr parse() const {
    7774       99454 :       return parse(getFeaturesStr());
    7775             :     }
    7776             : 
    7777             :     template<class Compare>
    7778         250 :     ParsedTargetAttr parse(Compare cmp) const {
    7779             :       ParsedTargetAttr Attrs = parse();
    7780             :       llvm::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp);
    7781         250 :       return Attrs;
    7782             :     }
    7783             : 
    7784      494078 :     bool isDefaultVersion() const { return getFeaturesStr() == "default"; }
    7785             : 
    7786      543614 :     static ParsedTargetAttr parse(StringRef Features) {
    7787             :       ParsedTargetAttr Ret;
    7788             :       if (Features == "default") return Ret;
    7789             :       SmallVector<StringRef, 1> AttrFeatures;
    7790      543382 :       Features.split(AttrFeatures, ",");
    7791             : 
    7792             :       // Grab the various features and prepend a "+" to turn on the feature to
    7793             :       // the backend and add them to our existing set of features.
    7794     1826644 :       for (auto &Feature : AttrFeatures) {
    7795             :         // Go ahead and trim whitespace rather than either erroring or
    7796             :         // accepting it weirdly.
    7797      641631 :         Feature = Feature.trim();
    7798             : 
    7799             :         // We don't support cpu tuning this way currently.
    7800             :         // TODO: Support the fpmath option. It will require checking
    7801             :         // overall feature validity for the function with the rest of the
    7802             :         // attributes on the function.
    7803           0 :         if (Feature.startswith("fpmath=") || Feature.startswith("tune="))
    7804           0 :           continue;
    7805             : 
    7806             :         // While we're here iterating check for a different target cpu.
    7807             :         if (Feature.startswith("arch=")) {
    7808         548 :           if (!Ret.Architecture.empty())
    7809           3 :             Ret.DuplicateArchitecture = true;
    7810             :           else
    7811        1090 :             Ret.Architecture = Feature.split("=").second.trim();
    7812             :         } else if (Feature.startswith("no-"))
    7813         315 :           Ret.Features.push_back("-" + Feature.split("-").second.str());
    7814             :         else
    7815     2564080 :           Ret.Features.push_back("+" + Feature.str());
    7816             :       }
    7817             :       return Ret;
    7818             :     }
    7819             :   
    7820             : 
    7821             :   static bool classof(const Attr *A) { return A->getKind() == attr::Target; }
    7822             : };
    7823             : 
    7824             : class TestTypestateAttr : public InheritableAttr {
    7825             : public:
    7826             :   enum ConsumedState {
    7827             :     Consumed,
    7828             :     Unconsumed
    7829             :   };
    7830             : private:
    7831             :   ConsumedState testState;
    7832             : 
    7833             : public:
    7834             :   static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState TestState, SourceRange Loc = SourceRange()) {
    7835             :     auto *A = new (Ctx) TestTypestateAttr(Loc, Ctx, TestState, 0);
    7836             :     A->setImplicit(true);
    7837             :     return A;
    7838             :   }
    7839             : 
    7840             :   TestTypestateAttr(SourceRange R, ASTContext &Ctx
    7841             :               , ConsumedState TestState
    7842             :               , unsigned SI
    7843             :              )
    7844          13 :     : InheritableAttr(attr::TestTypestate, R, SI, false, false)
    7845          13 :               , testState(TestState)
    7846             :   {
    7847             :   }
    7848             : 
    7849             :   TestTypestateAttr *clone(ASTContext &C) const;
    7850             :   void printPretty(raw_ostream &OS,
    7851             :                    const PrintingPolicy &Policy) const;
    7852             :   const char *getSpelling() const;
    7853             :   ConsumedState getTestState() const {
    7854             :     return testState;
    7855             :   }
    7856             : 
    7857           5 :   static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
    7858           5 :     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
    7859           5 :       .Case("consumed", TestTypestateAttr::Consumed)
    7860           5 :       .Case("unconsumed", TestTypestateAttr::Unconsumed)
    7861             :       .Default(Optional<ConsumedState>());
    7862           5 :     if (R) {
    7863           5 :       Out = *R;
    7864           5 :       return true;
    7865             :     }
    7866             :     return false;
    7867             :   }
    7868             : 
    7869             :   static const char *ConvertConsumedStateToStr(ConsumedState Val) {
    7870           0 :     switch(Val) {
    7871             :     case TestTypestateAttr::Consumed: return "consumed";
    7872           0 :     case TestTypestateAttr::Unconsumed: return "unconsumed";
    7873             :     }
    7874           0 :     llvm_unreachable("No enumerator with that value");
    7875             :   }
    7876             : 
    7877             : 
    7878             :   static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; }
    7879             : };
    7880             : 
    7881             : class ThisCallAttr : public InheritableAttr {
    7882             : public:
    7883             :   static ThisCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7884             :     auto *A = new (Ctx) ThisCallAttr(Loc, Ctx, 0);
    7885             :     A->setImplicit(true);
    7886             :     return A;
    7887             :   }
    7888             : 
    7889             :   ThisCallAttr(SourceRange R, ASTContext &Ctx
    7890             :               , unsigned SI
    7891             :              )
    7892             :     : InheritableAttr(attr::ThisCall, R, SI, false, false)
    7893             :   {
    7894             :   }
    7895             : 
    7896             :   ThisCallAttr *clone(ASTContext &C) const;
    7897             :   void printPretty(raw_ostream &OS,
    7898             :                    const PrintingPolicy &Policy) const;
    7899             :   const char *getSpelling() const;
    7900             : 
    7901             : 
    7902             :   static bool classof(const Attr *A) { return A->getKind() == attr::ThisCall; }
    7903             : };
    7904             : 
    7905             : class ThreadAttr : public Attr {
    7906             : public:
    7907             :   static ThreadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7908             :     auto *A = new (Ctx) ThreadAttr(Loc, Ctx, 0);
    7909             :     A->setImplicit(true);
    7910             :     return A;
    7911             :   }
    7912             : 
    7913             :   ThreadAttr(SourceRange R, ASTContext &Ctx
    7914             :               , unsigned SI
    7915             :              )
    7916             :     : Attr(attr::Thread, R, SI, false)
    7917             :   {
    7918             :   }
    7919             : 
    7920             :   ThreadAttr *clone(ASTContext &C) const;
    7921             :   void printPretty(raw_ostream &OS,
    7922             :                    const PrintingPolicy &Policy) const;
    7923             :   const char *getSpelling() const;
    7924             : 
    7925             : 
    7926             :   static bool classof(const Attr *A) { return A->getKind() == attr::Thread; }
    7927             : };
    7928             : 
    7929             : class TransparentUnionAttr : public InheritableAttr {
    7930             : public:
    7931             :   static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7932             :     auto *A = new (Ctx) TransparentUnionAttr(Loc, Ctx, 0);
    7933             :     A->setImplicit(true);
    7934             :     return A;
    7935             :   }
    7936             : 
    7937             :   TransparentUnionAttr(SourceRange R, ASTContext &Ctx
    7938             :               , unsigned SI
    7939             :              )
    7940             :     : InheritableAttr(attr::TransparentUnion, R, SI, false, false)
    7941             :   {
    7942             :   }
    7943             : 
    7944             :   TransparentUnionAttr *clone(ASTContext &C) const;
    7945             :   void printPretty(raw_ostream &OS,
    7946             :                    const PrintingPolicy &Policy) const;
    7947             :   const char *getSpelling() const;
    7948             : 
    7949             : 
    7950             :   static bool classof(const Attr *A) { return A->getKind() == attr::TransparentUnion; }
    7951             : };
    7952             : 
    7953             : class TrivialABIAttr : public InheritableAttr {
    7954             : public:
    7955             :   static TrivialABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    7956             :     auto *A = new (Ctx) TrivialABIAttr(Loc, Ctx, 0);
    7957             :     A->setImplicit(true);
    7958             :     return A;
    7959             :   }
    7960             : 
    7961             :   TrivialABIAttr(SourceRange R, ASTContext &Ctx
    7962             :               , unsigned SI
    7963             :              )
    7964             :     : InheritableAttr(attr::TrivialABI, R, SI, false, false)
    7965             :   {
    7966             :   }
    7967             : 
    7968             :   TrivialABIAttr *clone(ASTContext &C) const;
    7969             :   void printPretty(raw_ostream &OS,
    7970             :                    const PrintingPolicy &Policy) const;
    7971             :   const char *getSpelling() const;
    7972             : 
    7973             : 
    7974          20 :   static bool classof(const Attr *A) { return A->getKind() == attr::TrivialABI; }
    7975             : };
    7976             : 
    7977             : class TryAcquireCapabilityAttr : public InheritableAttr {
    7978             : Expr * successValue;
    7979             : 
    7980             :   unsigned args_Size;
    7981             :   Expr * *args_;
    7982             : 
    7983             : public:
    7984             :   enum Spelling {
    7985             :     GNU_try_acquire_capability = 0,
    7986             :     CXX11_clang_try_acquire_capability = 1,
    7987             :     GNU_try_acquire_shared_capability = 2,
    7988             :     CXX11_clang_try_acquire_shared_capability = 3
    7989             :   };
    7990             : 
    7991             :   static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
    7992             :     auto *A = new (Ctx) TryAcquireCapabilityAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, S);
    7993             :     A->setImplicit(true);
    7994             :     return A;
    7995             :   }
    7996             : 
    7997          19 :   TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
    7998             :               , Expr * SuccessValue
    7999             :               , Expr * *Args, unsigned ArgsSize
    8000             :               , unsigned SI
    8001             :              )
    8002          19 :     : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true)
    8003             :               , successValue(SuccessValue)
    8004          38 :               , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
    8005             :   {
    8006          19 :     std::copy(Args, Args + args_Size, args_);
    8007          19 :   }
    8008             : 
    8009             :   TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
    8010             :               , Expr * SuccessValue
    8011             :               , unsigned SI
    8012             :              )
    8013             :     : InheritableAttr(attr::TryAcquireCapability, R, SI, true, true)
    8014             :               , successValue(SuccessValue)
    8015             :               , args_Size(0), args_(nullptr)
    8016             :   {
    8017             :   }
    8018             : 
    8019             :   TryAcquireCapabilityAttr *clone(ASTContext &C) const;
    8020             :   void printPretty(raw_ostream &OS,
    8021             :                    const PrintingPolicy &Policy) const;
    8022             :   const char *getSpelling() const;
    8023             :   Spelling getSemanticSpelling() const {
    8024             :   switch (SpellingListIndex) {
    8025             :     default: llvm_unreachable("Unknown spelling list index");
    8026             :     case 0: return GNU_try_acquire_capability;
    8027             :     case 1: return CXX11_clang_try_acquire_capability;
    8028             :     case 2: return GNU_try_acquire_shared_capability;
    8029             :     case 3: return CXX11_clang_try_acquire_shared_capability;
    8030             :   }
    8031             :   }
    8032          74 :   bool isShared() const { return SpellingListIndex == 2 ||
    8033             :     SpellingListIndex == 3; }
    8034             :   Expr * getSuccessValue() const {
    8035             :     return successValue;
    8036             :   }
    8037             : 
    8038             :   typedef Expr ** args_iterator;
    8039             :   args_iterator args_begin() const { return args_; }
    8040          87 :   args_iterator args_end() const { return args_ + args_Size; }
    8041             :   unsigned args_size() const { return args_Size; }
    8042          87 :   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
    8043             : 
    8044             : 
    8045             : 
    8046             : 
    8047             :   static bool classof(const Attr *A) { return A->getKind() == attr::TryAcquireCapability; }
    8048             : };
    8049             : 
    8050             : class TypeTagForDatatypeAttr : public InheritableAttr {
    8051             : IdentifierInfo * argumentKind;
    8052             : 
    8053             : TypeSourceInfo * matchingCType;
    8054             : 
    8055             : bool layoutCompatible;
    8056             : 
    8057             : bool mustBeNull;
    8058             : 
    8059             : public:
    8060             :   static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Loc = SourceRange()) {
    8061             :     auto *A = new (Ctx) TypeTagForDatatypeAttr(Loc, Ctx, ArgumentKind, MatchingCType, LayoutCompatible, MustBeNull, 0);
    8062             :     A->setImplicit(true);
    8063             :     return A;
    8064             :   }
    8065             : 
    8066             :   TypeTagForDatatypeAttr(SourceRange R, ASTContext &Ctx
    8067             :               , IdentifierInfo * ArgumentKind
    8068             :               , TypeSourceInfo * MatchingCType
    8069             :               , bool LayoutCompatible
    8070             :               , bool MustBeNull
    8071             :               , unsigned SI
    8072             :              )
    8073         164 :     : InheritableAttr(attr::TypeTagForDatatype, R, SI, false, false)
    8074             :               , argumentKind(ArgumentKind)
    8075             :               , matchingCType(MatchingCType)
    8076             :               , layoutCompatible(LayoutCompatible)
    8077         164 :               , mustBeNull(MustBeNull)
    8078             :   {
    8079             :   }
    8080             : 
    8081             :   TypeTagForDatatypeAttr *clone(ASTContext &C) const;
    8082             :   void printPretty(raw_ostream &OS,
    8083             :                    const PrintingPolicy &Policy) const;
    8084             :   const char *getSpelling() const;
    8085             :   IdentifierInfo * getArgumentKind() const {
    8086             :     return argumentKind;
    8087             :   }
    8088             : 
    8089             :   QualType getMatchingCType() const {
    8090             :     return matchingCType->getType();
    8091             :   }  TypeSourceInfo * getMatchingCTypeLoc() const {
    8092             :     return matchingCType;
    8093             :   }
    8094             : 
    8095             :   bool getLayoutCompatible() const {
    8096             :     return layoutCompatible;
    8097             :   }
    8098             : 
    8099             :   bool getMustBeNull() const {
    8100             :     return mustBeNull;
    8101             :   }
    8102             : 
    8103             : 
    8104             : 
    8105             :   static bool classof(const Attr *A) { return A->getKind() == attr::TypeTagForDatatype; }
    8106             : };
    8107             : 
    8108             : class TypeVisibilityAttr : public InheritableAttr {
    8109             : public:
    8110             :   enum VisibilityType {
    8111             :     Default,
    8112             :     Hidden,
    8113             :     Protected
    8114             :   };
    8115             : private:
    8116             :   VisibilityType visibility;
    8117             : 
    8118             : public:
    8119       61281 :   static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
    8120       61281 :     auto *A = new (Ctx) TypeVisibilityAttr(Loc, Ctx, Visibility, 0);
    8121             :     A->setImplicit(true);
    8122       61281 :     return A;
    8123             :   }
    8124             : 
    8125             :   TypeVisibilityAttr(SourceRange R, ASTContext &Ctx
    8126             :               , VisibilityType Visibility
    8127             :               , unsigned SI
    8128             :              )
    8129       61634 :     : InheritableAttr(attr::TypeVisibility, R, SI, false, false)
    8130       61634 :               , visibility(Visibility)
    8131             :   {
    8132             :   }
    8133             : 
    8134             :   TypeVisibilityAttr *clone(ASTContext &C) const;
    8135             :   void printPretty(raw_ostream &OS,
    8136             :                    const PrintingPolicy &Policy) const;
    8137             :   const char *getSpelling() const;
    8138             :   VisibilityType getVisibility() const {
    8139             :     return visibility;
    8140             :   }
    8141             : 
    8142             :   static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
    8143             :     Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
    8144             :       .Case("default", TypeVisibilityAttr::Default)
    8145             :       .Case("hidden", TypeVisibilityAttr::Hidden)
    8146             :       .Case("internal", TypeVisibilityAttr::Hidden)
    8147             :       .Case("protected", TypeVisibilityAttr::Protected)
    8148             :       .Default(Optional<VisibilityType>());
    8149             :     if (R) {
    8150             :       Out = *R;
    8151             :       return true;
    8152             :     }
    8153             :     return false;
    8154             :   }
    8155             : 
    8156             :   static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
    8157           0 :     switch(Val) {
    8158             :     case TypeVisibilityAttr::Default: return "default";
    8159           0 :     case TypeVisibilityAttr::Hidden: return "hidden";
    8160           0 :     case TypeVisibilityAttr::Protected: return "protected";
    8161             :     }
    8162           0 :     llvm_unreachable("No enumerator with that value");
    8163             :   }
    8164             : 
    8165             : 
    8166           0 :   static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; }
    8167             : };
    8168             : 
    8169             : class UnavailableAttr : public InheritableAttr {
    8170             : unsigned messageLength;
    8171             : char *message;
    8172             : 
    8173             : public:
    8174             :   enum ImplicitReason {
    8175             :     IR_None,
    8176             :     IR_ARCForbiddenType,
    8177             :     IR_ForbiddenWeak,
    8178             :     IR_ARCForbiddenConversion,
    8179             :     IR_ARCInitReturnsUnrelated,
    8180             :     IR_ARCFieldWithOwnership
    8181             :   };
    8182             : private:
    8183             :   ImplicitReason implicitReason;
    8184             : 
    8185             : public:
    8186          52 :   static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, ImplicitReason ImplicitReason, SourceRange Loc = SourceRange()) {
    8187         104 :     auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, ImplicitReason, 0);
    8188             :     A->setImplicit(true);
    8189          52 :     return A;
    8190             :   }
    8191             : 
    8192             :   static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
    8193             :     auto *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, 0);
    8194             :     A->setImplicit(true);
    8195             :     return A;
    8196             :   }
    8197             : 
    8198         118 :   UnavailableAttr(SourceRange R, ASTContext &Ctx
    8199             :               , llvm::StringRef Message
    8200             :               , ImplicitReason ImplicitReason
    8201             :               , unsigned SI
    8202             :              )
    8203         118 :     : InheritableAttr(attr::Unavailable, R, SI, false, false)
    8204         118 :               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
    8205         236 :               , implicitReason(ImplicitReason)
    8206             :   {
    8207         118 :       if (!Message.empty())
    8208          12 :         std::memcpy(message, Message.data(), messageLength);
    8209         118 :   }
    8210             : 
    8211         897 :   UnavailableAttr(SourceRange R, ASTContext &Ctx
    8212             :               , llvm::StringRef Message
    8213             :               , unsigned SI
    8214             :              )
    8215         897 :     : InheritableAttr(attr::Unavailable, R, SI, false, false)
    8216         897 :               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
    8217        1794 :               , implicitReason(ImplicitReason(0))
    8218             :   {
    8219         897 :       if (!Message.empty())
    8220        1404 :         std::memcpy(message, Message.data(), messageLength);
    8221         897 :   }
    8222             : 
    8223             :   UnavailableAttr(SourceRange R, ASTContext &Ctx
    8224             :               , unsigned SI
    8225             :              )
    8226             :     : InheritableAttr(attr::Unavailable, R, SI, false, false)
    8227             :               , messageLength(0),message(nullptr)
    8228             :               , implicitReason(ImplicitReason(0))
    8229             :   {
    8230             :   }
    8231             : 
    8232             :   UnavailableAttr *clone(ASTContext &C) const;
    8233             :   void printPretty(raw_ostream &OS,
    8234             :                    const PrintingPolicy &Policy) const;
    8235             :   const char *getSpelling() const;
    8236             :   llvm::StringRef getMessage() const {
    8237         635 :     return llvm::StringRef(message, messageLength);
    8238             :   }
    8239             :   unsigned getMessageLength() const {
    8240             :     return messageLength;
    8241             :   }
    8242             :   void setMessage(ASTContext &C, llvm::StringRef S) {
    8243             :     messageLength = S.size();
    8244             :     this->message = new (C, 1) char [messageLength];
    8245             :     if (!S.empty())
    8246             :       std::memcpy(this->message, S.data(), messageLength);
    8247             :   }
    8248             : 
    8249             :   ImplicitReason getImplicitReason() const {
    8250             :     return implicitReason;
    8251             :   }
    8252             : 
    8253             : 
    8254             : 
    8255             :   static bool classof(const Attr *A) { return A->getKind() == attr::Unavailable; }
    8256             : };
    8257             : 
    8258             : class UnusedAttr : public InheritableAttr {
    8259             : public:
    8260             :   enum Spelling {
    8261             :     CXX11_maybe_unused = 0,
    8262             :     GNU_unused = 1,
    8263             :     CXX11_gnu_unused = 2,
    8264             :     C2x_maybe_unused = 3
    8265             :   };
    8266             : 
    8267          19 :   static UnusedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    8268          19 :     auto *A = new (Ctx) UnusedAttr(Loc, Ctx, S);
    8269             :     A->setImplicit(true);
    8270          19 :     return A;
    8271             :   }
    8272             : 
    8273             :   UnusedAttr(SourceRange R, ASTContext &Ctx
    8274             :               , unsigned SI
    8275             :              )
    8276             :     : InheritableAttr(attr::Unused, R, SI, false, false)
    8277             :   {
    8278             :   }
    8279             : 
    8280             :   UnusedAttr *clone(ASTContext &C) const;
    8281             :   void printPretty(raw_ostream &OS,
    8282             :                    const PrintingPolicy &Policy) const;
    8283             :   const char *getSpelling() const;
    8284             :   Spelling getSemanticSpelling() const {
    8285        7132 :   switch (SpellingListIndex) {
    8286           0 :     default: llvm_unreachable("Unknown spelling list index");
    8287             :     case 0: return CXX11_maybe_unused;
    8288             :     case 1: return GNU_unused;
    8289             :     case 2: return CXX11_gnu_unused;
    8290             :     case 3: return C2x_maybe_unused;
    8291             :   }
    8292             :   }
    8293             : 
    8294             : 
    8295             :   static bool classof(const Attr *A) { return A->getKind() == attr::Unused; }
    8296             : };
    8297             : 
    8298             : class UsedAttr : public InheritableAttr {
    8299             : public:
    8300          56 :   static UsedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8301          56 :     auto *A = new (Ctx) UsedAttr(Loc, Ctx, 0);
    8302             :     A->setImplicit(true);
    8303          56 :     return A;
    8304             :   }
    8305             : 
    8306             :   UsedAttr(SourceRange R, ASTContext &Ctx
    8307             :               , unsigned SI
    8308             :              )
    8309             :     : InheritableAttr(attr::Used, R, SI, false, false)
    8310             :   {
    8311             :   }
    8312             : 
    8313             :   UsedAttr *clone(ASTContext &C) const;
    8314             :   void printPretty(raw_ostream &OS,
    8315             :                    const PrintingPolicy &Policy) const;
    8316             :   const char *getSpelling() const;
    8317             : 
    8318             : 
    8319           4 :   static bool classof(const Attr *A) { return A->getKind() == attr::Used; }
    8320             : };
    8321             : 
    8322             : class UuidAttr : public InheritableAttr {
    8323             : unsigned guidLength;
    8324             : char *guid;
    8325             : 
    8326             : public:
    8327             :   static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Loc = SourceRange()) {
    8328             :     auto *A = new (Ctx) UuidAttr(Loc, Ctx, Guid, 0);
    8329             :     A->setImplicit(true);
    8330             :     return A;
    8331             :   }
    8332             : 
    8333         136 :   UuidAttr(SourceRange R, ASTContext &Ctx
    8334             :               , llvm::StringRef Guid
    8335             :               , unsigned SI
    8336             :              )
    8337         136 :     : InheritableAttr(attr::Uuid, R, SI, false, false)
    8338         272 :               , guidLength(Guid.size()),guid(new (Ctx, 1) char[guidLength])
    8339             :   {
    8340         136 :       if (!Guid.empty())
    8341         272 :         std::memcpy(guid, Guid.data(), guidLength);
    8342         136 :   }
    8343             : 
    8344             :   UuidAttr *clone(ASTContext &C) const;
    8345             :   void printPretty(raw_ostream &OS,
    8346             :                    const PrintingPolicy &Policy) const;
    8347             :   const char *getSpelling() const;
    8348             :   llvm::StringRef getGuid() const {
    8349         178 :     return llvm::StringRef(guid, guidLength);
    8350             :   }
    8351             :   unsigned getGuidLength() const {
    8352             :     return guidLength;
    8353             :   }
    8354             :   void setGuid(ASTContext &C, llvm::StringRef S) {
    8355             :     guidLength = S.size();
    8356             :     this->guid = new (C, 1) char [guidLength];
    8357             :     if (!S.empty())
    8358             :       std::memcpy(this->guid, S.data(), guidLength);
    8359             :   }
    8360             : 
    8361             : 
    8362             : 
    8363          16 :   static bool classof(const Attr *A) { return A->getKind() == attr::Uuid; }
    8364             : };
    8365             : 
    8366             : class VecReturnAttr : public InheritableAttr {
    8367             : public:
    8368             :   static VecReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8369             :     auto *A = new (Ctx) VecReturnAttr(Loc, Ctx, 0);
    8370             :     A->setImplicit(true);
    8371             :     return A;
    8372             :   }
    8373             : 
    8374             :   VecReturnAttr(SourceRange R, ASTContext &Ctx
    8375             :               , unsigned SI
    8376             :              )
    8377             :     : InheritableAttr(attr::VecReturn, R, SI, false, false)
    8378             :   {
    8379             :   }
    8380             : 
    8381             :   VecReturnAttr *clone(ASTContext &C) const;
    8382             :   void printPretty(raw_ostream &OS,
    8383             :                    const PrintingPolicy &Policy) const;
    8384             :   const char *getSpelling() const;
    8385             : 
    8386             : 
    8387             :   static bool classof(const Attr *A) { return A->getKind() == attr::VecReturn; }
    8388             : };
    8389             : 
    8390             : class VecTypeHintAttr : public InheritableAttr {
    8391             : TypeSourceInfo * typeHint;
    8392             : 
    8393             : public:
    8394             :   static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Loc = SourceRange()) {
    8395             :     auto *A = new (Ctx) VecTypeHintAttr(Loc, Ctx, TypeHint, 0);
    8396             :     A->setImplicit(true);
    8397             :     return A;
    8398             :   }
    8399             : 
    8400             :   VecTypeHintAttr(SourceRange R, ASTContext &Ctx
    8401             :               , TypeSourceInfo * TypeHint
    8402             :               , unsigned SI
    8403             :              )
    8404           5 :     : InheritableAttr(attr::VecTypeHint, R, SI, false, false)
    8405           5 :               , typeHint(TypeHint)
    8406             :   {
    8407             :   }
    8408             : 
    8409             :   VecTypeHintAttr *clone(ASTContext &C) const;
    8410             :   void printPretty(raw_ostream &OS,
    8411             :                    const PrintingPolicy &Policy) const;
    8412             :   const char *getSpelling() const;
    8413             :   QualType getTypeHint() const {
    8414             :     return typeHint->getType();
    8415             :   }  TypeSourceInfo * getTypeHintLoc() const {
    8416             :     return typeHint;
    8417             :   }
    8418             : 
    8419             : 
    8420             : 
    8421             :   static bool classof(const Attr *A) { return A->getKind() == attr::VecTypeHint; }
    8422             : };
    8423             : 
    8424             : class VectorCallAttr : public InheritableAttr {
    8425             : public:
    8426             :   static VectorCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8427             :     auto *A = new (Ctx) VectorCallAttr(Loc, Ctx, 0);
    8428             :     A->setImplicit(true);
    8429             :     return A;
    8430             :   }
    8431             : 
    8432             :   VectorCallAttr(SourceRange R, ASTContext &Ctx
    8433             :               , unsigned SI
    8434             :              )
    8435             :     : InheritableAttr(attr::VectorCall, R, SI, false, false)
    8436             :   {
    8437             :   }
    8438             : 
    8439             :   VectorCallAttr *clone(ASTContext &C) const;
    8440             :   void printPretty(raw_ostream &OS,
    8441             :                    const PrintingPolicy &Policy) const;
    8442             :   const char *getSpelling() const;
    8443             : 
    8444             : 
    8445             :   static bool classof(const Attr *A) { return A->getKind() == attr::VectorCall; }
    8446             : };
    8447             : 
    8448             : class VisibilityAttr : public InheritableAttr {
    8449             : public:
    8450             :   enum VisibilityType {
    8451             :     Default,
    8452             :     Hidden,
    8453             :     Protected
    8454             :   };
    8455             : private:
    8456             :   VisibilityType visibility;
    8457             : 
    8458             : public:
    8459      120719 :   static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
    8460      120719 :     auto *A = new (Ctx) VisibilityAttr(Loc, Ctx, Visibility, 0);
    8461             :     A->setImplicit(true);
    8462      120719 :     return A;
    8463             :   }
    8464             : 
    8465             :   VisibilityAttr(SourceRange R, ASTContext &Ctx
    8466             :               , VisibilityType Visibility
    8467             :               , unsigned SI
    8468             :              )
    8469      171710 :     : InheritableAttr(attr::Visibility, R, SI, false, false)
    8470      171710 :               , visibility(Visibility)
    8471             :   {
    8472             :   }
    8473             : 
    8474             :   VisibilityAttr *clone(ASTContext &C) const;
    8475             :   void printPretty(raw_ostream &OS,
    8476             :                    const PrintingPolicy &Policy) const;
    8477             :   const char *getSpelling() const;
    8478             :   VisibilityType getVisibility() const {
    8479             :     return visibility;
    8480             :   }
    8481             : 
    8482       48361 :   static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
    8483       48361 :     Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
    8484       48361 :       .Case("default", VisibilityAttr::Default)
    8485       48361 :       .Case("hidden", VisibilityAttr::Hidden)
    8486       48361 :       .Case("internal", VisibilityAttr::Hidden)
    8487       48361 :       .Case("protected", VisibilityAttr::Protected)
    8488             :       .Default(Optional<VisibilityType>());
    8489       48361 :     if (R) {
    8490       48361 :       Out = *R;
    8491       48361 :       return true;
    8492             :     }
    8493             :     return false;
    8494             :   }
    8495             : 
    8496             :   static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
    8497           3 :     switch(Val) {
    8498             :     case VisibilityAttr::Default: return "default";
    8499           2 :     case VisibilityAttr::Hidden: return "hidden";
    8500           0 :     case VisibilityAttr::Protected: return "protected";
    8501             :     }
    8502           0 :     llvm_unreachable("No enumerator with that value");
    8503             :   }
    8504             : 
    8505             : 
    8506           6 :   static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; }
    8507             : };
    8508             : 
    8509             : class WarnUnusedAttr : public InheritableAttr {
    8510             : public:
    8511             :   static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8512             :     auto *A = new (Ctx) WarnUnusedAttr(Loc, Ctx, 0);
    8513             :     A->setImplicit(true);
    8514             :     return A;
    8515             :   }
    8516             : 
    8517             :   WarnUnusedAttr(SourceRange R, ASTContext &Ctx
    8518             :               , unsigned SI
    8519             :              )
    8520             :     : InheritableAttr(attr::WarnUnused, R, SI, false, false)
    8521             :   {
    8522             :   }
    8523             : 
    8524             :   WarnUnusedAttr *clone(ASTContext &C) const;
    8525             :   void printPretty(raw_ostream &OS,
    8526             :                    const PrintingPolicy &Policy) const;
    8527             :   const char *getSpelling() const;
    8528             : 
    8529             : 
    8530             :   static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnused; }
    8531             : };
    8532             : 
    8533             : class WarnUnusedResultAttr : public InheritableAttr {
    8534             : public:
    8535             :   enum Spelling {
    8536             :     CXX11_nodiscard = 0,
    8537             :     C2x_nodiscard = 1,
    8538             :     CXX11_clang_warn_unused_result = 2,
    8539             :     GNU_warn_unused_result = 3,
    8540             :     CXX11_gnu_warn_unused_result = 4
    8541             :   };
    8542             : 
    8543             :   static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    8544             :     auto *A = new (Ctx) WarnUnusedResultAttr(Loc, Ctx, S);
    8545             :     A->setImplicit(true);
    8546             :     return A;
    8547             :   }
    8548             : 
    8549             :   WarnUnusedResultAttr(SourceRange R, ASTContext &Ctx
    8550             :               , unsigned SI
    8551             :              )
    8552             :     : InheritableAttr(attr::WarnUnusedResult, R, SI, false, false)
    8553             :   {
    8554             :   }
    8555             : 
    8556             :   WarnUnusedResultAttr *clone(ASTContext &C) const;
    8557             :   void printPretty(raw_ostream &OS,
    8558             :                    const PrintingPolicy &Policy) const;
    8559             :   const char *getSpelling() const;
    8560             :   Spelling getSemanticSpelling() const {
    8561             :   switch (SpellingListIndex) {
    8562             :     default: llvm_unreachable("Unknown spelling list index");
    8563             :     case 0: return CXX11_nodiscard;
    8564             :     case 1: return C2x_nodiscard;
    8565             :     case 2: return CXX11_clang_warn_unused_result;
    8566             :     case 3: return GNU_warn_unused_result;
    8567             :     case 4: return CXX11_gnu_warn_unused_result;
    8568             :   }
    8569             :   }
    8570             : 
    8571             : 
    8572             :   static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnusedResult; }
    8573             : };
    8574             : 
    8575             : class WeakAttr : public InheritableAttr {
    8576             : public:
    8577          82 :   static WeakAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8578          82 :     auto *A = new (Ctx) WeakAttr(Loc, Ctx, 0);
    8579             :     A->setImplicit(true);
    8580          82 :     return A;
    8581             :   }
    8582             : 
    8583             :   WeakAttr(SourceRange R, ASTContext &Ctx
    8584             :               , unsigned SI
    8585             :              )
    8586             :     : InheritableAttr(attr::Weak, R, SI, false, false)
    8587             :   {
    8588             :   }
    8589             : 
    8590             :   WeakAttr *clone(ASTContext &C) const;
    8591             :   void printPretty(raw_ostream &OS,
    8592             :                    const PrintingPolicy &Policy) const;
    8593             :   const char *getSpelling() const;
    8594             : 
    8595             : 
    8596          10 :   static bool classof(const Attr *A) { return A->getKind() == attr::Weak; }
    8597             : };
    8598             : 
    8599             : class WeakImportAttr : public InheritableAttr {
    8600             : public:
    8601             :   static WeakImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8602             :     auto *A = new (Ctx) WeakImportAttr(Loc, Ctx, 0);
    8603             :     A->setImplicit(true);
    8604             :     return A;
    8605             :   }
    8606             : 
    8607             :   WeakImportAttr(SourceRange R, ASTContext &Ctx
    8608             :               , unsigned SI
    8609             :              )
    8610             :     : InheritableAttr(attr::WeakImport, R, SI, false, false)
    8611             :   {
    8612             :   }
    8613             : 
    8614             :   WeakImportAttr *clone(ASTContext &C) const;
    8615             :   void printPretty(raw_ostream &OS,
    8616             :                    const PrintingPolicy &Policy) const;
    8617             :   const char *getSpelling() const;
    8618             : 
    8619             : 
    8620           2 :   static bool classof(const Attr *A) { return A->getKind() == attr::WeakImport; }
    8621             : };
    8622             : 
    8623             : class WeakRefAttr : public InheritableAttr {
    8624             : unsigned aliaseeLength;
    8625             : char *aliasee;
    8626             : 
    8627             : public:
    8628             :   static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
    8629             :     auto *A = new (Ctx) WeakRefAttr(Loc, Ctx, Aliasee, 0);
    8630             :     A->setImplicit(true);
    8631             :     return A;
    8632             :   }
    8633             : 
    8634           0 :   WeakRefAttr(SourceRange R, ASTContext &Ctx
    8635             :               , llvm::StringRef Aliasee
    8636             :               , unsigned SI
    8637             :              )
    8638           0 :     : InheritableAttr(attr::WeakRef, R, SI, false, false)
    8639           0 :               , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
    8640             :   {
    8641           0 :       if (!Aliasee.empty())
    8642           0 :         std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
    8643           0 :   }
    8644             : 
    8645             :   WeakRefAttr(SourceRange R, ASTContext &Ctx
    8646             :               , unsigned SI
    8647             :              )
    8648       11791 :     : InheritableAttr(attr::WeakRef, R, SI, false, false)
    8649       11791 :               , aliaseeLength(0),aliasee(nullptr)
    8650             :   {
    8651             :   }
    8652             : 
    8653             :   WeakRefAttr *clone(ASTContext &C) const;
    8654             :   void printPretty(raw_ostream &OS,
    8655             :                    const PrintingPolicy &Policy) const;
    8656             :   const char *getSpelling() const;
    8657             :   llvm::StringRef getAliasee() const {
    8658           0 :     return llvm::StringRef(aliasee, aliaseeLength);
    8659             :   }
    8660             :   unsigned getAliaseeLength() const {
    8661             :     return aliaseeLength;
    8662             :   }
    8663             :   void setAliasee(ASTContext &C, llvm::StringRef S) {
    8664             :     aliaseeLength = S.size();
    8665             :     this->aliasee = new (C, 1) char [aliaseeLength];
    8666             :     if (!S.empty())
    8667             :       std::memcpy(this->aliasee, S.data(), aliaseeLength);
    8668             :   }
    8669             : 
    8670             : 
    8671             : 
    8672           8 :   static bool classof(const Attr *A) { return A->getKind() == attr::WeakRef; }
    8673             : };
    8674             : 
    8675             : class WorkGroupSizeHintAttr : public InheritableAttr {
    8676             : unsigned xDim;
    8677             : 
    8678             : unsigned yDim;
    8679             : 
    8680             : unsigned zDim;
    8681             : 
    8682             : public:
    8683             :   static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
    8684             :     auto *A = new (Ctx) WorkGroupSizeHintAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
    8685             :     A->setImplicit(true);
    8686             :     return A;
    8687             :   }
    8688             : 
    8689             :   WorkGroupSizeHintAttr(SourceRange R, ASTContext &Ctx
    8690             :               , unsigned XDim
    8691             :               , unsigned YDim
    8692             :               , unsigned ZDim
    8693             :               , unsigned SI
    8694             :              )
    8695           5 :     : InheritableAttr(attr::WorkGroupSizeHint, R, SI, false, false)
    8696             :               , xDim(XDim)
    8697             :               , yDim(YDim)
    8698           5 :               , zDim(ZDim)
    8699             :   {
    8700             :   }
    8701             : 
    8702             :   WorkGroupSizeHintAttr *clone(ASTContext &C) const;
    8703             :   void printPretty(raw_ostream &OS,
    8704             :                    const PrintingPolicy &Policy) const;
    8705             :   const char *getSpelling() const;
    8706             :   unsigned getXDim() const {
    8707             :     return xDim;
    8708             :   }
    8709             : 
    8710             :   unsigned getYDim() const {
    8711             :     return yDim;
    8712             :   }
    8713             : 
    8714             :   unsigned getZDim() const {
    8715             :     return zDim;
    8716             :   }
    8717             : 
    8718             : 
    8719             : 
    8720             :   static bool classof(const Attr *A) { return A->getKind() == attr::WorkGroupSizeHint; }
    8721             : };
    8722             : 
    8723             : class X86ForceAlignArgPointerAttr : public InheritableAttr {
    8724             : public:
    8725             :   static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
    8726             :     auto *A = new (Ctx) X86ForceAlignArgPointerAttr(Loc, Ctx, 0);
    8727             :     A->setImplicit(true);
    8728             :     return A;
    8729             :   }
    8730             : 
    8731             :   X86ForceAlignArgPointerAttr(SourceRange R, ASTContext &Ctx
    8732             :               , unsigned SI
    8733             :              )
    8734             :     : InheritableAttr(attr::X86ForceAlignArgPointer, R, SI, false, false)
    8735             :   {
    8736             :   }
    8737             : 
    8738             :   X86ForceAlignArgPointerAttr *clone(ASTContext &C) const;
    8739             :   void printPretty(raw_ostream &OS,
    8740             :                    const PrintingPolicy &Policy) const;
    8741             :   const char *getSpelling() const;
    8742             : 
    8743             : 
    8744             :   static bool classof(const Attr *A) { return A->getKind() == attr::X86ForceAlignArgPointer; }
    8745             : };
    8746             : 
    8747             : class XRayInstrumentAttr : public InheritableAttr {
    8748             : public:
    8749             :   enum Spelling {
    8750             :     GNU_xray_always_instrument = 0,
    8751             :     CXX11_clang_xray_always_instrument = 1,
    8752             :     C2x_clang_xray_always_instrument = 2,
    8753             :     GNU_xray_never_instrument = 3,
    8754             :     CXX11_clang_xray_never_instrument = 4,
    8755             :     C2x_clang_xray_never_instrument = 5
    8756             :   };
    8757             : 
    8758             :   static XRayInstrumentAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
    8759             :     auto *A = new (Ctx) XRayInstrumentAttr(Loc, Ctx, S);
    8760             :     A->setImplicit(true);
    8761             :     return A;
    8762             :   }
    8763             : 
    8764             :   XRayInstrumentAttr(SourceRange R, ASTContext &Ctx
    8765             :               , unsigned SI
    8766             :              )
    8767             :     : InheritableAttr(attr::XRayInstrument, R, SI, false, false)
    8768             :   {
    8769             :   }
    8770             : 
    8771             :   XRayInstrumentAttr *clone(ASTContext &C) const;
    8772             :   void printPretty(raw_ostream &OS,
    8773             :                    const PrintingPolicy &Policy) const;
    8774             :   const char *getSpelling() const;
    8775             :   Spelling getSemanticSpelling() const {
    8776             :   switch (SpellingListIndex) {
    8777             :     default: llvm_unreachable("Unknown spelling list index");
    8778             :     case 0: return GNU_xray_always_instrument;
    8779             :     case 1: return CXX11_clang_xray_always_instrument;
    8780             :     case 2: return C2x_clang_xray_always_instrument;
    8781             :     case 3: return GNU_xray_never_instrument;
    8782             :     case 4: return CXX11_clang_xray_never_instrument;
    8783             :     case 5: return C2x_clang_xray_never_instrument;
    8784             :   }
    8785             :   }
    8786          35 :   bool alwaysXRayInstrument() const { return SpellingListIndex == 0 ||
    8787          35 :     SpellingListIndex == 1 ||
    8788             :     SpellingListIndex == 2; }
    8789          55 :   bool neverXRayInstrument() const { return SpellingListIndex == 3 ||
    8790          55 :     SpellingListIndex == 4 ||
    8791             :     SpellingListIndex == 5; }
    8792             : 
    8793             : 
    8794             :   static bool classof(const Attr *A) { return A->getKind() == attr::XRayInstrument; }
    8795             : };
    8796             : 
    8797             : class XRayLogArgsAttr : public InheritableAttr {
    8798             : unsigned argumentCount;
    8799             : 
    8800             : public:
    8801             :   static XRayLogArgsAttr *CreateImplicit(ASTContext &Ctx, unsigned ArgumentCount, SourceRange Loc = SourceRange()) {
    8802             :     auto *A = new (Ctx) XRayLogArgsAttr(Loc, Ctx, ArgumentCount, 0);
    8803             :     A->setImplicit(true);
    8804             :     return A;
    8805             :   }
    8806             : 
    8807             :   XRayLogArgsAttr(SourceRange R, ASTContext &Ctx
    8808             :               , unsigned ArgumentCount
    8809             :               , unsigned SI
    8810             :              )
    8811          11 :     : InheritableAttr(attr::XRayLogArgs, R, SI, false, false)
    8812          11 :               , argumentCount(ArgumentCount)
    8813             :   {
    8814             :   }
    8815             : 
    8816             :   XRayLogArgsAttr *clone(ASTContext &C) const;
    8817             :   void printPretty(raw_ostream &OS,
    8818             :                    const PrintingPolicy &Policy) const;
    8819             :   const char *getSpelling() const;
    8820             :   unsigned getArgumentCount() const {
    8821             :     return argumentCount;
    8822             :   }
    8823             : 
    8824             : 
    8825             : 
    8826             :   static bool classof(const Attr *A) { return A->getKind() == attr::XRayLogArgs; }
    8827             : };
    8828             : 
    8829             : #endif // LLVM_CLANG_ATTR_CLASSES_INC

Generated by: LCOV version 1.13