Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Attribute classes' definitions *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 : #ifndef LLVM_CLANG_ATTR_CLASSES_INC
10 : #define LLVM_CLANG_ATTR_CLASSES_INC
11 :
12 : class AMDGPUNumSGPRAttr : public InheritableAttr {
13 : unsigned numSGPR;
14 :
15 :
16 : public:
17 : static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) {
18 : AMDGPUNumSGPRAttr *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0);
19 : A->setImplicit(true);
20 : return A;
21 : }
22 :
23 : AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx
24 : , unsigned NumSGPR
25 : , unsigned SI
26 : )
27 : : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, 0, 0)
28 : , numSGPR(NumSGPR)
29 : {
30 :
31 : }
32 :
33 : AMDGPUNumSGPRAttr *clone(ASTContext &C) const;
34 : void printPretty(raw_ostream &OS,
35 : const PrintingPolicy &Policy) const;
36 : const char *getSpelling() const;
37 : unsigned getNumSGPR() const {
38 : return numSGPR;
39 : }
40 :
41 :
42 :
43 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; }
44 : };
45 :
46 : class AMDGPUNumVGPRAttr : public InheritableAttr {
47 : unsigned numVGPR;
48 :
49 :
50 : public:
51 : static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) {
52 : AMDGPUNumVGPRAttr *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0);
53 : A->setImplicit(true);
54 : return A;
55 : }
56 :
57 : AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx
58 : , unsigned NumVGPR
59 : , unsigned SI
60 : )
61 : : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, 0, 0)
62 : , numVGPR(NumVGPR)
63 : {
64 :
65 : }
66 :
67 : AMDGPUNumVGPRAttr *clone(ASTContext &C) const;
68 : void printPretty(raw_ostream &OS,
69 : const PrintingPolicy &Policy) const;
70 : const char *getSpelling() const;
71 : unsigned getNumVGPR() const {
72 : return numVGPR;
73 : }
74 :
75 :
76 :
77 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; }
78 : };
79 :
80 : class ARMInterruptAttr : public InheritableAttr {
81 : public:
82 : enum InterruptType {
83 : IRQ,
84 : FIQ,
85 : SWI,
86 : ABORT,
87 : UNDEF,
88 : Generic
89 : };
90 : private:
91 : InterruptType interrupt;
92 :
93 :
94 : public:
95 : static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
96 : ARMInterruptAttr *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0);
97 : A->setImplicit(true);
98 : return A;
99 : }
100 :
101 : ARMInterruptAttr(SourceRange R, ASTContext &Ctx
102 : , InterruptType Interrupt
103 : , unsigned SI
104 : )
105 : : InheritableAttr(attr::ARMInterrupt, R, SI, 0, 0)
106 : , interrupt(Interrupt)
107 : {
108 :
109 : }
110 :
111 : ARMInterruptAttr(SourceRange R, ASTContext &Ctx
112 : , unsigned SI
113 : )
114 : : InheritableAttr(attr::ARMInterrupt, R, SI, 0, 0)
115 : , interrupt(InterruptType(0))
116 : {
117 : }
118 :
119 : ARMInterruptAttr *clone(ASTContext &C) const;
120 : void printPretty(raw_ostream &OS,
121 : const PrintingPolicy &Policy) const;
122 : const char *getSpelling() const;
123 : InterruptType getInterrupt() const {
124 : return interrupt;
125 : }
126 :
127 : static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
128 : Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
129 : .Case("IRQ", ARMInterruptAttr::IRQ)
130 : .Case("FIQ", ARMInterruptAttr::FIQ)
131 : .Case("SWI", ARMInterruptAttr::SWI)
132 : .Case("ABORT", ARMInterruptAttr::ABORT)
133 : .Case("UNDEF", ARMInterruptAttr::UNDEF)
134 : .Case("", ARMInterruptAttr::Generic)
135 : .Default(Optional<InterruptType>());
136 : if (R) {
137 : Out = *R;
138 : return true;
139 : }
140 : return false;
141 : }
142 :
143 : static const char *ConvertInterruptTypeToStr(InterruptType Val) {
144 : switch(Val) {
145 : case ARMInterruptAttr::IRQ: return "IRQ";
146 : case ARMInterruptAttr::FIQ: return "FIQ";
147 : case ARMInterruptAttr::SWI: return "SWI";
148 : case ARMInterruptAttr::ABORT: return "ABORT";
149 : case ARMInterruptAttr::UNDEF: return "UNDEF";
150 : case ARMInterruptAttr::Generic: return "";
151 : }
152 : llvm_unreachable("No enumerator with that value");
153 : }
154 :
155 :
156 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; }
157 : };
158 :
159 : class AcquireCapabilityAttr : public InheritableAttr {
160 : unsigned args_Size;
161 : Expr * *args_;
162 :
163 :
164 : public:
165 : enum Spelling {
166 : GNU_acquire_capability = 0,
167 : CXX11_clang_acquire_capability = 1,
168 : GNU_acquire_shared_capability = 2,
169 : CXX11_clang_acquire_shared_capability = 3,
170 : GNU_exclusive_lock_function = 4,
171 : GNU_shared_lock_function = 5
172 : };
173 :
174 : static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
175 : AcquireCapabilityAttr *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
176 : A->setImplicit(true);
177 : return A;
178 : }
179 :
180 : AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
181 : , Expr * *Args, unsigned ArgsSize
182 : , unsigned SI
183 : )
184 : : InheritableAttr(attr::AcquireCapability, R, SI, 1, 1)
185 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
186 : {
187 : std::copy(Args, Args + args_Size, args_);
188 : }
189 :
190 : AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
191 : , unsigned SI
192 : )
193 : : InheritableAttr(attr::AcquireCapability, R, SI, 1, 1)
194 : , args_Size(0), args_(nullptr)
195 : {
196 : }
197 :
198 : AcquireCapabilityAttr *clone(ASTContext &C) const;
199 : void printPretty(raw_ostream &OS,
200 : const PrintingPolicy &Policy) const;
201 : const char *getSpelling() const;
202 : Spelling getSemanticSpelling() const {
203 : switch (SpellingListIndex) {
204 : default: llvm_unreachable("Unknown spelling list index");
205 : case 0: return GNU_acquire_capability;
206 : case 1: return CXX11_clang_acquire_capability;
207 : case 2: return GNU_acquire_shared_capability;
208 : case 3: return CXX11_clang_acquire_shared_capability;
209 : case 4: return GNU_exclusive_lock_function;
210 : case 5: return GNU_shared_lock_function;
211 : }
212 : }
213 : bool isShared() const { return SpellingListIndex == 2 ||
214 : SpellingListIndex == 3 ||
215 : SpellingListIndex == 5; }
216 : typedef Expr ** args_iterator;
217 0 : args_iterator args_begin() const { return args_; }
218 0 : args_iterator args_end() const { return args_ + args_Size; }
219 : unsigned args_size() const { return args_Size; }
220 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
221 :
222 :
223 :
224 :
225 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; }
226 : };
227 :
228 : class AcquiredAfterAttr : public InheritableAttr {
229 : unsigned args_Size;
230 : Expr * *args_;
231 :
232 :
233 : public:
234 : static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
235 : AcquiredAfterAttr *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0);
236 : A->setImplicit(true);
237 : return A;
238 : }
239 :
240 : AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
241 : , Expr * *Args, unsigned ArgsSize
242 : , unsigned SI
243 : )
244 : : InheritableAttr(attr::AcquiredAfter, R, SI, 1, 1)
245 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
246 : {
247 : std::copy(Args, Args + args_Size, args_);
248 : }
249 :
250 : AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
251 : , unsigned SI
252 : )
253 : : InheritableAttr(attr::AcquiredAfter, R, SI, 1, 1)
254 : , args_Size(0), args_(nullptr)
255 : {
256 : }
257 :
258 : AcquiredAfterAttr *clone(ASTContext &C) const;
259 : void printPretty(raw_ostream &OS,
260 : const PrintingPolicy &Policy) const;
261 : const char *getSpelling() const;
262 : typedef Expr ** args_iterator;
263 0 : args_iterator args_begin() const { return args_; }
264 0 : args_iterator args_end() const { return args_ + args_Size; }
265 : unsigned args_size() const { return args_Size; }
266 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
267 :
268 :
269 :
270 :
271 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; }
272 : };
273 :
274 : class AcquiredBeforeAttr : public InheritableAttr {
275 : unsigned args_Size;
276 : Expr * *args_;
277 :
278 :
279 : public:
280 : static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
281 : AcquiredBeforeAttr *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0);
282 : A->setImplicit(true);
283 : return A;
284 : }
285 :
286 : AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
287 : , Expr * *Args, unsigned ArgsSize
288 : , unsigned SI
289 : )
290 : : InheritableAttr(attr::AcquiredBefore, R, SI, 1, 1)
291 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
292 : {
293 : std::copy(Args, Args + args_Size, args_);
294 : }
295 :
296 : AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
297 : , unsigned SI
298 : )
299 : : InheritableAttr(attr::AcquiredBefore, R, SI, 1, 1)
300 : , args_Size(0), args_(nullptr)
301 : {
302 : }
303 :
304 : AcquiredBeforeAttr *clone(ASTContext &C) const;
305 : void printPretty(raw_ostream &OS,
306 : const PrintingPolicy &Policy) const;
307 : const char *getSpelling() const;
308 : typedef Expr ** args_iterator;
309 0 : args_iterator args_begin() const { return args_; }
310 0 : args_iterator args_end() const { return args_ + args_Size; }
311 : unsigned args_size() const { return args_Size; }
312 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
313 :
314 :
315 :
316 :
317 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; }
318 : };
319 :
320 : class AliasAttr : public Attr {
321 : unsigned aliaseeLength;
322 : char *aliasee;
323 :
324 :
325 : public:
326 : static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
327 : AliasAttr *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0);
328 : A->setImplicit(true);
329 : return A;
330 : }
331 :
332 : AliasAttr(SourceRange R, ASTContext &Ctx
333 : , llvm::StringRef Aliasee
334 : , unsigned SI
335 : )
336 : : Attr(attr::Alias, R, SI, 0, 0)
337 : , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
338 : {
339 : if (!Aliasee.empty())
340 : std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
341 : }
342 :
343 : AliasAttr *clone(ASTContext &C) const;
344 : void printPretty(raw_ostream &OS,
345 : const PrintingPolicy &Policy) const;
346 : const char *getSpelling() const;
347 : llvm::StringRef getAliasee() const {
348 : return llvm::StringRef(aliasee, aliaseeLength);
349 : }
350 : unsigned getAliaseeLength() const {
351 : return aliaseeLength;
352 : }
353 : void setAliasee(ASTContext &C, llvm::StringRef S) {
354 : aliaseeLength = S.size();
355 : this->aliasee = new (C, 1) char [aliaseeLength];
356 : if (!S.empty())
357 : std::memcpy(this->aliasee, S.data(), aliaseeLength);
358 : }
359 :
360 :
361 :
362 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Alias; }
363 : };
364 :
365 : class AlignMac68kAttr : public InheritableAttr {
366 :
367 : public:
368 : static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
369 : AlignMac68kAttr *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0);
370 : A->setImplicit(true);
371 : return A;
372 : }
373 :
374 : AlignMac68kAttr(SourceRange R, ASTContext &Ctx
375 : , unsigned SI
376 : )
377 : : InheritableAttr(attr::AlignMac68k, R, SI, 0, 0)
378 : {
379 : }
380 :
381 : AlignMac68kAttr *clone(ASTContext &C) const;
382 : void printPretty(raw_ostream &OS,
383 : const PrintingPolicy &Policy) const;
384 : const char *getSpelling() const;
385 :
386 :
387 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; }
388 : };
389 :
390 : class AlignValueAttr : public Attr {
391 : Expr * alignment;
392 :
393 :
394 : public:
395 : static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) {
396 : AlignValueAttr *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0);
397 : A->setImplicit(true);
398 : return A;
399 : }
400 :
401 : AlignValueAttr(SourceRange R, ASTContext &Ctx
402 : , Expr * Alignment
403 : , unsigned SI
404 : )
405 : : Attr(attr::AlignValue, R, SI, 0, 0)
406 : , alignment(Alignment)
407 : {
408 :
409 : }
410 :
411 : AlignValueAttr *clone(ASTContext &C) const;
412 : void printPretty(raw_ostream &OS,
413 : const PrintingPolicy &Policy) const;
414 : const char *getSpelling() const;
415 : Expr * getAlignment() const {
416 0 : return alignment;
417 : }
418 :
419 :
420 :
421 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; }
422 : };
423 :
424 : class AlignedAttr : public InheritableAttr {
425 : bool isalignmentExpr;
426 : union {
427 : Expr *alignmentExpr;
428 : TypeSourceInfo *alignmentType;
429 : };
430 :
431 :
432 : public:
433 : enum Spelling {
434 : GNU_aligned = 0,
435 : CXX11_gnu_aligned = 1,
436 : Declspec_align = 2,
437 : Keyword_alignas = 3,
438 : Keyword_Alignas = 4
439 : };
440 :
441 : static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) {
442 : AlignedAttr *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S);
443 : A->setImplicit(true);
444 : return A;
445 : }
446 :
447 : AlignedAttr(SourceRange R, ASTContext &Ctx
448 : , bool IsAlignmentExpr, void *Alignment
449 : , unsigned SI
450 : )
451 : : InheritableAttr(attr::Aligned, R, SI, 0, 0)
452 : , isalignmentExpr(IsAlignmentExpr)
453 : {
454 : if (isalignmentExpr)
455 : alignmentExpr = reinterpret_cast<Expr *>(Alignment);
456 : else
457 : alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment);
458 : }
459 :
460 : AlignedAttr(SourceRange R, ASTContext &Ctx
461 : , unsigned SI
462 : )
463 : : InheritableAttr(attr::Aligned, R, SI, 0, 0)
464 : , isalignmentExpr(false)
465 : {
466 : }
467 :
468 : AlignedAttr *clone(ASTContext &C) const;
469 : void printPretty(raw_ostream &OS,
470 : const PrintingPolicy &Policy) const;
471 : const char *getSpelling() const;
472 : Spelling getSemanticSpelling() const {
473 : switch (SpellingListIndex) {
474 : default: llvm_unreachable("Unknown spelling list index");
475 : case 0: return GNU_aligned;
476 : case 1: return CXX11_gnu_aligned;
477 : case 2: return Declspec_align;
478 : case 3: return Keyword_alignas;
479 : case 4: return Keyword_Alignas;
480 : }
481 : }
482 : bool isGNU() const { return SpellingListIndex == 0 ||
483 : SpellingListIndex == 1; }
484 : bool isC11() const { return SpellingListIndex == 4; }
485 : bool isAlignas() const { return SpellingListIndex == 3 ||
486 : SpellingListIndex == 4; }
487 : bool isDeclspec() const { return SpellingListIndex == 2; }
488 : bool isAlignmentDependent() const;
489 : unsigned getAlignment(ASTContext &Ctx) const;
490 : bool isAlignmentExpr() const {
491 : return isalignmentExpr;
492 : }
493 : Expr *getAlignmentExpr() const {
494 : assert(isalignmentExpr);
495 : return alignmentExpr;
496 : }
497 : TypeSourceInfo *getAlignmentType() const {
498 : assert(!isalignmentExpr);
499 : return alignmentType;
500 : }
501 :
502 :
503 :
504 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; }
505 : };
506 :
507 : class AlwaysInlineAttr : public InheritableAttr {
508 :
509 : public:
510 : enum Spelling {
511 : GNU_always_inline = 0,
512 : CXX11_gnu_always_inline = 1,
513 : Keyword_forceinline = 2
514 : };
515 :
516 : static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
517 : AlwaysInlineAttr *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S);
518 : A->setImplicit(true);
519 : return A;
520 : }
521 :
522 : AlwaysInlineAttr(SourceRange R, ASTContext &Ctx
523 : , unsigned SI
524 : )
525 : : InheritableAttr(attr::AlwaysInline, R, SI, 0, 0)
526 : {
527 : }
528 :
529 : AlwaysInlineAttr *clone(ASTContext &C) const;
530 : void printPretty(raw_ostream &OS,
531 : const PrintingPolicy &Policy) const;
532 : const char *getSpelling() const;
533 : Spelling getSemanticSpelling() const {
534 : switch (SpellingListIndex) {
535 : default: llvm_unreachable("Unknown spelling list index");
536 : case 0: return GNU_always_inline;
537 : case 1: return CXX11_gnu_always_inline;
538 : case 2: return Keyword_forceinline;
539 : }
540 : }
541 :
542 :
543 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; }
544 : };
545 :
546 : class AnalyzerNoReturnAttr : public InheritableAttr {
547 :
548 : public:
549 : static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
550 : AnalyzerNoReturnAttr *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0);
551 : A->setImplicit(true);
552 : return A;
553 : }
554 :
555 : AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx
556 : , unsigned SI
557 : )
558 : : InheritableAttr(attr::AnalyzerNoReturn, R, SI, 0, 0)
559 : {
560 : }
561 :
562 : AnalyzerNoReturnAttr *clone(ASTContext &C) const;
563 : void printPretty(raw_ostream &OS,
564 : const PrintingPolicy &Policy) const;
565 : const char *getSpelling() const;
566 :
567 :
568 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; }
569 : };
570 :
571 : class AnnotateAttr : public InheritableParamAttr {
572 : unsigned annotationLength;
573 : char *annotation;
574 :
575 :
576 : public:
577 : static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) {
578 : AnnotateAttr *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0);
579 : A->setImplicit(true);
580 : return A;
581 : }
582 :
583 : AnnotateAttr(SourceRange R, ASTContext &Ctx
584 : , llvm::StringRef Annotation
585 : , unsigned SI
586 : )
587 : : InheritableParamAttr(attr::Annotate, R, SI, 0, 0)
588 : , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength])
589 : {
590 : if (!Annotation.empty())
591 : std::memcpy(annotation, Annotation.data(), annotationLength);
592 : }
593 :
594 : AnnotateAttr *clone(ASTContext &C) const;
595 : void printPretty(raw_ostream &OS,
596 : const PrintingPolicy &Policy) const;
597 : const char *getSpelling() const;
598 : llvm::StringRef getAnnotation() const {
599 : return llvm::StringRef(annotation, annotationLength);
600 : }
601 : unsigned getAnnotationLength() const {
602 : return annotationLength;
603 : }
604 : void setAnnotation(ASTContext &C, llvm::StringRef S) {
605 : annotationLength = S.size();
606 : this->annotation = new (C, 1) char [annotationLength];
607 : if (!S.empty())
608 : std::memcpy(this->annotation, S.data(), annotationLength);
609 : }
610 :
611 :
612 :
613 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; }
614 : };
615 :
616 : class ArcWeakrefUnavailableAttr : public InheritableAttr {
617 :
618 : public:
619 : static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
620 : ArcWeakrefUnavailableAttr *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0);
621 : A->setImplicit(true);
622 : return A;
623 : }
624 :
625 : ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx
626 : , unsigned SI
627 : )
628 : : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, 0, 0)
629 : {
630 : }
631 :
632 : ArcWeakrefUnavailableAttr *clone(ASTContext &C) const;
633 : void printPretty(raw_ostream &OS,
634 : const PrintingPolicy &Policy) const;
635 : const char *getSpelling() const;
636 :
637 :
638 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; }
639 : };
640 :
641 : class ArgumentWithTypeTagAttr : public InheritableAttr {
642 : IdentifierInfo * argumentKind;
643 :
644 : unsigned argumentIdx;
645 :
646 : unsigned typeTagIdx;
647 :
648 : bool isPointer;
649 :
650 :
651 : public:
652 : enum Spelling {
653 : GNU_argument_with_type_tag = 0,
654 : GNU_pointer_with_type_tag = 1
655 : };
656 :
657 : static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, unsigned ArgumentIdx, unsigned TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) {
658 : ArgumentWithTypeTagAttr *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S);
659 : A->setImplicit(true);
660 : return A;
661 : }
662 :
663 : ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
664 : , IdentifierInfo * ArgumentKind
665 : , unsigned ArgumentIdx
666 : , unsigned TypeTagIdx
667 : , bool IsPointer
668 : , unsigned SI
669 : )
670 : : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, 0, 0)
671 : , argumentKind(ArgumentKind)
672 : , argumentIdx(ArgumentIdx)
673 : , typeTagIdx(TypeTagIdx)
674 : , isPointer(IsPointer)
675 : {
676 :
677 :
678 :
679 :
680 : }
681 :
682 : ArgumentWithTypeTagAttr *clone(ASTContext &C) const;
683 : void printPretty(raw_ostream &OS,
684 : const PrintingPolicy &Policy) const;
685 : const char *getSpelling() const;
686 : Spelling getSemanticSpelling() const {
687 : switch (SpellingListIndex) {
688 : default: llvm_unreachable("Unknown spelling list index");
689 : case 0: return GNU_argument_with_type_tag;
690 : case 1: return GNU_pointer_with_type_tag;
691 : }
692 : }
693 : IdentifierInfo * getArgumentKind() const {
694 : return argumentKind;
695 : }
696 :
697 : unsigned getArgumentIdx() const {
698 : return argumentIdx;
699 : }
700 :
701 : unsigned getTypeTagIdx() const {
702 : return typeTagIdx;
703 : }
704 :
705 : bool getIsPointer() const {
706 : return isPointer;
707 : }
708 :
709 :
710 :
711 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
712 : };
713 :
714 : class AsmLabelAttr : public InheritableAttr {
715 : unsigned labelLength;
716 : char *label;
717 :
718 :
719 : public:
720 : static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) {
721 : AsmLabelAttr *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0);
722 : A->setImplicit(true);
723 : return A;
724 : }
725 :
726 : AsmLabelAttr(SourceRange R, ASTContext &Ctx
727 : , llvm::StringRef Label
728 : , unsigned SI
729 : )
730 : : InheritableAttr(attr::AsmLabel, R, SI, 0, 0)
731 : , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
732 : {
733 : if (!Label.empty())
734 : std::memcpy(label, Label.data(), labelLength);
735 : }
736 :
737 : AsmLabelAttr *clone(ASTContext &C) const;
738 : void printPretty(raw_ostream &OS,
739 : const PrintingPolicy &Policy) const;
740 : const char *getSpelling() const;
741 : llvm::StringRef getLabel() const {
742 : return llvm::StringRef(label, labelLength);
743 : }
744 : unsigned getLabelLength() const {
745 : return labelLength;
746 : }
747 : void setLabel(ASTContext &C, llvm::StringRef S) {
748 : labelLength = S.size();
749 : this->label = new (C, 1) char [labelLength];
750 : if (!S.empty())
751 : std::memcpy(this->label, S.data(), labelLength);
752 : }
753 :
754 :
755 :
756 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; }
757 : };
758 :
759 : class AssertCapabilityAttr : public InheritableAttr {
760 : Expr * expr;
761 :
762 :
763 : public:
764 : enum Spelling {
765 : GNU_assert_capability = 0,
766 : CXX11_clang_assert_capability = 1,
767 : GNU_assert_shared_capability = 2,
768 : CXX11_clang_assert_shared_capability = 3
769 : };
770 :
771 : static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * Expr, SourceRange Loc = SourceRange()) {
772 : AssertCapabilityAttr *A = new (Ctx) AssertCapabilityAttr(Loc, Ctx, Expr, S);
773 : A->setImplicit(true);
774 : return A;
775 : }
776 :
777 : AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
778 : , Expr * Expr
779 : , unsigned SI
780 : )
781 : : InheritableAttr(attr::AssertCapability, R, SI, 1, 1)
782 : , expr(Expr)
783 : {
784 :
785 : }
786 :
787 : AssertCapabilityAttr *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_assert_capability;
795 : case 1: return CXX11_clang_assert_capability;
796 : case 2: return GNU_assert_shared_capability;
797 : case 3: return CXX11_clang_assert_shared_capability;
798 : }
799 : }
800 : bool isShared() const { return SpellingListIndex == 2 ||
801 : SpellingListIndex == 3; }
802 : Expr * getExpr() const {
803 0 : return expr;
804 : }
805 :
806 :
807 :
808 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; }
809 : };
810 :
811 : class AssertExclusiveLockAttr : public InheritableAttr {
812 : unsigned args_Size;
813 : Expr * *args_;
814 :
815 :
816 : public:
817 : static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
818 : AssertExclusiveLockAttr *A = new (Ctx) AssertExclusiveLockAttr(Loc, Ctx, Args, ArgsSize, 0);
819 : A->setImplicit(true);
820 : return A;
821 : }
822 :
823 : AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
824 : , Expr * *Args, unsigned ArgsSize
825 : , unsigned SI
826 : )
827 : : InheritableAttr(attr::AssertExclusiveLock, R, SI, 1, 1)
828 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
829 : {
830 : std::copy(Args, Args + args_Size, args_);
831 : }
832 :
833 : AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
834 : , unsigned SI
835 : )
836 : : InheritableAttr(attr::AssertExclusiveLock, R, SI, 1, 1)
837 : , args_Size(0), args_(nullptr)
838 : {
839 : }
840 :
841 : AssertExclusiveLockAttr *clone(ASTContext &C) const;
842 : void printPretty(raw_ostream &OS,
843 : const PrintingPolicy &Policy) const;
844 : const char *getSpelling() const;
845 : typedef Expr ** args_iterator;
846 0 : args_iterator args_begin() const { return args_; }
847 0 : args_iterator args_end() const { return args_ + args_Size; }
848 : unsigned args_size() const { return args_Size; }
849 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
850 :
851 :
852 :
853 :
854 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; }
855 : };
856 :
857 : class AssertSharedLockAttr : public InheritableAttr {
858 : unsigned args_Size;
859 : Expr * *args_;
860 :
861 :
862 : public:
863 : static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
864 : AssertSharedLockAttr *A = new (Ctx) AssertSharedLockAttr(Loc, Ctx, Args, ArgsSize, 0);
865 : A->setImplicit(true);
866 : return A;
867 : }
868 :
869 : AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
870 : , Expr * *Args, unsigned ArgsSize
871 : , unsigned SI
872 : )
873 : : InheritableAttr(attr::AssertSharedLock, R, SI, 1, 1)
874 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
875 : {
876 : std::copy(Args, Args + args_Size, args_);
877 : }
878 :
879 : AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
880 : , unsigned SI
881 : )
882 : : InheritableAttr(attr::AssertSharedLock, R, SI, 1, 1)
883 : , args_Size(0), args_(nullptr)
884 : {
885 : }
886 :
887 : AssertSharedLockAttr *clone(ASTContext &C) const;
888 : void printPretty(raw_ostream &OS,
889 : const PrintingPolicy &Policy) const;
890 : const char *getSpelling() const;
891 : typedef Expr ** args_iterator;
892 0 : args_iterator args_begin() const { return args_; }
893 0 : args_iterator args_end() const { return args_ + args_Size; }
894 : unsigned args_size() const { return args_Size; }
895 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
896 :
897 :
898 :
899 :
900 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; }
901 : };
902 :
903 : class AssumeAlignedAttr : public InheritableAttr {
904 : Expr * alignment;
905 :
906 : Expr * offset;
907 :
908 :
909 : public:
910 : static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Loc = SourceRange()) {
911 : AssumeAlignedAttr *A = new (Ctx) AssumeAlignedAttr(Loc, Ctx, Alignment, Offset, 0);
912 : A->setImplicit(true);
913 : return A;
914 : }
915 :
916 : AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
917 : , Expr * Alignment
918 : , Expr * Offset
919 : , unsigned SI
920 : )
921 : : InheritableAttr(attr::AssumeAligned, R, SI, 0, 0)
922 : , alignment(Alignment)
923 : , offset(Offset)
924 : {
925 :
926 :
927 : }
928 :
929 : AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
930 : , Expr * Alignment
931 : , unsigned SI
932 : )
933 : : InheritableAttr(attr::AssumeAligned, R, SI, 0, 0)
934 : , alignment()
935 : , offset()
936 : {
937 :
938 : }
939 :
940 : AssumeAlignedAttr *clone(ASTContext &C) const;
941 : void printPretty(raw_ostream &OS,
942 : const PrintingPolicy &Policy) const;
943 : const char *getSpelling() const;
944 : Expr * getAlignment() const {
945 0 : return alignment;
946 : }
947 :
948 : Expr * getOffset() const {
949 0 : return offset;
950 : }
951 :
952 :
953 :
954 0 : static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; }
955 : };
956 :
957 : class AvailabilityAttr : public InheritableAttr {
958 : IdentifierInfo * platform;
959 :
960 : VersionTuple introduced;
961 :
962 :
963 : VersionTuple deprecated;
964 :
965 :
966 : VersionTuple obsoleted;
967 :
968 :
969 : bool unavailable;
970 :
971 : unsigned messageLength;
972 : char *message;
973 :
974 :
975 : public:
976 : static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
977 : AvailabilityAttr *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, 0);
978 : A->setImplicit(true);
979 : return A;
980 : }
981 :
982 : AvailabilityAttr(SourceRange R, ASTContext &Ctx
983 : , IdentifierInfo * Platform
984 : , VersionTuple Introduced
985 : , VersionTuple Deprecated
986 : , VersionTuple Obsoleted
987 : , bool Unavailable
988 : , llvm::StringRef Message
989 : , unsigned SI
990 : )
991 : : InheritableAttr(attr::Availability, R, SI, 0, 1)
992 : , platform(Platform)
993 : , introduced(Introduced)
994 : , deprecated(Deprecated)
995 : , obsoleted(Obsoleted)
996 : , unavailable(Unavailable)
997 : , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
998 : {
999 :
1000 :
1001 :
1002 :
1003 :
1004 : if (!Message.empty())
1005 : std::memcpy(message, Message.data(), messageLength);
1006 : }
1007 :
1008 : AvailabilityAttr *clone(ASTContext &C) const;
1009 : void printPretty(raw_ostream &OS,
1010 : const PrintingPolicy &Policy) const;
1011 : const char *getSpelling() const;
1012 : IdentifierInfo * getPlatform() const {
1013 : return platform;
1014 : }
1015 :
1016 : VersionTuple getIntroduced() const {
1017 : return introduced;
1018 : }
1019 : void setIntroduced(ASTContext &C, VersionTuple V) {
1020 : introduced = V;
1021 : }
1022 :
1023 : VersionTuple getDeprecated() const {
1024 : return deprecated;
1025 : }
1026 : void setDeprecated(ASTContext &C, VersionTuple V) {
1027 : deprecated = V;
1028 : }
1029 :
1030 : VersionTuple getObsoleted() const {
1031 : return obsoleted;
1032 : }
1033 : void setObsoleted(ASTContext &C, VersionTuple V) {
1034 : obsoleted = V;
1035 : }
1036 :
1037 : bool getUnavailable() const {
1038 : return unavailable;
1039 : }
1040 :
1041 : llvm::StringRef getMessage() const {
1042 : return llvm::StringRef(message, messageLength);
1043 : }
1044 : unsigned getMessageLength() const {
1045 : return messageLength;
1046 : }
1047 : void setMessage(ASTContext &C, llvm::StringRef S) {
1048 : messageLength = S.size();
1049 : this->message = new (C, 1) char [messageLength];
1050 : if (!S.empty())
1051 : std::memcpy(this->message, S.data(), messageLength);
1052 : }
1053 :
1054 : static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
1055 : return llvm::StringSwitch<llvm::StringRef>(Platform)
1056 : .Case("android", "Android")
1057 : .Case("ios", "iOS")
1058 : .Case("macosx", "OS X")
1059 : .Case("ios_app_extension", "iOS (App Extension)")
1060 : .Case("macosx_app_extension", "OS X (App Extension)")
1061 : .Default(llvm::StringRef());
1062 : }
1063 :
1064 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Availability; }
1065 : };
1066 :
1067 : class BlocksAttr : public InheritableAttr {
1068 : public:
1069 : enum BlockType {
1070 : ByRef
1071 : };
1072 : private:
1073 : BlockType type;
1074 :
1075 :
1076 : public:
1077 : static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Loc = SourceRange()) {
1078 : BlocksAttr *A = new (Ctx) BlocksAttr(Loc, Ctx, Type, 0);
1079 : A->setImplicit(true);
1080 : return A;
1081 : }
1082 :
1083 : BlocksAttr(SourceRange R, ASTContext &Ctx
1084 : , BlockType Type
1085 : , unsigned SI
1086 : )
1087 : : InheritableAttr(attr::Blocks, R, SI, 0, 0)
1088 : , type(Type)
1089 : {
1090 :
1091 : }
1092 :
1093 : BlocksAttr *clone(ASTContext &C) const;
1094 : void printPretty(raw_ostream &OS,
1095 : const PrintingPolicy &Policy) const;
1096 : const char *getSpelling() const;
1097 : BlockType getType() const {
1098 : return type;
1099 : }
1100 :
1101 : static bool ConvertStrToBlockType(StringRef Val, BlockType &Out) {
1102 : Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val)
1103 : .Case("byref", BlocksAttr::ByRef)
1104 : .Default(Optional<BlockType>());
1105 : if (R) {
1106 : Out = *R;
1107 : return true;
1108 : }
1109 : return false;
1110 : }
1111 :
1112 : static const char *ConvertBlockTypeToStr(BlockType Val) {
1113 : switch(Val) {
1114 : case BlocksAttr::ByRef: return "byref";
1115 : }
1116 : llvm_unreachable("No enumerator with that value");
1117 : }
1118 :
1119 :
1120 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; }
1121 : };
1122 :
1123 : class C11NoReturnAttr : public InheritableAttr {
1124 :
1125 : public:
1126 : static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1127 : C11NoReturnAttr *A = new (Ctx) C11NoReturnAttr(Loc, Ctx, 0);
1128 : A->setImplicit(true);
1129 : return A;
1130 : }
1131 :
1132 : C11NoReturnAttr(SourceRange R, ASTContext &Ctx
1133 : , unsigned SI
1134 : )
1135 : : InheritableAttr(attr::C11NoReturn, R, SI, 0, 0)
1136 : {
1137 : }
1138 :
1139 : C11NoReturnAttr *clone(ASTContext &C) const;
1140 : void printPretty(raw_ostream &OS,
1141 : const PrintingPolicy &Policy) const;
1142 : const char *getSpelling() const;
1143 :
1144 :
1145 0 : static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; }
1146 : };
1147 :
1148 : class CDeclAttr : public InheritableAttr {
1149 :
1150 : public:
1151 : static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1152 : CDeclAttr *A = new (Ctx) CDeclAttr(Loc, Ctx, 0);
1153 : A->setImplicit(true);
1154 : return A;
1155 : }
1156 :
1157 : CDeclAttr(SourceRange R, ASTContext &Ctx
1158 : , unsigned SI
1159 : )
1160 : : InheritableAttr(attr::CDecl, R, SI, 0, 0)
1161 : {
1162 : }
1163 :
1164 : CDeclAttr *clone(ASTContext &C) const;
1165 : void printPretty(raw_ostream &OS,
1166 : const PrintingPolicy &Policy) const;
1167 : const char *getSpelling() const;
1168 :
1169 :
1170 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; }
1171 : };
1172 :
1173 : class CFAuditedTransferAttr : public InheritableAttr {
1174 :
1175 : public:
1176 : static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1177 : CFAuditedTransferAttr *A = new (Ctx) CFAuditedTransferAttr(Loc, Ctx, 0);
1178 : A->setImplicit(true);
1179 : return A;
1180 : }
1181 :
1182 : CFAuditedTransferAttr(SourceRange R, ASTContext &Ctx
1183 : , unsigned SI
1184 : )
1185 : : InheritableAttr(attr::CFAuditedTransfer, R, SI, 0, 0)
1186 : {
1187 : }
1188 :
1189 : CFAuditedTransferAttr *clone(ASTContext &C) const;
1190 : void printPretty(raw_ostream &OS,
1191 : const PrintingPolicy &Policy) const;
1192 : const char *getSpelling() const;
1193 :
1194 :
1195 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; }
1196 : };
1197 :
1198 : class CFConsumedAttr : public InheritableParamAttr {
1199 :
1200 : public:
1201 : static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1202 : CFConsumedAttr *A = new (Ctx) CFConsumedAttr(Loc, Ctx, 0);
1203 : A->setImplicit(true);
1204 : return A;
1205 : }
1206 :
1207 : CFConsumedAttr(SourceRange R, ASTContext &Ctx
1208 : , unsigned SI
1209 : )
1210 : : InheritableParamAttr(attr::CFConsumed, R, SI, 0, 0)
1211 : {
1212 : }
1213 :
1214 : CFConsumedAttr *clone(ASTContext &C) const;
1215 : void printPretty(raw_ostream &OS,
1216 : const PrintingPolicy &Policy) const;
1217 : const char *getSpelling() const;
1218 :
1219 :
1220 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; }
1221 : };
1222 :
1223 : class CFReturnsNotRetainedAttr : public InheritableAttr {
1224 :
1225 : public:
1226 : static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1227 : CFReturnsNotRetainedAttr *A = new (Ctx) CFReturnsNotRetainedAttr(Loc, Ctx, 0);
1228 : A->setImplicit(true);
1229 : return A;
1230 : }
1231 :
1232 : CFReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
1233 : , unsigned SI
1234 : )
1235 : : InheritableAttr(attr::CFReturnsNotRetained, R, SI, 0, 0)
1236 : {
1237 : }
1238 :
1239 : CFReturnsNotRetainedAttr *clone(ASTContext &C) const;
1240 : void printPretty(raw_ostream &OS,
1241 : const PrintingPolicy &Policy) const;
1242 : const char *getSpelling() const;
1243 :
1244 :
1245 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; }
1246 : };
1247 :
1248 : class CFReturnsRetainedAttr : public InheritableAttr {
1249 :
1250 : public:
1251 : static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1252 : CFReturnsRetainedAttr *A = new (Ctx) CFReturnsRetainedAttr(Loc, Ctx, 0);
1253 : A->setImplicit(true);
1254 : return A;
1255 : }
1256 :
1257 : CFReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
1258 : , unsigned SI
1259 : )
1260 : : InheritableAttr(attr::CFReturnsRetained, R, SI, 0, 0)
1261 : {
1262 : }
1263 :
1264 : CFReturnsRetainedAttr *clone(ASTContext &C) const;
1265 : void printPretty(raw_ostream &OS,
1266 : const PrintingPolicy &Policy) const;
1267 : const char *getSpelling() const;
1268 :
1269 :
1270 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; }
1271 : };
1272 :
1273 : class CFUnknownTransferAttr : public InheritableAttr {
1274 :
1275 : public:
1276 : static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1277 : CFUnknownTransferAttr *A = new (Ctx) CFUnknownTransferAttr(Loc, Ctx, 0);
1278 : A->setImplicit(true);
1279 : return A;
1280 : }
1281 :
1282 : CFUnknownTransferAttr(SourceRange R, ASTContext &Ctx
1283 : , unsigned SI
1284 : )
1285 : : InheritableAttr(attr::CFUnknownTransfer, R, SI, 0, 0)
1286 : {
1287 : }
1288 :
1289 : CFUnknownTransferAttr *clone(ASTContext &C) const;
1290 : void printPretty(raw_ostream &OS,
1291 : const PrintingPolicy &Policy) const;
1292 : const char *getSpelling() const;
1293 :
1294 :
1295 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; }
1296 : };
1297 :
1298 : class CUDAConstantAttr : public InheritableAttr {
1299 :
1300 : public:
1301 : static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1302 : CUDAConstantAttr *A = new (Ctx) CUDAConstantAttr(Loc, Ctx, 0);
1303 : A->setImplicit(true);
1304 : return A;
1305 : }
1306 :
1307 : CUDAConstantAttr(SourceRange R, ASTContext &Ctx
1308 : , unsigned SI
1309 : )
1310 : : InheritableAttr(attr::CUDAConstant, R, SI, 0, 0)
1311 : {
1312 : }
1313 :
1314 : CUDAConstantAttr *clone(ASTContext &C) const;
1315 : void printPretty(raw_ostream &OS,
1316 : const PrintingPolicy &Policy) const;
1317 : const char *getSpelling() const;
1318 :
1319 :
1320 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; }
1321 : };
1322 :
1323 : class CUDADeviceAttr : public InheritableAttr {
1324 :
1325 : public:
1326 : static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1327 : CUDADeviceAttr *A = new (Ctx) CUDADeviceAttr(Loc, Ctx, 0);
1328 : A->setImplicit(true);
1329 : return A;
1330 : }
1331 :
1332 : CUDADeviceAttr(SourceRange R, ASTContext &Ctx
1333 : , unsigned SI
1334 : )
1335 : : InheritableAttr(attr::CUDADevice, R, SI, 0, 0)
1336 : {
1337 : }
1338 :
1339 : CUDADeviceAttr *clone(ASTContext &C) const;
1340 : void printPretty(raw_ostream &OS,
1341 : const PrintingPolicy &Policy) const;
1342 : const char *getSpelling() const;
1343 :
1344 :
1345 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; }
1346 : };
1347 :
1348 : class CUDAGlobalAttr : public InheritableAttr {
1349 :
1350 : public:
1351 : static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1352 : CUDAGlobalAttr *A = new (Ctx) CUDAGlobalAttr(Loc, Ctx, 0);
1353 : A->setImplicit(true);
1354 : return A;
1355 : }
1356 :
1357 : CUDAGlobalAttr(SourceRange R, ASTContext &Ctx
1358 : , unsigned SI
1359 : )
1360 : : InheritableAttr(attr::CUDAGlobal, R, SI, 0, 0)
1361 : {
1362 : }
1363 :
1364 : CUDAGlobalAttr *clone(ASTContext &C) const;
1365 : void printPretty(raw_ostream &OS,
1366 : const PrintingPolicy &Policy) const;
1367 : const char *getSpelling() const;
1368 :
1369 :
1370 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; }
1371 : };
1372 :
1373 : class CUDAHostAttr : public InheritableAttr {
1374 :
1375 : public:
1376 : static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1377 : CUDAHostAttr *A = new (Ctx) CUDAHostAttr(Loc, Ctx, 0);
1378 : A->setImplicit(true);
1379 : return A;
1380 : }
1381 :
1382 : CUDAHostAttr(SourceRange R, ASTContext &Ctx
1383 : , unsigned SI
1384 : )
1385 : : InheritableAttr(attr::CUDAHost, R, SI, 0, 0)
1386 : {
1387 : }
1388 :
1389 : CUDAHostAttr *clone(ASTContext &C) const;
1390 : void printPretty(raw_ostream &OS,
1391 : const PrintingPolicy &Policy) const;
1392 : const char *getSpelling() const;
1393 :
1394 :
1395 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; }
1396 : };
1397 :
1398 : class CUDAInvalidTargetAttr : public InheritableAttr {
1399 :
1400 : public:
1401 : static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1402 : CUDAInvalidTargetAttr *A = new (Ctx) CUDAInvalidTargetAttr(Loc, Ctx, 0);
1403 : A->setImplicit(true);
1404 : return A;
1405 : }
1406 :
1407 : CUDAInvalidTargetAttr(SourceRange R, ASTContext &Ctx
1408 : , unsigned SI
1409 : )
1410 : : InheritableAttr(attr::CUDAInvalidTarget, R, SI, 0, 0)
1411 : {
1412 : }
1413 :
1414 : CUDAInvalidTargetAttr *clone(ASTContext &C) const;
1415 : void printPretty(raw_ostream &OS,
1416 : const PrintingPolicy &Policy) const;
1417 : const char *getSpelling() const;
1418 :
1419 :
1420 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; }
1421 : };
1422 :
1423 : class CUDALaunchBoundsAttr : public InheritableAttr {
1424 : Expr * maxThreads;
1425 :
1426 : Expr * minBlocks;
1427 :
1428 :
1429 : public:
1430 : static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Loc = SourceRange()) {
1431 : CUDALaunchBoundsAttr *A = new (Ctx) CUDALaunchBoundsAttr(Loc, Ctx, MaxThreads, MinBlocks, 0);
1432 : A->setImplicit(true);
1433 : return A;
1434 : }
1435 :
1436 : CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
1437 : , Expr * MaxThreads
1438 : , Expr * MinBlocks
1439 : , unsigned SI
1440 : )
1441 : : InheritableAttr(attr::CUDALaunchBounds, R, SI, 0, 0)
1442 : , maxThreads(MaxThreads)
1443 : , minBlocks(MinBlocks)
1444 : {
1445 :
1446 :
1447 : }
1448 :
1449 : CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
1450 : , Expr * MaxThreads
1451 : , unsigned SI
1452 : )
1453 : : InheritableAttr(attr::CUDALaunchBounds, R, SI, 0, 0)
1454 : , maxThreads()
1455 : , minBlocks()
1456 : {
1457 :
1458 : }
1459 :
1460 : CUDALaunchBoundsAttr *clone(ASTContext &C) const;
1461 : void printPretty(raw_ostream &OS,
1462 : const PrintingPolicy &Policy) const;
1463 : const char *getSpelling() const;
1464 : Expr * getMaxThreads() const {
1465 0 : return maxThreads;
1466 : }
1467 :
1468 : Expr * getMinBlocks() const {
1469 0 : return minBlocks;
1470 : }
1471 :
1472 :
1473 :
1474 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; }
1475 : };
1476 :
1477 : class CUDASharedAttr : public InheritableAttr {
1478 :
1479 : public:
1480 : static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1481 : CUDASharedAttr *A = new (Ctx) CUDASharedAttr(Loc, Ctx, 0);
1482 : A->setImplicit(true);
1483 : return A;
1484 : }
1485 :
1486 : CUDASharedAttr(SourceRange R, ASTContext &Ctx
1487 : , unsigned SI
1488 : )
1489 : : InheritableAttr(attr::CUDAShared, R, SI, 0, 0)
1490 : {
1491 : }
1492 :
1493 : CUDASharedAttr *clone(ASTContext &C) const;
1494 : void printPretty(raw_ostream &OS,
1495 : const PrintingPolicy &Policy) const;
1496 : const char *getSpelling() const;
1497 :
1498 :
1499 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; }
1500 : };
1501 :
1502 : class CXX11NoReturnAttr : public InheritableAttr {
1503 :
1504 : public:
1505 : static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1506 : CXX11NoReturnAttr *A = new (Ctx) CXX11NoReturnAttr(Loc, Ctx, 0);
1507 : A->setImplicit(true);
1508 : return A;
1509 : }
1510 :
1511 : CXX11NoReturnAttr(SourceRange R, ASTContext &Ctx
1512 : , unsigned SI
1513 : )
1514 : : InheritableAttr(attr::CXX11NoReturn, R, SI, 0, 0)
1515 : {
1516 : }
1517 :
1518 : CXX11NoReturnAttr *clone(ASTContext &C) const;
1519 : void printPretty(raw_ostream &OS,
1520 : const PrintingPolicy &Policy) const;
1521 : const char *getSpelling() const;
1522 :
1523 :
1524 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; }
1525 : };
1526 :
1527 : class CallableWhenAttr : public InheritableAttr {
1528 : public:
1529 : enum ConsumedState {
1530 : Unknown,
1531 : Consumed,
1532 : Unconsumed
1533 : };
1534 : private:
1535 : unsigned callableStates_Size;
1536 : ConsumedState *callableStates_;
1537 :
1538 :
1539 : public:
1540 : static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Loc = SourceRange()) {
1541 : CallableWhenAttr *A = new (Ctx) CallableWhenAttr(Loc, Ctx, CallableStates, CallableStatesSize, 0);
1542 : A->setImplicit(true);
1543 : return A;
1544 : }
1545 :
1546 : CallableWhenAttr(SourceRange R, ASTContext &Ctx
1547 : , ConsumedState *CallableStates, unsigned CallableStatesSize
1548 : , unsigned SI
1549 : )
1550 : : InheritableAttr(attr::CallableWhen, R, SI, 0, 0)
1551 : , callableStates_Size(CallableStatesSize), callableStates_(new (Ctx, 16) ConsumedState[callableStates_Size])
1552 : {
1553 : std::copy(CallableStates, CallableStates + callableStates_Size, callableStates_);
1554 : }
1555 :
1556 : CallableWhenAttr(SourceRange R, ASTContext &Ctx
1557 : , unsigned SI
1558 : )
1559 : : InheritableAttr(attr::CallableWhen, R, SI, 0, 0)
1560 : , callableStates_Size(0), callableStates_(nullptr)
1561 : {
1562 : }
1563 :
1564 : CallableWhenAttr *clone(ASTContext &C) const;
1565 : void printPretty(raw_ostream &OS,
1566 : const PrintingPolicy &Policy) const;
1567 : const char *getSpelling() const;
1568 : typedef ConsumedState* callableStates_iterator;
1569 : callableStates_iterator callableStates_begin() const { return callableStates_; }
1570 : callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; }
1571 : unsigned callableStates_size() const { return callableStates_Size; }
1572 : llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); }
1573 :
1574 :
1575 : static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
1576 : Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
1577 : .Case("unknown", CallableWhenAttr::Unknown)
1578 : .Case("consumed", CallableWhenAttr::Consumed)
1579 : .Case("unconsumed", CallableWhenAttr::Unconsumed)
1580 : .Default(Optional<ConsumedState>());
1581 : if (R) {
1582 : Out = *R;
1583 : return true;
1584 : }
1585 : return false;
1586 : }
1587 :
1588 : static const char *ConvertConsumedStateToStr(ConsumedState Val) {
1589 : switch(Val) {
1590 : case CallableWhenAttr::Unknown: return "unknown";
1591 : case CallableWhenAttr::Consumed: return "consumed";
1592 : case CallableWhenAttr::Unconsumed: return "unconsumed";
1593 : }
1594 : llvm_unreachable("No enumerator with that value");
1595 : }
1596 :
1597 :
1598 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; }
1599 : };
1600 :
1601 : class CapabilityAttr : public InheritableAttr {
1602 : unsigned nameLength;
1603 : char *name;
1604 :
1605 :
1606 : public:
1607 : enum Spelling {
1608 : GNU_capability = 0,
1609 : CXX11_clang_capability = 1,
1610 : GNU_shared_capability = 2,
1611 : CXX11_clang_shared_capability = 3
1612 : };
1613 :
1614 : static CapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
1615 : CapabilityAttr *A = new (Ctx) CapabilityAttr(Loc, Ctx, Name, S);
1616 : A->setImplicit(true);
1617 : return A;
1618 : }
1619 :
1620 : CapabilityAttr(SourceRange R, ASTContext &Ctx
1621 : , llvm::StringRef Name
1622 : , unsigned SI
1623 : )
1624 : : InheritableAttr(attr::Capability, R, SI, 0, 0)
1625 : , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
1626 : {
1627 : if (!Name.empty())
1628 : std::memcpy(name, Name.data(), nameLength);
1629 : }
1630 :
1631 : CapabilityAttr *clone(ASTContext &C) const;
1632 : void printPretty(raw_ostream &OS,
1633 : const PrintingPolicy &Policy) const;
1634 : const char *getSpelling() const;
1635 : Spelling getSemanticSpelling() const {
1636 : switch (SpellingListIndex) {
1637 : default: llvm_unreachable("Unknown spelling list index");
1638 : case 0: return GNU_capability;
1639 : case 1: return CXX11_clang_capability;
1640 : case 2: return GNU_shared_capability;
1641 : case 3: return CXX11_clang_shared_capability;
1642 : }
1643 : }
1644 : bool isShared() const { return SpellingListIndex == 2 ||
1645 : SpellingListIndex == 3; }
1646 : llvm::StringRef getName() const {
1647 : return llvm::StringRef(name, nameLength);
1648 : }
1649 : unsigned getNameLength() const {
1650 : return nameLength;
1651 : }
1652 : void setName(ASTContext &C, llvm::StringRef S) {
1653 : nameLength = S.size();
1654 : this->name = new (C, 1) char [nameLength];
1655 : if (!S.empty())
1656 : std::memcpy(this->name, S.data(), nameLength);
1657 : }
1658 :
1659 :
1660 : bool isMutex() const { return getName().equals_lower("mutex"); }
1661 : bool isRole() const { return getName().equals_lower("role"); }
1662 :
1663 :
1664 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Capability; }
1665 : };
1666 :
1667 : class CapturedRecordAttr : public InheritableAttr {
1668 :
1669 : public:
1670 : static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1671 : CapturedRecordAttr *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0);
1672 : A->setImplicit(true);
1673 : return A;
1674 : }
1675 :
1676 : CapturedRecordAttr(SourceRange R, ASTContext &Ctx
1677 : , unsigned SI
1678 : )
1679 : : InheritableAttr(attr::CapturedRecord, R, SI, 0, 0)
1680 : {
1681 : }
1682 :
1683 : CapturedRecordAttr *clone(ASTContext &C) const;
1684 : void printPretty(raw_ostream &OS,
1685 : const PrintingPolicy &Policy) const;
1686 : const char *getSpelling() const;
1687 :
1688 :
1689 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; }
1690 : };
1691 :
1692 : class CarriesDependencyAttr : public InheritableParamAttr {
1693 :
1694 : public:
1695 : static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1696 : CarriesDependencyAttr *A = new (Ctx) CarriesDependencyAttr(Loc, Ctx, 0);
1697 : A->setImplicit(true);
1698 : return A;
1699 : }
1700 :
1701 : CarriesDependencyAttr(SourceRange R, ASTContext &Ctx
1702 : , unsigned SI
1703 : )
1704 : : InheritableParamAttr(attr::CarriesDependency, R, SI, 0, 0)
1705 : {
1706 : }
1707 :
1708 : CarriesDependencyAttr *clone(ASTContext &C) const;
1709 : void printPretty(raw_ostream &OS,
1710 : const PrintingPolicy &Policy) const;
1711 : const char *getSpelling() const;
1712 :
1713 :
1714 0 : static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; }
1715 : };
1716 :
1717 : class CleanupAttr : public InheritableAttr {
1718 : FunctionDecl * functionDecl;
1719 :
1720 :
1721 : public:
1722 : static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Loc = SourceRange()) {
1723 : CleanupAttr *A = new (Ctx) CleanupAttr(Loc, Ctx, FunctionDecl, 0);
1724 : A->setImplicit(true);
1725 : return A;
1726 : }
1727 :
1728 : CleanupAttr(SourceRange R, ASTContext &Ctx
1729 : , FunctionDecl * FunctionDecl
1730 : , unsigned SI
1731 : )
1732 : : InheritableAttr(attr::Cleanup, R, SI, 0, 0)
1733 : , functionDecl(FunctionDecl)
1734 : {
1735 :
1736 : }
1737 :
1738 : CleanupAttr *clone(ASTContext &C) const;
1739 : void printPretty(raw_ostream &OS,
1740 : const PrintingPolicy &Policy) const;
1741 : const char *getSpelling() const;
1742 : FunctionDecl * getFunctionDecl() const {
1743 : return functionDecl;
1744 : }
1745 :
1746 :
1747 :
1748 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; }
1749 : };
1750 :
1751 : class ColdAttr : public InheritableAttr {
1752 :
1753 : public:
1754 : static ColdAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1755 : ColdAttr *A = new (Ctx) ColdAttr(Loc, Ctx, 0);
1756 : A->setImplicit(true);
1757 : return A;
1758 : }
1759 :
1760 : ColdAttr(SourceRange R, ASTContext &Ctx
1761 : , unsigned SI
1762 : )
1763 : : InheritableAttr(attr::Cold, R, SI, 0, 0)
1764 : {
1765 : }
1766 :
1767 : ColdAttr *clone(ASTContext &C) const;
1768 : void printPretty(raw_ostream &OS,
1769 : const PrintingPolicy &Policy) const;
1770 : const char *getSpelling() const;
1771 :
1772 :
1773 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Cold; }
1774 : };
1775 :
1776 : class CommonAttr : public InheritableAttr {
1777 :
1778 : public:
1779 : static CommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1780 : CommonAttr *A = new (Ctx) CommonAttr(Loc, Ctx, 0);
1781 : A->setImplicit(true);
1782 : return A;
1783 : }
1784 :
1785 : CommonAttr(SourceRange R, ASTContext &Ctx
1786 : , unsigned SI
1787 : )
1788 : : InheritableAttr(attr::Common, R, SI, 0, 0)
1789 : {
1790 : }
1791 :
1792 : CommonAttr *clone(ASTContext &C) const;
1793 : void printPretty(raw_ostream &OS,
1794 : const PrintingPolicy &Policy) const;
1795 : const char *getSpelling() const;
1796 :
1797 :
1798 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Common; }
1799 : };
1800 :
1801 : class ConstAttr : public InheritableAttr {
1802 :
1803 : public:
1804 : static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1805 : ConstAttr *A = new (Ctx) ConstAttr(Loc, Ctx, 0);
1806 : A->setImplicit(true);
1807 : return A;
1808 : }
1809 :
1810 : ConstAttr(SourceRange R, ASTContext &Ctx
1811 : , unsigned SI
1812 : )
1813 : : InheritableAttr(attr::Const, R, SI, 0, 0)
1814 : {
1815 : }
1816 :
1817 : ConstAttr *clone(ASTContext &C) const;
1818 : void printPretty(raw_ostream &OS,
1819 : const PrintingPolicy &Policy) const;
1820 : const char *getSpelling() const;
1821 :
1822 :
1823 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Const; }
1824 : };
1825 :
1826 : class ConstructorAttr : public InheritableAttr {
1827 : int priority;
1828 :
1829 :
1830 : public:
1831 : static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
1832 : ConstructorAttr *A = new (Ctx) ConstructorAttr(Loc, Ctx, Priority, 0);
1833 : A->setImplicit(true);
1834 : return A;
1835 : }
1836 :
1837 : ConstructorAttr(SourceRange R, ASTContext &Ctx
1838 : , int Priority
1839 : , unsigned SI
1840 : )
1841 : : InheritableAttr(attr::Constructor, R, SI, 0, 0)
1842 : , priority(Priority)
1843 : {
1844 :
1845 : }
1846 :
1847 : ConstructorAttr(SourceRange R, ASTContext &Ctx
1848 : , unsigned SI
1849 : )
1850 : : InheritableAttr(attr::Constructor, R, SI, 0, 0)
1851 : , priority()
1852 : {
1853 : }
1854 :
1855 : ConstructorAttr *clone(ASTContext &C) const;
1856 : void printPretty(raw_ostream &OS,
1857 : const PrintingPolicy &Policy) const;
1858 : const char *getSpelling() const;
1859 : int getPriority() const {
1860 : return priority;
1861 : }
1862 :
1863 : static const int DefaultPriority = 65535;
1864 :
1865 :
1866 :
1867 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Constructor; }
1868 : };
1869 :
1870 : class ConsumableAttr : public InheritableAttr {
1871 : public:
1872 : enum ConsumedState {
1873 : Unknown,
1874 : Consumed,
1875 : Unconsumed
1876 : };
1877 : private:
1878 : ConsumedState defaultState;
1879 :
1880 :
1881 : public:
1882 : static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumedState DefaultState, SourceRange Loc = SourceRange()) {
1883 : ConsumableAttr *A = new (Ctx) ConsumableAttr(Loc, Ctx, DefaultState, 0);
1884 : A->setImplicit(true);
1885 : return A;
1886 : }
1887 :
1888 : ConsumableAttr(SourceRange R, ASTContext &Ctx
1889 : , ConsumedState DefaultState
1890 : , unsigned SI
1891 : )
1892 : : InheritableAttr(attr::Consumable, R, SI, 0, 0)
1893 : , defaultState(DefaultState)
1894 : {
1895 :
1896 : }
1897 :
1898 : ConsumableAttr *clone(ASTContext &C) const;
1899 : void printPretty(raw_ostream &OS,
1900 : const PrintingPolicy &Policy) const;
1901 : const char *getSpelling() const;
1902 : ConsumedState getDefaultState() const {
1903 : return defaultState;
1904 : }
1905 :
1906 : static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
1907 : Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
1908 : .Case("unknown", ConsumableAttr::Unknown)
1909 : .Case("consumed", ConsumableAttr::Consumed)
1910 : .Case("unconsumed", ConsumableAttr::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 ConsumableAttr::Unknown: return "unknown";
1922 : case ConsumableAttr::Consumed: return "consumed";
1923 : case ConsumableAttr::Unconsumed: return "unconsumed";
1924 : }
1925 : llvm_unreachable("No enumerator with that value");
1926 : }
1927 :
1928 :
1929 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; }
1930 : };
1931 :
1932 : class ConsumableAutoCastAttr : public InheritableAttr {
1933 :
1934 : public:
1935 : static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1936 : ConsumableAutoCastAttr *A = new (Ctx) ConsumableAutoCastAttr(Loc, Ctx, 0);
1937 : A->setImplicit(true);
1938 : return A;
1939 : }
1940 :
1941 : ConsumableAutoCastAttr(SourceRange R, ASTContext &Ctx
1942 : , unsigned SI
1943 : )
1944 : : InheritableAttr(attr::ConsumableAutoCast, R, SI, 0, 0)
1945 : {
1946 : }
1947 :
1948 : ConsumableAutoCastAttr *clone(ASTContext &C) const;
1949 : void printPretty(raw_ostream &OS,
1950 : const PrintingPolicy &Policy) const;
1951 : const char *getSpelling() const;
1952 :
1953 :
1954 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableAutoCast; }
1955 : };
1956 :
1957 : class ConsumableSetOnReadAttr : public InheritableAttr {
1958 :
1959 : public:
1960 : static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1961 : ConsumableSetOnReadAttr *A = new (Ctx) ConsumableSetOnReadAttr(Loc, Ctx, 0);
1962 : A->setImplicit(true);
1963 : return A;
1964 : }
1965 :
1966 : ConsumableSetOnReadAttr(SourceRange R, ASTContext &Ctx
1967 : , unsigned SI
1968 : )
1969 : : InheritableAttr(attr::ConsumableSetOnRead, R, SI, 0, 0)
1970 : {
1971 : }
1972 :
1973 : ConsumableSetOnReadAttr *clone(ASTContext &C) const;
1974 : void printPretty(raw_ostream &OS,
1975 : const PrintingPolicy &Policy) const;
1976 : const char *getSpelling() const;
1977 :
1978 :
1979 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableSetOnRead; }
1980 : };
1981 :
1982 : class DLLExportAttr : public InheritableAttr {
1983 :
1984 : public:
1985 : static DLLExportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1986 : DLLExportAttr *A = new (Ctx) DLLExportAttr(Loc, Ctx, 0);
1987 : A->setImplicit(true);
1988 : return A;
1989 : }
1990 :
1991 : DLLExportAttr(SourceRange R, ASTContext &Ctx
1992 : , unsigned SI
1993 : )
1994 : : InheritableAttr(attr::DLLExport, R, SI, 0, 0)
1995 : {
1996 : }
1997 :
1998 : DLLExportAttr *clone(ASTContext &C) const;
1999 : void printPretty(raw_ostream &OS,
2000 : const PrintingPolicy &Policy) const;
2001 : const char *getSpelling() const;
2002 :
2003 :
2004 0 : static bool classof(const Attr *A) { return A->getKind() == attr::DLLExport; }
2005 : };
2006 :
2007 : class DLLImportAttr : public InheritableAttr {
2008 :
2009 : public:
2010 : static DLLImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2011 : DLLImportAttr *A = new (Ctx) DLLImportAttr(Loc, Ctx, 0);
2012 : A->setImplicit(true);
2013 : return A;
2014 : }
2015 :
2016 : DLLImportAttr(SourceRange R, ASTContext &Ctx
2017 : , unsigned SI
2018 : )
2019 : : InheritableAttr(attr::DLLImport, R, SI, 0, 0)
2020 : {
2021 : }
2022 :
2023 : DLLImportAttr *clone(ASTContext &C) const;
2024 : void printPretty(raw_ostream &OS,
2025 : const PrintingPolicy &Policy) const;
2026 : const char *getSpelling() const;
2027 :
2028 :
2029 0 : static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; }
2030 : };
2031 :
2032 : class DeprecatedAttr : public InheritableAttr {
2033 : unsigned messageLength;
2034 : char *message;
2035 :
2036 :
2037 : public:
2038 : static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
2039 : DeprecatedAttr *A = new (Ctx) DeprecatedAttr(Loc, Ctx, Message, 0);
2040 : A->setImplicit(true);
2041 : return A;
2042 : }
2043 :
2044 : DeprecatedAttr(SourceRange R, ASTContext &Ctx
2045 : , llvm::StringRef Message
2046 : , unsigned SI
2047 : )
2048 : : InheritableAttr(attr::Deprecated, R, SI, 0, 0)
2049 : , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2050 : {
2051 : if (!Message.empty())
2052 : std::memcpy(message, Message.data(), messageLength);
2053 : }
2054 :
2055 : DeprecatedAttr(SourceRange R, ASTContext &Ctx
2056 : , unsigned SI
2057 : )
2058 : : InheritableAttr(attr::Deprecated, R, SI, 0, 0)
2059 : , messageLength(0),message(0)
2060 : {
2061 : }
2062 :
2063 : DeprecatedAttr *clone(ASTContext &C) const;
2064 : void printPretty(raw_ostream &OS,
2065 : const PrintingPolicy &Policy) const;
2066 : const char *getSpelling() const;
2067 : llvm::StringRef getMessage() const {
2068 : return llvm::StringRef(message, messageLength);
2069 : }
2070 : unsigned getMessageLength() const {
2071 : return messageLength;
2072 : }
2073 : void setMessage(ASTContext &C, llvm::StringRef S) {
2074 : messageLength = S.size();
2075 : this->message = new (C, 1) char [messageLength];
2076 : if (!S.empty())
2077 : std::memcpy(this->message, S.data(), messageLength);
2078 : }
2079 :
2080 :
2081 :
2082 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Deprecated; }
2083 : };
2084 :
2085 : class DestructorAttr : public InheritableAttr {
2086 : int priority;
2087 :
2088 :
2089 : public:
2090 : static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
2091 : DestructorAttr *A = new (Ctx) DestructorAttr(Loc, Ctx, Priority, 0);
2092 : A->setImplicit(true);
2093 : return A;
2094 : }
2095 :
2096 : DestructorAttr(SourceRange R, ASTContext &Ctx
2097 : , int Priority
2098 : , unsigned SI
2099 : )
2100 : : InheritableAttr(attr::Destructor, R, SI, 0, 0)
2101 : , priority(Priority)
2102 : {
2103 :
2104 : }
2105 :
2106 : DestructorAttr(SourceRange R, ASTContext &Ctx
2107 : , unsigned SI
2108 : )
2109 : : InheritableAttr(attr::Destructor, R, SI, 0, 0)
2110 : , priority()
2111 : {
2112 : }
2113 :
2114 : DestructorAttr *clone(ASTContext &C) const;
2115 : void printPretty(raw_ostream &OS,
2116 : const PrintingPolicy &Policy) const;
2117 : const char *getSpelling() const;
2118 : int getPriority() const {
2119 : return priority;
2120 : }
2121 :
2122 : static const int DefaultPriority = 65535;
2123 :
2124 :
2125 :
2126 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Destructor; }
2127 : };
2128 :
2129 : class EnableIfAttr : public InheritableAttr {
2130 : Expr * cond;
2131 :
2132 : unsigned messageLength;
2133 : char *message;
2134 :
2135 :
2136 : public:
2137 : static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
2138 : EnableIfAttr *A = new (Ctx) EnableIfAttr(Loc, Ctx, Cond, Message, 0);
2139 : A->setImplicit(true);
2140 : return A;
2141 : }
2142 :
2143 : EnableIfAttr(SourceRange R, ASTContext &Ctx
2144 : , Expr * Cond
2145 : , llvm::StringRef Message
2146 : , unsigned SI
2147 : )
2148 : : InheritableAttr(attr::EnableIf, R, SI, 0, 0)
2149 : , cond(Cond)
2150 : , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2151 : {
2152 :
2153 : if (!Message.empty())
2154 : std::memcpy(message, Message.data(), messageLength);
2155 : }
2156 :
2157 : EnableIfAttr *clone(ASTContext &C) const;
2158 : void printPretty(raw_ostream &OS,
2159 : const PrintingPolicy &Policy) const;
2160 : const char *getSpelling() const;
2161 : Expr * getCond() const {
2162 0 : return cond;
2163 : }
2164 :
2165 : llvm::StringRef getMessage() const {
2166 : return llvm::StringRef(message, messageLength);
2167 : }
2168 : unsigned getMessageLength() const {
2169 : return messageLength;
2170 : }
2171 : void setMessage(ASTContext &C, llvm::StringRef S) {
2172 : messageLength = S.size();
2173 : this->message = new (C, 1) char [messageLength];
2174 : if (!S.empty())
2175 : std::memcpy(this->message, S.data(), messageLength);
2176 : }
2177 :
2178 :
2179 :
2180 0 : static bool classof(const Attr *A) { return A->getKind() == attr::EnableIf; }
2181 : };
2182 :
2183 : class ExclusiveTrylockFunctionAttr : public InheritableAttr {
2184 : Expr * successValue;
2185 :
2186 : unsigned args_Size;
2187 : Expr * *args_;
2188 :
2189 :
2190 : public:
2191 : static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
2192 : ExclusiveTrylockFunctionAttr *A = new (Ctx) ExclusiveTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
2193 : A->setImplicit(true);
2194 : return A;
2195 : }
2196 :
2197 : ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
2198 : , Expr * SuccessValue
2199 : , Expr * *Args, unsigned ArgsSize
2200 : , unsigned SI
2201 : )
2202 : : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, 1, 1)
2203 : , successValue(SuccessValue)
2204 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
2205 : {
2206 :
2207 : std::copy(Args, Args + args_Size, args_);
2208 : }
2209 :
2210 : ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
2211 : , Expr * SuccessValue
2212 : , unsigned SI
2213 : )
2214 : : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, 1, 1)
2215 : , successValue()
2216 : , args_Size(0), args_(nullptr)
2217 : {
2218 :
2219 : }
2220 :
2221 : ExclusiveTrylockFunctionAttr *clone(ASTContext &C) const;
2222 : void printPretty(raw_ostream &OS,
2223 : const PrintingPolicy &Policy) const;
2224 : const char *getSpelling() const;
2225 : Expr * getSuccessValue() const {
2226 0 : return successValue;
2227 : }
2228 :
2229 : typedef Expr ** args_iterator;
2230 0 : args_iterator args_begin() const { return args_; }
2231 0 : args_iterator args_end() const { return args_ + args_Size; }
2232 : unsigned args_size() const { return args_Size; }
2233 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
2234 :
2235 :
2236 :
2237 :
2238 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ExclusiveTrylockFunction; }
2239 : };
2240 :
2241 : class FallThroughAttr : public Attr {
2242 :
2243 : public:
2244 : static FallThroughAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2245 : FallThroughAttr *A = new (Ctx) FallThroughAttr(Loc, Ctx, 0);
2246 : A->setImplicit(true);
2247 : return A;
2248 : }
2249 :
2250 : FallThroughAttr(SourceRange R, ASTContext &Ctx
2251 : , unsigned SI
2252 : )
2253 : : Attr(attr::FallThrough, R, SI, 0, 0)
2254 : {
2255 : }
2256 :
2257 : FallThroughAttr *clone(ASTContext &C) const;
2258 : void printPretty(raw_ostream &OS,
2259 : const PrintingPolicy &Policy) const;
2260 : const char *getSpelling() const;
2261 :
2262 :
2263 0 : static bool classof(const Attr *A) { return A->getKind() == attr::FallThrough; }
2264 : };
2265 :
2266 : class FastCallAttr : public InheritableAttr {
2267 :
2268 : public:
2269 : static FastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2270 : FastCallAttr *A = new (Ctx) FastCallAttr(Loc, Ctx, 0);
2271 : A->setImplicit(true);
2272 : return A;
2273 : }
2274 :
2275 : FastCallAttr(SourceRange R, ASTContext &Ctx
2276 : , unsigned SI
2277 : )
2278 : : InheritableAttr(attr::FastCall, R, SI, 0, 0)
2279 : {
2280 : }
2281 :
2282 : FastCallAttr *clone(ASTContext &C) const;
2283 : void printPretty(raw_ostream &OS,
2284 : const PrintingPolicy &Policy) const;
2285 : const char *getSpelling() const;
2286 :
2287 :
2288 0 : static bool classof(const Attr *A) { return A->getKind() == attr::FastCall; }
2289 : };
2290 :
2291 : class FinalAttr : public InheritableAttr {
2292 :
2293 : public:
2294 : enum Spelling {
2295 : Keyword_final = 0,
2296 : Keyword_sealed = 1
2297 : };
2298 :
2299 : static FinalAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
2300 : FinalAttr *A = new (Ctx) FinalAttr(Loc, Ctx, S);
2301 : A->setImplicit(true);
2302 : return A;
2303 : }
2304 :
2305 : FinalAttr(SourceRange R, ASTContext &Ctx
2306 : , unsigned SI
2307 : )
2308 : : InheritableAttr(attr::Final, R, SI, 0, 0)
2309 : {
2310 : }
2311 :
2312 : FinalAttr *clone(ASTContext &C) const;
2313 : void printPretty(raw_ostream &OS,
2314 : const PrintingPolicy &Policy) const;
2315 : const char *getSpelling() const;
2316 : Spelling getSemanticSpelling() const {
2317 : switch (SpellingListIndex) {
2318 : default: llvm_unreachable("Unknown spelling list index");
2319 : case 0: return Keyword_final;
2320 : case 1: return Keyword_sealed;
2321 : }
2322 : }
2323 : bool isSpelledAsSealed() const { return SpellingListIndex == 1; }
2324 :
2325 :
2326 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Final; }
2327 : };
2328 :
2329 : class FlagEnumAttr : public InheritableAttr {
2330 :
2331 : public:
2332 : static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2333 : FlagEnumAttr *A = new (Ctx) FlagEnumAttr(Loc, Ctx, 0);
2334 : A->setImplicit(true);
2335 : return A;
2336 : }
2337 :
2338 : FlagEnumAttr(SourceRange R, ASTContext &Ctx
2339 : , unsigned SI
2340 : )
2341 : : InheritableAttr(attr::FlagEnum, R, SI, 0, 0)
2342 : {
2343 : }
2344 :
2345 : FlagEnumAttr *clone(ASTContext &C) const;
2346 : void printPretty(raw_ostream &OS,
2347 : const PrintingPolicy &Policy) const;
2348 : const char *getSpelling() const;
2349 :
2350 : private:
2351 : llvm::APInt FlagBits;
2352 : public:
2353 : llvm::APInt &getFlagBits() {
2354 : return FlagBits;
2355 : }
2356 :
2357 : const llvm::APInt &getFlagBits() const {
2358 : return FlagBits;
2359 : }
2360 :
2361 :
2362 0 : static bool classof(const Attr *A) { return A->getKind() == attr::FlagEnum; }
2363 : };
2364 :
2365 : class FlattenAttr : public InheritableAttr {
2366 :
2367 : public:
2368 : static FlattenAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2369 : FlattenAttr *A = new (Ctx) FlattenAttr(Loc, Ctx, 0);
2370 : A->setImplicit(true);
2371 : return A;
2372 : }
2373 :
2374 : FlattenAttr(SourceRange R, ASTContext &Ctx
2375 : , unsigned SI
2376 : )
2377 : : InheritableAttr(attr::Flatten, R, SI, 0, 0)
2378 : {
2379 : }
2380 :
2381 : FlattenAttr *clone(ASTContext &C) const;
2382 : void printPretty(raw_ostream &OS,
2383 : const PrintingPolicy &Policy) const;
2384 : const char *getSpelling() const;
2385 :
2386 :
2387 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Flatten; }
2388 : };
2389 :
2390 : class FormatAttr : public InheritableAttr {
2391 : IdentifierInfo * type;
2392 :
2393 : int formatIdx;
2394 :
2395 : int firstArg;
2396 :
2397 :
2398 : public:
2399 : static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Loc = SourceRange()) {
2400 : FormatAttr *A = new (Ctx) FormatAttr(Loc, Ctx, Type, FormatIdx, FirstArg, 0);
2401 : A->setImplicit(true);
2402 : return A;
2403 : }
2404 :
2405 : FormatAttr(SourceRange R, ASTContext &Ctx
2406 : , IdentifierInfo * Type
2407 : , int FormatIdx
2408 : , int FirstArg
2409 : , unsigned SI
2410 : )
2411 : : InheritableAttr(attr::Format, R, SI, 0, 0)
2412 : , type(Type)
2413 : , formatIdx(FormatIdx)
2414 : , firstArg(FirstArg)
2415 : {
2416 :
2417 :
2418 :
2419 : }
2420 :
2421 : FormatAttr *clone(ASTContext &C) const;
2422 : void printPretty(raw_ostream &OS,
2423 : const PrintingPolicy &Policy) const;
2424 : const char *getSpelling() const;
2425 : IdentifierInfo * getType() const {
2426 : return type;
2427 : }
2428 :
2429 : int getFormatIdx() const {
2430 : return formatIdx;
2431 : }
2432 :
2433 : int getFirstArg() const {
2434 : return firstArg;
2435 : }
2436 :
2437 :
2438 :
2439 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Format; }
2440 : };
2441 :
2442 : class FormatArgAttr : public InheritableAttr {
2443 : int formatIdx;
2444 :
2445 :
2446 : public:
2447 : static FormatArgAttr *CreateImplicit(ASTContext &Ctx, int FormatIdx, SourceRange Loc = SourceRange()) {
2448 : FormatArgAttr *A = new (Ctx) FormatArgAttr(Loc, Ctx, FormatIdx, 0);
2449 : A->setImplicit(true);
2450 : return A;
2451 : }
2452 :
2453 : FormatArgAttr(SourceRange R, ASTContext &Ctx
2454 : , int FormatIdx
2455 : , unsigned SI
2456 : )
2457 : : InheritableAttr(attr::FormatArg, R, SI, 0, 0)
2458 : , formatIdx(FormatIdx)
2459 : {
2460 :
2461 : }
2462 :
2463 : FormatArgAttr *clone(ASTContext &C) const;
2464 : void printPretty(raw_ostream &OS,
2465 : const PrintingPolicy &Policy) const;
2466 : const char *getSpelling() const;
2467 : int getFormatIdx() const {
2468 : return formatIdx;
2469 : }
2470 :
2471 :
2472 :
2473 0 : static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; }
2474 : };
2475 :
2476 : class GNUInlineAttr : public InheritableAttr {
2477 :
2478 : public:
2479 : static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2480 : GNUInlineAttr *A = new (Ctx) GNUInlineAttr(Loc, Ctx, 0);
2481 : A->setImplicit(true);
2482 : return A;
2483 : }
2484 :
2485 : GNUInlineAttr(SourceRange R, ASTContext &Ctx
2486 : , unsigned SI
2487 : )
2488 : : InheritableAttr(attr::GNUInline, R, SI, 0, 0)
2489 : {
2490 : }
2491 :
2492 : GNUInlineAttr *clone(ASTContext &C) const;
2493 : void printPretty(raw_ostream &OS,
2494 : const PrintingPolicy &Policy) const;
2495 : const char *getSpelling() const;
2496 :
2497 :
2498 0 : static bool classof(const Attr *A) { return A->getKind() == attr::GNUInline; }
2499 : };
2500 :
2501 : class GuardedByAttr : public InheritableAttr {
2502 : Expr * arg;
2503 :
2504 :
2505 : public:
2506 : static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
2507 : GuardedByAttr *A = new (Ctx) GuardedByAttr(Loc, Ctx, Arg, 0);
2508 : A->setImplicit(true);
2509 : return A;
2510 : }
2511 :
2512 : GuardedByAttr(SourceRange R, ASTContext &Ctx
2513 : , Expr * Arg
2514 : , unsigned SI
2515 : )
2516 : : InheritableAttr(attr::GuardedBy, R, SI, 1, 1)
2517 : , arg(Arg)
2518 : {
2519 :
2520 : }
2521 :
2522 : GuardedByAttr *clone(ASTContext &C) const;
2523 : void printPretty(raw_ostream &OS,
2524 : const PrintingPolicy &Policy) const;
2525 : const char *getSpelling() const;
2526 : Expr * getArg() const {
2527 0 : return arg;
2528 : }
2529 :
2530 :
2531 :
2532 0 : static bool classof(const Attr *A) { return A->getKind() == attr::GuardedBy; }
2533 : };
2534 :
2535 : class GuardedVarAttr : public InheritableAttr {
2536 :
2537 : public:
2538 : static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2539 : GuardedVarAttr *A = new (Ctx) GuardedVarAttr(Loc, Ctx, 0);
2540 : A->setImplicit(true);
2541 : return A;
2542 : }
2543 :
2544 : GuardedVarAttr(SourceRange R, ASTContext &Ctx
2545 : , unsigned SI
2546 : )
2547 : : InheritableAttr(attr::GuardedVar, R, SI, 0, 0)
2548 : {
2549 : }
2550 :
2551 : GuardedVarAttr *clone(ASTContext &C) const;
2552 : void printPretty(raw_ostream &OS,
2553 : const PrintingPolicy &Policy) const;
2554 : const char *getSpelling() const;
2555 :
2556 :
2557 0 : static bool classof(const Attr *A) { return A->getKind() == attr::GuardedVar; }
2558 : };
2559 :
2560 : class HotAttr : public InheritableAttr {
2561 :
2562 : public:
2563 : static HotAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2564 : HotAttr *A = new (Ctx) HotAttr(Loc, Ctx, 0);
2565 : A->setImplicit(true);
2566 : return A;
2567 : }
2568 :
2569 : HotAttr(SourceRange R, ASTContext &Ctx
2570 : , unsigned SI
2571 : )
2572 : : InheritableAttr(attr::Hot, R, SI, 0, 0)
2573 : {
2574 : }
2575 :
2576 : HotAttr *clone(ASTContext &C) const;
2577 : void printPretty(raw_ostream &OS,
2578 : const PrintingPolicy &Policy) const;
2579 : const char *getSpelling() const;
2580 :
2581 :
2582 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Hot; }
2583 : };
2584 :
2585 : class IBActionAttr : public InheritableAttr {
2586 :
2587 : public:
2588 : static IBActionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2589 : IBActionAttr *A = new (Ctx) IBActionAttr(Loc, Ctx, 0);
2590 : A->setImplicit(true);
2591 : return A;
2592 : }
2593 :
2594 : IBActionAttr(SourceRange R, ASTContext &Ctx
2595 : , unsigned SI
2596 : )
2597 : : InheritableAttr(attr::IBAction, R, SI, 0, 0)
2598 : {
2599 : }
2600 :
2601 : IBActionAttr *clone(ASTContext &C) const;
2602 : void printPretty(raw_ostream &OS,
2603 : const PrintingPolicy &Policy) const;
2604 : const char *getSpelling() const;
2605 :
2606 :
2607 0 : static bool classof(const Attr *A) { return A->getKind() == attr::IBAction; }
2608 : };
2609 :
2610 : class IBOutletAttr : public InheritableAttr {
2611 :
2612 : public:
2613 : static IBOutletAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2614 : IBOutletAttr *A = new (Ctx) IBOutletAttr(Loc, Ctx, 0);
2615 : A->setImplicit(true);
2616 : return A;
2617 : }
2618 :
2619 : IBOutletAttr(SourceRange R, ASTContext &Ctx
2620 : , unsigned SI
2621 : )
2622 : : InheritableAttr(attr::IBOutlet, R, SI, 0, 0)
2623 : {
2624 : }
2625 :
2626 : IBOutletAttr *clone(ASTContext &C) const;
2627 : void printPretty(raw_ostream &OS,
2628 : const PrintingPolicy &Policy) const;
2629 : const char *getSpelling() const;
2630 :
2631 :
2632 0 : static bool classof(const Attr *A) { return A->getKind() == attr::IBOutlet; }
2633 : };
2634 :
2635 : class IBOutletCollectionAttr : public InheritableAttr {
2636 : TypeSourceInfo * interface;
2637 :
2638 :
2639 : public:
2640 : static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Loc = SourceRange()) {
2641 : IBOutletCollectionAttr *A = new (Ctx) IBOutletCollectionAttr(Loc, Ctx, Interface, 0);
2642 : A->setImplicit(true);
2643 : return A;
2644 : }
2645 :
2646 : IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
2647 : , TypeSourceInfo * Interface
2648 : , unsigned SI
2649 : )
2650 : : InheritableAttr(attr::IBOutletCollection, R, SI, 0, 0)
2651 : , interface(Interface)
2652 : {
2653 :
2654 : }
2655 :
2656 : IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
2657 : , unsigned SI
2658 : )
2659 : : InheritableAttr(attr::IBOutletCollection, R, SI, 0, 0)
2660 : , interface()
2661 : {
2662 : }
2663 :
2664 : IBOutletCollectionAttr *clone(ASTContext &C) const;
2665 : void printPretty(raw_ostream &OS,
2666 : const PrintingPolicy &Policy) const;
2667 : const char *getSpelling() const;
2668 : QualType getInterface() const {
2669 : return interface->getType();
2670 : } TypeSourceInfo * getInterfaceLoc() const {
2671 : return interface;
2672 : }
2673 :
2674 :
2675 :
2676 0 : static bool classof(const Attr *A) { return A->getKind() == attr::IBOutletCollection; }
2677 : };
2678 :
2679 : class InitPriorityAttr : public InheritableAttr {
2680 : unsigned priority;
2681 :
2682 :
2683 : public:
2684 : static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, SourceRange Loc = SourceRange()) {
2685 : InitPriorityAttr *A = new (Ctx) InitPriorityAttr(Loc, Ctx, Priority, 0);
2686 : A->setImplicit(true);
2687 : return A;
2688 : }
2689 :
2690 : InitPriorityAttr(SourceRange R, ASTContext &Ctx
2691 : , unsigned Priority
2692 : , unsigned SI
2693 : )
2694 : : InheritableAttr(attr::InitPriority, R, SI, 0, 0)
2695 : , priority(Priority)
2696 : {
2697 :
2698 : }
2699 :
2700 : InitPriorityAttr *clone(ASTContext &C) const;
2701 : void printPretty(raw_ostream &OS,
2702 : const PrintingPolicy &Policy) const;
2703 : const char *getSpelling() const;
2704 : unsigned getPriority() const {
2705 : return priority;
2706 : }
2707 :
2708 :
2709 :
2710 0 : static bool classof(const Attr *A) { return A->getKind() == attr::InitPriority; }
2711 : };
2712 :
2713 : class InitSegAttr : public Attr {
2714 : unsigned sectionLength;
2715 : char *section;
2716 :
2717 :
2718 : public:
2719 : static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, SourceRange Loc = SourceRange()) {
2720 : InitSegAttr *A = new (Ctx) InitSegAttr(Loc, Ctx, Section, 0);
2721 : A->setImplicit(true);
2722 : return A;
2723 : }
2724 :
2725 : InitSegAttr(SourceRange R, ASTContext &Ctx
2726 : , llvm::StringRef Section
2727 : , unsigned SI
2728 : )
2729 : : Attr(attr::InitSeg, R, SI, 0, 0)
2730 : , sectionLength(Section.size()),section(new (Ctx, 1) char[sectionLength])
2731 : {
2732 : if (!Section.empty())
2733 : std::memcpy(section, Section.data(), sectionLength);
2734 : }
2735 :
2736 : InitSegAttr *clone(ASTContext &C) const;
2737 : void printPretty(raw_ostream &OS,
2738 : const PrintingPolicy &Policy) const;
2739 : const char *getSpelling() const;
2740 : llvm::StringRef getSection() const {
2741 : return llvm::StringRef(section, sectionLength);
2742 : }
2743 : unsigned getSectionLength() const {
2744 : return sectionLength;
2745 : }
2746 : void setSection(ASTContext &C, llvm::StringRef S) {
2747 : sectionLength = S.size();
2748 : this->section = new (C, 1) char [sectionLength];
2749 : if (!S.empty())
2750 : std::memcpy(this->section, S.data(), sectionLength);
2751 : }
2752 :
2753 :
2754 : void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
2755 : OS << '(' << getSection() << ')';
2756 : }
2757 :
2758 :
2759 0 : static bool classof(const Attr *A) { return A->getKind() == attr::InitSeg; }
2760 : };
2761 :
2762 : class IntelOclBiccAttr : public InheritableAttr {
2763 :
2764 : public:
2765 : static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2766 : IntelOclBiccAttr *A = new (Ctx) IntelOclBiccAttr(Loc, Ctx, 0);
2767 : A->setImplicit(true);
2768 : return A;
2769 : }
2770 :
2771 : IntelOclBiccAttr(SourceRange R, ASTContext &Ctx
2772 : , unsigned SI
2773 : )
2774 : : InheritableAttr(attr::IntelOclBicc, R, SI, 0, 0)
2775 : {
2776 : }
2777 :
2778 : IntelOclBiccAttr *clone(ASTContext &C) const;
2779 : void printPretty(raw_ostream &OS,
2780 : const PrintingPolicy &Policy) const;
2781 : const char *getSpelling() const;
2782 :
2783 :
2784 0 : static bool classof(const Attr *A) { return A->getKind() == attr::IntelOclBicc; }
2785 : };
2786 :
2787 : class LockReturnedAttr : public InheritableAttr {
2788 : Expr * arg;
2789 :
2790 :
2791 : public:
2792 : static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
2793 : LockReturnedAttr *A = new (Ctx) LockReturnedAttr(Loc, Ctx, Arg, 0);
2794 : A->setImplicit(true);
2795 : return A;
2796 : }
2797 :
2798 : LockReturnedAttr(SourceRange R, ASTContext &Ctx
2799 : , Expr * Arg
2800 : , unsigned SI
2801 : )
2802 : : InheritableAttr(attr::LockReturned, R, SI, 1, 0)
2803 : , arg(Arg)
2804 : {
2805 :
2806 : }
2807 :
2808 : LockReturnedAttr *clone(ASTContext &C) const;
2809 : void printPretty(raw_ostream &OS,
2810 : const PrintingPolicy &Policy) const;
2811 : const char *getSpelling() const;
2812 : Expr * getArg() const {
2813 0 : return arg;
2814 : }
2815 :
2816 :
2817 :
2818 0 : static bool classof(const Attr *A) { return A->getKind() == attr::LockReturned; }
2819 : };
2820 :
2821 : class LocksExcludedAttr : public InheritableAttr {
2822 : unsigned args_Size;
2823 : Expr * *args_;
2824 :
2825 :
2826 : public:
2827 : static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
2828 : LocksExcludedAttr *A = new (Ctx) LocksExcludedAttr(Loc, Ctx, Args, ArgsSize, 0);
2829 : A->setImplicit(true);
2830 : return A;
2831 : }
2832 :
2833 : LocksExcludedAttr(SourceRange R, ASTContext &Ctx
2834 : , Expr * *Args, unsigned ArgsSize
2835 : , unsigned SI
2836 : )
2837 : : InheritableAttr(attr::LocksExcluded, R, SI, 1, 1)
2838 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
2839 : {
2840 : std::copy(Args, Args + args_Size, args_);
2841 : }
2842 :
2843 : LocksExcludedAttr(SourceRange R, ASTContext &Ctx
2844 : , unsigned SI
2845 : )
2846 : : InheritableAttr(attr::LocksExcluded, R, SI, 1, 1)
2847 : , args_Size(0), args_(nullptr)
2848 : {
2849 : }
2850 :
2851 : LocksExcludedAttr *clone(ASTContext &C) const;
2852 : void printPretty(raw_ostream &OS,
2853 : const PrintingPolicy &Policy) const;
2854 : const char *getSpelling() const;
2855 : typedef Expr ** args_iterator;
2856 0 : args_iterator args_begin() const { return args_; }
2857 0 : args_iterator args_end() const { return args_ + args_Size; }
2858 : unsigned args_size() const { return args_Size; }
2859 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
2860 :
2861 :
2862 :
2863 :
2864 0 : static bool classof(const Attr *A) { return A->getKind() == attr::LocksExcluded; }
2865 : };
2866 :
2867 : class LoopHintAttr : public Attr {
2868 : public:
2869 : enum OptionType {
2870 : Vectorize,
2871 : VectorizeWidth,
2872 : Interleave,
2873 : InterleaveCount,
2874 : Unroll,
2875 : UnrollCount
2876 : };
2877 : private:
2878 : OptionType option;
2879 :
2880 : public:
2881 : enum LoopHintState {
2882 : Default,
2883 : Enable,
2884 : Disable,
2885 : AssumeSafety
2886 : };
2887 : private:
2888 : LoopHintState state;
2889 :
2890 : Expr * value;
2891 :
2892 :
2893 : public:
2894 : enum Spelling {
2895 : Pragma_clang_loop = 0,
2896 : Pragma_unroll = 1,
2897 : Pragma_nounroll = 2
2898 : };
2899 :
2900 : static LoopHintAttr *CreateImplicit(ASTContext &Ctx, Spelling S, OptionType Option, LoopHintState State, Expr * Value, SourceRange Loc = SourceRange()) {
2901 : LoopHintAttr *A = new (Ctx) LoopHintAttr(Loc, Ctx, Option, State, Value, S);
2902 : A->setImplicit(true);
2903 : return A;
2904 : }
2905 :
2906 : LoopHintAttr(SourceRange R, ASTContext &Ctx
2907 : , OptionType Option
2908 : , LoopHintState State
2909 : , Expr * Value
2910 : , unsigned SI
2911 : )
2912 : : Attr(attr::LoopHint, R, SI, 0, 0)
2913 : , option(Option)
2914 : , state(State)
2915 : , value(Value)
2916 : {
2917 :
2918 :
2919 :
2920 : }
2921 :
2922 : LoopHintAttr *clone(ASTContext &C) const;
2923 : void printPretty(raw_ostream &OS,
2924 : const PrintingPolicy &Policy) const;
2925 : const char *getSpelling() const;
2926 : Spelling getSemanticSpelling() const {
2927 : switch (SpellingListIndex) {
2928 : default: llvm_unreachable("Unknown spelling list index");
2929 : case 0: return Pragma_clang_loop;
2930 : case 1: return Pragma_unroll;
2931 : case 2: return Pragma_nounroll;
2932 : }
2933 : }
2934 : OptionType getOption() const {
2935 : return option;
2936 : }
2937 :
2938 : static bool ConvertStrToOptionType(StringRef Val, OptionType &Out) {
2939 : Optional<OptionType> R = llvm::StringSwitch<Optional<OptionType>>(Val)
2940 : .Case("vectorize", LoopHintAttr::Vectorize)
2941 : .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
2942 : .Case("interleave", LoopHintAttr::Interleave)
2943 : .Case("interleave_count", LoopHintAttr::InterleaveCount)
2944 : .Case("unroll", LoopHintAttr::Unroll)
2945 : .Case("unroll_count", LoopHintAttr::UnrollCount)
2946 : .Default(Optional<OptionType>());
2947 : if (R) {
2948 : Out = *R;
2949 : return true;
2950 : }
2951 : return false;
2952 : }
2953 :
2954 : static const char *ConvertOptionTypeToStr(OptionType Val) {
2955 : switch(Val) {
2956 : case LoopHintAttr::Vectorize: return "vectorize";
2957 : case LoopHintAttr::VectorizeWidth: return "vectorize_width";
2958 : case LoopHintAttr::Interleave: return "interleave";
2959 : case LoopHintAttr::InterleaveCount: return "interleave_count";
2960 : case LoopHintAttr::Unroll: return "unroll";
2961 : case LoopHintAttr::UnrollCount: return "unroll_count";
2962 : }
2963 : llvm_unreachable("No enumerator with that value");
2964 : }
2965 : LoopHintState getState() const {
2966 : return state;
2967 : }
2968 :
2969 : static bool ConvertStrToLoopHintState(StringRef Val, LoopHintState &Out) {
2970 : Optional<LoopHintState> R = llvm::StringSwitch<Optional<LoopHintState>>(Val)
2971 : .Case("default", LoopHintAttr::Default)
2972 : .Case("enable", LoopHintAttr::Enable)
2973 : .Case("disable", LoopHintAttr::Disable)
2974 : .Case("assume_safety", LoopHintAttr::AssumeSafety)
2975 : .Default(Optional<LoopHintState>());
2976 : if (R) {
2977 : Out = *R;
2978 : return true;
2979 : }
2980 : return false;
2981 : }
2982 :
2983 : static const char *ConvertLoopHintStateToStr(LoopHintState Val) {
2984 : switch(Val) {
2985 : case LoopHintAttr::Default: return "default";
2986 : case LoopHintAttr::Enable: return "enable";
2987 : case LoopHintAttr::Disable: return "disable";
2988 : case LoopHintAttr::AssumeSafety: return "assume_safety";
2989 : }
2990 : llvm_unreachable("No enumerator with that value");
2991 : }
2992 : Expr * getValue() const {
2993 0 : return value;
2994 : }
2995 :
2996 :
2997 : static const char *getOptionName(int Option) {
2998 : switch(Option) {
2999 : case Vectorize: return "vectorize";
3000 : case VectorizeWidth: return "vectorize_width";
3001 : case Interleave: return "interleave";
3002 : case InterleaveCount: return "interleave_count";
3003 : case Unroll: return "unroll";
3004 : case UnrollCount: return "unroll_count";
3005 : }
3006 : llvm_unreachable("Unhandled LoopHint option.");
3007 : }
3008 :
3009 : void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
3010 : unsigned SpellingIndex = getSpellingListIndex();
3011 : // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
3012 : // "nounroll" is already emitted as the pragma name.
3013 : if (SpellingIndex == Pragma_nounroll) {
3014 : OS << "\n";
3015 : return;
3016 : }
3017 : else if (SpellingIndex == Pragma_unroll) {
3018 : OS << getValueString(Policy) << "\n";
3019 : return;
3020 : }
3021 :
3022 : assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
3023 : OS << getOptionName(option) << getValueString(Policy) << "\n";
3024 : }
3025 :
3026 : // Return a string containing the loop hint argument including the
3027 : // enclosing parentheses.
3028 : std::string getValueString(const PrintingPolicy &Policy) const {
3029 : std::string ValueName;
3030 : llvm::raw_string_ostream OS(ValueName);
3031 : OS << "(";
3032 : if (option == VectorizeWidth || option == InterleaveCount ||
3033 : option == UnrollCount)
3034 : value->printPretty(OS, nullptr, Policy);
3035 : else if (state == Default)
3036 : return "";
3037 : else if (state == Enable)
3038 : OS << (option == Unroll ? "full" : "enable");
3039 : else if (state == AssumeSafety)
3040 : OS << "assume_safety";
3041 : else
3042 : OS << "disable";
3043 : OS << ")";
3044 : return OS.str();
3045 : }
3046 :
3047 : // Return a string suitable for identifying this attribute in diagnostics.
3048 : std::string getDiagnosticName(const PrintingPolicy &Policy) const {
3049 : unsigned SpellingIndex = getSpellingListIndex();
3050 : if (SpellingIndex == Pragma_nounroll)
3051 : return "#pragma nounroll";
3052 : else if (SpellingIndex == Pragma_unroll)
3053 : return "#pragma unroll" + getValueString(Policy);
3054 :
3055 : assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
3056 : return getOptionName(option) + getValueString(Policy);
3057 : }
3058 :
3059 :
3060 0 : static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; }
3061 : };
3062 :
3063 : class MSABIAttr : public InheritableAttr {
3064 :
3065 : public:
3066 : static MSABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3067 : MSABIAttr *A = new (Ctx) MSABIAttr(Loc, Ctx, 0);
3068 : A->setImplicit(true);
3069 : return A;
3070 : }
3071 :
3072 : MSABIAttr(SourceRange R, ASTContext &Ctx
3073 : , unsigned SI
3074 : )
3075 : : InheritableAttr(attr::MSABI, R, SI, 0, 0)
3076 : {
3077 : }
3078 :
3079 : MSABIAttr *clone(ASTContext &C) const;
3080 : void printPretty(raw_ostream &OS,
3081 : const PrintingPolicy &Policy) const;
3082 : const char *getSpelling() const;
3083 :
3084 :
3085 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MSABI; }
3086 : };
3087 :
3088 : class MSInheritanceAttr : public InheritableAttr {
3089 : bool bestCase;
3090 :
3091 :
3092 : public:
3093 : enum Spelling {
3094 : Keyword_single_inheritance = 0,
3095 : Keyword_multiple_inheritance = 1,
3096 : Keyword_virtual_inheritance = 2,
3097 : Keyword_unspecified_inheritance = 3
3098 : };
3099 :
3100 : static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool BestCase, SourceRange Loc = SourceRange()) {
3101 : MSInheritanceAttr *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, BestCase, S);
3102 : A->setImplicit(true);
3103 : return A;
3104 : }
3105 :
3106 : MSInheritanceAttr(SourceRange R, ASTContext &Ctx
3107 : , bool BestCase
3108 : , unsigned SI
3109 : )
3110 : : InheritableAttr(attr::MSInheritance, R, SI, 0, 0)
3111 : , bestCase(BestCase)
3112 : {
3113 :
3114 : }
3115 :
3116 : MSInheritanceAttr(SourceRange R, ASTContext &Ctx
3117 : , unsigned SI
3118 : )
3119 : : InheritableAttr(attr::MSInheritance, R, SI, 0, 0)
3120 : , bestCase()
3121 : {
3122 : }
3123 :
3124 : MSInheritanceAttr *clone(ASTContext &C) const;
3125 : void printPretty(raw_ostream &OS,
3126 : const PrintingPolicy &Policy) const;
3127 : const char *getSpelling() const;
3128 : Spelling getSemanticSpelling() const {
3129 : switch (SpellingListIndex) {
3130 : default: llvm_unreachable("Unknown spelling list index");
3131 : case 0: return Keyword_single_inheritance;
3132 : case 1: return Keyword_multiple_inheritance;
3133 : case 2: return Keyword_virtual_inheritance;
3134 : case 3: return Keyword_unspecified_inheritance;
3135 : }
3136 : }
3137 : bool getBestCase() const {
3138 : return bestCase;
3139 : }
3140 :
3141 : static const bool DefaultBestCase = 1;
3142 :
3143 :
3144 : static bool hasVBPtrOffsetField(Spelling Inheritance) {
3145 : return Inheritance == Keyword_unspecified_inheritance;
3146 : }
3147 :
3148 : // Only member pointers to functions need a this adjustment, since it can be
3149 : // combined with the field offset for data pointers.
3150 : static bool hasNVOffsetField(bool IsMemberFunction, Spelling Inheritance) {
3151 : return IsMemberFunction && Inheritance >= Keyword_multiple_inheritance;
3152 : }
3153 :
3154 : static bool hasVBTableOffsetField(Spelling Inheritance) {
3155 : return Inheritance >= Keyword_virtual_inheritance;
3156 : }
3157 :
3158 : static bool hasOnlyOneField(bool IsMemberFunction,
3159 : Spelling Inheritance) {
3160 : if (IsMemberFunction)
3161 : return Inheritance <= Keyword_single_inheritance;
3162 : return Inheritance <= Keyword_multiple_inheritance;
3163 : }
3164 :
3165 :
3166 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MSInheritance; }
3167 : };
3168 :
3169 : class MSNoVTableAttr : public InheritableAttr {
3170 :
3171 : public:
3172 : static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3173 : MSNoVTableAttr *A = new (Ctx) MSNoVTableAttr(Loc, Ctx, 0);
3174 : A->setImplicit(true);
3175 : return A;
3176 : }
3177 :
3178 : MSNoVTableAttr(SourceRange R, ASTContext &Ctx
3179 : , unsigned SI
3180 : )
3181 : : InheritableAttr(attr::MSNoVTable, R, SI, 0, 0)
3182 : {
3183 : }
3184 :
3185 : MSNoVTableAttr *clone(ASTContext &C) const;
3186 : void printPretty(raw_ostream &OS,
3187 : const PrintingPolicy &Policy) const;
3188 : const char *getSpelling() const;
3189 :
3190 :
3191 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MSNoVTable; }
3192 : };
3193 :
3194 : class MSP430InterruptAttr : public InheritableAttr {
3195 : unsigned number;
3196 :
3197 :
3198 : public:
3199 : static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Loc = SourceRange()) {
3200 : MSP430InterruptAttr *A = new (Ctx) MSP430InterruptAttr(Loc, Ctx, Number, 0);
3201 : A->setImplicit(true);
3202 : return A;
3203 : }
3204 :
3205 : MSP430InterruptAttr(SourceRange R, ASTContext &Ctx
3206 : , unsigned Number
3207 : , unsigned SI
3208 : )
3209 : : InheritableAttr(attr::MSP430Interrupt, R, SI, 0, 0)
3210 : , number(Number)
3211 : {
3212 :
3213 : }
3214 :
3215 : MSP430InterruptAttr *clone(ASTContext &C) const;
3216 : void printPretty(raw_ostream &OS,
3217 : const PrintingPolicy &Policy) const;
3218 : const char *getSpelling() const;
3219 : unsigned getNumber() const {
3220 : return number;
3221 : }
3222 :
3223 :
3224 :
3225 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MSP430Interrupt; }
3226 : };
3227 :
3228 : class MSStructAttr : public InheritableAttr {
3229 :
3230 : public:
3231 : static MSStructAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3232 : MSStructAttr *A = new (Ctx) MSStructAttr(Loc, Ctx, 0);
3233 : A->setImplicit(true);
3234 : return A;
3235 : }
3236 :
3237 : MSStructAttr(SourceRange R, ASTContext &Ctx
3238 : , unsigned SI
3239 : )
3240 : : InheritableAttr(attr::MSStruct, R, SI, 0, 0)
3241 : {
3242 : }
3243 :
3244 : MSStructAttr *clone(ASTContext &C) const;
3245 : void printPretty(raw_ostream &OS,
3246 : const PrintingPolicy &Policy) const;
3247 : const char *getSpelling() const;
3248 :
3249 :
3250 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MSStruct; }
3251 : };
3252 :
3253 : class MSVtorDispAttr : public InheritableAttr {
3254 : unsigned vdm;
3255 :
3256 :
3257 : public:
3258 : static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, SourceRange Loc = SourceRange()) {
3259 : MSVtorDispAttr *A = new (Ctx) MSVtorDispAttr(Loc, Ctx, Vdm, 0);
3260 : A->setImplicit(true);
3261 : return A;
3262 : }
3263 :
3264 : MSVtorDispAttr(SourceRange R, ASTContext &Ctx
3265 : , unsigned Vdm
3266 : , unsigned SI
3267 : )
3268 : : InheritableAttr(attr::MSVtorDisp, R, SI, 0, 0)
3269 : , vdm(Vdm)
3270 : {
3271 :
3272 : }
3273 :
3274 : MSVtorDispAttr *clone(ASTContext &C) const;
3275 : void printPretty(raw_ostream &OS,
3276 : const PrintingPolicy &Policy) const;
3277 : const char *getSpelling() const;
3278 : unsigned getVdm() const {
3279 : return vdm;
3280 : }
3281 :
3282 :
3283 : enum Mode {
3284 : Never,
3285 : ForVBaseOverride,
3286 : ForVFTable
3287 : };
3288 :
3289 : Mode getVtorDispMode() const { return Mode(vdm); }
3290 :
3291 :
3292 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MSVtorDisp; }
3293 : };
3294 :
3295 : class MaxFieldAlignmentAttr : public InheritableAttr {
3296 : unsigned alignment;
3297 :
3298 :
3299 : public:
3300 : static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Loc = SourceRange()) {
3301 : MaxFieldAlignmentAttr *A = new (Ctx) MaxFieldAlignmentAttr(Loc, Ctx, Alignment, 0);
3302 : A->setImplicit(true);
3303 : return A;
3304 : }
3305 :
3306 : MaxFieldAlignmentAttr(SourceRange R, ASTContext &Ctx
3307 : , unsigned Alignment
3308 : , unsigned SI
3309 : )
3310 : : InheritableAttr(attr::MaxFieldAlignment, R, SI, 0, 0)
3311 : , alignment(Alignment)
3312 : {
3313 :
3314 : }
3315 :
3316 : MaxFieldAlignmentAttr *clone(ASTContext &C) const;
3317 : void printPretty(raw_ostream &OS,
3318 : const PrintingPolicy &Policy) const;
3319 : const char *getSpelling() const;
3320 : unsigned getAlignment() const {
3321 : return alignment;
3322 : }
3323 :
3324 :
3325 :
3326 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MaxFieldAlignment; }
3327 : };
3328 :
3329 : class MayAliasAttr : public InheritableAttr {
3330 :
3331 : public:
3332 : static MayAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3333 : MayAliasAttr *A = new (Ctx) MayAliasAttr(Loc, Ctx, 0);
3334 : A->setImplicit(true);
3335 : return A;
3336 : }
3337 :
3338 : MayAliasAttr(SourceRange R, ASTContext &Ctx
3339 : , unsigned SI
3340 : )
3341 : : InheritableAttr(attr::MayAlias, R, SI, 0, 0)
3342 : {
3343 : }
3344 :
3345 : MayAliasAttr *clone(ASTContext &C) const;
3346 : void printPretty(raw_ostream &OS,
3347 : const PrintingPolicy &Policy) const;
3348 : const char *getSpelling() const;
3349 :
3350 :
3351 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MayAlias; }
3352 : };
3353 :
3354 : class MinSizeAttr : public InheritableAttr {
3355 :
3356 : public:
3357 : static MinSizeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3358 : MinSizeAttr *A = new (Ctx) MinSizeAttr(Loc, Ctx, 0);
3359 : A->setImplicit(true);
3360 : return A;
3361 : }
3362 :
3363 : MinSizeAttr(SourceRange R, ASTContext &Ctx
3364 : , unsigned SI
3365 : )
3366 : : InheritableAttr(attr::MinSize, R, SI, 0, 0)
3367 : {
3368 : }
3369 :
3370 : MinSizeAttr *clone(ASTContext &C) const;
3371 : void printPretty(raw_ostream &OS,
3372 : const PrintingPolicy &Policy) const;
3373 : const char *getSpelling() const;
3374 :
3375 :
3376 0 : static bool classof(const Attr *A) { return A->getKind() == attr::MinSize; }
3377 : };
3378 :
3379 : class Mips16Attr : public InheritableAttr {
3380 :
3381 : public:
3382 : static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3383 : Mips16Attr *A = new (Ctx) Mips16Attr(Loc, Ctx, 0);
3384 : A->setImplicit(true);
3385 : return A;
3386 : }
3387 :
3388 : Mips16Attr(SourceRange R, ASTContext &Ctx
3389 : , unsigned SI
3390 : )
3391 : : InheritableAttr(attr::Mips16, R, SI, 0, 0)
3392 : {
3393 : }
3394 :
3395 : Mips16Attr *clone(ASTContext &C) const;
3396 : void printPretty(raw_ostream &OS,
3397 : const PrintingPolicy &Policy) const;
3398 : const char *getSpelling() const;
3399 :
3400 :
3401 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; }
3402 : };
3403 :
3404 : class ModeAttr : public Attr {
3405 : IdentifierInfo * mode;
3406 :
3407 :
3408 : public:
3409 : static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Loc = SourceRange()) {
3410 : ModeAttr *A = new (Ctx) ModeAttr(Loc, Ctx, Mode, 0);
3411 : A->setImplicit(true);
3412 : return A;
3413 : }
3414 :
3415 : ModeAttr(SourceRange R, ASTContext &Ctx
3416 : , IdentifierInfo * Mode
3417 : , unsigned SI
3418 : )
3419 : : Attr(attr::Mode, R, SI, 0, 0)
3420 : , mode(Mode)
3421 : {
3422 :
3423 : }
3424 :
3425 : ModeAttr *clone(ASTContext &C) const;
3426 : void printPretty(raw_ostream &OS,
3427 : const PrintingPolicy &Policy) const;
3428 : const char *getSpelling() const;
3429 : IdentifierInfo * getMode() const {
3430 : return mode;
3431 : }
3432 :
3433 :
3434 :
3435 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Mode; }
3436 : };
3437 :
3438 : class NSConsumedAttr : public InheritableParamAttr {
3439 :
3440 : public:
3441 : static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3442 : NSConsumedAttr *A = new (Ctx) NSConsumedAttr(Loc, Ctx, 0);
3443 : A->setImplicit(true);
3444 : return A;
3445 : }
3446 :
3447 : NSConsumedAttr(SourceRange R, ASTContext &Ctx
3448 : , unsigned SI
3449 : )
3450 : : InheritableParamAttr(attr::NSConsumed, R, SI, 0, 0)
3451 : {
3452 : }
3453 :
3454 : NSConsumedAttr *clone(ASTContext &C) const;
3455 : void printPretty(raw_ostream &OS,
3456 : const PrintingPolicy &Policy) const;
3457 : const char *getSpelling() const;
3458 :
3459 :
3460 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; }
3461 : };
3462 :
3463 : class NSConsumesSelfAttr : public InheritableAttr {
3464 :
3465 : public:
3466 : static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3467 : NSConsumesSelfAttr *A = new (Ctx) NSConsumesSelfAttr(Loc, Ctx, 0);
3468 : A->setImplicit(true);
3469 : return A;
3470 : }
3471 :
3472 : NSConsumesSelfAttr(SourceRange R, ASTContext &Ctx
3473 : , unsigned SI
3474 : )
3475 : : InheritableAttr(attr::NSConsumesSelf, R, SI, 0, 0)
3476 : {
3477 : }
3478 :
3479 : NSConsumesSelfAttr *clone(ASTContext &C) const;
3480 : void printPretty(raw_ostream &OS,
3481 : const PrintingPolicy &Policy) const;
3482 : const char *getSpelling() const;
3483 :
3484 :
3485 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; }
3486 : };
3487 :
3488 : class NSReturnsAutoreleasedAttr : public InheritableAttr {
3489 :
3490 : public:
3491 : static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3492 : NSReturnsAutoreleasedAttr *A = new (Ctx) NSReturnsAutoreleasedAttr(Loc, Ctx, 0);
3493 : A->setImplicit(true);
3494 : return A;
3495 : }
3496 :
3497 : NSReturnsAutoreleasedAttr(SourceRange R, ASTContext &Ctx
3498 : , unsigned SI
3499 : )
3500 : : InheritableAttr(attr::NSReturnsAutoreleased, R, SI, 0, 0)
3501 : {
3502 : }
3503 :
3504 : NSReturnsAutoreleasedAttr *clone(ASTContext &C) const;
3505 : void printPretty(raw_ostream &OS,
3506 : const PrintingPolicy &Policy) const;
3507 : const char *getSpelling() const;
3508 :
3509 :
3510 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; }
3511 : };
3512 :
3513 : class NSReturnsNotRetainedAttr : public InheritableAttr {
3514 :
3515 : public:
3516 : static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3517 : NSReturnsNotRetainedAttr *A = new (Ctx) NSReturnsNotRetainedAttr(Loc, Ctx, 0);
3518 : A->setImplicit(true);
3519 : return A;
3520 : }
3521 :
3522 : NSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
3523 : , unsigned SI
3524 : )
3525 : : InheritableAttr(attr::NSReturnsNotRetained, R, SI, 0, 0)
3526 : {
3527 : }
3528 :
3529 : NSReturnsNotRetainedAttr *clone(ASTContext &C) const;
3530 : void printPretty(raw_ostream &OS,
3531 : const PrintingPolicy &Policy) const;
3532 : const char *getSpelling() const;
3533 :
3534 :
3535 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; }
3536 : };
3537 :
3538 : class NSReturnsRetainedAttr : public InheritableAttr {
3539 :
3540 : public:
3541 : static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3542 : NSReturnsRetainedAttr *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0);
3543 : A->setImplicit(true);
3544 : return A;
3545 : }
3546 :
3547 : NSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
3548 : , unsigned SI
3549 : )
3550 : : InheritableAttr(attr::NSReturnsRetained, R, SI, 0, 0)
3551 : {
3552 : }
3553 :
3554 : NSReturnsRetainedAttr *clone(ASTContext &C) const;
3555 : void printPretty(raw_ostream &OS,
3556 : const PrintingPolicy &Policy) const;
3557 : const char *getSpelling() const;
3558 :
3559 :
3560 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; }
3561 : };
3562 :
3563 : class NakedAttr : public InheritableAttr {
3564 :
3565 : public:
3566 : static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3567 : NakedAttr *A = new (Ctx) NakedAttr(Loc, Ctx, 0);
3568 : A->setImplicit(true);
3569 : return A;
3570 : }
3571 :
3572 : NakedAttr(SourceRange R, ASTContext &Ctx
3573 : , unsigned SI
3574 : )
3575 : : InheritableAttr(attr::Naked, R, SI, 0, 0)
3576 : {
3577 : }
3578 :
3579 : NakedAttr *clone(ASTContext &C) const;
3580 : void printPretty(raw_ostream &OS,
3581 : const PrintingPolicy &Policy) const;
3582 : const char *getSpelling() const;
3583 :
3584 :
3585 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Naked; }
3586 : };
3587 :
3588 : class NoCommonAttr : public InheritableAttr {
3589 :
3590 : public:
3591 : static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3592 : NoCommonAttr *A = new (Ctx) NoCommonAttr(Loc, Ctx, 0);
3593 : A->setImplicit(true);
3594 : return A;
3595 : }
3596 :
3597 : NoCommonAttr(SourceRange R, ASTContext &Ctx
3598 : , unsigned SI
3599 : )
3600 : : InheritableAttr(attr::NoCommon, R, SI, 0, 0)
3601 : {
3602 : }
3603 :
3604 : NoCommonAttr *clone(ASTContext &C) const;
3605 : void printPretty(raw_ostream &OS,
3606 : const PrintingPolicy &Policy) const;
3607 : const char *getSpelling() const;
3608 :
3609 :
3610 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; }
3611 : };
3612 :
3613 : class NoDebugAttr : public InheritableAttr {
3614 :
3615 : public:
3616 : static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3617 : NoDebugAttr *A = new (Ctx) NoDebugAttr(Loc, Ctx, 0);
3618 : A->setImplicit(true);
3619 : return A;
3620 : }
3621 :
3622 : NoDebugAttr(SourceRange R, ASTContext &Ctx
3623 : , unsigned SI
3624 : )
3625 : : InheritableAttr(attr::NoDebug, R, SI, 0, 0)
3626 : {
3627 : }
3628 :
3629 : NoDebugAttr *clone(ASTContext &C) const;
3630 : void printPretty(raw_ostream &OS,
3631 : const PrintingPolicy &Policy) const;
3632 : const char *getSpelling() const;
3633 :
3634 :
3635 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; }
3636 : };
3637 :
3638 : class NoDuplicateAttr : public InheritableAttr {
3639 :
3640 : public:
3641 : static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3642 : NoDuplicateAttr *A = new (Ctx) NoDuplicateAttr(Loc, Ctx, 0);
3643 : A->setImplicit(true);
3644 : return A;
3645 : }
3646 :
3647 : NoDuplicateAttr(SourceRange R, ASTContext &Ctx
3648 : , unsigned SI
3649 : )
3650 : : InheritableAttr(attr::NoDuplicate, R, SI, 0, 0)
3651 : {
3652 : }
3653 :
3654 : NoDuplicateAttr *clone(ASTContext &C) const;
3655 : void printPretty(raw_ostream &OS,
3656 : const PrintingPolicy &Policy) const;
3657 : const char *getSpelling() const;
3658 :
3659 :
3660 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; }
3661 : };
3662 :
3663 : class NoInlineAttr : public InheritableAttr {
3664 :
3665 : public:
3666 : static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3667 : NoInlineAttr *A = new (Ctx) NoInlineAttr(Loc, Ctx, 0);
3668 : A->setImplicit(true);
3669 : return A;
3670 : }
3671 :
3672 : NoInlineAttr(SourceRange R, ASTContext &Ctx
3673 : , unsigned SI
3674 : )
3675 : : InheritableAttr(attr::NoInline, R, SI, 0, 0)
3676 : {
3677 : }
3678 :
3679 : NoInlineAttr *clone(ASTContext &C) const;
3680 : void printPretty(raw_ostream &OS,
3681 : const PrintingPolicy &Policy) const;
3682 : const char *getSpelling() const;
3683 :
3684 :
3685 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; }
3686 : };
3687 :
3688 : class NoInstrumentFunctionAttr : public InheritableAttr {
3689 :
3690 : public:
3691 : static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3692 : NoInstrumentFunctionAttr *A = new (Ctx) NoInstrumentFunctionAttr(Loc, Ctx, 0);
3693 : A->setImplicit(true);
3694 : return A;
3695 : }
3696 :
3697 : NoInstrumentFunctionAttr(SourceRange R, ASTContext &Ctx
3698 : , unsigned SI
3699 : )
3700 : : InheritableAttr(attr::NoInstrumentFunction, R, SI, 0, 0)
3701 : {
3702 : }
3703 :
3704 : NoInstrumentFunctionAttr *clone(ASTContext &C) const;
3705 : void printPretty(raw_ostream &OS,
3706 : const PrintingPolicy &Policy) const;
3707 : const char *getSpelling() const;
3708 :
3709 :
3710 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; }
3711 : };
3712 :
3713 : class NoMips16Attr : public InheritableAttr {
3714 :
3715 : public:
3716 : static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3717 : NoMips16Attr *A = new (Ctx) NoMips16Attr(Loc, Ctx, 0);
3718 : A->setImplicit(true);
3719 : return A;
3720 : }
3721 :
3722 : NoMips16Attr(SourceRange R, ASTContext &Ctx
3723 : , unsigned SI
3724 : )
3725 : : InheritableAttr(attr::NoMips16, R, SI, 0, 0)
3726 : {
3727 : }
3728 :
3729 : NoMips16Attr *clone(ASTContext &C) const;
3730 : void printPretty(raw_ostream &OS,
3731 : const PrintingPolicy &Policy) const;
3732 : const char *getSpelling() const;
3733 :
3734 :
3735 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; }
3736 : };
3737 :
3738 : class NoReturnAttr : public InheritableAttr {
3739 :
3740 : public:
3741 : static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3742 : NoReturnAttr *A = new (Ctx) NoReturnAttr(Loc, Ctx, 0);
3743 : A->setImplicit(true);
3744 : return A;
3745 : }
3746 :
3747 : NoReturnAttr(SourceRange R, ASTContext &Ctx
3748 : , unsigned SI
3749 : )
3750 : : InheritableAttr(attr::NoReturn, R, SI, 0, 0)
3751 : {
3752 : }
3753 :
3754 : NoReturnAttr *clone(ASTContext &C) const;
3755 : void printPretty(raw_ostream &OS,
3756 : const PrintingPolicy &Policy) const;
3757 : const char *getSpelling() const;
3758 :
3759 :
3760 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; }
3761 : };
3762 :
3763 : class NoSanitizeAttr : public InheritableAttr {
3764 : unsigned sanitizers_Size;
3765 : std::string *sanitizers_;
3766 :
3767 :
3768 : public:
3769 : static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, std::string *Sanitizers, unsigned SanitizersSize, SourceRange Loc = SourceRange()) {
3770 : NoSanitizeAttr *A = new (Ctx) NoSanitizeAttr(Loc, Ctx, Sanitizers, SanitizersSize, 0);
3771 : A->setImplicit(true);
3772 : return A;
3773 : }
3774 :
3775 : NoSanitizeAttr(SourceRange R, ASTContext &Ctx
3776 : , std::string *Sanitizers, unsigned SanitizersSize
3777 : , unsigned SI
3778 : )
3779 : : InheritableAttr(attr::NoSanitize, R, SI, 0, 0)
3780 : , sanitizers_Size(SanitizersSize), sanitizers_(new (Ctx, 16) std::string[sanitizers_Size])
3781 : {
3782 : std::copy(Sanitizers, Sanitizers + sanitizers_Size, sanitizers_);
3783 : }
3784 :
3785 : NoSanitizeAttr(SourceRange R, ASTContext &Ctx
3786 : , unsigned SI
3787 : )
3788 : : InheritableAttr(attr::NoSanitize, R, SI, 0, 0)
3789 : , sanitizers_Size(0), sanitizers_(nullptr)
3790 : {
3791 : }
3792 :
3793 : NoSanitizeAttr *clone(ASTContext &C) const;
3794 : void printPretty(raw_ostream &OS,
3795 : const PrintingPolicy &Policy) const;
3796 : const char *getSpelling() const;
3797 : typedef std::string* sanitizers_iterator;
3798 : sanitizers_iterator sanitizers_begin() const { return sanitizers_; }
3799 : sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; }
3800 : unsigned sanitizers_size() const { return sanitizers_Size; }
3801 : llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); }
3802 :
3803 :
3804 :
3805 : SanitizerMask getMask() const {
3806 : SanitizerMask Mask = 0;
3807 : for (auto SanitizerName : sanitizers()) {
3808 : SanitizerMask ParsedMask =
3809 : parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
3810 : Mask |= expandSanitizerGroups(ParsedMask);
3811 : }
3812 : return Mask;
3813 : }
3814 :
3815 :
3816 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; }
3817 : };
3818 :
3819 : class NoSplitStackAttr : public InheritableAttr {
3820 :
3821 : public:
3822 : static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3823 : NoSplitStackAttr *A = new (Ctx) NoSplitStackAttr(Loc, Ctx, 0);
3824 : A->setImplicit(true);
3825 : return A;
3826 : }
3827 :
3828 : NoSplitStackAttr(SourceRange R, ASTContext &Ctx
3829 : , unsigned SI
3830 : )
3831 : : InheritableAttr(attr::NoSplitStack, R, SI, 0, 0)
3832 : {
3833 : }
3834 :
3835 : NoSplitStackAttr *clone(ASTContext &C) const;
3836 : void printPretty(raw_ostream &OS,
3837 : const PrintingPolicy &Policy) const;
3838 : const char *getSpelling() const;
3839 :
3840 :
3841 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; }
3842 : };
3843 :
3844 : class NoThreadSafetyAnalysisAttr : public InheritableAttr {
3845 :
3846 : public:
3847 : static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3848 : NoThreadSafetyAnalysisAttr *A = new (Ctx) NoThreadSafetyAnalysisAttr(Loc, Ctx, 0);
3849 : A->setImplicit(true);
3850 : return A;
3851 : }
3852 :
3853 : NoThreadSafetyAnalysisAttr(SourceRange R, ASTContext &Ctx
3854 : , unsigned SI
3855 : )
3856 : : InheritableAttr(attr::NoThreadSafetyAnalysis, R, SI, 0, 0)
3857 : {
3858 : }
3859 :
3860 : NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const;
3861 : void printPretty(raw_ostream &OS,
3862 : const PrintingPolicy &Policy) const;
3863 : const char *getSpelling() const;
3864 :
3865 :
3866 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; }
3867 : };
3868 :
3869 : class NoThrowAttr : public InheritableAttr {
3870 :
3871 : public:
3872 : static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3873 : NoThrowAttr *A = new (Ctx) NoThrowAttr(Loc, Ctx, 0);
3874 : A->setImplicit(true);
3875 : return A;
3876 : }
3877 :
3878 : NoThrowAttr(SourceRange R, ASTContext &Ctx
3879 : , unsigned SI
3880 : )
3881 : : InheritableAttr(attr::NoThrow, R, SI, 0, 0)
3882 : {
3883 : }
3884 :
3885 : NoThrowAttr *clone(ASTContext &C) const;
3886 : void printPretty(raw_ostream &OS,
3887 : const PrintingPolicy &Policy) const;
3888 : const char *getSpelling() const;
3889 :
3890 :
3891 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; }
3892 : };
3893 :
3894 : class NonNullAttr : public InheritableAttr {
3895 : unsigned args_Size;
3896 : unsigned *args_;
3897 :
3898 :
3899 : public:
3900 : static NonNullAttr *CreateImplicit(ASTContext &Ctx, unsigned *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
3901 : NonNullAttr *A = new (Ctx) NonNullAttr(Loc, Ctx, Args, ArgsSize, 0);
3902 : A->setImplicit(true);
3903 : return A;
3904 : }
3905 :
3906 : NonNullAttr(SourceRange R, ASTContext &Ctx
3907 : , unsigned *Args, unsigned ArgsSize
3908 : , unsigned SI
3909 : )
3910 : : InheritableAttr(attr::NonNull, R, SI, 0, 1)
3911 : , args_Size(ArgsSize), args_(new (Ctx, 16) unsigned[args_Size])
3912 : {
3913 : std::copy(Args, Args + args_Size, args_);
3914 : }
3915 :
3916 : NonNullAttr(SourceRange R, ASTContext &Ctx
3917 : , unsigned SI
3918 : )
3919 : : InheritableAttr(attr::NonNull, R, SI, 0, 1)
3920 : , args_Size(0), args_(nullptr)
3921 : {
3922 : }
3923 :
3924 : NonNullAttr *clone(ASTContext &C) const;
3925 : void printPretty(raw_ostream &OS,
3926 : const PrintingPolicy &Policy) const;
3927 : const char *getSpelling() const;
3928 : typedef unsigned* args_iterator;
3929 : args_iterator args_begin() const { return args_; }
3930 : args_iterator args_end() const { return args_ + args_Size; }
3931 : unsigned args_size() const { return args_Size; }
3932 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
3933 :
3934 :
3935 : bool isNonNull(unsigned idx) const {
3936 : if (!args_size())
3937 : return true;
3938 : for (const auto &V : args())
3939 : if (V == idx)
3940 : return true;
3941 : return false;
3942 : }
3943 :
3944 0 : static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
3945 : };
3946 :
3947 : class OMPThreadPrivateDeclAttr : public InheritableAttr {
3948 :
3949 : public:
3950 : static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3951 : OMPThreadPrivateDeclAttr *A = new (Ctx) OMPThreadPrivateDeclAttr(Loc, Ctx, 0);
3952 : A->setImplicit(true);
3953 : return A;
3954 : }
3955 :
3956 : OMPThreadPrivateDeclAttr(SourceRange R, ASTContext &Ctx
3957 : , unsigned SI
3958 : )
3959 : : InheritableAttr(attr::OMPThreadPrivateDecl, R, SI, 0, 0)
3960 : {
3961 : }
3962 :
3963 : OMPThreadPrivateDeclAttr *clone(ASTContext &C) const;
3964 : void printPretty(raw_ostream &OS,
3965 : const PrintingPolicy &Policy) const;
3966 : const char *getSpelling() const;
3967 :
3968 :
3969 0 : static bool classof(const Attr *A) { return A->getKind() == attr::OMPThreadPrivateDecl; }
3970 : };
3971 :
3972 : class ObjCBoxableAttr : public Attr {
3973 :
3974 : public:
3975 : static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3976 : ObjCBoxableAttr *A = new (Ctx) ObjCBoxableAttr(Loc, Ctx, 0);
3977 : A->setImplicit(true);
3978 : return A;
3979 : }
3980 :
3981 : ObjCBoxableAttr(SourceRange R, ASTContext &Ctx
3982 : , unsigned SI
3983 : )
3984 : : Attr(attr::ObjCBoxable, R, SI, 0, 0)
3985 : {
3986 : }
3987 :
3988 : ObjCBoxableAttr *clone(ASTContext &C) const;
3989 : void printPretty(raw_ostream &OS,
3990 : const PrintingPolicy &Policy) const;
3991 : const char *getSpelling() const;
3992 :
3993 :
3994 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBoxable; }
3995 : };
3996 :
3997 : class ObjCBridgeAttr : public InheritableAttr {
3998 : IdentifierInfo * bridgedType;
3999 :
4000 :
4001 : public:
4002 : static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
4003 : ObjCBridgeAttr *A = new (Ctx) ObjCBridgeAttr(Loc, Ctx, BridgedType, 0);
4004 : A->setImplicit(true);
4005 : return A;
4006 : }
4007 :
4008 : ObjCBridgeAttr(SourceRange R, ASTContext &Ctx
4009 : , IdentifierInfo * BridgedType
4010 : , unsigned SI
4011 : )
4012 : : InheritableAttr(attr::ObjCBridge, R, SI, 0, 0)
4013 : , bridgedType(BridgedType)
4014 : {
4015 :
4016 : }
4017 :
4018 : ObjCBridgeAttr *clone(ASTContext &C) const;
4019 : void printPretty(raw_ostream &OS,
4020 : const PrintingPolicy &Policy) const;
4021 : const char *getSpelling() const;
4022 : IdentifierInfo * getBridgedType() const {
4023 : return bridgedType;
4024 : }
4025 :
4026 :
4027 :
4028 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridge; }
4029 : };
4030 :
4031 : class ObjCBridgeMutableAttr : public InheritableAttr {
4032 : IdentifierInfo * bridgedType;
4033 :
4034 :
4035 : public:
4036 : static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Loc = SourceRange()) {
4037 : ObjCBridgeMutableAttr *A = new (Ctx) ObjCBridgeMutableAttr(Loc, Ctx, BridgedType, 0);
4038 : A->setImplicit(true);
4039 : return A;
4040 : }
4041 :
4042 : ObjCBridgeMutableAttr(SourceRange R, ASTContext &Ctx
4043 : , IdentifierInfo * BridgedType
4044 : , unsigned SI
4045 : )
4046 : : InheritableAttr(attr::ObjCBridgeMutable, R, SI, 0, 0)
4047 : , bridgedType(BridgedType)
4048 : {
4049 :
4050 : }
4051 :
4052 : ObjCBridgeMutableAttr *clone(ASTContext &C) const;
4053 : void printPretty(raw_ostream &OS,
4054 : const PrintingPolicy &Policy) const;
4055 : const char *getSpelling() const;
4056 : IdentifierInfo * getBridgedType() const {
4057 : return bridgedType;
4058 : }
4059 :
4060 :
4061 :
4062 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeMutable; }
4063 : };
4064 :
4065 : class ObjCBridgeRelatedAttr : public InheritableAttr {
4066 : IdentifierInfo * relatedClass;
4067 :
4068 : IdentifierInfo * classMethod;
4069 :
4070 : IdentifierInfo * instanceMethod;
4071 :
4072 :
4073 : public:
4074 : static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Loc = SourceRange()) {
4075 : ObjCBridgeRelatedAttr *A = new (Ctx) ObjCBridgeRelatedAttr(Loc, Ctx, RelatedClass, ClassMethod, InstanceMethod, 0);
4076 : A->setImplicit(true);
4077 : return A;
4078 : }
4079 :
4080 : ObjCBridgeRelatedAttr(SourceRange R, ASTContext &Ctx
4081 : , IdentifierInfo * RelatedClass
4082 : , IdentifierInfo * ClassMethod
4083 : , IdentifierInfo * InstanceMethod
4084 : , unsigned SI
4085 : )
4086 : : InheritableAttr(attr::ObjCBridgeRelated, R, SI, 0, 0)
4087 : , relatedClass(RelatedClass)
4088 : , classMethod(ClassMethod)
4089 : , instanceMethod(InstanceMethod)
4090 : {
4091 :
4092 :
4093 :
4094 : }
4095 :
4096 : ObjCBridgeRelatedAttr *clone(ASTContext &C) const;
4097 : void printPretty(raw_ostream &OS,
4098 : const PrintingPolicy &Policy) const;
4099 : const char *getSpelling() const;
4100 : IdentifierInfo * getRelatedClass() const {
4101 : return relatedClass;
4102 : }
4103 :
4104 : IdentifierInfo * getClassMethod() const {
4105 : return classMethod;
4106 : }
4107 :
4108 : IdentifierInfo * getInstanceMethod() const {
4109 : return instanceMethod;
4110 : }
4111 :
4112 :
4113 :
4114 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeRelated; }
4115 : };
4116 :
4117 : class ObjCDesignatedInitializerAttr : public Attr {
4118 :
4119 : public:
4120 : static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4121 : ObjCDesignatedInitializerAttr *A = new (Ctx) ObjCDesignatedInitializerAttr(Loc, Ctx, 0);
4122 : A->setImplicit(true);
4123 : return A;
4124 : }
4125 :
4126 : ObjCDesignatedInitializerAttr(SourceRange R, ASTContext &Ctx
4127 : , unsigned SI
4128 : )
4129 : : Attr(attr::ObjCDesignatedInitializer, R, SI, 0, 0)
4130 : {
4131 : }
4132 :
4133 : ObjCDesignatedInitializerAttr *clone(ASTContext &C) const;
4134 : void printPretty(raw_ostream &OS,
4135 : const PrintingPolicy &Policy) const;
4136 : const char *getSpelling() const;
4137 :
4138 :
4139 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDesignatedInitializer; }
4140 : };
4141 :
4142 : class ObjCExceptionAttr : public InheritableAttr {
4143 :
4144 : public:
4145 : static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4146 : ObjCExceptionAttr *A = new (Ctx) ObjCExceptionAttr(Loc, Ctx, 0);
4147 : A->setImplicit(true);
4148 : return A;
4149 : }
4150 :
4151 : ObjCExceptionAttr(SourceRange R, ASTContext &Ctx
4152 : , unsigned SI
4153 : )
4154 : : InheritableAttr(attr::ObjCException, R, SI, 0, 0)
4155 : {
4156 : }
4157 :
4158 : ObjCExceptionAttr *clone(ASTContext &C) const;
4159 : void printPretty(raw_ostream &OS,
4160 : const PrintingPolicy &Policy) const;
4161 : const char *getSpelling() const;
4162 :
4163 :
4164 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCException; }
4165 : };
4166 :
4167 : class ObjCExplicitProtocolImplAttr : public InheritableAttr {
4168 :
4169 : public:
4170 : static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4171 : ObjCExplicitProtocolImplAttr *A = new (Ctx) ObjCExplicitProtocolImplAttr(Loc, Ctx, 0);
4172 : A->setImplicit(true);
4173 : return A;
4174 : }
4175 :
4176 : ObjCExplicitProtocolImplAttr(SourceRange R, ASTContext &Ctx
4177 : , unsigned SI
4178 : )
4179 : : InheritableAttr(attr::ObjCExplicitProtocolImpl, R, SI, 0, 0)
4180 : {
4181 : }
4182 :
4183 : ObjCExplicitProtocolImplAttr *clone(ASTContext &C) const;
4184 : void printPretty(raw_ostream &OS,
4185 : const PrintingPolicy &Policy) const;
4186 : const char *getSpelling() const;
4187 :
4188 :
4189 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExplicitProtocolImpl; }
4190 : };
4191 :
4192 : class ObjCIndependentClassAttr : public InheritableAttr {
4193 :
4194 : public:
4195 : static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4196 : ObjCIndependentClassAttr *A = new (Ctx) ObjCIndependentClassAttr(Loc, Ctx, 0);
4197 : A->setImplicit(true);
4198 : return A;
4199 : }
4200 :
4201 : ObjCIndependentClassAttr(SourceRange R, ASTContext &Ctx
4202 : , unsigned SI
4203 : )
4204 : : InheritableAttr(attr::ObjCIndependentClass, R, SI, 0, 0)
4205 : {
4206 : }
4207 :
4208 : ObjCIndependentClassAttr *clone(ASTContext &C) const;
4209 : void printPretty(raw_ostream &OS,
4210 : const PrintingPolicy &Policy) const;
4211 : const char *getSpelling() const;
4212 :
4213 :
4214 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCIndependentClass; }
4215 : };
4216 :
4217 : class ObjCMethodFamilyAttr : public InheritableAttr {
4218 : public:
4219 : enum FamilyKind {
4220 : OMF_None,
4221 : OMF_alloc,
4222 : OMF_copy,
4223 : OMF_init,
4224 : OMF_mutableCopy,
4225 : OMF_new
4226 : };
4227 : private:
4228 : FamilyKind family;
4229 :
4230 :
4231 : public:
4232 : static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, FamilyKind Family, SourceRange Loc = SourceRange()) {
4233 : ObjCMethodFamilyAttr *A = new (Ctx) ObjCMethodFamilyAttr(Loc, Ctx, Family, 0);
4234 : A->setImplicit(true);
4235 : return A;
4236 : }
4237 :
4238 : ObjCMethodFamilyAttr(SourceRange R, ASTContext &Ctx
4239 : , FamilyKind Family
4240 : , unsigned SI
4241 : )
4242 : : InheritableAttr(attr::ObjCMethodFamily, R, SI, 0, 0)
4243 : , family(Family)
4244 : {
4245 :
4246 : }
4247 :
4248 : ObjCMethodFamilyAttr *clone(ASTContext &C) const;
4249 : void printPretty(raw_ostream &OS,
4250 : const PrintingPolicy &Policy) const;
4251 : const char *getSpelling() const;
4252 : FamilyKind getFamily() const {
4253 : return family;
4254 : }
4255 :
4256 : static bool ConvertStrToFamilyKind(StringRef Val, FamilyKind &Out) {
4257 : Optional<FamilyKind> R = llvm::StringSwitch<Optional<FamilyKind>>(Val)
4258 : .Case("none", ObjCMethodFamilyAttr::OMF_None)
4259 : .Case("alloc", ObjCMethodFamilyAttr::OMF_alloc)
4260 : .Case("copy", ObjCMethodFamilyAttr::OMF_copy)
4261 : .Case("init", ObjCMethodFamilyAttr::OMF_init)
4262 : .Case("mutableCopy", ObjCMethodFamilyAttr::OMF_mutableCopy)
4263 : .Case("new", ObjCMethodFamilyAttr::OMF_new)
4264 : .Default(Optional<FamilyKind>());
4265 : if (R) {
4266 : Out = *R;
4267 : return true;
4268 : }
4269 : return false;
4270 : }
4271 :
4272 : static const char *ConvertFamilyKindToStr(FamilyKind Val) {
4273 : switch(Val) {
4274 : case ObjCMethodFamilyAttr::OMF_None: return "none";
4275 : case ObjCMethodFamilyAttr::OMF_alloc: return "alloc";
4276 : case ObjCMethodFamilyAttr::OMF_copy: return "copy";
4277 : case ObjCMethodFamilyAttr::OMF_init: return "init";
4278 : case ObjCMethodFamilyAttr::OMF_mutableCopy: return "mutableCopy";
4279 : case ObjCMethodFamilyAttr::OMF_new: return "new";
4280 : }
4281 : llvm_unreachable("No enumerator with that value");
4282 : }
4283 :
4284 :
4285 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; }
4286 : };
4287 :
4288 : class ObjCNSObjectAttr : public InheritableAttr {
4289 :
4290 : public:
4291 : static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4292 : ObjCNSObjectAttr *A = new (Ctx) ObjCNSObjectAttr(Loc, Ctx, 0);
4293 : A->setImplicit(true);
4294 : return A;
4295 : }
4296 :
4297 : ObjCNSObjectAttr(SourceRange R, ASTContext &Ctx
4298 : , unsigned SI
4299 : )
4300 : : InheritableAttr(attr::ObjCNSObject, R, SI, 0, 0)
4301 : {
4302 : }
4303 :
4304 : ObjCNSObjectAttr *clone(ASTContext &C) const;
4305 : void printPretty(raw_ostream &OS,
4306 : const PrintingPolicy &Policy) const;
4307 : const char *getSpelling() const;
4308 :
4309 :
4310 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNSObject; }
4311 : };
4312 :
4313 : class ObjCPreciseLifetimeAttr : public InheritableAttr {
4314 :
4315 : public:
4316 : static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4317 : ObjCPreciseLifetimeAttr *A = new (Ctx) ObjCPreciseLifetimeAttr(Loc, Ctx, 0);
4318 : A->setImplicit(true);
4319 : return A;
4320 : }
4321 :
4322 : ObjCPreciseLifetimeAttr(SourceRange R, ASTContext &Ctx
4323 : , unsigned SI
4324 : )
4325 : : InheritableAttr(attr::ObjCPreciseLifetime, R, SI, 0, 0)
4326 : {
4327 : }
4328 :
4329 : ObjCPreciseLifetimeAttr *clone(ASTContext &C) const;
4330 : void printPretty(raw_ostream &OS,
4331 : const PrintingPolicy &Policy) const;
4332 : const char *getSpelling() const;
4333 :
4334 :
4335 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCPreciseLifetime; }
4336 : };
4337 :
4338 : class ObjCRequiresPropertyDefsAttr : public InheritableAttr {
4339 :
4340 : public:
4341 : static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4342 : ObjCRequiresPropertyDefsAttr *A = new (Ctx) ObjCRequiresPropertyDefsAttr(Loc, Ctx, 0);
4343 : A->setImplicit(true);
4344 : return A;
4345 : }
4346 :
4347 : ObjCRequiresPropertyDefsAttr(SourceRange R, ASTContext &Ctx
4348 : , unsigned SI
4349 : )
4350 : : InheritableAttr(attr::ObjCRequiresPropertyDefs, R, SI, 0, 0)
4351 : {
4352 : }
4353 :
4354 : ObjCRequiresPropertyDefsAttr *clone(ASTContext &C) const;
4355 : void printPretty(raw_ostream &OS,
4356 : const PrintingPolicy &Policy) const;
4357 : const char *getSpelling() const;
4358 :
4359 :
4360 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresPropertyDefs; }
4361 : };
4362 :
4363 : class ObjCRequiresSuperAttr : public InheritableAttr {
4364 :
4365 : public:
4366 : static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4367 : ObjCRequiresSuperAttr *A = new (Ctx) ObjCRequiresSuperAttr(Loc, Ctx, 0);
4368 : A->setImplicit(true);
4369 : return A;
4370 : }
4371 :
4372 : ObjCRequiresSuperAttr(SourceRange R, ASTContext &Ctx
4373 : , unsigned SI
4374 : )
4375 : : InheritableAttr(attr::ObjCRequiresSuper, R, SI, 0, 0)
4376 : {
4377 : }
4378 :
4379 : ObjCRequiresSuperAttr *clone(ASTContext &C) const;
4380 : void printPretty(raw_ostream &OS,
4381 : const PrintingPolicy &Policy) const;
4382 : const char *getSpelling() const;
4383 :
4384 :
4385 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresSuper; }
4386 : };
4387 :
4388 : class ObjCReturnsInnerPointerAttr : public InheritableAttr {
4389 :
4390 : public:
4391 : static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4392 : ObjCReturnsInnerPointerAttr *A = new (Ctx) ObjCReturnsInnerPointerAttr(Loc, Ctx, 0);
4393 : A->setImplicit(true);
4394 : return A;
4395 : }
4396 :
4397 : ObjCReturnsInnerPointerAttr(SourceRange R, ASTContext &Ctx
4398 : , unsigned SI
4399 : )
4400 : : InheritableAttr(attr::ObjCReturnsInnerPointer, R, SI, 0, 0)
4401 : {
4402 : }
4403 :
4404 : ObjCReturnsInnerPointerAttr *clone(ASTContext &C) const;
4405 : void printPretty(raw_ostream &OS,
4406 : const PrintingPolicy &Policy) const;
4407 : const char *getSpelling() const;
4408 :
4409 :
4410 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCReturnsInnerPointer; }
4411 : };
4412 :
4413 : class ObjCRootClassAttr : public InheritableAttr {
4414 :
4415 : public:
4416 : static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4417 : ObjCRootClassAttr *A = new (Ctx) ObjCRootClassAttr(Loc, Ctx, 0);
4418 : A->setImplicit(true);
4419 : return A;
4420 : }
4421 :
4422 : ObjCRootClassAttr(SourceRange R, ASTContext &Ctx
4423 : , unsigned SI
4424 : )
4425 : : InheritableAttr(attr::ObjCRootClass, R, SI, 0, 0)
4426 : {
4427 : }
4428 :
4429 : ObjCRootClassAttr *clone(ASTContext &C) const;
4430 : void printPretty(raw_ostream &OS,
4431 : const PrintingPolicy &Policy) const;
4432 : const char *getSpelling() const;
4433 :
4434 :
4435 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRootClass; }
4436 : };
4437 :
4438 : class ObjCRuntimeNameAttr : public Attr {
4439 : unsigned metadataNameLength;
4440 : char *metadataName;
4441 :
4442 :
4443 : public:
4444 : static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Loc = SourceRange()) {
4445 : ObjCRuntimeNameAttr *A = new (Ctx) ObjCRuntimeNameAttr(Loc, Ctx, MetadataName, 0);
4446 : A->setImplicit(true);
4447 : return A;
4448 : }
4449 :
4450 : ObjCRuntimeNameAttr(SourceRange R, ASTContext &Ctx
4451 : , llvm::StringRef MetadataName
4452 : , unsigned SI
4453 : )
4454 : : Attr(attr::ObjCRuntimeName, R, SI, 0, 0)
4455 : , metadataNameLength(MetadataName.size()),metadataName(new (Ctx, 1) char[metadataNameLength])
4456 : {
4457 : if (!MetadataName.empty())
4458 : std::memcpy(metadataName, MetadataName.data(), metadataNameLength);
4459 : }
4460 :
4461 : ObjCRuntimeNameAttr *clone(ASTContext &C) const;
4462 : void printPretty(raw_ostream &OS,
4463 : const PrintingPolicy &Policy) const;
4464 : const char *getSpelling() const;
4465 : llvm::StringRef getMetadataName() const {
4466 : return llvm::StringRef(metadataName, metadataNameLength);
4467 : }
4468 : unsigned getMetadataNameLength() const {
4469 : return metadataNameLength;
4470 : }
4471 : void setMetadataName(ASTContext &C, llvm::StringRef S) {
4472 : metadataNameLength = S.size();
4473 : this->metadataName = new (C, 1) char [metadataNameLength];
4474 : if (!S.empty())
4475 : std::memcpy(this->metadataName, S.data(), metadataNameLength);
4476 : }
4477 :
4478 :
4479 :
4480 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeName; }
4481 : };
4482 :
4483 : class OpenCLImageAccessAttr : public Attr {
4484 :
4485 : public:
4486 : enum Spelling {
4487 : Keyword_read_only = 0,
4488 : Keyword_write_only = 2,
4489 : Keyword_read_write = 4
4490 : };
4491 :
4492 : static OpenCLImageAccessAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4493 : OpenCLImageAccessAttr *A = new (Ctx) OpenCLImageAccessAttr(Loc, Ctx, S);
4494 : A->setImplicit(true);
4495 : return A;
4496 : }
4497 :
4498 : OpenCLImageAccessAttr(SourceRange R, ASTContext &Ctx
4499 : , unsigned SI
4500 : )
4501 : : Attr(attr::OpenCLImageAccess, R, SI, 0, 0)
4502 : {
4503 : }
4504 :
4505 : OpenCLImageAccessAttr *clone(ASTContext &C) const;
4506 : void printPretty(raw_ostream &OS,
4507 : const PrintingPolicy &Policy) const;
4508 : const char *getSpelling() const;
4509 : Spelling getSemanticSpelling() const {
4510 : switch (SpellingListIndex) {
4511 : default: llvm_unreachable("Unknown spelling list index");
4512 : case 0: return Keyword_read_only;
4513 : case 1: return Keyword_read_only;
4514 : case 2: return Keyword_write_only;
4515 : case 3: return Keyword_write_only;
4516 : case 4: return Keyword_read_write;
4517 : case 5: return Keyword_read_write;
4518 : }
4519 : }
4520 : bool isReadOnly() const { return SpellingListIndex == 0 ||
4521 : SpellingListIndex == 1; }
4522 : bool isReadWrite() const { return SpellingListIndex == 4 ||
4523 : SpellingListIndex == 5; }
4524 : bool isWriteOnly() const { return SpellingListIndex == 2 ||
4525 : SpellingListIndex == 3; }
4526 :
4527 :
4528 0 : static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLImageAccess; }
4529 : };
4530 :
4531 : class OpenCLKernelAttr : public InheritableAttr {
4532 :
4533 : public:
4534 : static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4535 : OpenCLKernelAttr *A = new (Ctx) OpenCLKernelAttr(Loc, Ctx, 0);
4536 : A->setImplicit(true);
4537 : return A;
4538 : }
4539 :
4540 : OpenCLKernelAttr(SourceRange R, ASTContext &Ctx
4541 : , unsigned SI
4542 : )
4543 : : InheritableAttr(attr::OpenCLKernel, R, SI, 0, 0)
4544 : {
4545 : }
4546 :
4547 : OpenCLKernelAttr *clone(ASTContext &C) const;
4548 : void printPretty(raw_ostream &OS,
4549 : const PrintingPolicy &Policy) const;
4550 : const char *getSpelling() const;
4551 :
4552 :
4553 0 : static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLKernel; }
4554 : };
4555 :
4556 : class OptimizeNoneAttr : public InheritableAttr {
4557 :
4558 : public:
4559 : static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4560 : OptimizeNoneAttr *A = new (Ctx) OptimizeNoneAttr(Loc, Ctx, 0);
4561 : A->setImplicit(true);
4562 : return A;
4563 : }
4564 :
4565 : OptimizeNoneAttr(SourceRange R, ASTContext &Ctx
4566 : , unsigned SI
4567 : )
4568 : : InheritableAttr(attr::OptimizeNone, R, SI, 0, 0)
4569 : {
4570 : }
4571 :
4572 : OptimizeNoneAttr *clone(ASTContext &C) const;
4573 : void printPretty(raw_ostream &OS,
4574 : const PrintingPolicy &Policy) const;
4575 : const char *getSpelling() const;
4576 :
4577 :
4578 0 : static bool classof(const Attr *A) { return A->getKind() == attr::OptimizeNone; }
4579 : };
4580 :
4581 : class OverloadableAttr : public Attr {
4582 :
4583 : public:
4584 : static OverloadableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4585 : OverloadableAttr *A = new (Ctx) OverloadableAttr(Loc, Ctx, 0);
4586 : A->setImplicit(true);
4587 : return A;
4588 : }
4589 :
4590 : OverloadableAttr(SourceRange R, ASTContext &Ctx
4591 : , unsigned SI
4592 : )
4593 : : Attr(attr::Overloadable, R, SI, 0, 0)
4594 : {
4595 : }
4596 :
4597 : OverloadableAttr *clone(ASTContext &C) const;
4598 : void printPretty(raw_ostream &OS,
4599 : const PrintingPolicy &Policy) const;
4600 : const char *getSpelling() const;
4601 :
4602 :
4603 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Overloadable; }
4604 : };
4605 :
4606 : class OverrideAttr : public InheritableAttr {
4607 :
4608 : public:
4609 : static OverrideAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4610 : OverrideAttr *A = new (Ctx) OverrideAttr(Loc, Ctx, 0);
4611 : A->setImplicit(true);
4612 : return A;
4613 : }
4614 :
4615 : OverrideAttr(SourceRange R, ASTContext &Ctx
4616 : , unsigned SI
4617 : )
4618 : : InheritableAttr(attr::Override, R, SI, 0, 0)
4619 : {
4620 : }
4621 :
4622 : OverrideAttr *clone(ASTContext &C) const;
4623 : void printPretty(raw_ostream &OS,
4624 : const PrintingPolicy &Policy) const;
4625 : const char *getSpelling() const;
4626 :
4627 :
4628 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Override; }
4629 : };
4630 :
4631 : class OwnershipAttr : public InheritableAttr {
4632 : IdentifierInfo * module;
4633 :
4634 : unsigned args_Size;
4635 : unsigned *args_;
4636 :
4637 :
4638 : public:
4639 : enum Spelling {
4640 : GNU_ownership_holds = 0,
4641 : GNU_ownership_returns = 1,
4642 : GNU_ownership_takes = 2
4643 : };
4644 :
4645 : static OwnershipAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * Module, unsigned *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
4646 : OwnershipAttr *A = new (Ctx) OwnershipAttr(Loc, Ctx, Module, Args, ArgsSize, S);
4647 : A->setImplicit(true);
4648 : return A;
4649 : }
4650 :
4651 : OwnershipAttr(SourceRange R, ASTContext &Ctx
4652 : , IdentifierInfo * Module
4653 : , unsigned *Args, unsigned ArgsSize
4654 : , unsigned SI
4655 : )
4656 : : InheritableAttr(attr::Ownership, R, SI, 0, 0)
4657 : , module(Module)
4658 : , args_Size(ArgsSize), args_(new (Ctx, 16) unsigned[args_Size])
4659 : {
4660 :
4661 : std::copy(Args, Args + args_Size, args_);
4662 : }
4663 :
4664 : OwnershipAttr(SourceRange R, ASTContext &Ctx
4665 : , IdentifierInfo * Module
4666 : , unsigned SI
4667 : )
4668 : : InheritableAttr(attr::Ownership, R, SI, 0, 0)
4669 : , module()
4670 : , args_Size(0), args_(nullptr)
4671 : {
4672 :
4673 : }
4674 :
4675 : OwnershipAttr *clone(ASTContext &C) const;
4676 : void printPretty(raw_ostream &OS,
4677 : const PrintingPolicy &Policy) const;
4678 : const char *getSpelling() const;
4679 : Spelling getSemanticSpelling() const {
4680 : switch (SpellingListIndex) {
4681 : default: llvm_unreachable("Unknown spelling list index");
4682 : case 0: return GNU_ownership_holds;
4683 : case 1: return GNU_ownership_returns;
4684 : case 2: return GNU_ownership_takes;
4685 : }
4686 : }
4687 : bool isHolds() const { return SpellingListIndex == 0; }
4688 : bool isReturns() const { return SpellingListIndex == 1; }
4689 : bool isTakes() const { return SpellingListIndex == 2; }
4690 : IdentifierInfo * getModule() const {
4691 : return module;
4692 : }
4693 :
4694 : typedef unsigned* args_iterator;
4695 : args_iterator args_begin() const { return args_; }
4696 : args_iterator args_end() const { return args_ + args_Size; }
4697 : unsigned args_size() const { return args_Size; }
4698 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
4699 :
4700 :
4701 :
4702 : enum OwnershipKind { Holds, Returns, Takes };
4703 : OwnershipKind getOwnKind() const {
4704 : return isHolds() ? Holds :
4705 : isTakes() ? Takes :
4706 : Returns;
4707 : }
4708 :
4709 :
4710 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Ownership; }
4711 : };
4712 :
4713 : class PackedAttr : public InheritableAttr {
4714 :
4715 : public:
4716 : static PackedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4717 : PackedAttr *A = new (Ctx) PackedAttr(Loc, Ctx, 0);
4718 : A->setImplicit(true);
4719 : return A;
4720 : }
4721 :
4722 : PackedAttr(SourceRange R, ASTContext &Ctx
4723 : , unsigned SI
4724 : )
4725 : : InheritableAttr(attr::Packed, R, SI, 0, 0)
4726 : {
4727 : }
4728 :
4729 : PackedAttr *clone(ASTContext &C) const;
4730 : void printPretty(raw_ostream &OS,
4731 : const PrintingPolicy &Policy) const;
4732 : const char *getSpelling() const;
4733 :
4734 :
4735 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Packed; }
4736 : };
4737 :
4738 : class ParamTypestateAttr : public InheritableAttr {
4739 : public:
4740 : enum ConsumedState {
4741 : Unknown,
4742 : Consumed,
4743 : Unconsumed
4744 : };
4745 : private:
4746 : ConsumedState paramState;
4747 :
4748 :
4749 : public:
4750 : static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState ParamState, SourceRange Loc = SourceRange()) {
4751 : ParamTypestateAttr *A = new (Ctx) ParamTypestateAttr(Loc, Ctx, ParamState, 0);
4752 : A->setImplicit(true);
4753 : return A;
4754 : }
4755 :
4756 : ParamTypestateAttr(SourceRange R, ASTContext &Ctx
4757 : , ConsumedState ParamState
4758 : , unsigned SI
4759 : )
4760 : : InheritableAttr(attr::ParamTypestate, R, SI, 0, 0)
4761 : , paramState(ParamState)
4762 : {
4763 :
4764 : }
4765 :
4766 : ParamTypestateAttr *clone(ASTContext &C) const;
4767 : void printPretty(raw_ostream &OS,
4768 : const PrintingPolicy &Policy) const;
4769 : const char *getSpelling() const;
4770 : ConsumedState getParamState() const {
4771 : return paramState;
4772 : }
4773 :
4774 : static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
4775 : Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
4776 : .Case("unknown", ParamTypestateAttr::Unknown)
4777 : .Case("consumed", ParamTypestateAttr::Consumed)
4778 : .Case("unconsumed", ParamTypestateAttr::Unconsumed)
4779 : .Default(Optional<ConsumedState>());
4780 : if (R) {
4781 : Out = *R;
4782 : return true;
4783 : }
4784 : return false;
4785 : }
4786 :
4787 : static const char *ConvertConsumedStateToStr(ConsumedState Val) {
4788 : switch(Val) {
4789 : case ParamTypestateAttr::Unknown: return "unknown";
4790 : case ParamTypestateAttr::Consumed: return "consumed";
4791 : case ParamTypestateAttr::Unconsumed: return "unconsumed";
4792 : }
4793 : llvm_unreachable("No enumerator with that value");
4794 : }
4795 :
4796 :
4797 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; }
4798 : };
4799 :
4800 : class PascalAttr : public InheritableAttr {
4801 :
4802 : public:
4803 : static PascalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4804 : PascalAttr *A = new (Ctx) PascalAttr(Loc, Ctx, 0);
4805 : A->setImplicit(true);
4806 : return A;
4807 : }
4808 :
4809 : PascalAttr(SourceRange R, ASTContext &Ctx
4810 : , unsigned SI
4811 : )
4812 : : InheritableAttr(attr::Pascal, R, SI, 0, 0)
4813 : {
4814 : }
4815 :
4816 : PascalAttr *clone(ASTContext &C) const;
4817 : void printPretty(raw_ostream &OS,
4818 : const PrintingPolicy &Policy) const;
4819 : const char *getSpelling() const;
4820 :
4821 :
4822 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Pascal; }
4823 : };
4824 :
4825 : class PcsAttr : public InheritableAttr {
4826 : public:
4827 : enum PCSType {
4828 : AAPCS,
4829 : AAPCS_VFP
4830 : };
4831 : private:
4832 : PCSType pCS;
4833 :
4834 :
4835 : public:
4836 : static PcsAttr *CreateImplicit(ASTContext &Ctx, PCSType PCS, SourceRange Loc = SourceRange()) {
4837 : PcsAttr *A = new (Ctx) PcsAttr(Loc, Ctx, PCS, 0);
4838 : A->setImplicit(true);
4839 : return A;
4840 : }
4841 :
4842 : PcsAttr(SourceRange R, ASTContext &Ctx
4843 : , PCSType PCS
4844 : , unsigned SI
4845 : )
4846 : : InheritableAttr(attr::Pcs, R, SI, 0, 0)
4847 : , pCS(PCS)
4848 : {
4849 :
4850 : }
4851 :
4852 : PcsAttr *clone(ASTContext &C) const;
4853 : void printPretty(raw_ostream &OS,
4854 : const PrintingPolicy &Policy) const;
4855 : const char *getSpelling() const;
4856 : PCSType getPCS() const {
4857 : return pCS;
4858 : }
4859 :
4860 : static bool ConvertStrToPCSType(StringRef Val, PCSType &Out) {
4861 : Optional<PCSType> R = llvm::StringSwitch<Optional<PCSType>>(Val)
4862 : .Case("aapcs", PcsAttr::AAPCS)
4863 : .Case("aapcs-vfp", PcsAttr::AAPCS_VFP)
4864 : .Default(Optional<PCSType>());
4865 : if (R) {
4866 : Out = *R;
4867 : return true;
4868 : }
4869 : return false;
4870 : }
4871 :
4872 : static const char *ConvertPCSTypeToStr(PCSType Val) {
4873 : switch(Val) {
4874 : case PcsAttr::AAPCS: return "aapcs";
4875 : case PcsAttr::AAPCS_VFP: return "aapcs-vfp";
4876 : }
4877 : llvm_unreachable("No enumerator with that value");
4878 : }
4879 :
4880 :
4881 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; }
4882 : };
4883 :
4884 : class PtGuardedByAttr : public InheritableAttr {
4885 : Expr * arg;
4886 :
4887 :
4888 : public:
4889 : static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
4890 : PtGuardedByAttr *A = new (Ctx) PtGuardedByAttr(Loc, Ctx, Arg, 0);
4891 : A->setImplicit(true);
4892 : return A;
4893 : }
4894 :
4895 : PtGuardedByAttr(SourceRange R, ASTContext &Ctx
4896 : , Expr * Arg
4897 : , unsigned SI
4898 : )
4899 : : InheritableAttr(attr::PtGuardedBy, R, SI, 1, 1)
4900 : , arg(Arg)
4901 : {
4902 :
4903 : }
4904 :
4905 : PtGuardedByAttr *clone(ASTContext &C) const;
4906 : void printPretty(raw_ostream &OS,
4907 : const PrintingPolicy &Policy) const;
4908 : const char *getSpelling() const;
4909 : Expr * getArg() const {
4910 0 : return arg;
4911 : }
4912 :
4913 :
4914 :
4915 0 : static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedBy; }
4916 : };
4917 :
4918 : class PtGuardedVarAttr : public InheritableAttr {
4919 :
4920 : public:
4921 : static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4922 : PtGuardedVarAttr *A = new (Ctx) PtGuardedVarAttr(Loc, Ctx, 0);
4923 : A->setImplicit(true);
4924 : return A;
4925 : }
4926 :
4927 : PtGuardedVarAttr(SourceRange R, ASTContext &Ctx
4928 : , unsigned SI
4929 : )
4930 : : InheritableAttr(attr::PtGuardedVar, R, SI, 0, 0)
4931 : {
4932 : }
4933 :
4934 : PtGuardedVarAttr *clone(ASTContext &C) const;
4935 : void printPretty(raw_ostream &OS,
4936 : const PrintingPolicy &Policy) const;
4937 : const char *getSpelling() const;
4938 :
4939 :
4940 0 : static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedVar; }
4941 : };
4942 :
4943 : class PureAttr : public InheritableAttr {
4944 :
4945 : public:
4946 : static PureAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4947 : PureAttr *A = new (Ctx) PureAttr(Loc, Ctx, 0);
4948 : A->setImplicit(true);
4949 : return A;
4950 : }
4951 :
4952 : PureAttr(SourceRange R, ASTContext &Ctx
4953 : , unsigned SI
4954 : )
4955 : : InheritableAttr(attr::Pure, R, SI, 0, 0)
4956 : {
4957 : }
4958 :
4959 : PureAttr *clone(ASTContext &C) const;
4960 : void printPretty(raw_ostream &OS,
4961 : const PrintingPolicy &Policy) const;
4962 : const char *getSpelling() const;
4963 :
4964 :
4965 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Pure; }
4966 : };
4967 :
4968 : class ReleaseCapabilityAttr : public InheritableAttr {
4969 : unsigned args_Size;
4970 : Expr * *args_;
4971 :
4972 :
4973 : public:
4974 : enum Spelling {
4975 : GNU_release_capability = 0,
4976 : CXX11_clang_release_capability = 1,
4977 : GNU_release_shared_capability = 2,
4978 : CXX11_clang_release_shared_capability = 3,
4979 : GNU_release_generic_capability = 4,
4980 : CXX11_clang_release_generic_capability = 5,
4981 : GNU_unlock_function = 6
4982 : };
4983 :
4984 : static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
4985 : ReleaseCapabilityAttr *A = new (Ctx) ReleaseCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
4986 : A->setImplicit(true);
4987 : return A;
4988 : }
4989 :
4990 : ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
4991 : , Expr * *Args, unsigned ArgsSize
4992 : , unsigned SI
4993 : )
4994 : : InheritableAttr(attr::ReleaseCapability, R, SI, 1, 1)
4995 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
4996 : {
4997 : std::copy(Args, Args + args_Size, args_);
4998 : }
4999 :
5000 : ReleaseCapabilityAttr(SourceRange R, ASTContext &Ctx
5001 : , unsigned SI
5002 : )
5003 : : InheritableAttr(attr::ReleaseCapability, R, SI, 1, 1)
5004 : , args_Size(0), args_(nullptr)
5005 : {
5006 : }
5007 :
5008 : ReleaseCapabilityAttr *clone(ASTContext &C) const;
5009 : void printPretty(raw_ostream &OS,
5010 : const PrintingPolicy &Policy) const;
5011 : const char *getSpelling() const;
5012 : Spelling getSemanticSpelling() const {
5013 : switch (SpellingListIndex) {
5014 : default: llvm_unreachable("Unknown spelling list index");
5015 : case 0: return GNU_release_capability;
5016 : case 1: return CXX11_clang_release_capability;
5017 : case 2: return GNU_release_shared_capability;
5018 : case 3: return CXX11_clang_release_shared_capability;
5019 : case 4: return GNU_release_generic_capability;
5020 : case 5: return CXX11_clang_release_generic_capability;
5021 : case 6: return GNU_unlock_function;
5022 : }
5023 : }
5024 : bool isShared() const { return SpellingListIndex == 2 ||
5025 : SpellingListIndex == 3; }
5026 : bool isGeneric() const { return SpellingListIndex == 4 ||
5027 : SpellingListIndex == 5 ||
5028 : SpellingListIndex == 6; }
5029 : typedef Expr ** args_iterator;
5030 0 : args_iterator args_begin() const { return args_; }
5031 0 : args_iterator args_end() const { return args_ + args_Size; }
5032 : unsigned args_size() const { return args_Size; }
5033 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5034 :
5035 :
5036 :
5037 :
5038 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseCapability; }
5039 : };
5040 :
5041 : class ReqdWorkGroupSizeAttr : public InheritableAttr {
5042 : unsigned xDim;
5043 :
5044 : unsigned yDim;
5045 :
5046 : unsigned zDim;
5047 :
5048 :
5049 : public:
5050 : static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
5051 : ReqdWorkGroupSizeAttr *A = new (Ctx) ReqdWorkGroupSizeAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
5052 : A->setImplicit(true);
5053 : return A;
5054 : }
5055 :
5056 : ReqdWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
5057 : , unsigned XDim
5058 : , unsigned YDim
5059 : , unsigned ZDim
5060 : , unsigned SI
5061 : )
5062 : : InheritableAttr(attr::ReqdWorkGroupSize, R, SI, 0, 0)
5063 : , xDim(XDim)
5064 : , yDim(YDim)
5065 : , zDim(ZDim)
5066 : {
5067 :
5068 :
5069 :
5070 : }
5071 :
5072 : ReqdWorkGroupSizeAttr *clone(ASTContext &C) const;
5073 : void printPretty(raw_ostream &OS,
5074 : const PrintingPolicy &Policy) const;
5075 : const char *getSpelling() const;
5076 : unsigned getXDim() const {
5077 : return xDim;
5078 : }
5079 :
5080 : unsigned getYDim() const {
5081 : return yDim;
5082 : }
5083 :
5084 : unsigned getZDim() const {
5085 : return zDim;
5086 : }
5087 :
5088 :
5089 :
5090 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ReqdWorkGroupSize; }
5091 : };
5092 :
5093 : class RequiresCapabilityAttr : public InheritableAttr {
5094 : unsigned args_Size;
5095 : Expr * *args_;
5096 :
5097 :
5098 : public:
5099 : enum Spelling {
5100 : GNU_requires_capability = 0,
5101 : CXX11_clang_requires_capability = 1,
5102 : GNU_exclusive_locks_required = 2,
5103 : GNU_requires_shared_capability = 3,
5104 : CXX11_clang_requires_shared_capability = 4,
5105 : GNU_shared_locks_required = 5
5106 : };
5107 :
5108 : static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
5109 : RequiresCapabilityAttr *A = new (Ctx) RequiresCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
5110 : A->setImplicit(true);
5111 : return A;
5112 : }
5113 :
5114 : RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
5115 : , Expr * *Args, unsigned ArgsSize
5116 : , unsigned SI
5117 : )
5118 : : InheritableAttr(attr::RequiresCapability, R, SI, 1, 1)
5119 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
5120 : {
5121 : std::copy(Args, Args + args_Size, args_);
5122 : }
5123 :
5124 : RequiresCapabilityAttr(SourceRange R, ASTContext &Ctx
5125 : , unsigned SI
5126 : )
5127 : : InheritableAttr(attr::RequiresCapability, R, SI, 1, 1)
5128 : , args_Size(0), args_(nullptr)
5129 : {
5130 : }
5131 :
5132 : RequiresCapabilityAttr *clone(ASTContext &C) const;
5133 : void printPretty(raw_ostream &OS,
5134 : const PrintingPolicy &Policy) const;
5135 : const char *getSpelling() const;
5136 : Spelling getSemanticSpelling() const {
5137 : switch (SpellingListIndex) {
5138 : default: llvm_unreachable("Unknown spelling list index");
5139 : case 0: return GNU_requires_capability;
5140 : case 1: return CXX11_clang_requires_capability;
5141 : case 2: return GNU_exclusive_locks_required;
5142 : case 3: return GNU_requires_shared_capability;
5143 : case 4: return CXX11_clang_requires_shared_capability;
5144 : case 5: return GNU_shared_locks_required;
5145 : }
5146 : }
5147 : bool isShared() const { return SpellingListIndex == 3 ||
5148 : SpellingListIndex == 5 ||
5149 : SpellingListIndex == 4; }
5150 : typedef Expr ** args_iterator;
5151 0 : args_iterator args_begin() const { return args_; }
5152 0 : args_iterator args_end() const { return args_ + args_Size; }
5153 : unsigned args_size() const { return args_Size; }
5154 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5155 :
5156 :
5157 :
5158 :
5159 0 : static bool classof(const Attr *A) { return A->getKind() == attr::RequiresCapability; }
5160 : };
5161 :
5162 : class RestrictAttr : public InheritableAttr {
5163 :
5164 : public:
5165 : enum Spelling {
5166 : Declspec_restrict = 0,
5167 : GNU_malloc = 1,
5168 : CXX11_gnu_malloc = 2
5169 : };
5170 :
5171 : static RestrictAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
5172 : RestrictAttr *A = new (Ctx) RestrictAttr(Loc, Ctx, S);
5173 : A->setImplicit(true);
5174 : return A;
5175 : }
5176 :
5177 : RestrictAttr(SourceRange R, ASTContext &Ctx
5178 : , unsigned SI
5179 : )
5180 : : InheritableAttr(attr::Restrict, R, SI, 0, 0)
5181 : {
5182 : }
5183 :
5184 : RestrictAttr *clone(ASTContext &C) const;
5185 : void printPretty(raw_ostream &OS,
5186 : const PrintingPolicy &Policy) const;
5187 : const char *getSpelling() const;
5188 : Spelling getSemanticSpelling() const {
5189 : switch (SpellingListIndex) {
5190 : default: llvm_unreachable("Unknown spelling list index");
5191 : case 0: return Declspec_restrict;
5192 : case 1: return GNU_malloc;
5193 : case 2: return CXX11_gnu_malloc;
5194 : }
5195 : }
5196 :
5197 :
5198 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Restrict; }
5199 : };
5200 :
5201 : class ReturnTypestateAttr : public InheritableAttr {
5202 : public:
5203 : enum ConsumedState {
5204 : Unknown,
5205 : Consumed,
5206 : Unconsumed
5207 : };
5208 : private:
5209 : ConsumedState state;
5210 :
5211 :
5212 : public:
5213 : static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState State, SourceRange Loc = SourceRange()) {
5214 : ReturnTypestateAttr *A = new (Ctx) ReturnTypestateAttr(Loc, Ctx, State, 0);
5215 : A->setImplicit(true);
5216 : return A;
5217 : }
5218 :
5219 : ReturnTypestateAttr(SourceRange R, ASTContext &Ctx
5220 : , ConsumedState State
5221 : , unsigned SI
5222 : )
5223 : : InheritableAttr(attr::ReturnTypestate, R, SI, 0, 0)
5224 : , state(State)
5225 : {
5226 :
5227 : }
5228 :
5229 : ReturnTypestateAttr *clone(ASTContext &C) const;
5230 : void printPretty(raw_ostream &OS,
5231 : const PrintingPolicy &Policy) const;
5232 : const char *getSpelling() const;
5233 : ConsumedState getState() const {
5234 : return state;
5235 : }
5236 :
5237 : static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
5238 : Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
5239 : .Case("unknown", ReturnTypestateAttr::Unknown)
5240 : .Case("consumed", ReturnTypestateAttr::Consumed)
5241 : .Case("unconsumed", ReturnTypestateAttr::Unconsumed)
5242 : .Default(Optional<ConsumedState>());
5243 : if (R) {
5244 : Out = *R;
5245 : return true;
5246 : }
5247 : return false;
5248 : }
5249 :
5250 : static const char *ConvertConsumedStateToStr(ConsumedState Val) {
5251 : switch(Val) {
5252 : case ReturnTypestateAttr::Unknown: return "unknown";
5253 : case ReturnTypestateAttr::Consumed: return "consumed";
5254 : case ReturnTypestateAttr::Unconsumed: return "unconsumed";
5255 : }
5256 : llvm_unreachable("No enumerator with that value");
5257 : }
5258 :
5259 :
5260 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; }
5261 : };
5262 :
5263 : class ReturnsNonNullAttr : public InheritableAttr {
5264 :
5265 : public:
5266 : static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5267 : ReturnsNonNullAttr *A = new (Ctx) ReturnsNonNullAttr(Loc, Ctx, 0);
5268 : A->setImplicit(true);
5269 : return A;
5270 : }
5271 :
5272 : ReturnsNonNullAttr(SourceRange R, ASTContext &Ctx
5273 : , unsigned SI
5274 : )
5275 : : InheritableAttr(attr::ReturnsNonNull, R, SI, 0, 0)
5276 : {
5277 : }
5278 :
5279 : ReturnsNonNullAttr *clone(ASTContext &C) const;
5280 : void printPretty(raw_ostream &OS,
5281 : const PrintingPolicy &Policy) const;
5282 : const char *getSpelling() const;
5283 :
5284 :
5285 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsNonNull; }
5286 : };
5287 :
5288 : class ReturnsTwiceAttr : public InheritableAttr {
5289 :
5290 : public:
5291 : static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5292 : ReturnsTwiceAttr *A = new (Ctx) ReturnsTwiceAttr(Loc, Ctx, 0);
5293 : A->setImplicit(true);
5294 : return A;
5295 : }
5296 :
5297 : ReturnsTwiceAttr(SourceRange R, ASTContext &Ctx
5298 : , unsigned SI
5299 : )
5300 : : InheritableAttr(attr::ReturnsTwice, R, SI, 0, 0)
5301 : {
5302 : }
5303 :
5304 : ReturnsTwiceAttr *clone(ASTContext &C) const;
5305 : void printPretty(raw_ostream &OS,
5306 : const PrintingPolicy &Policy) const;
5307 : const char *getSpelling() const;
5308 :
5309 :
5310 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsTwice; }
5311 : };
5312 :
5313 : class ScopedLockableAttr : public InheritableAttr {
5314 :
5315 : public:
5316 : static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5317 : ScopedLockableAttr *A = new (Ctx) ScopedLockableAttr(Loc, Ctx, 0);
5318 : A->setImplicit(true);
5319 : return A;
5320 : }
5321 :
5322 : ScopedLockableAttr(SourceRange R, ASTContext &Ctx
5323 : , unsigned SI
5324 : )
5325 : : InheritableAttr(attr::ScopedLockable, R, SI, 0, 0)
5326 : {
5327 : }
5328 :
5329 : ScopedLockableAttr *clone(ASTContext &C) const;
5330 : void printPretty(raw_ostream &OS,
5331 : const PrintingPolicy &Policy) const;
5332 : const char *getSpelling() const;
5333 :
5334 :
5335 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ScopedLockable; }
5336 : };
5337 :
5338 : class SectionAttr : public InheritableAttr {
5339 : unsigned nameLength;
5340 : char *name;
5341 :
5342 :
5343 : public:
5344 : enum Spelling {
5345 : GNU_section = 0,
5346 : CXX11_gnu_section = 1,
5347 : Declspec_allocate = 2
5348 : };
5349 :
5350 : static SectionAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
5351 : SectionAttr *A = new (Ctx) SectionAttr(Loc, Ctx, Name, S);
5352 : A->setImplicit(true);
5353 : return A;
5354 : }
5355 :
5356 : SectionAttr(SourceRange R, ASTContext &Ctx
5357 : , llvm::StringRef Name
5358 : , unsigned SI
5359 : )
5360 : : InheritableAttr(attr::Section, R, SI, 0, 0)
5361 : , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
5362 : {
5363 : if (!Name.empty())
5364 : std::memcpy(name, Name.data(), nameLength);
5365 : }
5366 :
5367 : SectionAttr *clone(ASTContext &C) const;
5368 : void printPretty(raw_ostream &OS,
5369 : const PrintingPolicy &Policy) const;
5370 : const char *getSpelling() const;
5371 : Spelling getSemanticSpelling() const {
5372 : switch (SpellingListIndex) {
5373 : default: llvm_unreachable("Unknown spelling list index");
5374 : case 0: return GNU_section;
5375 : case 1: return CXX11_gnu_section;
5376 : case 2: return Declspec_allocate;
5377 : }
5378 : }
5379 : llvm::StringRef getName() const {
5380 : return llvm::StringRef(name, nameLength);
5381 : }
5382 : unsigned getNameLength() const {
5383 : return nameLength;
5384 : }
5385 : void setName(ASTContext &C, llvm::StringRef S) {
5386 : nameLength = S.size();
5387 : this->name = new (C, 1) char [nameLength];
5388 : if (!S.empty())
5389 : std::memcpy(this->name, S.data(), nameLength);
5390 : }
5391 :
5392 :
5393 :
5394 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Section; }
5395 : };
5396 :
5397 : class SelectAnyAttr : public InheritableAttr {
5398 :
5399 : public:
5400 : static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5401 : SelectAnyAttr *A = new (Ctx) SelectAnyAttr(Loc, Ctx, 0);
5402 : A->setImplicit(true);
5403 : return A;
5404 : }
5405 :
5406 : SelectAnyAttr(SourceRange R, ASTContext &Ctx
5407 : , unsigned SI
5408 : )
5409 : : InheritableAttr(attr::SelectAny, R, SI, 0, 0)
5410 : {
5411 : }
5412 :
5413 : SelectAnyAttr *clone(ASTContext &C) const;
5414 : void printPretty(raw_ostream &OS,
5415 : const PrintingPolicy &Policy) const;
5416 : const char *getSpelling() const;
5417 :
5418 :
5419 0 : static bool classof(const Attr *A) { return A->getKind() == attr::SelectAny; }
5420 : };
5421 :
5422 : class SentinelAttr : public InheritableAttr {
5423 : int sentinel;
5424 :
5425 : int nullPos;
5426 :
5427 :
5428 : public:
5429 : static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Loc = SourceRange()) {
5430 : SentinelAttr *A = new (Ctx) SentinelAttr(Loc, Ctx, Sentinel, NullPos, 0);
5431 : A->setImplicit(true);
5432 : return A;
5433 : }
5434 :
5435 : SentinelAttr(SourceRange R, ASTContext &Ctx
5436 : , int Sentinel
5437 : , int NullPos
5438 : , unsigned SI
5439 : )
5440 : : InheritableAttr(attr::Sentinel, R, SI, 0, 0)
5441 : , sentinel(Sentinel)
5442 : , nullPos(NullPos)
5443 : {
5444 :
5445 :
5446 : }
5447 :
5448 : SentinelAttr(SourceRange R, ASTContext &Ctx
5449 : , unsigned SI
5450 : )
5451 : : InheritableAttr(attr::Sentinel, R, SI, 0, 0)
5452 : , sentinel()
5453 : , nullPos()
5454 : {
5455 : }
5456 :
5457 : SentinelAttr *clone(ASTContext &C) const;
5458 : void printPretty(raw_ostream &OS,
5459 : const PrintingPolicy &Policy) const;
5460 : const char *getSpelling() const;
5461 : int getSentinel() const {
5462 : return sentinel;
5463 : }
5464 :
5465 : static const int DefaultSentinel = 0;
5466 :
5467 : int getNullPos() const {
5468 : return nullPos;
5469 : }
5470 :
5471 : static const int DefaultNullPos = 0;
5472 :
5473 :
5474 :
5475 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Sentinel; }
5476 : };
5477 :
5478 : class SetTypestateAttr : public InheritableAttr {
5479 : public:
5480 : enum ConsumedState {
5481 : Unknown,
5482 : Consumed,
5483 : Unconsumed
5484 : };
5485 : private:
5486 : ConsumedState newState;
5487 :
5488 :
5489 : public:
5490 : static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState NewState, SourceRange Loc = SourceRange()) {
5491 : SetTypestateAttr *A = new (Ctx) SetTypestateAttr(Loc, Ctx, NewState, 0);
5492 : A->setImplicit(true);
5493 : return A;
5494 : }
5495 :
5496 : SetTypestateAttr(SourceRange R, ASTContext &Ctx
5497 : , ConsumedState NewState
5498 : , unsigned SI
5499 : )
5500 : : InheritableAttr(attr::SetTypestate, R, SI, 0, 0)
5501 : , newState(NewState)
5502 : {
5503 :
5504 : }
5505 :
5506 : SetTypestateAttr *clone(ASTContext &C) const;
5507 : void printPretty(raw_ostream &OS,
5508 : const PrintingPolicy &Policy) const;
5509 : const char *getSpelling() const;
5510 : ConsumedState getNewState() const {
5511 : return newState;
5512 : }
5513 :
5514 : static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
5515 : Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
5516 : .Case("unknown", SetTypestateAttr::Unknown)
5517 : .Case("consumed", SetTypestateAttr::Consumed)
5518 : .Case("unconsumed", SetTypestateAttr::Unconsumed)
5519 : .Default(Optional<ConsumedState>());
5520 : if (R) {
5521 : Out = *R;
5522 : return true;
5523 : }
5524 : return false;
5525 : }
5526 :
5527 : static const char *ConvertConsumedStateToStr(ConsumedState Val) {
5528 : switch(Val) {
5529 : case SetTypestateAttr::Unknown: return "unknown";
5530 : case SetTypestateAttr::Consumed: return "consumed";
5531 : case SetTypestateAttr::Unconsumed: return "unconsumed";
5532 : }
5533 : llvm_unreachable("No enumerator with that value");
5534 : }
5535 :
5536 :
5537 0 : static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; }
5538 : };
5539 :
5540 : class SharedTrylockFunctionAttr : public InheritableAttr {
5541 : Expr * successValue;
5542 :
5543 : unsigned args_Size;
5544 : Expr * *args_;
5545 :
5546 :
5547 : public:
5548 : static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
5549 : SharedTrylockFunctionAttr *A = new (Ctx) SharedTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
5550 : A->setImplicit(true);
5551 : return A;
5552 : }
5553 :
5554 : SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
5555 : , Expr * SuccessValue
5556 : , Expr * *Args, unsigned ArgsSize
5557 : , unsigned SI
5558 : )
5559 : : InheritableAttr(attr::SharedTrylockFunction, R, SI, 1, 1)
5560 : , successValue(SuccessValue)
5561 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
5562 : {
5563 :
5564 : std::copy(Args, Args + args_Size, args_);
5565 : }
5566 :
5567 : SharedTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
5568 : , Expr * SuccessValue
5569 : , unsigned SI
5570 : )
5571 : : InheritableAttr(attr::SharedTrylockFunction, R, SI, 1, 1)
5572 : , successValue()
5573 : , args_Size(0), args_(nullptr)
5574 : {
5575 :
5576 : }
5577 :
5578 : SharedTrylockFunctionAttr *clone(ASTContext &C) const;
5579 : void printPretty(raw_ostream &OS,
5580 : const PrintingPolicy &Policy) const;
5581 : const char *getSpelling() const;
5582 : Expr * getSuccessValue() const {
5583 0 : return successValue;
5584 : }
5585 :
5586 : typedef Expr ** args_iterator;
5587 0 : args_iterator args_begin() const { return args_; }
5588 0 : args_iterator args_end() const { return args_ + args_Size; }
5589 : unsigned args_size() const { return args_Size; }
5590 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5591 :
5592 :
5593 :
5594 :
5595 0 : static bool classof(const Attr *A) { return A->getKind() == attr::SharedTrylockFunction; }
5596 : };
5597 :
5598 : class StdCallAttr : public InheritableAttr {
5599 :
5600 : public:
5601 : static StdCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5602 : StdCallAttr *A = new (Ctx) StdCallAttr(Loc, Ctx, 0);
5603 : A->setImplicit(true);
5604 : return A;
5605 : }
5606 :
5607 : StdCallAttr(SourceRange R, ASTContext &Ctx
5608 : , unsigned SI
5609 : )
5610 : : InheritableAttr(attr::StdCall, R, SI, 0, 0)
5611 : {
5612 : }
5613 :
5614 : StdCallAttr *clone(ASTContext &C) const;
5615 : void printPretty(raw_ostream &OS,
5616 : const PrintingPolicy &Policy) const;
5617 : const char *getSpelling() const;
5618 :
5619 :
5620 0 : static bool classof(const Attr *A) { return A->getKind() == attr::StdCall; }
5621 : };
5622 :
5623 : class SysVABIAttr : public InheritableAttr {
5624 :
5625 : public:
5626 : static SysVABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5627 : SysVABIAttr *A = new (Ctx) SysVABIAttr(Loc, Ctx, 0);
5628 : A->setImplicit(true);
5629 : return A;
5630 : }
5631 :
5632 : SysVABIAttr(SourceRange R, ASTContext &Ctx
5633 : , unsigned SI
5634 : )
5635 : : InheritableAttr(attr::SysVABI, R, SI, 0, 0)
5636 : {
5637 : }
5638 :
5639 : SysVABIAttr *clone(ASTContext &C) const;
5640 : void printPretty(raw_ostream &OS,
5641 : const PrintingPolicy &Policy) const;
5642 : const char *getSpelling() const;
5643 :
5644 :
5645 0 : static bool classof(const Attr *A) { return A->getKind() == attr::SysVABI; }
5646 : };
5647 :
5648 : class TLSModelAttr : public InheritableAttr {
5649 : unsigned modelLength;
5650 : char *model;
5651 :
5652 :
5653 : public:
5654 : static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, SourceRange Loc = SourceRange()) {
5655 : TLSModelAttr *A = new (Ctx) TLSModelAttr(Loc, Ctx, Model, 0);
5656 : A->setImplicit(true);
5657 : return A;
5658 : }
5659 :
5660 : TLSModelAttr(SourceRange R, ASTContext &Ctx
5661 : , llvm::StringRef Model
5662 : , unsigned SI
5663 : )
5664 : : InheritableAttr(attr::TLSModel, R, SI, 0, 0)
5665 : , modelLength(Model.size()),model(new (Ctx, 1) char[modelLength])
5666 : {
5667 : if (!Model.empty())
5668 : std::memcpy(model, Model.data(), modelLength);
5669 : }
5670 :
5671 : TLSModelAttr *clone(ASTContext &C) const;
5672 : void printPretty(raw_ostream &OS,
5673 : const PrintingPolicy &Policy) const;
5674 : const char *getSpelling() const;
5675 : llvm::StringRef getModel() const {
5676 : return llvm::StringRef(model, modelLength);
5677 : }
5678 : unsigned getModelLength() const {
5679 : return modelLength;
5680 : }
5681 : void setModel(ASTContext &C, llvm::StringRef S) {
5682 : modelLength = S.size();
5683 : this->model = new (C, 1) char [modelLength];
5684 : if (!S.empty())
5685 : std::memcpy(this->model, S.data(), modelLength);
5686 : }
5687 :
5688 :
5689 :
5690 0 : static bool classof(const Attr *A) { return A->getKind() == attr::TLSModel; }
5691 : };
5692 :
5693 : class TargetAttr : public InheritableAttr {
5694 : unsigned featuresLength;
5695 : char *features;
5696 :
5697 :
5698 : public:
5699 : static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Features, SourceRange Loc = SourceRange()) {
5700 : TargetAttr *A = new (Ctx) TargetAttr(Loc, Ctx, Features, 0);
5701 : A->setImplicit(true);
5702 : return A;
5703 : }
5704 :
5705 : TargetAttr(SourceRange R, ASTContext &Ctx
5706 : , llvm::StringRef Features
5707 : , unsigned SI
5708 : )
5709 : : InheritableAttr(attr::Target, R, SI, 0, 0)
5710 : , featuresLength(Features.size()),features(new (Ctx, 1) char[featuresLength])
5711 : {
5712 : if (!Features.empty())
5713 : std::memcpy(features, Features.data(), featuresLength);
5714 : }
5715 :
5716 : TargetAttr *clone(ASTContext &C) const;
5717 : void printPretty(raw_ostream &OS,
5718 : const PrintingPolicy &Policy) const;
5719 : const char *getSpelling() const;
5720 : llvm::StringRef getFeatures() const {
5721 : return llvm::StringRef(features, featuresLength);
5722 : }
5723 : unsigned getFeaturesLength() const {
5724 : return featuresLength;
5725 : }
5726 : void setFeatures(ASTContext &C, llvm::StringRef S) {
5727 : featuresLength = S.size();
5728 : this->features = new (C, 1) char [featuresLength];
5729 : if (!S.empty())
5730 : std::memcpy(this->features, S.data(), featuresLength);
5731 : }
5732 :
5733 :
5734 :
5735 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Target; }
5736 : };
5737 :
5738 : class TestTypestateAttr : public InheritableAttr {
5739 : public:
5740 : enum ConsumedState {
5741 : Consumed,
5742 : Unconsumed
5743 : };
5744 : private:
5745 : ConsumedState testState;
5746 :
5747 :
5748 : public:
5749 : static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, ConsumedState TestState, SourceRange Loc = SourceRange()) {
5750 : TestTypestateAttr *A = new (Ctx) TestTypestateAttr(Loc, Ctx, TestState, 0);
5751 : A->setImplicit(true);
5752 : return A;
5753 : }
5754 :
5755 : TestTypestateAttr(SourceRange R, ASTContext &Ctx
5756 : , ConsumedState TestState
5757 : , unsigned SI
5758 : )
5759 : : InheritableAttr(attr::TestTypestate, R, SI, 0, 0)
5760 : , testState(TestState)
5761 : {
5762 :
5763 : }
5764 :
5765 : TestTypestateAttr *clone(ASTContext &C) const;
5766 : void printPretty(raw_ostream &OS,
5767 : const PrintingPolicy &Policy) const;
5768 : const char *getSpelling() const;
5769 : ConsumedState getTestState() const {
5770 : return testState;
5771 : }
5772 :
5773 : static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
5774 : Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
5775 : .Case("consumed", TestTypestateAttr::Consumed)
5776 : .Case("unconsumed", TestTypestateAttr::Unconsumed)
5777 : .Default(Optional<ConsumedState>());
5778 : if (R) {
5779 : Out = *R;
5780 : return true;
5781 : }
5782 : return false;
5783 : }
5784 :
5785 : static const char *ConvertConsumedStateToStr(ConsumedState Val) {
5786 : switch(Val) {
5787 : case TestTypestateAttr::Consumed: return "consumed";
5788 : case TestTypestateAttr::Unconsumed: return "unconsumed";
5789 : }
5790 : llvm_unreachable("No enumerator with that value");
5791 : }
5792 :
5793 :
5794 0 : static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; }
5795 : };
5796 :
5797 : class ThisCallAttr : public InheritableAttr {
5798 :
5799 : public:
5800 : static ThisCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5801 : ThisCallAttr *A = new (Ctx) ThisCallAttr(Loc, Ctx, 0);
5802 : A->setImplicit(true);
5803 : return A;
5804 : }
5805 :
5806 : ThisCallAttr(SourceRange R, ASTContext &Ctx
5807 : , unsigned SI
5808 : )
5809 : : InheritableAttr(attr::ThisCall, R, SI, 0, 0)
5810 : {
5811 : }
5812 :
5813 : ThisCallAttr *clone(ASTContext &C) const;
5814 : void printPretty(raw_ostream &OS,
5815 : const PrintingPolicy &Policy) const;
5816 : const char *getSpelling() const;
5817 :
5818 :
5819 0 : static bool classof(const Attr *A) { return A->getKind() == attr::ThisCall; }
5820 : };
5821 :
5822 : class ThreadAttr : public Attr {
5823 :
5824 : public:
5825 : static ThreadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5826 : ThreadAttr *A = new (Ctx) ThreadAttr(Loc, Ctx, 0);
5827 : A->setImplicit(true);
5828 : return A;
5829 : }
5830 :
5831 : ThreadAttr(SourceRange R, ASTContext &Ctx
5832 : , unsigned SI
5833 : )
5834 : : Attr(attr::Thread, R, SI, 0, 0)
5835 : {
5836 : }
5837 :
5838 : ThreadAttr *clone(ASTContext &C) const;
5839 : void printPretty(raw_ostream &OS,
5840 : const PrintingPolicy &Policy) const;
5841 : const char *getSpelling() const;
5842 :
5843 :
5844 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Thread; }
5845 : };
5846 :
5847 : class TransparentUnionAttr : public InheritableAttr {
5848 :
5849 : public:
5850 : static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5851 : TransparentUnionAttr *A = new (Ctx) TransparentUnionAttr(Loc, Ctx, 0);
5852 : A->setImplicit(true);
5853 : return A;
5854 : }
5855 :
5856 : TransparentUnionAttr(SourceRange R, ASTContext &Ctx
5857 : , unsigned SI
5858 : )
5859 : : InheritableAttr(attr::TransparentUnion, R, SI, 0, 0)
5860 : {
5861 : }
5862 :
5863 : TransparentUnionAttr *clone(ASTContext &C) const;
5864 : void printPretty(raw_ostream &OS,
5865 : const PrintingPolicy &Policy) const;
5866 : const char *getSpelling() const;
5867 :
5868 :
5869 0 : static bool classof(const Attr *A) { return A->getKind() == attr::TransparentUnion; }
5870 : };
5871 :
5872 : class TryAcquireCapabilityAttr : public InheritableAttr {
5873 : Expr * successValue;
5874 :
5875 : unsigned args_Size;
5876 : Expr * *args_;
5877 :
5878 :
5879 : public:
5880 : enum Spelling {
5881 : GNU_try_acquire_capability = 0,
5882 : CXX11_clang_try_acquire_capability = 1,
5883 : GNU_try_acquire_shared_capability = 2,
5884 : CXX11_clang_try_acquire_shared_capability = 3
5885 : };
5886 :
5887 : static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
5888 : TryAcquireCapabilityAttr *A = new (Ctx) TryAcquireCapabilityAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, S);
5889 : A->setImplicit(true);
5890 : return A;
5891 : }
5892 :
5893 : TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
5894 : , Expr * SuccessValue
5895 : , Expr * *Args, unsigned ArgsSize
5896 : , unsigned SI
5897 : )
5898 : : InheritableAttr(attr::TryAcquireCapability, R, SI, 1, 1)
5899 : , successValue(SuccessValue)
5900 : , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
5901 : {
5902 :
5903 : std::copy(Args, Args + args_Size, args_);
5904 : }
5905 :
5906 : TryAcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
5907 : , Expr * SuccessValue
5908 : , unsigned SI
5909 : )
5910 : : InheritableAttr(attr::TryAcquireCapability, R, SI, 1, 1)
5911 : , successValue()
5912 : , args_Size(0), args_(nullptr)
5913 : {
5914 :
5915 : }
5916 :
5917 : TryAcquireCapabilityAttr *clone(ASTContext &C) const;
5918 : void printPretty(raw_ostream &OS,
5919 : const PrintingPolicy &Policy) const;
5920 : const char *getSpelling() const;
5921 : Spelling getSemanticSpelling() const {
5922 : switch (SpellingListIndex) {
5923 : default: llvm_unreachable("Unknown spelling list index");
5924 : case 0: return GNU_try_acquire_capability;
5925 : case 1: return CXX11_clang_try_acquire_capability;
5926 : case 2: return GNU_try_acquire_shared_capability;
5927 : case 3: return CXX11_clang_try_acquire_shared_capability;
5928 : }
5929 : }
5930 : bool isShared() const { return SpellingListIndex == 2 ||
5931 : SpellingListIndex == 3; }
5932 : Expr * getSuccessValue() const {
5933 0 : return successValue;
5934 : }
5935 :
5936 : typedef Expr ** args_iterator;
5937 0 : args_iterator args_begin() const { return args_; }
5938 0 : args_iterator args_end() const { return args_ + args_Size; }
5939 : unsigned args_size() const { return args_Size; }
5940 : llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5941 :
5942 :
5943 :
5944 :
5945 0 : static bool classof(const Attr *A) { return A->getKind() == attr::TryAcquireCapability; }
5946 : };
5947 :
5948 : class TypeTagForDatatypeAttr : public InheritableAttr {
5949 : IdentifierInfo * argumentKind;
5950 :
5951 : TypeSourceInfo * matchingCType;
5952 :
5953 : bool layoutCompatible;
5954 :
5955 : bool mustBeNull;
5956 :
5957 :
5958 : public:
5959 : static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Loc = SourceRange()) {
5960 : TypeTagForDatatypeAttr *A = new (Ctx) TypeTagForDatatypeAttr(Loc, Ctx, ArgumentKind, MatchingCType, LayoutCompatible, MustBeNull, 0);
5961 : A->setImplicit(true);
5962 : return A;
5963 : }
5964 :
5965 : TypeTagForDatatypeAttr(SourceRange R, ASTContext &Ctx
5966 : , IdentifierInfo * ArgumentKind
5967 : , TypeSourceInfo * MatchingCType
5968 : , bool LayoutCompatible
5969 : , bool MustBeNull
5970 : , unsigned SI
5971 : )
5972 : : InheritableAttr(attr::TypeTagForDatatype, R, SI, 0, 0)
5973 : , argumentKind(ArgumentKind)
5974 : , matchingCType(MatchingCType)
5975 : , layoutCompatible(LayoutCompatible)
5976 : , mustBeNull(MustBeNull)
5977 : {
5978 :
5979 :
5980 :
5981 :
5982 : }
5983 :
5984 : TypeTagForDatatypeAttr *clone(ASTContext &C) const;
5985 : void printPretty(raw_ostream &OS,
5986 : const PrintingPolicy &Policy) const;
5987 : const char *getSpelling() const;
5988 : IdentifierInfo * getArgumentKind() const {
5989 : return argumentKind;
5990 : }
5991 :
5992 : QualType getMatchingCType() const {
5993 : return matchingCType->getType();
5994 : } TypeSourceInfo * getMatchingCTypeLoc() const {
5995 : return matchingCType;
5996 : }
5997 :
5998 : bool getLayoutCompatible() const {
5999 : return layoutCompatible;
6000 : }
6001 :
6002 : bool getMustBeNull() const {
6003 : return mustBeNull;
6004 : }
6005 :
6006 :
6007 :
6008 0 : static bool classof(const Attr *A) { return A->getKind() == attr::TypeTagForDatatype; }
6009 : };
6010 :
6011 : class TypeVisibilityAttr : public InheritableAttr {
6012 : public:
6013 : enum VisibilityType {
6014 : Default,
6015 : Hidden,
6016 : Protected
6017 : };
6018 : private:
6019 : VisibilityType visibility;
6020 :
6021 :
6022 : public:
6023 : static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
6024 : TypeVisibilityAttr *A = new (Ctx) TypeVisibilityAttr(Loc, Ctx, Visibility, 0);
6025 : A->setImplicit(true);
6026 : return A;
6027 : }
6028 :
6029 : TypeVisibilityAttr(SourceRange R, ASTContext &Ctx
6030 : , VisibilityType Visibility
6031 : , unsigned SI
6032 : )
6033 : : InheritableAttr(attr::TypeVisibility, R, SI, 0, 0)
6034 : , visibility(Visibility)
6035 : {
6036 :
6037 : }
6038 :
6039 : TypeVisibilityAttr *clone(ASTContext &C) const;
6040 : void printPretty(raw_ostream &OS,
6041 : const PrintingPolicy &Policy) const;
6042 : const char *getSpelling() const;
6043 : VisibilityType getVisibility() const {
6044 : return visibility;
6045 : }
6046 :
6047 : static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
6048 : Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
6049 : .Case("default", TypeVisibilityAttr::Default)
6050 : .Case("hidden", TypeVisibilityAttr::Hidden)
6051 : .Case("internal", TypeVisibilityAttr::Hidden)
6052 : .Case("protected", TypeVisibilityAttr::Protected)
6053 : .Default(Optional<VisibilityType>());
6054 : if (R) {
6055 : Out = *R;
6056 : return true;
6057 : }
6058 : return false;
6059 : }
6060 :
6061 : static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
6062 : switch(Val) {
6063 : case TypeVisibilityAttr::Default: return "default";
6064 : case TypeVisibilityAttr::Hidden: return "hidden";
6065 : case TypeVisibilityAttr::Protected: return "protected";
6066 : }
6067 : llvm_unreachable("No enumerator with that value");
6068 : }
6069 :
6070 :
6071 0 : static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; }
6072 : };
6073 :
6074 : class UnavailableAttr : public InheritableAttr {
6075 : unsigned messageLength;
6076 : char *message;
6077 :
6078 :
6079 : public:
6080 : static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
6081 : UnavailableAttr *A = new (Ctx) UnavailableAttr(Loc, Ctx, Message, 0);
6082 : A->setImplicit(true);
6083 : return A;
6084 : }
6085 :
6086 : UnavailableAttr(SourceRange R, ASTContext &Ctx
6087 : , llvm::StringRef Message
6088 : , unsigned SI
6089 : )
6090 : : InheritableAttr(attr::Unavailable, R, SI, 0, 0)
6091 : , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
6092 : {
6093 : if (!Message.empty())
6094 : std::memcpy(message, Message.data(), messageLength);
6095 : }
6096 :
6097 : UnavailableAttr(SourceRange R, ASTContext &Ctx
6098 : , unsigned SI
6099 : )
6100 : : InheritableAttr(attr::Unavailable, R, SI, 0, 0)
6101 : , messageLength(0),message(0)
6102 : {
6103 : }
6104 :
6105 : UnavailableAttr *clone(ASTContext &C) const;
6106 : void printPretty(raw_ostream &OS,
6107 : const PrintingPolicy &Policy) const;
6108 : const char *getSpelling() const;
6109 : llvm::StringRef getMessage() const {
6110 : return llvm::StringRef(message, messageLength);
6111 : }
6112 : unsigned getMessageLength() const {
6113 : return messageLength;
6114 : }
6115 : void setMessage(ASTContext &C, llvm::StringRef S) {
6116 : messageLength = S.size();
6117 : this->message = new (C, 1) char [messageLength];
6118 : if (!S.empty())
6119 : std::memcpy(this->message, S.data(), messageLength);
6120 : }
6121 :
6122 :
6123 :
6124 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Unavailable; }
6125 : };
6126 :
6127 : class UnusedAttr : public InheritableAttr {
6128 :
6129 : public:
6130 : static UnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6131 : UnusedAttr *A = new (Ctx) UnusedAttr(Loc, Ctx, 0);
6132 : A->setImplicit(true);
6133 : return A;
6134 : }
6135 :
6136 : UnusedAttr(SourceRange R, ASTContext &Ctx
6137 : , unsigned SI
6138 : )
6139 : : InheritableAttr(attr::Unused, R, SI, 0, 0)
6140 : {
6141 : }
6142 :
6143 : UnusedAttr *clone(ASTContext &C) const;
6144 : void printPretty(raw_ostream &OS,
6145 : const PrintingPolicy &Policy) const;
6146 : const char *getSpelling() const;
6147 :
6148 :
6149 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Unused; }
6150 : };
6151 :
6152 : class UsedAttr : public InheritableAttr {
6153 :
6154 : public:
6155 : static UsedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6156 : UsedAttr *A = new (Ctx) UsedAttr(Loc, Ctx, 0);
6157 : A->setImplicit(true);
6158 : return A;
6159 : }
6160 :
6161 : UsedAttr(SourceRange R, ASTContext &Ctx
6162 : , unsigned SI
6163 : )
6164 : : InheritableAttr(attr::Used, R, SI, 0, 0)
6165 : {
6166 : }
6167 :
6168 : UsedAttr *clone(ASTContext &C) const;
6169 : void printPretty(raw_ostream &OS,
6170 : const PrintingPolicy &Policy) const;
6171 : const char *getSpelling() const;
6172 :
6173 :
6174 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Used; }
6175 : };
6176 :
6177 : class UuidAttr : public InheritableAttr {
6178 : unsigned guidLength;
6179 : char *guid;
6180 :
6181 :
6182 : public:
6183 : static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Loc = SourceRange()) {
6184 : UuidAttr *A = new (Ctx) UuidAttr(Loc, Ctx, Guid, 0);
6185 : A->setImplicit(true);
6186 : return A;
6187 : }
6188 :
6189 : UuidAttr(SourceRange R, ASTContext &Ctx
6190 : , llvm::StringRef Guid
6191 : , unsigned SI
6192 : )
6193 : : InheritableAttr(attr::Uuid, R, SI, 0, 0)
6194 : , guidLength(Guid.size()),guid(new (Ctx, 1) char[guidLength])
6195 : {
6196 : if (!Guid.empty())
6197 : std::memcpy(guid, Guid.data(), guidLength);
6198 : }
6199 :
6200 : UuidAttr *clone(ASTContext &C) const;
6201 : void printPretty(raw_ostream &OS,
6202 : const PrintingPolicy &Policy) const;
6203 : const char *getSpelling() const;
6204 : llvm::StringRef getGuid() const {
6205 : return llvm::StringRef(guid, guidLength);
6206 : }
6207 : unsigned getGuidLength() const {
6208 : return guidLength;
6209 : }
6210 : void setGuid(ASTContext &C, llvm::StringRef S) {
6211 : guidLength = S.size();
6212 : this->guid = new (C, 1) char [guidLength];
6213 : if (!S.empty())
6214 : std::memcpy(this->guid, S.data(), guidLength);
6215 : }
6216 :
6217 :
6218 :
6219 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Uuid; }
6220 : };
6221 :
6222 : class VecReturnAttr : public InheritableAttr {
6223 :
6224 : public:
6225 : static VecReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6226 : VecReturnAttr *A = new (Ctx) VecReturnAttr(Loc, Ctx, 0);
6227 : A->setImplicit(true);
6228 : return A;
6229 : }
6230 :
6231 : VecReturnAttr(SourceRange R, ASTContext &Ctx
6232 : , unsigned SI
6233 : )
6234 : : InheritableAttr(attr::VecReturn, R, SI, 0, 0)
6235 : {
6236 : }
6237 :
6238 : VecReturnAttr *clone(ASTContext &C) const;
6239 : void printPretty(raw_ostream &OS,
6240 : const PrintingPolicy &Policy) const;
6241 : const char *getSpelling() const;
6242 :
6243 :
6244 0 : static bool classof(const Attr *A) { return A->getKind() == attr::VecReturn; }
6245 : };
6246 :
6247 : class VecTypeHintAttr : public InheritableAttr {
6248 : TypeSourceInfo * typeHint;
6249 :
6250 :
6251 : public:
6252 : static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Loc = SourceRange()) {
6253 : VecTypeHintAttr *A = new (Ctx) VecTypeHintAttr(Loc, Ctx, TypeHint, 0);
6254 : A->setImplicit(true);
6255 : return A;
6256 : }
6257 :
6258 : VecTypeHintAttr(SourceRange R, ASTContext &Ctx
6259 : , TypeSourceInfo * TypeHint
6260 : , unsigned SI
6261 : )
6262 : : InheritableAttr(attr::VecTypeHint, R, SI, 0, 0)
6263 : , typeHint(TypeHint)
6264 : {
6265 :
6266 : }
6267 :
6268 : VecTypeHintAttr *clone(ASTContext &C) const;
6269 : void printPretty(raw_ostream &OS,
6270 : const PrintingPolicy &Policy) const;
6271 : const char *getSpelling() const;
6272 : QualType getTypeHint() const {
6273 : return typeHint->getType();
6274 : } TypeSourceInfo * getTypeHintLoc() const {
6275 : return typeHint;
6276 : }
6277 :
6278 :
6279 :
6280 0 : static bool classof(const Attr *A) { return A->getKind() == attr::VecTypeHint; }
6281 : };
6282 :
6283 : class VectorCallAttr : public InheritableAttr {
6284 :
6285 : public:
6286 : static VectorCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6287 : VectorCallAttr *A = new (Ctx) VectorCallAttr(Loc, Ctx, 0);
6288 : A->setImplicit(true);
6289 : return A;
6290 : }
6291 :
6292 : VectorCallAttr(SourceRange R, ASTContext &Ctx
6293 : , unsigned SI
6294 : )
6295 : : InheritableAttr(attr::VectorCall, R, SI, 0, 0)
6296 : {
6297 : }
6298 :
6299 : VectorCallAttr *clone(ASTContext &C) const;
6300 : void printPretty(raw_ostream &OS,
6301 : const PrintingPolicy &Policy) const;
6302 : const char *getSpelling() const;
6303 :
6304 :
6305 0 : static bool classof(const Attr *A) { return A->getKind() == attr::VectorCall; }
6306 : };
6307 :
6308 : class VisibilityAttr : public InheritableAttr {
6309 : public:
6310 : enum VisibilityType {
6311 : Default,
6312 : Hidden,
6313 : Protected
6314 : };
6315 : private:
6316 : VisibilityType visibility;
6317 :
6318 :
6319 : public:
6320 : static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityType Visibility, SourceRange Loc = SourceRange()) {
6321 : VisibilityAttr *A = new (Ctx) VisibilityAttr(Loc, Ctx, Visibility, 0);
6322 : A->setImplicit(true);
6323 : return A;
6324 : }
6325 :
6326 : VisibilityAttr(SourceRange R, ASTContext &Ctx
6327 : , VisibilityType Visibility
6328 : , unsigned SI
6329 : )
6330 : : InheritableAttr(attr::Visibility, R, SI, 0, 0)
6331 : , visibility(Visibility)
6332 : {
6333 :
6334 : }
6335 :
6336 : VisibilityAttr *clone(ASTContext &C) const;
6337 : void printPretty(raw_ostream &OS,
6338 : const PrintingPolicy &Policy) const;
6339 : const char *getSpelling() const;
6340 : VisibilityType getVisibility() const {
6341 : return visibility;
6342 : }
6343 :
6344 : static bool ConvertStrToVisibilityType(StringRef Val, VisibilityType &Out) {
6345 : Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
6346 : .Case("default", VisibilityAttr::Default)
6347 : .Case("hidden", VisibilityAttr::Hidden)
6348 : .Case("internal", VisibilityAttr::Hidden)
6349 : .Case("protected", VisibilityAttr::Protected)
6350 : .Default(Optional<VisibilityType>());
6351 : if (R) {
6352 : Out = *R;
6353 : return true;
6354 : }
6355 : return false;
6356 : }
6357 :
6358 : static const char *ConvertVisibilityTypeToStr(VisibilityType Val) {
6359 : switch(Val) {
6360 : case VisibilityAttr::Default: return "default";
6361 : case VisibilityAttr::Hidden: return "hidden";
6362 : case VisibilityAttr::Protected: return "protected";
6363 : }
6364 : llvm_unreachable("No enumerator with that value");
6365 : }
6366 :
6367 :
6368 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; }
6369 : };
6370 :
6371 : class WarnUnusedAttr : public InheritableAttr {
6372 :
6373 : public:
6374 : static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6375 : WarnUnusedAttr *A = new (Ctx) WarnUnusedAttr(Loc, Ctx, 0);
6376 : A->setImplicit(true);
6377 : return A;
6378 : }
6379 :
6380 : WarnUnusedAttr(SourceRange R, ASTContext &Ctx
6381 : , unsigned SI
6382 : )
6383 : : InheritableAttr(attr::WarnUnused, R, SI, 0, 0)
6384 : {
6385 : }
6386 :
6387 : WarnUnusedAttr *clone(ASTContext &C) const;
6388 : void printPretty(raw_ostream &OS,
6389 : const PrintingPolicy &Policy) const;
6390 : const char *getSpelling() const;
6391 :
6392 :
6393 0 : static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnused; }
6394 : };
6395 :
6396 : class WarnUnusedResultAttr : public InheritableAttr {
6397 :
6398 : public:
6399 : static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6400 : WarnUnusedResultAttr *A = new (Ctx) WarnUnusedResultAttr(Loc, Ctx, 0);
6401 : A->setImplicit(true);
6402 : return A;
6403 : }
6404 :
6405 : WarnUnusedResultAttr(SourceRange R, ASTContext &Ctx
6406 : , unsigned SI
6407 : )
6408 : : InheritableAttr(attr::WarnUnusedResult, R, SI, 0, 0)
6409 : {
6410 : }
6411 :
6412 : WarnUnusedResultAttr *clone(ASTContext &C) const;
6413 : void printPretty(raw_ostream &OS,
6414 : const PrintingPolicy &Policy) const;
6415 : const char *getSpelling() const;
6416 :
6417 :
6418 0 : static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnusedResult; }
6419 : };
6420 :
6421 : class WeakAttr : public InheritableAttr {
6422 :
6423 : public:
6424 : static WeakAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6425 : WeakAttr *A = new (Ctx) WeakAttr(Loc, Ctx, 0);
6426 : A->setImplicit(true);
6427 : return A;
6428 : }
6429 :
6430 : WeakAttr(SourceRange R, ASTContext &Ctx
6431 : , unsigned SI
6432 : )
6433 : : InheritableAttr(attr::Weak, R, SI, 0, 0)
6434 : {
6435 : }
6436 :
6437 : WeakAttr *clone(ASTContext &C) const;
6438 : void printPretty(raw_ostream &OS,
6439 : const PrintingPolicy &Policy) const;
6440 : const char *getSpelling() const;
6441 :
6442 :
6443 0 : static bool classof(const Attr *A) { return A->getKind() == attr::Weak; }
6444 : };
6445 :
6446 : class WeakImportAttr : public InheritableAttr {
6447 :
6448 : public:
6449 : static WeakImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6450 : WeakImportAttr *A = new (Ctx) WeakImportAttr(Loc, Ctx, 0);
6451 : A->setImplicit(true);
6452 : return A;
6453 : }
6454 :
6455 : WeakImportAttr(SourceRange R, ASTContext &Ctx
6456 : , unsigned SI
6457 : )
6458 : : InheritableAttr(attr::WeakImport, R, SI, 0, 0)
6459 : {
6460 : }
6461 :
6462 : WeakImportAttr *clone(ASTContext &C) const;
6463 : void printPretty(raw_ostream &OS,
6464 : const PrintingPolicy &Policy) const;
6465 : const char *getSpelling() const;
6466 :
6467 :
6468 0 : static bool classof(const Attr *A) { return A->getKind() == attr::WeakImport; }
6469 : };
6470 :
6471 : class WeakRefAttr : public InheritableAttr {
6472 : unsigned aliaseeLength;
6473 : char *aliasee;
6474 :
6475 :
6476 : public:
6477 : static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
6478 : WeakRefAttr *A = new (Ctx) WeakRefAttr(Loc, Ctx, Aliasee, 0);
6479 : A->setImplicit(true);
6480 : return A;
6481 : }
6482 :
6483 : WeakRefAttr(SourceRange R, ASTContext &Ctx
6484 : , llvm::StringRef Aliasee
6485 : , unsigned SI
6486 : )
6487 : : InheritableAttr(attr::WeakRef, R, SI, 0, 0)
6488 : , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
6489 : {
6490 : if (!Aliasee.empty())
6491 : std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
6492 : }
6493 :
6494 : WeakRefAttr(SourceRange R, ASTContext &Ctx
6495 : , unsigned SI
6496 : )
6497 : : InheritableAttr(attr::WeakRef, R, SI, 0, 0)
6498 : , aliaseeLength(0),aliasee(0)
6499 : {
6500 : }
6501 :
6502 : WeakRefAttr *clone(ASTContext &C) const;
6503 : void printPretty(raw_ostream &OS,
6504 : const PrintingPolicy &Policy) const;
6505 : const char *getSpelling() const;
6506 : llvm::StringRef getAliasee() const {
6507 : return llvm::StringRef(aliasee, aliaseeLength);
6508 : }
6509 : unsigned getAliaseeLength() const {
6510 : return aliaseeLength;
6511 : }
6512 : void setAliasee(ASTContext &C, llvm::StringRef S) {
6513 : aliaseeLength = S.size();
6514 : this->aliasee = new (C, 1) char [aliaseeLength];
6515 : if (!S.empty())
6516 : std::memcpy(this->aliasee, S.data(), aliaseeLength);
6517 : }
6518 :
6519 :
6520 :
6521 0 : static bool classof(const Attr *A) { return A->getKind() == attr::WeakRef; }
6522 : };
6523 :
6524 : class WorkGroupSizeHintAttr : public InheritableAttr {
6525 : unsigned xDim;
6526 :
6527 : unsigned yDim;
6528 :
6529 : unsigned zDim;
6530 :
6531 :
6532 : public:
6533 : static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Loc = SourceRange()) {
6534 : WorkGroupSizeHintAttr *A = new (Ctx) WorkGroupSizeHintAttr(Loc, Ctx, XDim, YDim, ZDim, 0);
6535 : A->setImplicit(true);
6536 : return A;
6537 : }
6538 :
6539 : WorkGroupSizeHintAttr(SourceRange R, ASTContext &Ctx
6540 : , unsigned XDim
6541 : , unsigned YDim
6542 : , unsigned ZDim
6543 : , unsigned SI
6544 : )
6545 : : InheritableAttr(attr::WorkGroupSizeHint, R, SI, 0, 0)
6546 : , xDim(XDim)
6547 : , yDim(YDim)
6548 : , zDim(ZDim)
6549 : {
6550 :
6551 :
6552 :
6553 : }
6554 :
6555 : WorkGroupSizeHintAttr *clone(ASTContext &C) const;
6556 : void printPretty(raw_ostream &OS,
6557 : const PrintingPolicy &Policy) const;
6558 : const char *getSpelling() const;
6559 : unsigned getXDim() const {
6560 : return xDim;
6561 : }
6562 :
6563 : unsigned getYDim() const {
6564 : return yDim;
6565 : }
6566 :
6567 : unsigned getZDim() const {
6568 : return zDim;
6569 : }
6570 :
6571 :
6572 :
6573 0 : static bool classof(const Attr *A) { return A->getKind() == attr::WorkGroupSizeHint; }
6574 : };
6575 :
6576 : class X86ForceAlignArgPointerAttr : public InheritableAttr {
6577 :
6578 : public:
6579 : static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
6580 : X86ForceAlignArgPointerAttr *A = new (Ctx) X86ForceAlignArgPointerAttr(Loc, Ctx, 0);
6581 : A->setImplicit(true);
6582 : return A;
6583 : }
6584 :
6585 : X86ForceAlignArgPointerAttr(SourceRange R, ASTContext &Ctx
6586 : , unsigned SI
6587 : )
6588 : : InheritableAttr(attr::X86ForceAlignArgPointer, R, SI, 0, 0)
6589 : {
6590 : }
6591 :
6592 : X86ForceAlignArgPointerAttr *clone(ASTContext &C) const;
6593 : void printPretty(raw_ostream &OS,
6594 : const PrintingPolicy &Policy) const;
6595 : const char *getSpelling() const;
6596 :
6597 :
6598 0 : static bool classof(const Attr *A) { return A->getKind() == attr::X86ForceAlignArgPointer; }
6599 : };
6600 :
6601 : #endif
|
