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