1 | /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
2 | |* *| |
3 | |* Attribute classes' definitions *| |
4 | |* *| |
5 | |* Automatically generated file, do not edit! *| |
6 | |* *| |
7 | \*===----------------------------------------------------------------------===*/ |
8 | |
9 | #ifndef LLVM_CLANG_ATTR_CLASSES_INC |
10 | #define LLVM_CLANG_ATTR_CLASSES_INC |
11 | |
12 | class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr { |
13 | unsigned min; |
14 | |
15 | unsigned max; |
16 | |
17 | public: |
18 | static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) { |
19 | auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0); |
20 | A->setImplicit(true); |
21 | return A; |
22 | } |
23 | |
24 | AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx |
25 | , unsigned Min |
26 | , unsigned Max |
27 | , unsigned SI |
28 | ) |
29 | : InheritableAttr(attr::AMDGPUFlatWorkGroupSize, R, SI, false, false) |
30 | , min(Min) |
31 | , max(Max) |
32 | { |
33 | } |
34 | |
35 | AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const; |
36 | void printPretty(raw_ostream &OS, |
37 | const PrintingPolicy &Policy) const; |
38 | const char *getSpelling() const; |
39 | unsigned getMin() const { |
40 | return min; |
41 | } |
42 | |
43 | unsigned getMax() const { |
44 | return max; |
45 | } |
46 | |
47 | |
48 | |
49 | static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; } |
50 | }; |
51 | |
52 | class AMDGPUNumSGPRAttr : public InheritableAttr { |
53 | unsigned numSGPR; |
54 | |
55 | public: |
56 | static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) { |
57 | auto *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0); |
58 | A->setImplicit(true); |
59 | return A; |
60 | } |
61 | |
62 | AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx |
63 | , unsigned NumSGPR |
64 | , unsigned SI |
65 | ) |
66 | : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, false, false) |
67 | , numSGPR(NumSGPR) |
68 | { |
69 | } |
70 | |
71 | AMDGPUNumSGPRAttr *clone(ASTContext &C) const; |
72 | void printPretty(raw_ostream &OS, |
73 | const PrintingPolicy &Policy) const; |
74 | const char *getSpelling() const; |
75 | unsigned getNumSGPR() const { |
76 | return numSGPR; |
77 | } |
78 | |
79 | |
80 | |
81 | static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; } |
82 | }; |
83 | |
84 | class AMDGPUNumVGPRAttr : public InheritableAttr { |
85 | unsigned numVGPR; |
86 | |
87 | public: |
88 | static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) { |
89 | auto *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0); |
90 | A->setImplicit(true); |
91 | return A; |
92 | } |
93 | |
94 | AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx |
95 | , unsigned NumVGPR |
96 | , unsigned SI |
97 | ) |
98 | : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, false, false) |
99 | , numVGPR(NumVGPR) |
100 | { |
101 | } |
102 | |
103 | AMDGPUNumVGPRAttr *clone(ASTContext &C) const; |
104 | void printPretty(raw_ostream &OS, |
105 | const PrintingPolicy &Policy) const; |
106 | const char *getSpelling() const; |
107 | unsigned getNumVGPR() const { |
108 | return numVGPR; |
109 | } |
110 | |
111 | |
112 | |
113 | static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; } |
114 | }; |
115 | |
116 | class AMDGPUWavesPerEUAttr : public InheritableAttr { |
117 | unsigned min; |
118 | |
119 | unsigned max; |
120 | |
121 | public: |
122 | static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) { |
123 | auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0); |
124 | A->setImplicit(true); |
125 | return A; |
126 | } |
127 | |
128 | AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx |
129 | , unsigned Min |
130 | , unsigned Max |
131 | , unsigned SI |
132 | ) |
133 | : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false) |
134 | , min(Min) |
135 | , max(Max) |
136 | { |
137 | } |
138 | |
139 | AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx |
140 | , unsigned Min |
141 | , unsigned SI |
142 | ) |
143 | : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false) |
144 | , min(Min) |
145 | , max() |
146 | { |
147 | } |
148 | |
149 | AMDGPUWavesPerEUAttr *clone(ASTContext &C) const; |
150 | void printPretty(raw_ostream &OS, |
151 | const PrintingPolicy &Policy) const; |
152 | const char *getSpelling() const; |
153 | unsigned getMin() const { |
154 | return min; |
155 | } |
156 | |
157 | unsigned getMax() const { |
158 | return max; |
159 | } |
160 | |
161 | |
162 | |
163 | static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; } |
164 | }; |
165 | |
166 | class ARMInterruptAttr : public InheritableAttr { |
167 | public: |
168 | enum InterruptType { |
169 | IRQ, |
170 | FIQ, |
171 | SWI, |
172 | ABORT, |
173 | UNDEF, |
174 | Generic |
175 | }; |
176 | private: |
177 | InterruptType interrupt; |
178 | |
179 | public: |
180 | static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) { |
181 | auto *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0); |
182 | A->setImplicit(true); |
183 | return A; |
184 | } |
185 | |
186 | ARMInterruptAttr(SourceRange R, ASTContext &Ctx |
187 | , InterruptType Interrupt |
188 | , unsigned SI |
189 | ) |
190 | : InheritableAttr(attr::ARMInterrupt, R, SI, false, false) |
191 | , interrupt(Interrupt) |
192 | { |
193 | } |
194 | |
195 | ARMInterruptAttr(SourceRange R, ASTContext &Ctx |
196 | , unsigned SI |
197 | ) |
198 | : InheritableAttr(attr::ARMInterrupt, R, SI, false, false) |
199 | , interrupt(InterruptType(0)) |
200 | { |
201 | } |
202 | |
203 | ARMInterruptAttr *clone(ASTContext &C) const; |
204 | void printPretty(raw_ostream &OS, |
205 | const PrintingPolicy &Policy) const; |
206 | const char *getSpelling() const; |
207 | InterruptType getInterrupt() const { |
208 | return interrupt; |
209 | } |
210 | |
211 | static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) { |
212 | Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val) |
213 | .Case("IRQ" , ARMInterruptAttr::IRQ) |
214 | .Case("FIQ" , ARMInterruptAttr::FIQ) |
215 | .Case("SWI" , ARMInterruptAttr::SWI) |
216 | .Case("ABORT" , ARMInterruptAttr::ABORT) |
217 | .Case("UNDEF" , ARMInterruptAttr::UNDEF) |
218 | .Case("" , ARMInterruptAttr::Generic) |
219 | .Default(Optional<InterruptType>()); |
220 | if (R) { |
221 | Out = *R; |
222 | return true; |
223 | } |
224 | return false; |
225 | } |
226 | |
227 | static const char *ConvertInterruptTypeToStr(InterruptType Val) { |
228 | switch(Val) { |
229 | case ARMInterruptAttr::IRQ: return "IRQ" ; |
230 | case ARMInterruptAttr::FIQ: return "FIQ" ; |
231 | case ARMInterruptAttr::SWI: return "SWI" ; |
232 | case ARMInterruptAttr::ABORT: return "ABORT" ; |
233 | case ARMInterruptAttr::UNDEF: return "UNDEF" ; |
234 | case ARMInterruptAttr::Generic: return "" ; |
235 | } |
236 | llvm_unreachable("No enumerator with that value" ); |
237 | } |
238 | |
239 | |
240 | static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; } |
241 | }; |
242 | |
243 | class AVRInterruptAttr : public InheritableAttr { |
244 | public: |
245 | static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
246 | auto *A = new (Ctx) AVRInterruptAttr(Loc, Ctx, 0); |
247 | A->setImplicit(true); |
248 | return A; |
249 | } |
250 | |
251 | AVRInterruptAttr(SourceRange R, ASTContext &Ctx |
252 | , unsigned SI |
253 | ) |
254 | : InheritableAttr(attr::AVRInterrupt, R, SI, false, false) |
255 | { |
256 | } |
257 | |
258 | AVRInterruptAttr *clone(ASTContext &C) const; |
259 | void printPretty(raw_ostream &OS, |
260 | const PrintingPolicy &Policy) const; |
261 | const char *getSpelling() const; |
262 | |
263 | |
264 | static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; } |
265 | }; |
266 | |
267 | class AVRSignalAttr : public InheritableAttr { |
268 | public: |
269 | static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
270 | auto *A = new (Ctx) AVRSignalAttr(Loc, Ctx, 0); |
271 | A->setImplicit(true); |
272 | return A; |
273 | } |
274 | |
275 | AVRSignalAttr(SourceRange R, ASTContext &Ctx |
276 | , unsigned SI |
277 | ) |
278 | : InheritableAttr(attr::AVRSignal, R, SI, false, false) |
279 | { |
280 | } |
281 | |
282 | AVRSignalAttr *clone(ASTContext &C) const; |
283 | void printPretty(raw_ostream &OS, |
284 | const PrintingPolicy &Policy) const; |
285 | const char *getSpelling() const; |
286 | |
287 | |
288 | static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; } |
289 | }; |
290 | |
291 | class AbiTagAttr : public Attr { |
292 | unsigned tags_Size; |
293 | StringRef *tags_; |
294 | |
295 | public: |
296 | static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Loc = SourceRange()) { |
297 | auto *A = new (Ctx) AbiTagAttr(Loc, Ctx, Tags, TagsSize, 0); |
298 | A->setImplicit(true); |
299 | return A; |
300 | } |
301 | |
302 | AbiTagAttr(SourceRange R, ASTContext &Ctx |
303 | , StringRef *Tags, unsigned TagsSize |
304 | , unsigned SI |
305 | ) |
306 | : Attr(attr::AbiTag, R, SI, false) |
307 | , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size]) |
308 | { |
309 | for (size_t I = 0, E = tags_Size; I != E; |
310 | ++I) { |
311 | StringRef Ref = Tags[I]; |
312 | if (!Ref.empty()) { |
313 | char *Mem = new (Ctx, 1) char[Ref.size()]; |
314 | std::memcpy(Mem, Ref.data(), Ref.size()); |
315 | tags_[I] = StringRef(Mem, Ref.size()); |
316 | } |
317 | } |
318 | } |
319 | |
320 | AbiTagAttr(SourceRange R, ASTContext &Ctx |
321 | , unsigned SI |
322 | ) |
323 | : Attr(attr::AbiTag, R, SI, false) |
324 | , tags_Size(0), tags_(nullptr) |
325 | { |
326 | } |
327 | |
328 | AbiTagAttr *clone(ASTContext &C) const; |
329 | void printPretty(raw_ostream &OS, |
330 | const PrintingPolicy &Policy) const; |
331 | const char *getSpelling() const; |
332 | typedef StringRef* tags_iterator; |
333 | tags_iterator tags_begin() const { return tags_; } |
334 | tags_iterator tags_end() const { return tags_ + tags_Size; } |
335 | unsigned tags_size() const { return tags_Size; } |
336 | llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); } |
337 | |
338 | |
339 | |
340 | |
341 | static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; } |
342 | }; |
343 | |
344 | class AcquireCapabilityAttr : public InheritableAttr { |
345 | unsigned args_Size; |
346 | Expr * *args_; |
347 | |
348 | public: |
349 | enum Spelling { |
350 | GNU_acquire_capability = 0, |
351 | CXX11_clang_acquire_capability = 1, |
352 | GNU_acquire_shared_capability = 2, |
353 | CXX11_clang_acquire_shared_capability = 3, |
354 | GNU_exclusive_lock_function = 4, |
355 | GNU_shared_lock_function = 5 |
356 | }; |
357 | |
358 | static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { |
359 | auto *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S); |
360 | A->setImplicit(true); |
361 | return A; |
362 | } |
363 | |
364 | AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx |
365 | , Expr * *Args, unsigned ArgsSize |
366 | , unsigned SI |
367 | ) |
368 | : InheritableAttr(attr::AcquireCapability, R, SI, true, true) |
369 | , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) |
370 | { |
371 | std::copy(Args, Args + args_Size, args_); |
372 | } |
373 | |
374 | AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx |
375 | , unsigned SI |
376 | ) |
377 | : InheritableAttr(attr::AcquireCapability, R, SI, true, true) |
378 | , args_Size(0), args_(nullptr) |
379 | { |
380 | } |
381 | |
382 | AcquireCapabilityAttr *clone(ASTContext &C) const; |
383 | void printPretty(raw_ostream &OS, |
384 | const PrintingPolicy &Policy) const; |
385 | const char *getSpelling() const; |
386 | Spelling getSemanticSpelling() const { |
387 | switch (SpellingListIndex) { |
388 | default: llvm_unreachable("Unknown spelling list index" ); |
389 | case 0: return GNU_acquire_capability; |
390 | case 1: return CXX11_clang_acquire_capability; |
391 | case 2: return GNU_acquire_shared_capability; |
392 | case 3: return CXX11_clang_acquire_shared_capability; |
393 | case 4: return GNU_exclusive_lock_function; |
394 | case 5: return GNU_shared_lock_function; |
395 | } |
396 | } |
397 | bool isShared() const { return SpellingListIndex == 2 || |
398 | SpellingListIndex == 3 || |
399 | SpellingListIndex == 5; } |
400 | typedef Expr ** args_iterator; |
401 | args_iterator args_begin() const { return args_; } |
402 | args_iterator args_end() const { return args_ + args_Size; } |
403 | unsigned args_size() const { return args_Size; } |
404 | llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
405 | |
406 | |
407 | |
408 | |
409 | static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; } |
410 | }; |
411 | |
412 | class AcquiredAfterAttr : public InheritableAttr { |
413 | unsigned args_Size; |
414 | Expr * *args_; |
415 | |
416 | public: |
417 | static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { |
418 | auto *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0); |
419 | A->setImplicit(true); |
420 | return A; |
421 | } |
422 | |
423 | AcquiredAfterAttr(SourceRange R, ASTContext &Ctx |
424 | , Expr * *Args, unsigned ArgsSize |
425 | , unsigned SI |
426 | ) |
427 | : InheritableAttr(attr::AcquiredAfter, R, SI, true, true) |
428 | , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) |
429 | { |
430 | std::copy(Args, Args + args_Size, args_); |
431 | } |
432 | |
433 | AcquiredAfterAttr(SourceRange R, ASTContext &Ctx |
434 | , unsigned SI |
435 | ) |
436 | : InheritableAttr(attr::AcquiredAfter, R, SI, true, true) |
437 | , args_Size(0), args_(nullptr) |
438 | { |
439 | } |
440 | |
441 | AcquiredAfterAttr *clone(ASTContext &C) const; |
442 | void printPretty(raw_ostream &OS, |
443 | const PrintingPolicy &Policy) const; |
444 | const char *getSpelling() const; |
445 | typedef Expr ** args_iterator; |
446 | args_iterator args_begin() const { return args_; } |
447 | args_iterator args_end() const { return args_ + args_Size; } |
448 | unsigned args_size() const { return args_Size; } |
449 | llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
450 | |
451 | |
452 | |
453 | |
454 | static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; } |
455 | }; |
456 | |
457 | class AcquiredBeforeAttr : public InheritableAttr { |
458 | unsigned args_Size; |
459 | Expr * *args_; |
460 | |
461 | public: |
462 | static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { |
463 | auto *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0); |
464 | A->setImplicit(true); |
465 | return A; |
466 | } |
467 | |
468 | AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx |
469 | , Expr * *Args, unsigned ArgsSize |
470 | , unsigned SI |
471 | ) |
472 | : InheritableAttr(attr::AcquiredBefore, R, SI, true, true) |
473 | , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) |
474 | { |
475 | std::copy(Args, Args + args_Size, args_); |
476 | } |
477 | |
478 | AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx |
479 | , unsigned SI |
480 | ) |
481 | : InheritableAttr(attr::AcquiredBefore, R, SI, true, true) |
482 | , args_Size(0), args_(nullptr) |
483 | { |
484 | } |
485 | |
486 | AcquiredBeforeAttr *clone(ASTContext &C) const; |
487 | void printPretty(raw_ostream &OS, |
488 | const PrintingPolicy &Policy) const; |
489 | const char *getSpelling() const; |
490 | typedef Expr ** args_iterator; |
491 | args_iterator args_begin() const { return args_; } |
492 | args_iterator args_end() const { return args_ + args_Size; } |
493 | unsigned args_size() const { return args_Size; } |
494 | llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
495 | |
496 | |
497 | |
498 | |
499 | static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; } |
500 | }; |
501 | |
502 | class AliasAttr : public Attr { |
503 | unsigned aliaseeLength; |
504 | char *aliasee; |
505 | |
506 | public: |
507 | static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) { |
508 | auto *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0); |
509 | A->setImplicit(true); |
510 | return A; |
511 | } |
512 | |
513 | AliasAttr(SourceRange R, ASTContext &Ctx |
514 | , llvm::StringRef Aliasee |
515 | , unsigned SI |
516 | ) |
517 | : Attr(attr::Alias, R, SI, false) |
518 | , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength]) |
519 | { |
520 | if (!Aliasee.empty()) |
521 | std::memcpy(aliasee, Aliasee.data(), aliaseeLength); |
522 | } |
523 | |
524 | AliasAttr *clone(ASTContext &C) const; |
525 | void printPretty(raw_ostream &OS, |
526 | const PrintingPolicy &Policy) const; |
527 | const char *getSpelling() const; |
528 | llvm::StringRef getAliasee() const { |
529 | return llvm::StringRef(aliasee, aliaseeLength); |
530 | } |
531 | unsigned getAliaseeLength() const { |
532 | return aliaseeLength; |
533 | } |
534 | void setAliasee(ASTContext &C, llvm::StringRef S) { |
535 | aliaseeLength = S.size(); |
536 | this->aliasee = new (C, 1) char [aliaseeLength]; |
537 | if (!S.empty()) |
538 | std::memcpy(this->aliasee, S.data(), aliaseeLength); |
539 | } |
540 | |
541 | |
542 | |
543 | static bool classof(const Attr *A) { return A->getKind() == attr::Alias; } |
544 | }; |
545 | |
546 | class AlignMac68kAttr : public InheritableAttr { |
547 | public: |
548 | static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
549 | auto *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0); |
550 | A->setImplicit(true); |
551 | return A; |
552 | } |
553 | |
554 | AlignMac68kAttr(SourceRange R, ASTContext &Ctx |
555 | , unsigned SI |
556 | ) |
557 | : InheritableAttr(attr::AlignMac68k, R, SI, false, false) |
558 | { |
559 | } |
560 | |
561 | AlignMac68kAttr *clone(ASTContext &C) const; |
562 | void printPretty(raw_ostream &OS, |
563 | const PrintingPolicy &Policy) const; |
564 | const char *getSpelling() const; |
565 | |
566 | |
567 | static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; } |
568 | }; |
569 | |
570 | class AlignValueAttr : public Attr { |
571 | Expr * alignment; |
572 | |
573 | public: |
574 | static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) { |
575 | auto *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0); |
576 | A->setImplicit(true); |
577 | return A; |
578 | } |
579 | |
580 | AlignValueAttr(SourceRange R, ASTContext &Ctx |
581 | , Expr * Alignment |
582 | , unsigned SI |
583 | ) |
584 | : Attr(attr::AlignValue, R, SI, false) |
585 | , alignment(Alignment) |
586 | { |
587 | } |
588 | |
589 | AlignValueAttr *clone(ASTContext &C) const; |
590 | void printPretty(raw_ostream &OS, |
591 | const PrintingPolicy &Policy) const; |
592 | const char *getSpelling() const; |
593 | Expr * getAlignment() const { |
594 | return alignment; |
595 | } |
596 | |
597 | |
598 | |
599 | static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; } |
600 | }; |
601 | |
602 | class AlignedAttr : public InheritableAttr { |
603 | bool isalignmentExpr; |
604 | union { |
605 | Expr *alignmentExpr; |
606 | TypeSourceInfo *alignmentType; |
607 | }; |
608 | |
609 | public: |
610 | enum Spelling { |
611 | GNU_aligned = 0, |
612 | CXX11_gnu_aligned = 1, |
613 | Declspec_align = 2, |
614 | Keyword_alignas = 3, |
615 | Keyword_Alignas = 4 |
616 | }; |
617 | |
618 | static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) { |
619 | auto *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S); |
620 | A->setImplicit(true); |
621 | return A; |
622 | } |
623 | |
624 | AlignedAttr(SourceRange R, ASTContext &Ctx |
625 | , bool IsAlignmentExpr, void *Alignment |
626 | , unsigned SI |
627 | ) |
628 | : InheritableAttr(attr::Aligned, R, SI, false, false) |
629 | , isalignmentExpr(IsAlignmentExpr) |
630 | { |
631 | if (isalignmentExpr) |
632 | alignmentExpr = reinterpret_cast<Expr *>(Alignment); |
633 | else |
634 | alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment); |
635 | } |
636 | |
637 | AlignedAttr(SourceRange R, ASTContext &Ctx |
638 | , unsigned SI |
639 | ) |
640 | : InheritableAttr(attr::Aligned, R, SI, false, false) |
641 | , isalignmentExpr(false) |
642 | { |
643 | } |
644 | |
645 | AlignedAttr *clone(ASTContext &C) const; |
646 | void printPretty(raw_ostream &OS, |
647 | const PrintingPolicy &Policy) const; |
648 | const char *getSpelling() const; |
649 | Spelling getSemanticSpelling() const { |
650 | switch (SpellingListIndex) { |
651 | default: llvm_unreachable("Unknown spelling list index" ); |
652 | case 0: return GNU_aligned; |
653 | case 1: return CXX11_gnu_aligned; |
654 | case 2: return Declspec_align; |
655 | case 3: return Keyword_alignas; |
656 | case 4: return Keyword_Alignas; |
657 | } |
658 | } |
659 | bool isGNU() const { return SpellingListIndex == 0 || |
660 | SpellingListIndex == 1; } |
661 | bool isC11() const { return SpellingListIndex == 4; } |
662 | bool isAlignas() const { return SpellingListIndex == 3 || |
663 | SpellingListIndex == 4; } |
664 | bool isDeclspec() const { return SpellingListIndex == 2; } |
665 | bool isAlignmentDependent() const; |
666 | unsigned getAlignment(ASTContext &Ctx) const; |
667 | bool isAlignmentExpr() const { |
668 | return isalignmentExpr; |
669 | } |
670 | Expr *getAlignmentExpr() const { |
671 | assert(isalignmentExpr); |
672 | return alignmentExpr; |
673 | } |
674 | TypeSourceInfo *getAlignmentType() const { |
675 | assert(!isalignmentExpr); |
676 | return alignmentType; |
677 | } |
678 | |
679 | |
680 | |
681 | static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; } |
682 | }; |
683 | |
684 | class AllocAlignAttr : public InheritableAttr { |
685 | ParamIdx paramIndex; |
686 | |
687 | public: |
688 | static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Loc = SourceRange()) { |
689 | auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0); |
690 | A->setImplicit(true); |
691 | return A; |
692 | } |
693 | |
694 | AllocAlignAttr(SourceRange R, ASTContext &Ctx |
695 | , ParamIdx ParamIndex |
696 | , unsigned SI |
697 | ) |
698 | : InheritableAttr(attr::AllocAlign, R, SI, false, false) |
699 | , paramIndex(ParamIndex) |
700 | { |
701 | } |
702 | |
703 | AllocAlignAttr *clone(ASTContext &C) const; |
704 | void printPretty(raw_ostream &OS, |
705 | const PrintingPolicy &Policy) const; |
706 | const char *getSpelling() const; |
707 | ParamIdx getParamIndex() const { |
708 | return paramIndex; |
709 | } |
710 | |
711 | |
712 | |
713 | static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; } |
714 | }; |
715 | |
716 | class AllocSizeAttr : public InheritableAttr { |
717 | ParamIdx elemSizeParam; |
718 | |
719 | ParamIdx numElemsParam; |
720 | |
721 | public: |
722 | static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Loc = SourceRange()) { |
723 | auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0); |
724 | A->setImplicit(true); |
725 | return A; |
726 | } |
727 | |
728 | AllocSizeAttr(SourceRange R, ASTContext &Ctx |
729 | , ParamIdx ElemSizeParam |
730 | , ParamIdx NumElemsParam |
731 | , unsigned SI |
732 | ) |
733 | : InheritableAttr(attr::AllocSize, R, SI, false, false) |
734 | , elemSizeParam(ElemSizeParam) |
735 | , numElemsParam(NumElemsParam) |
736 | { |
737 | } |
738 | |
739 | AllocSizeAttr(SourceRange R, ASTContext &Ctx |
740 | , ParamIdx ElemSizeParam |
741 | , unsigned SI |
742 | ) |
743 | : InheritableAttr(attr::AllocSize, R, SI, false, false) |
744 | , elemSizeParam(ElemSizeParam) |
745 | , numElemsParam() |
746 | { |
747 | } |
748 | |
749 | AllocSizeAttr *clone(ASTContext &C) const; |
750 | void printPretty(raw_ostream &OS, |
751 | const PrintingPolicy &Policy) const; |
752 | const char *getSpelling() const; |
753 | ParamIdx getElemSizeParam() const { |
754 | return elemSizeParam; |
755 | } |
756 | |
757 | ParamIdx getNumElemsParam() const { |
758 | return numElemsParam; |
759 | } |
760 | |
761 | |
762 | |
763 | static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; } |
764 | }; |
765 | |
766 | class AlwaysInlineAttr : public InheritableAttr { |
767 | public: |
768 | enum Spelling { |
769 | GNU_always_inline = 0, |
770 | CXX11_gnu_always_inline = 1, |
771 | Keyword_forceinline = 2 |
772 | }; |
773 | |
774 | static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) { |
775 | auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S); |
776 | A->setImplicit(true); |
777 | return A; |
778 | } |
779 | |
780 | AlwaysInlineAttr(SourceRange R, ASTContext &Ctx |
781 | , unsigned SI |
782 | ) |
783 | : InheritableAttr(attr::AlwaysInline, R, SI, false, false) |
784 | { |
785 | } |
786 | |
787 | AlwaysInlineAttr *clone(ASTContext &C) const; |
788 | void printPretty(raw_ostream &OS, |
789 | const PrintingPolicy &Policy) const; |
790 | const char *getSpelling() const; |
791 | Spelling getSemanticSpelling() const { |
792 | switch (SpellingListIndex) { |
793 | default: llvm_unreachable("Unknown spelling list index" ); |
794 | case 0: return GNU_always_inline; |
795 | case 1: return CXX11_gnu_always_inline; |
796 | case 2: return Keyword_forceinline; |
797 | } |
798 | } |
799 | |
800 | |
801 | static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; } |
802 | }; |
803 | |
804 | class AnalyzerNoReturnAttr : public InheritableAttr { |
805 | public: |
806 | static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
807 | auto *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0); |
808 | A->setImplicit(true); |
809 | return A; |
810 | } |
811 | |
812 | AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx |
813 | , unsigned SI |
814 | ) |
815 | : InheritableAttr(attr::AnalyzerNoReturn, R, SI, false, false) |
816 | { |
817 | } |
818 | |
819 | AnalyzerNoReturnAttr *clone(ASTContext &C) const; |
820 | void printPretty(raw_ostream &OS, |
821 | const PrintingPolicy &Policy) const; |
822 | const char *getSpelling() const; |
823 | |
824 | |
825 | static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; } |
826 | }; |
827 | |
828 | class AnnotateAttr : public InheritableParamAttr { |
829 | unsigned annotationLength; |
830 | char *annotation; |
831 | |
832 | public: |
833 | static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) { |
834 | auto *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0); |
835 | A->setImplicit(true); |
836 | return A; |
837 | } |
838 | |
839 | AnnotateAttr(SourceRange R, ASTContext &Ctx |
840 | , llvm::StringRef Annotation |
841 | , unsigned SI |
842 | ) |
843 | : InheritableParamAttr(attr::Annotate, R, SI, false, false) |
844 | , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength]) |
845 | { |
846 | if (!Annotation.empty()) |
847 | std::memcpy(annotation, Annotation.data(), annotationLength); |
848 | } |
849 | |
850 | AnnotateAttr *clone(ASTContext &C) const; |
851 | void printPretty(raw_ostream &OS, |
852 | const PrintingPolicy &Policy) const; |
853 | const char *getSpelling() const; |
854 | llvm::StringRef getAnnotation() const { |
855 | return llvm::StringRef(annotation, annotationLength); |
856 | } |
857 | unsigned getAnnotationLength() const { |
858 | return annotationLength; |
859 | } |
860 | void setAnnotation(ASTContext &C, llvm::StringRef S) { |
861 | annotationLength = S.size(); |
862 | this->annotation = new (C, 1) char [annotationLength]; |
863 | if (!S.empty()) |
864 | std::memcpy(this->annotation, S.data(), annotationLength); |
865 | } |
866 | |
867 | |
868 | |
869 | static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; } |
870 | }; |
871 | |
872 | class AnyX86InterruptAttr : public InheritableAttr { |
873 | public: |
874 | static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
875 | auto *A = new (Ctx) AnyX86InterruptAttr(Loc, Ctx, 0); |
876 | A->setImplicit(true); |
877 | return A; |
878 | } |
879 | |
880 | AnyX86InterruptAttr(SourceRange R, ASTContext &Ctx |
881 | , unsigned SI |
882 | ) |
883 | : InheritableAttr(attr::AnyX86Interrupt, R, SI, false, false) |
884 | { |
885 | } |
886 | |
887 | AnyX86InterruptAttr *clone(ASTContext &C) const; |
888 | void printPretty(raw_ostream &OS, |
889 | const PrintingPolicy &Policy) const; |
890 | const char *getSpelling() const; |
891 | |
892 | |
893 | static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; } |
894 | }; |
895 | |
896 | class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr { |
897 | public: |
898 | static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
899 | auto *A = new (Ctx) AnyX86NoCallerSavedRegistersAttr(Loc, Ctx, 0); |
900 | A->setImplicit(true); |
901 | return A; |
902 | } |
903 | |
904 | AnyX86NoCallerSavedRegistersAttr(SourceRange R, ASTContext &Ctx |
905 | , unsigned SI |
906 | ) |
907 | : InheritableAttr(attr::AnyX86NoCallerSavedRegisters, R, SI, false, false) |
908 | { |
909 | } |
910 | |
911 | AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const; |
912 | void printPretty(raw_ostream &OS, |
913 | const PrintingPolicy &Policy) const; |
914 | const char *getSpelling() const; |
915 | |
916 | |
917 | static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; } |
918 | }; |
919 | |
920 | class AnyX86NoCfCheckAttr : public InheritableAttr { |
921 | public: |
922 | static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
923 | auto *A = new (Ctx) AnyX86NoCfCheckAttr(Loc, Ctx, 0); |
924 | A->setImplicit(true); |
925 | return A; |
926 | } |
927 | |
928 | AnyX86NoCfCheckAttr(SourceRange R, ASTContext &Ctx |
929 | , unsigned SI |
930 | ) |
931 | : InheritableAttr(attr::AnyX86NoCfCheck, R, SI, false, false) |
932 | { |
933 | } |
934 | |
935 | AnyX86NoCfCheckAttr *clone(ASTContext &C) const; |
936 | void printPretty(raw_ostream &OS, |
937 | const PrintingPolicy &Policy) const; |
938 | const char *getSpelling() const; |
939 | |
940 | |
941 | static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCfCheck; } |
942 | }; |
943 | |
944 | class ArcWeakrefUnavailableAttr : public InheritableAttr { |
945 | public: |
946 | static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
947 | auto *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0); |
948 | A->setImplicit(true); |
949 | return A; |
950 | } |
951 | |
952 | ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx |
953 | , unsigned SI |
954 | ) |
955 | : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, false, false) |
956 | { |
957 | } |
958 | |
959 | ArcWeakrefUnavailableAttr *clone(ASTContext &C) const; |
960 | void printPretty(raw_ostream &OS, |
961 | const PrintingPolicy &Policy) const; |
962 | const char *getSpelling() const; |
963 | |
964 | |
965 | static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; } |
966 | }; |
967 | |
968 | class ArgumentWithTypeTagAttr : public InheritableAttr { |
969 | IdentifierInfo * argumentKind; |
970 | |
971 | ParamIdx argumentIdx; |
972 | |
973 | ParamIdx typeTagIdx; |
974 | |
975 | bool isPointer; |
976 | |
977 | public: |
978 | enum Spelling { |
979 | GNU_argument_with_type_tag = 0, |
980 | CXX11_clang_argument_with_type_tag = 1, |
981 | C2x_clang_argument_with_type_tag = 2, |
982 | GNU_pointer_with_type_tag = 3, |
983 | CXX11_clang_pointer_with_type_tag = 4, |
984 | C2x_clang_pointer_with_type_tag = 5 |
985 | }; |
986 | |
987 | static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) { |
988 | auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S); |
989 | A->setImplicit(true); |
990 | return A; |
991 | } |
992 | |
993 | static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Loc = SourceRange()) { |
994 | auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, S); |
995 | A->setImplicit(true); |
996 | return A; |
997 | } |
998 | |
999 | ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx |
1000 | , IdentifierInfo * ArgumentKind |
1001 | , ParamIdx ArgumentIdx |
1002 | , ParamIdx TypeTagIdx |
1003 | , bool IsPointer |
1004 | , unsigned SI |
1005 | ) |
1006 | : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false) |
1007 | , argumentKind(ArgumentKind) |
1008 | , argumentIdx(ArgumentIdx) |
1009 | , typeTagIdx(TypeTagIdx) |
1010 | , isPointer(IsPointer) |
1011 | { |
1012 | } |
1013 | |
1014 | ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx |
1015 | , IdentifierInfo * ArgumentKind |
1016 | , ParamIdx ArgumentIdx |
1017 | , ParamIdx TypeTagIdx |
1018 | , unsigned SI |
1019 | ) |
1020 | : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false) |
1021 | , argumentKind(ArgumentKind) |
1022 | , argumentIdx(ArgumentIdx) |
1023 | , typeTagIdx(TypeTagIdx) |
1024 | , isPointer() |
1025 | { |
1026 | } |
1027 | |
1028 | ArgumentWithTypeTagAttr *clone(ASTContext &C) const; |
1029 | void printPretty(raw_ostream &OS, |
1030 | const PrintingPolicy &Policy) const; |
1031 | const char *getSpelling() const; |
1032 | Spelling getSemanticSpelling() const { |
1033 | switch (SpellingListIndex) { |
1034 | default: llvm_unreachable("Unknown spelling list index" ); |
1035 | case 0: return GNU_argument_with_type_tag; |
1036 | case 1: return CXX11_clang_argument_with_type_tag; |
1037 | case 2: return C2x_clang_argument_with_type_tag; |
1038 | case 3: return GNU_pointer_with_type_tag; |
1039 | case 4: return CXX11_clang_pointer_with_type_tag; |
1040 | case 5: return C2x_clang_pointer_with_type_tag; |
1041 | } |
1042 | } |
1043 | IdentifierInfo * getArgumentKind() const { |
1044 | return argumentKind; |
1045 | } |
1046 | |
1047 | ParamIdx getArgumentIdx() const { |
1048 | return argumentIdx; |
1049 | } |
1050 | |
1051 | ParamIdx getTypeTagIdx() const { |
1052 | return typeTagIdx; |
1053 | } |
1054 | |
1055 | bool getIsPointer() const { |
1056 | return isPointer; |
1057 | } |
1058 | |
1059 | |
1060 | |
1061 | static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; } |
1062 | }; |
1063 | |
1064 | class ArtificialAttr : public InheritableAttr { |
1065 | public: |
1066 | static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1067 | auto *A = new (Ctx) ArtificialAttr(Loc, Ctx, 0); |
1068 | A->setImplicit(true); |
1069 | return A; |
1070 | } |
1071 | |
1072 | ArtificialAttr(SourceRange R, ASTContext &Ctx |
1073 | , unsigned SI |
1074 | ) |
1075 | : InheritableAttr(attr::Artificial, R, SI, false, false) |
1076 | { |
1077 | } |
1078 | |
1079 | ArtificialAttr *clone(ASTContext &C) const; |
1080 | void printPretty(raw_ostream &OS, |
1081 | const PrintingPolicy &Policy) const; |
1082 | const char *getSpelling() const; |
1083 | |
1084 | |
1085 | static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; } |
1086 | }; |
1087 | |
1088 | class AsmLabelAttr : public InheritableAttr { |
1089 | unsigned labelLength; |
1090 | char *label; |
1091 | |
1092 | public: |
1093 | static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) { |
1094 | auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0); |
1095 | A->setImplicit(true); |
1096 | return A; |
1097 | } |
1098 | |
1099 | AsmLabelAttr(SourceRange R, ASTContext &Ctx |
1100 | , llvm::StringRef Label |
1101 | , unsigned SI |
1102 | ) |
1103 | : InheritableAttr(attr::AsmLabel, R, SI, false, false) |
1104 | , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength]) |
1105 | { |
1106 | if (!Label.empty()) |
1107 | std::memcpy(label, Label.data(), labelLength); |
1108 | } |
1109 | |
1110 | AsmLabelAttr *clone(ASTContext &C) const; |
1111 | void printPretty(raw_ostream &OS, |
1112 | const PrintingPolicy &Policy) const; |
1113 | const char *getSpelling() const; |
1114 | llvm::StringRef getLabel() const { |
1115 | return llvm::StringRef(label, labelLength); |
1116 | } |
1117 | unsigned getLabelLength() const { |
1118 | return labelLength; |
1119 | } |
1120 | void setLabel(ASTContext &C, llvm::StringRef S) { |
1121 | labelLength = S.size(); |
1122 | this->label = new (C, 1) char [labelLength]; |
1123 | if (!S.empty()) |
1124 | std::memcpy(this->label, S.data(), labelLength); |
1125 | } |
1126 | |
1127 | |
1128 | |
1129 | static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; } |
1130 | }; |
1131 | |
1132 | class AssertCapabilityAttr : public InheritableAttr { |
1133 | unsigned args_Size; |
1134 | Expr * *args_; |
1135 | |
1136 | public: |
1137 | enum Spelling { |
1138 | GNU_assert_capability = 0, |
1139 | CXX11_clang_assert_capability = 1, |
1140 | GNU_assert_shared_capability = 2, |
1141 | CXX11_clang_assert_shared_capability = 3 |
1142 | }; |
1143 | |
1144 | static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { |
1145 | auto *A = new (Ctx) AssertCapabilityAttr(Loc, Ctx, Args, ArgsSize, S); |
1146 | A->setImplicit(true); |
1147 | return A; |
1148 | } |
1149 | |
1150 | AssertCapabilityAttr(SourceRange R, ASTContext &Ctx |
1151 | , Expr * *Args, unsigned ArgsSize |
1152 | , unsigned SI |
1153 | ) |
1154 | : InheritableAttr(attr::AssertCapability, R, SI, true, true) |
1155 | , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) |
1156 | { |
1157 | std::copy(Args, Args + args_Size, args_); |
1158 | } |
1159 | |
1160 | AssertCapabilityAttr(SourceRange R, ASTContext &Ctx |
1161 | , unsigned SI |
1162 | ) |
1163 | : InheritableAttr(attr::AssertCapability, R, SI, true, true) |
1164 | , args_Size(0), args_(nullptr) |
1165 | { |
1166 | } |
1167 | |
1168 | AssertCapabilityAttr *clone(ASTContext &C) const; |
1169 | void printPretty(raw_ostream &OS, |
1170 | const PrintingPolicy &Policy) const; |
1171 | const char *getSpelling() const; |
1172 | Spelling getSemanticSpelling() const { |
1173 | switch (SpellingListIndex) { |
1174 | default: llvm_unreachable("Unknown spelling list index" ); |
1175 | case 0: return GNU_assert_capability; |
1176 | case 1: return CXX11_clang_assert_capability; |
1177 | case 2: return GNU_assert_shared_capability; |
1178 | case 3: return CXX11_clang_assert_shared_capability; |
1179 | } |
1180 | } |
1181 | bool isShared() const { return SpellingListIndex == 2 || |
1182 | SpellingListIndex == 3; } |
1183 | typedef Expr ** args_iterator; |
1184 | args_iterator args_begin() const { return args_; } |
1185 | args_iterator args_end() const { return args_ + args_Size; } |
1186 | unsigned args_size() const { return args_Size; } |
1187 | llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
1188 | |
1189 | |
1190 | |
1191 | |
1192 | static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; } |
1193 | }; |
1194 | |
1195 | class AssertExclusiveLockAttr : public InheritableAttr { |
1196 | unsigned args_Size; |
1197 | Expr * *args_; |
1198 | |
1199 | public: |
1200 | static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { |
1201 | auto *A = new (Ctx) AssertExclusiveLockAttr(Loc, Ctx, Args, ArgsSize, 0); |
1202 | A->setImplicit(true); |
1203 | return A; |
1204 | } |
1205 | |
1206 | AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx |
1207 | , Expr * *Args, unsigned ArgsSize |
1208 | , unsigned SI |
1209 | ) |
1210 | : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true) |
1211 | , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) |
1212 | { |
1213 | std::copy(Args, Args + args_Size, args_); |
1214 | } |
1215 | |
1216 | AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx |
1217 | , unsigned SI |
1218 | ) |
1219 | : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true) |
1220 | , args_Size(0), args_(nullptr) |
1221 | { |
1222 | } |
1223 | |
1224 | AssertExclusiveLockAttr *clone(ASTContext &C) const; |
1225 | void printPretty(raw_ostream &OS, |
1226 | const PrintingPolicy &Policy) const; |
1227 | const char *getSpelling() const; |
1228 | typedef Expr ** args_iterator; |
1229 | args_iterator args_begin() const { return args_; } |
1230 | args_iterator args_end() const { return args_ + args_Size; } |
1231 | unsigned args_size() const { return args_Size; } |
1232 | llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
1233 | |
1234 | |
1235 | |
1236 | |
1237 | static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; } |
1238 | }; |
1239 | |
1240 | class AssertSharedLockAttr : public InheritableAttr { |
1241 | unsigned args_Size; |
1242 | Expr * *args_; |
1243 | |
1244 | public: |
1245 | static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) { |
1246 | auto *A = new (Ctx) AssertSharedLockAttr(Loc, Ctx, Args, ArgsSize, 0); |
1247 | A->setImplicit(true); |
1248 | return A; |
1249 | } |
1250 | |
1251 | AssertSharedLockAttr(SourceRange R, ASTContext &Ctx |
1252 | , Expr * *Args, unsigned ArgsSize |
1253 | , unsigned SI |
1254 | ) |
1255 | : InheritableAttr(attr::AssertSharedLock, R, SI, true, true) |
1256 | , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size]) |
1257 | { |
1258 | std::copy(Args, Args + args_Size, args_); |
1259 | } |
1260 | |
1261 | AssertSharedLockAttr(SourceRange R, ASTContext &Ctx |
1262 | , unsigned SI |
1263 | ) |
1264 | : InheritableAttr(attr::AssertSharedLock, R, SI, true, true) |
1265 | , args_Size(0), args_(nullptr) |
1266 | { |
1267 | } |
1268 | |
1269 | AssertSharedLockAttr *clone(ASTContext &C) const; |
1270 | void printPretty(raw_ostream &OS, |
1271 | const PrintingPolicy &Policy) const; |
1272 | const char *getSpelling() const; |
1273 | typedef Expr ** args_iterator; |
1274 | args_iterator args_begin() const { return args_; } |
1275 | args_iterator args_end() const { return args_ + args_Size; } |
1276 | unsigned args_size() const { return args_Size; } |
1277 | llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); } |
1278 | |
1279 | |
1280 | |
1281 | |
1282 | static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; } |
1283 | }; |
1284 | |
1285 | class AssumeAlignedAttr : public InheritableAttr { |
1286 | Expr * alignment; |
1287 | |
1288 | Expr * offset; |
1289 | |
1290 | public: |
1291 | static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Loc = SourceRange()) { |
1292 | auto *A = new (Ctx) AssumeAlignedAttr(Loc, Ctx, Alignment, Offset, 0); |
1293 | A->setImplicit(true); |
1294 | return A; |
1295 | } |
1296 | |
1297 | AssumeAlignedAttr(SourceRange R, ASTContext &Ctx |
1298 | , Expr * Alignment |
1299 | , Expr * Offset |
1300 | , unsigned SI |
1301 | ) |
1302 | : InheritableAttr(attr::AssumeAligned, R, SI, false, false) |
1303 | , alignment(Alignment) |
1304 | , offset(Offset) |
1305 | { |
1306 | } |
1307 | |
1308 | AssumeAlignedAttr(SourceRange R, ASTContext &Ctx |
1309 | , Expr * Alignment |
1310 | , unsigned SI |
1311 | ) |
1312 | : InheritableAttr(attr::AssumeAligned, R, SI, false, false) |
1313 | , alignment(Alignment) |
1314 | , offset() |
1315 | { |
1316 | } |
1317 | |
1318 | AssumeAlignedAttr *clone(ASTContext &C) const; |
1319 | void printPretty(raw_ostream &OS, |
1320 | const PrintingPolicy &Policy) const; |
1321 | const char *getSpelling() const; |
1322 | Expr * getAlignment() const { |
1323 | return alignment; |
1324 | } |
1325 | |
1326 | Expr * getOffset() const { |
1327 | return offset; |
1328 | } |
1329 | |
1330 | |
1331 | |
1332 | static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; } |
1333 | }; |
1334 | |
1335 | class AvailabilityAttr : public InheritableAttr { |
1336 | IdentifierInfo * platform; |
1337 | |
1338 | VersionTuple introduced; |
1339 | |
1340 | |
1341 | VersionTuple deprecated; |
1342 | |
1343 | |
1344 | VersionTuple obsoleted; |
1345 | |
1346 | |
1347 | bool unavailable; |
1348 | |
1349 | unsigned messageLength; |
1350 | char *message; |
1351 | |
1352 | bool strict; |
1353 | |
1354 | unsigned replacementLength; |
1355 | char *replacement; |
1356 | |
1357 | public: |
1358 | static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) { |
1359 | auto *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, Strict, Replacement, 0); |
1360 | A->setImplicit(true); |
1361 | return A; |
1362 | } |
1363 | |
1364 | AvailabilityAttr(SourceRange R, ASTContext &Ctx |
1365 | , IdentifierInfo * Platform |
1366 | , VersionTuple Introduced |
1367 | , VersionTuple Deprecated |
1368 | , VersionTuple Obsoleted |
1369 | , bool Unavailable |
1370 | , llvm::StringRef Message |
1371 | , bool Strict |
1372 | , llvm::StringRef Replacement |
1373 | , unsigned SI |
1374 | ) |
1375 | : InheritableAttr(attr::Availability, R, SI, false, true) |
1376 | , platform(Platform) |
1377 | , introduced(Introduced) |
1378 | , deprecated(Deprecated) |
1379 | , obsoleted(Obsoleted) |
1380 | , unavailable(Unavailable) |
1381 | , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength]) |
1382 | , strict(Strict) |
1383 | , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength]) |
1384 | { |
1385 | if (!Message.empty()) |
1386 | std::memcpy(message, Message.data(), messageLength); |
1387 | if (!Replacement.empty()) |
1388 | std::memcpy(replacement, Replacement.data(), replacementLength); |
1389 | } |
1390 | |
1391 | AvailabilityAttr *clone(ASTContext &C) const; |
1392 | void printPretty(raw_ostream &OS, |
1393 | const PrintingPolicy &Policy) const; |
1394 | const char *getSpelling() const; |
1395 | IdentifierInfo * getPlatform() const { |
1396 | return platform; |
1397 | } |
1398 | |
1399 | VersionTuple getIntroduced() const { |
1400 | return introduced; |
1401 | } |
1402 | void setIntroduced(ASTContext &C, VersionTuple V) { |
1403 | introduced = V; |
1404 | } |
1405 | |
1406 | VersionTuple getDeprecated() const { |
1407 | return deprecated; |
1408 | } |
1409 | void setDeprecated(ASTContext &C, VersionTuple V) { |
1410 | deprecated = V; |
1411 | } |
1412 | |
1413 | VersionTuple getObsoleted() const { |
1414 | return obsoleted; |
1415 | } |
1416 | void setObsoleted(ASTContext &C, VersionTuple V) { |
1417 | obsoleted = V; |
1418 | } |
1419 | |
1420 | bool getUnavailable() const { |
1421 | return unavailable; |
1422 | } |
1423 | |
1424 | llvm::StringRef getMessage() const { |
1425 | return llvm::StringRef(message, messageLength); |
1426 | } |
1427 | unsigned getMessageLength() const { |
1428 | return messageLength; |
1429 | } |
1430 | void setMessage(ASTContext &C, llvm::StringRef S) { |
1431 | messageLength = S.size(); |
1432 | this->message = new (C, 1) char [messageLength]; |
1433 | if (!S.empty()) |
1434 | std::memcpy(this->message, S.data(), messageLength); |
1435 | } |
1436 | |
1437 | bool getStrict() const { |
1438 | return strict; |
1439 | } |
1440 | |
1441 | llvm::StringRef getReplacement() const { |
1442 | return llvm::StringRef(replacement, replacementLength); |
1443 | } |
1444 | unsigned getReplacementLength() const { |
1445 | return replacementLength; |
1446 | } |
1447 | void setReplacement(ASTContext &C, llvm::StringRef S) { |
1448 | replacementLength = S.size(); |
1449 | this->replacement = new (C, 1) char [replacementLength]; |
1450 | if (!S.empty()) |
1451 | std::memcpy(this->replacement, S.data(), replacementLength); |
1452 | } |
1453 | |
1454 | static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) { |
1455 | return llvm::StringSwitch<llvm::StringRef>(Platform) |
1456 | .Case("android" , "Android" ) |
1457 | .Case("ios" , "iOS" ) |
1458 | .Case("macos" , "macOS" ) |
1459 | .Case("tvos" , "tvOS" ) |
1460 | .Case("watchos" , "watchOS" ) |
1461 | .Case("ios_app_extension" , "iOS (App Extension)" ) |
1462 | .Case("macos_app_extension" , "macOS (App Extension)" ) |
1463 | .Case("tvos_app_extension" , "tvOS (App Extension)" ) |
1464 | .Case("watchos_app_extension" , "watchOS (App Extension)" ) |
1465 | .Default(llvm::StringRef()); |
1466 | } |
1467 | static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) { |
1468 | return llvm::StringSwitch<llvm::StringRef>(Platform) |
1469 | .Case("ios" , "iOS" ) |
1470 | .Case("macos" , "macOS" ) |
1471 | .Case("tvos" , "tvOS" ) |
1472 | .Case("watchos" , "watchOS" ) |
1473 | .Case("ios_app_extension" , "iOSApplicationExtension" ) |
1474 | .Case("macos_app_extension" , "macOSApplicationExtension" ) |
1475 | .Case("tvos_app_extension" , "tvOSApplicationExtension" ) |
1476 | .Case("watchos_app_extension" , "watchOSApplicationExtension" ) |
1477 | .Default(Platform); |
1478 | } |
1479 | static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) { |
1480 | return llvm::StringSwitch<llvm::StringRef>(Platform) |
1481 | .Case("iOS" , "ios" ) |
1482 | .Case("macOS" , "macos" ) |
1483 | .Case("tvOS" , "tvos" ) |
1484 | .Case("watchOS" , "watchos" ) |
1485 | .Case("iOSApplicationExtension" , "ios_app_extension" ) |
1486 | .Case("macOSApplicationExtension" , "macos_app_extension" ) |
1487 | .Case("tvOSApplicationExtension" , "tvos_app_extension" ) |
1488 | .Case("watchOSApplicationExtension" , "watchos_app_extension" ) |
1489 | .Default(Platform); |
1490 | } |
1491 | |
1492 | static bool classof(const Attr *A) { return A->getKind() == attr::Availability; } |
1493 | }; |
1494 | |
1495 | class BlocksAttr : public InheritableAttr { |
1496 | public: |
1497 | enum BlockType { |
1498 | ByRef |
1499 | }; |
1500 | private: |
1501 | BlockType type; |
1502 | |
1503 | public: |
1504 | static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Loc = SourceRange()) { |
1505 | auto *A = new (Ctx) BlocksAttr(Loc, Ctx, Type, 0); |
1506 | A->setImplicit(true); |
1507 | return A; |
1508 | } |
1509 | |
1510 | BlocksAttr(SourceRange R, ASTContext &Ctx |
1511 | , BlockType Type |
1512 | , unsigned SI |
1513 | ) |
1514 | : InheritableAttr(attr::Blocks, R, SI, false, false) |
1515 | , type(Type) |
1516 | { |
1517 | } |
1518 | |
1519 | BlocksAttr *clone(ASTContext &C) const; |
1520 | void printPretty(raw_ostream &OS, |
1521 | const PrintingPolicy &Policy) const; |
1522 | const char *getSpelling() const; |
1523 | BlockType getType() const { |
1524 | return type; |
1525 | } |
1526 | |
1527 | static bool ConvertStrToBlockType(StringRef Val, BlockType &Out) { |
1528 | Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val) |
1529 | .Case("byref" , BlocksAttr::ByRef) |
1530 | .Default(Optional<BlockType>()); |
1531 | if (R) { |
1532 | Out = *R; |
1533 | return true; |
1534 | } |
1535 | return false; |
1536 | } |
1537 | |
1538 | static const char *ConvertBlockTypeToStr(BlockType Val) { |
1539 | switch(Val) { |
1540 | case BlocksAttr::ByRef: return "byref" ; |
1541 | } |
1542 | llvm_unreachable("No enumerator with that value" ); |
1543 | } |
1544 | |
1545 | |
1546 | static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; } |
1547 | }; |
1548 | |
1549 | class C11NoReturnAttr : public InheritableAttr { |
1550 | public: |
1551 | static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1552 | auto *A = new (Ctx) C11NoReturnAttr(Loc, Ctx, 0); |
1553 | A->setImplicit(true); |
1554 | return A; |
1555 | } |
1556 | |
1557 | C11NoReturnAttr(SourceRange R, ASTContext &Ctx |
1558 | , unsigned SI |
1559 | ) |
1560 | : InheritableAttr(attr::C11NoReturn, R, SI, false, false) |
1561 | { |
1562 | } |
1563 | |
1564 | C11NoReturnAttr *clone(ASTContext &C) const; |
1565 | void printPretty(raw_ostream &OS, |
1566 | const PrintingPolicy &Policy) const; |
1567 | const char *getSpelling() const; |
1568 | |
1569 | |
1570 | static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; } |
1571 | }; |
1572 | |
1573 | class CDeclAttr : public InheritableAttr { |
1574 | public: |
1575 | static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1576 | auto *A = new (Ctx) CDeclAttr(Loc, Ctx, 0); |
1577 | A->setImplicit(true); |
1578 | return A; |
1579 | } |
1580 | |
1581 | CDeclAttr(SourceRange R, ASTContext &Ctx |
1582 | , unsigned SI |
1583 | ) |
1584 | : InheritableAttr(attr::CDecl, R, SI, false, false) |
1585 | { |
1586 | } |
1587 | |
1588 | CDeclAttr *clone(ASTContext &C) const; |
1589 | void printPretty(raw_ostream &OS, |
1590 | const PrintingPolicy &Policy) const; |
1591 | const char *getSpelling() const; |
1592 | |
1593 | |
1594 | static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; } |
1595 | }; |
1596 | |
1597 | class CFAuditedTransferAttr : public InheritableAttr { |
1598 | public: |
1599 | static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1600 | auto *A = new (Ctx) CFAuditedTransferAttr(Loc, Ctx, 0); |
1601 | A->setImplicit(true); |
1602 | return A; |
1603 | } |
1604 | |
1605 | CFAuditedTransferAttr(SourceRange R, ASTContext &Ctx |
1606 | , unsigned SI |
1607 | ) |
1608 | : InheritableAttr(attr::CFAuditedTransfer, R, SI, false, false) |
1609 | { |
1610 | } |
1611 | |
1612 | CFAuditedTransferAttr *clone(ASTContext &C) const; |
1613 | void printPretty(raw_ostream &OS, |
1614 | const PrintingPolicy &Policy) const; |
1615 | const char *getSpelling() const; |
1616 | |
1617 | |
1618 | static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; } |
1619 | }; |
1620 | |
1621 | class CFConsumedAttr : public InheritableParamAttr { |
1622 | public: |
1623 | static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1624 | auto *A = new (Ctx) CFConsumedAttr(Loc, Ctx, 0); |
1625 | A->setImplicit(true); |
1626 | return A; |
1627 | } |
1628 | |
1629 | CFConsumedAttr(SourceRange R, ASTContext &Ctx |
1630 | , unsigned SI |
1631 | ) |
1632 | : InheritableParamAttr(attr::CFConsumed, R, SI, false, false) |
1633 | { |
1634 | } |
1635 | |
1636 | CFConsumedAttr *clone(ASTContext &C) const; |
1637 | void printPretty(raw_ostream &OS, |
1638 | const PrintingPolicy &Policy) const; |
1639 | const char *getSpelling() const; |
1640 | |
1641 | |
1642 | static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; } |
1643 | }; |
1644 | |
1645 | class CFReturnsNotRetainedAttr : public InheritableAttr { |
1646 | public: |
1647 | static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1648 | auto *A = new (Ctx) CFReturnsNotRetainedAttr(Loc, Ctx, 0); |
1649 | A->setImplicit(true); |
1650 | return A; |
1651 | } |
1652 | |
1653 | CFReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx |
1654 | , unsigned SI |
1655 | ) |
1656 | : InheritableAttr(attr::CFReturnsNotRetained, R, SI, false, false) |
1657 | { |
1658 | } |
1659 | |
1660 | CFReturnsNotRetainedAttr *clone(ASTContext &C) const; |
1661 | void printPretty(raw_ostream &OS, |
1662 | const PrintingPolicy &Policy) const; |
1663 | const char *getSpelling() const; |
1664 | |
1665 | |
1666 | static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; } |
1667 | }; |
1668 | |
1669 | class CFReturnsRetainedAttr : public InheritableAttr { |
1670 | public: |
1671 | static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1672 | auto *A = new (Ctx) CFReturnsRetainedAttr(Loc, Ctx, 0); |
1673 | A->setImplicit(true); |
1674 | return A; |
1675 | } |
1676 | |
1677 | CFReturnsRetainedAttr(SourceRange R, ASTContext &Ctx |
1678 | , unsigned SI |
1679 | ) |
1680 | : InheritableAttr(attr::CFReturnsRetained, R, SI, false, false) |
1681 | { |
1682 | } |
1683 | |
1684 | CFReturnsRetainedAttr *clone(ASTContext &C) const; |
1685 | void printPretty(raw_ostream &OS, |
1686 | const PrintingPolicy &Policy) const; |
1687 | const char *getSpelling() const; |
1688 | |
1689 | |
1690 | static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; } |
1691 | }; |
1692 | |
1693 | class CFUnknownTransferAttr : public InheritableAttr { |
1694 | public: |
1695 | static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1696 | auto *A = new (Ctx) CFUnknownTransferAttr(Loc, Ctx, 0); |
1697 | A->setImplicit(true); |
1698 | return A; |
1699 | } |
1700 | |
1701 | CFUnknownTransferAttr(SourceRange R, ASTContext &Ctx |
1702 | , unsigned SI |
1703 | ) |
1704 | : InheritableAttr(attr::CFUnknownTransfer, R, SI, false, false) |
1705 | { |
1706 | } |
1707 | |
1708 | CFUnknownTransferAttr *clone(ASTContext &C) const; |
1709 | void printPretty(raw_ostream &OS, |
1710 | const PrintingPolicy &Policy) const; |
1711 | const char *getSpelling() const; |
1712 | |
1713 | |
1714 | static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; } |
1715 | }; |
1716 | |
1717 | class CPUDispatchAttr : public InheritableAttr { |
1718 | unsigned cpus_Size; |
1719 | IdentifierInfo * *cpus_; |
1720 | |
1721 | public: |
1722 | static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) { |
1723 | auto *A = new (Ctx) CPUDispatchAttr(Loc, Ctx, Cpus, CpusSize, 0); |
1724 | A->setImplicit(true); |
1725 | return A; |
1726 | } |
1727 | |
1728 | CPUDispatchAttr(SourceRange R, ASTContext &Ctx |
1729 | , IdentifierInfo * *Cpus, unsigned CpusSize |
1730 | , unsigned SI |
1731 | ) |
1732 | : InheritableAttr(attr::CPUDispatch, R, SI, false, false) |
1733 | , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size]) |
1734 | { |
1735 | std::copy(Cpus, Cpus + cpus_Size, cpus_); |
1736 | } |
1737 | |
1738 | CPUDispatchAttr(SourceRange R, ASTContext &Ctx |
1739 | , unsigned SI |
1740 | ) |
1741 | : InheritableAttr(attr::CPUDispatch, R, SI, false, false) |
1742 | , cpus_Size(0), cpus_(nullptr) |
1743 | { |
1744 | } |
1745 | |
1746 | CPUDispatchAttr *clone(ASTContext &C) const; |
1747 | void printPretty(raw_ostream &OS, |
1748 | const PrintingPolicy &Policy) const; |
1749 | const char *getSpelling() const; |
1750 | typedef IdentifierInfo ** cpus_iterator; |
1751 | cpus_iterator cpus_begin() const { return cpus_; } |
1752 | cpus_iterator cpus_end() const { return cpus_ + cpus_Size; } |
1753 | unsigned cpus_size() const { return cpus_Size; } |
1754 | llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); } |
1755 | |
1756 | |
1757 | |
1758 | |
1759 | static bool classof(const Attr *A) { return A->getKind() == attr::CPUDispatch; } |
1760 | }; |
1761 | |
1762 | class CPUSpecificAttr : public InheritableAttr { |
1763 | unsigned cpus_Size; |
1764 | IdentifierInfo * *cpus_; |
1765 | |
1766 | public: |
1767 | static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) { |
1768 | auto *A = new (Ctx) CPUSpecificAttr(Loc, Ctx, Cpus, CpusSize, 0); |
1769 | A->setImplicit(true); |
1770 | return A; |
1771 | } |
1772 | |
1773 | CPUSpecificAttr(SourceRange R, ASTContext &Ctx |
1774 | , IdentifierInfo * *Cpus, unsigned CpusSize |
1775 | , unsigned SI |
1776 | ) |
1777 | : InheritableAttr(attr::CPUSpecific, R, SI, false, false) |
1778 | , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size]) |
1779 | { |
1780 | std::copy(Cpus, Cpus + cpus_Size, cpus_); |
1781 | } |
1782 | |
1783 | CPUSpecificAttr(SourceRange R, ASTContext &Ctx |
1784 | , unsigned SI |
1785 | ) |
1786 | : InheritableAttr(attr::CPUSpecific, R, SI, false, false) |
1787 | , cpus_Size(0), cpus_(nullptr) |
1788 | { |
1789 | } |
1790 | |
1791 | CPUSpecificAttr *clone(ASTContext &C) const; |
1792 | void printPretty(raw_ostream &OS, |
1793 | const PrintingPolicy &Policy) const; |
1794 | const char *getSpelling() const; |
1795 | typedef IdentifierInfo ** cpus_iterator; |
1796 | cpus_iterator cpus_begin() const { return cpus_; } |
1797 | cpus_iterator cpus_end() const { return cpus_ + cpus_Size; } |
1798 | unsigned cpus_size() const { return cpus_Size; } |
1799 | llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); } |
1800 | |
1801 | |
1802 | |
1803 | unsigned ActiveArgIndex = 0; |
1804 | |
1805 | IdentifierInfo *getCurCPUName() const { |
1806 | return *(cpus_begin() + ActiveArgIndex); |
1807 | } |
1808 | |
1809 | |
1810 | static bool classof(const Attr *A) { return A->getKind() == attr::CPUSpecific; } |
1811 | }; |
1812 | |
1813 | class CUDAConstantAttr : public InheritableAttr { |
1814 | public: |
1815 | static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1816 | auto *A = new (Ctx) CUDAConstantAttr(Loc, Ctx, 0); |
1817 | A->setImplicit(true); |
1818 | return A; |
1819 | } |
1820 | |
1821 | CUDAConstantAttr(SourceRange R, ASTContext &Ctx |
1822 | , unsigned SI |
1823 | ) |
1824 | : InheritableAttr(attr::CUDAConstant, R, SI, false, false) |
1825 | { |
1826 | } |
1827 | |
1828 | CUDAConstantAttr *clone(ASTContext &C) const; |
1829 | void printPretty(raw_ostream &OS, |
1830 | const PrintingPolicy &Policy) const; |
1831 | const char *getSpelling() const; |
1832 | |
1833 | |
1834 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; } |
1835 | }; |
1836 | |
1837 | class CUDADeviceAttr : public InheritableAttr { |
1838 | public: |
1839 | static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1840 | auto *A = new (Ctx) CUDADeviceAttr(Loc, Ctx, 0); |
1841 | A->setImplicit(true); |
1842 | return A; |
1843 | } |
1844 | |
1845 | CUDADeviceAttr(SourceRange R, ASTContext &Ctx |
1846 | , unsigned SI |
1847 | ) |
1848 | : InheritableAttr(attr::CUDADevice, R, SI, false, false) |
1849 | { |
1850 | } |
1851 | |
1852 | CUDADeviceAttr *clone(ASTContext &C) const; |
1853 | void printPretty(raw_ostream &OS, |
1854 | const PrintingPolicy &Policy) const; |
1855 | const char *getSpelling() const; |
1856 | |
1857 | |
1858 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; } |
1859 | }; |
1860 | |
1861 | class CUDAGlobalAttr : public InheritableAttr { |
1862 | public: |
1863 | static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1864 | auto *A = new (Ctx) CUDAGlobalAttr(Loc, Ctx, 0); |
1865 | A->setImplicit(true); |
1866 | return A; |
1867 | } |
1868 | |
1869 | CUDAGlobalAttr(SourceRange R, ASTContext &Ctx |
1870 | , unsigned SI |
1871 | ) |
1872 | : InheritableAttr(attr::CUDAGlobal, R, SI, false, false) |
1873 | { |
1874 | } |
1875 | |
1876 | CUDAGlobalAttr *clone(ASTContext &C) const; |
1877 | void printPretty(raw_ostream &OS, |
1878 | const PrintingPolicy &Policy) const; |
1879 | const char *getSpelling() const; |
1880 | |
1881 | |
1882 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; } |
1883 | }; |
1884 | |
1885 | class CUDAHostAttr : public InheritableAttr { |
1886 | public: |
1887 | static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1888 | auto *A = new (Ctx) CUDAHostAttr(Loc, Ctx, 0); |
1889 | A->setImplicit(true); |
1890 | return A; |
1891 | } |
1892 | |
1893 | CUDAHostAttr(SourceRange R, ASTContext &Ctx |
1894 | , unsigned SI |
1895 | ) |
1896 | : InheritableAttr(attr::CUDAHost, R, SI, false, false) |
1897 | { |
1898 | } |
1899 | |
1900 | CUDAHostAttr *clone(ASTContext &C) const; |
1901 | void printPretty(raw_ostream &OS, |
1902 | const PrintingPolicy &Policy) const; |
1903 | const char *getSpelling() const; |
1904 | |
1905 | |
1906 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; } |
1907 | }; |
1908 | |
1909 | class CUDAInvalidTargetAttr : public InheritableAttr { |
1910 | public: |
1911 | static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1912 | auto *A = new (Ctx) CUDAInvalidTargetAttr(Loc, Ctx, 0); |
1913 | A->setImplicit(true); |
1914 | return A; |
1915 | } |
1916 | |
1917 | CUDAInvalidTargetAttr(SourceRange R, ASTContext &Ctx |
1918 | , unsigned SI |
1919 | ) |
1920 | : InheritableAttr(attr::CUDAInvalidTarget, R, SI, false, false) |
1921 | { |
1922 | } |
1923 | |
1924 | CUDAInvalidTargetAttr *clone(ASTContext &C) const; |
1925 | void printPretty(raw_ostream &OS, |
1926 | const PrintingPolicy &Policy) const; |
1927 | const char *getSpelling() const; |
1928 | |
1929 | |
1930 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; } |
1931 | }; |
1932 | |
1933 | class CUDALaunchBoundsAttr : public InheritableAttr { |
1934 | Expr * maxThreads; |
1935 | |
1936 | Expr * minBlocks; |
1937 | |
1938 | public: |
1939 | static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Loc = SourceRange()) { |
1940 | auto *A = new (Ctx) CUDALaunchBoundsAttr(Loc, Ctx, MaxThreads, MinBlocks, 0); |
1941 | A->setImplicit(true); |
1942 | return A; |
1943 | } |
1944 | |
1945 | CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx |
1946 | , Expr * MaxThreads |
1947 | , Expr * MinBlocks |
1948 | , unsigned SI |
1949 | ) |
1950 | : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false) |
1951 | , maxThreads(MaxThreads) |
1952 | , minBlocks(MinBlocks) |
1953 | { |
1954 | } |
1955 | |
1956 | CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx |
1957 | , Expr * MaxThreads |
1958 | , unsigned SI |
1959 | ) |
1960 | : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false) |
1961 | , maxThreads(MaxThreads) |
1962 | , minBlocks() |
1963 | { |
1964 | } |
1965 | |
1966 | CUDALaunchBoundsAttr *clone(ASTContext &C) const; |
1967 | void printPretty(raw_ostream &OS, |
1968 | const PrintingPolicy &Policy) const; |
1969 | const char *getSpelling() const; |
1970 | Expr * getMaxThreads() const { |
1971 | return maxThreads; |
1972 | } |
1973 | |
1974 | Expr * getMinBlocks() const { |
1975 | return minBlocks; |
1976 | } |
1977 | |
1978 | |
1979 | |
1980 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; } |
1981 | }; |
1982 | |
1983 | class CUDASharedAttr : public InheritableAttr { |
1984 | public: |
1985 | static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
1986 | auto *A = new (Ctx) CUDASharedAttr(Loc, Ctx, 0); |
1987 | A->setImplicit(true); |
1988 | return A; |
1989 | } |
1990 | |
1991 | CUDASharedAttr(SourceRange R, ASTContext &Ctx |
1992 | , unsigned SI |
1993 | ) |
1994 | : InheritableAttr(attr::CUDAShared, R, SI, false, false) |
1995 | { |
1996 | } |
1997 | |
1998 | CUDASharedAttr *clone(ASTContext &C) const; |
1999 | void printPretty(raw_ostream &OS, |
2000 | const PrintingPolicy &Policy) const; |
2001 | const char *getSpelling() const; |
2002 | |
2003 | |
2004 | static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; } |
2005 | }; |
2006 | |
2007 | class CXX11NoReturnAttr : public InheritableAttr { |
2008 | public: |
2009 | static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
2010 | auto *A = new (Ctx) CXX11NoReturnAttr(Loc, Ctx, 0); |
2011 | A->setImplicit(true); |
2012 | return A; |
2013 | } |
2014 | |
2015 | CXX11NoReturnAttr(SourceRange R, ASTContext &Ctx |
2016 | , unsigned SI |
2017 | ) |
2018 | : InheritableAttr(attr::CXX11NoReturn, R, SI, false, false) |
2019 | { |
2020 | } |
2021 | |
2022 | CXX11NoReturnAttr *clone(ASTContext &C) const; |
2023 | void printPretty(raw_ostream &OS, |
2024 | const PrintingPolicy &Policy) const; |
2025 | const char *getSpelling() const; |
2026 | |
2027 | |
2028 | static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; } |
2029 | }; |
2030 | |
2031 | class CallableWhenAttr : public InheritableAttr { |
2032 | public: |
2033 | enum ConsumedState { |
2034 | Unknown, |
2035 | Consumed, |
2036 | Unconsumed |
2037 | }; |
2038 | private: |
2039 | unsigned callableStates_Size; |
2040 | ConsumedState *callableStates_; |
2041 | |
2042 | public: |
2043 | static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Loc = SourceRange()) { |
2044 | auto *A = new (Ctx) CallableWhenAttr(Loc, Ctx, CallableStates, CallableStatesSize, 0); |
2045 | A->setImplicit(true); |
2046 | return A; |
2047 | } |
2048 | |
2049 | CallableWhenAttr(SourceRange R, ASTContext &Ctx |
2050 | , ConsumedState *CallableStates, unsigned CallableStatesSize |
2051 | , unsigned SI |
2052 | ) |
2053 | : InheritableAttr(attr::CallableWhen, R, SI, false, false) |
2054 | , callableStates_Size(CallableStatesSize), callableStates_(new (Ctx, 16) ConsumedState[callableStates_Size]) |
2055 | { |
2056 | std::copy(CallableStates, CallableStates + callableStates_Size, callableStates_); |
2057 | } |
2058 | |
2059 | CallableWhenAttr(SourceRange R, ASTContext &Ctx |
2060 | , unsigned SI |
2061 | ) |
2062 | : InheritableAttr(attr::CallableWhen, R, SI, false, false) |
2063 | , callableStates_Size(0), callableStates_(nullptr) |
2064 | { |
2065 | } |
2066 | |
2067 | CallableWhenAttr *clone(ASTContext &C) const; |
2068 | void printPretty(raw_ostream &OS, |
2069 | const PrintingPolicy &Policy) const; |
2070 | const char *getSpelling() const; |
2071 | typedef ConsumedState* callableStates_iterator; |
2072 | callableStates_iterator callableStates_begin() const { return callableStates_; } |
2073 | callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; } |
2074 | unsigned callableStates_size() const { return callableStates_Size; } |
2075 | llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); } |
2076 | |
2077 | |
2078 | static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) { |
2079 | Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val) |
2080 | .Case("unknown" , CallableWhenAttr::Unknown) |
2081 | .Case("consumed" , CallableWhenAttr::Consumed) |
2082 | .Case("unconsumed" , CallableWhenAttr::Unconsumed) |
2083 | .Default(Optional<ConsumedState>()); |
2084 | if (R) { |
2085 | Out = *R; |
2086 | return true; |
2087 | } |
2088 | return false; |
2089 | } |
2090 | |
2091 | static const char *ConvertConsumedStateToStr(ConsumedState Val) { |
2092 | switch(Val) { |
2093 | case CallableWhenAttr::Unknown: return "unknown" ; |
2094 | case CallableWhenAttr::Consumed: return "consumed" ; |
2095 | case CallableWhenAttr::Unconsumed: return "unconsumed" ; |
2096 | } |
2097 | llvm_unreachable("No enumerator with that value" ); |
2098 | } |
2099 | |
2100 | |
2101 | static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; } |
2102 | }; |
2103 | |
2104 | class CapabilityAttr : public InheritableAttr { |
2105 | unsigned nameLength; |
2106 | char *name; |
2107 | |
2108 | public: |
2109 | enum Spelling { |
2110 | GNU_capability = 0, |
2111 | CXX11_clang_capability = 1, |
2112 | GNU_shared_capability = 2, |
2113 | CXX11_clang_shared_capability = 3 |
2114 | }; |
2115 | |
2116 | static CapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) { |
2117 | auto *A = new (Ctx) CapabilityAttr(Loc, Ctx, Name, S); |
2118 | A->setImplicit(true); |
2119 | return A; |
2120 | } |
2121 | |
2122 | CapabilityAttr(SourceRange R, ASTContext &Ctx |
2123 | , llvm::StringRef Name |
2124 | , unsigned SI |
2125 | ) |
2126 | : InheritableAttr(attr::Capability, R, SI, false, false) |
2127 | , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength]) |
2128 | { |
2129 | if (!Name.empty()) |
2130 | std::memcpy(name, Name.data(), nameLength); |
2131 | } |
2132 | |
2133 | CapabilityAttr *clone(ASTContext &C) const; |
2134 | void printPretty(raw_ostream &OS, |
2135 | const PrintingPolicy &Policy) const; |
2136 | const char *getSpelling() const; |
2137 | Spelling getSemanticSpelling() const { |
2138 | switch (SpellingListIndex) { |
2139 | default: llvm_unreachable("Unknown spelling list index" ); |
2140 | case 0: return GNU_capability; |
2141 | case 1: return CXX11_clang_capability; |
2142 | case 2: return GNU_shared_capability; |
2143 | case 3: return CXX11_clang_shared_capability; |
2144 | } |
2145 | } |
2146 | bool isShared() const { return SpellingListIndex == 2 || |
2147 | SpellingListIndex == 3; } |
2148 | llvm::StringRef getName() const { |
2149 | return llvm::StringRef(name, nameLength); |
2150 | } |
2151 | unsigned getNameLength() const { |
2152 | return nameLength; |
2153 | } |
2154 | void setName(ASTContext &C, llvm::StringRef S) { |
2155 | nameLength = S.size(); |
2156 | this->name = new (C, 1) char [nameLength]; |
2157 | if (!S.empty()) |
2158 | std::memcpy(this->name, S.data(), nameLength); |
2159 | } |
2160 | |
2161 | |
2162 | bool isMutex() const { return getName().equals_lower("mutex" ); } |
2163 | bool isRole() const { return getName().equals_lower("role" ); } |
2164 | |
2165 | |
2166 | static bool classof(const Attr *A) { return A->getKind() == attr::Capability; } |
2167 | }; |
2168 | |
2169 | class CapturedRecordAttr : public InheritableAttr { |
2170 | public: |
2171 | static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
2172 | auto *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0); |
2173 | A->setImplicit(true); |
2174 | return A; |
2175 | } |
2176 | |
2177 | CapturedRecordAttr(SourceRange R, ASTContext &Ctx |
2178 | , unsigned SI |
2179 | ) |
2180 | : InheritableAttr(attr::CapturedRecord, R, SI, false, false) |
2181 | { |
2182 | } |
2183 | |
2184 | CapturedRecordAttr *clone(ASTContext &C) const; |
2185 | void printPretty(raw_ostream &OS, |
2186 | const PrintingPolicy &Policy) const; |
2187 | const char *getSpelling() const; |
2188 | |
2189 | |
2190 | static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; } |
2191 | }; |
2192 | |
2193 | class CarriesDependencyAttr : public InheritableParamAttr { |
2194 | public: |
2195 | static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) { |
2196 | auto *A = new (Ctx) CarriesDependencyAttr(Loc, Ctx, 0); |
2197 | A->setImplicit(true); |
2198 | return A; |
2199 | } |
2200 | |
2201 | CarriesDependencyAttr(SourceRange R, ASTContext &Ctx |
2202 | , unsigned SI |
2203 | ) |
2204 | : InheritableParamAttr(attr::CarriesDependency, R, SI, false, false) |
2205 | { |
2206 | } |
2207 | |
2208 | CarriesDependencyAttr *clone(ASTContext &C) const; |
2209 | void printPretty(raw_ostream &OS, |
2210 | const PrintingPolicy &Policy) const; |
2211 | const char *getSpelling() const; |
2212 | |
2213 | |
2214 | static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; } |
2215 | }; |
2216 | |
2217 | class CleanupAttr : public InheritableAttr { |
2218 | FunctionDecl * functionDecl; |
2219 | |
2220 | public: |
2221 | static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Loc = SourceRange()) { |
2222 | auto *A = new (Ctx) CleanupAttr(Loc, Ctx, FunctionDecl, 0); |
2223 | A->setImplicit(true); |
2224 | return A; |
2225 | } |
2226 | |
2227 | CleanupAttr(SourceRange R, ASTContext &Ctx |
2228 | , FunctionDecl * FunctionDecl |
2229 | , unsigned SI |
2230 | ) |
2231 | : InheritableAttr(attr::Cleanup, R, SI, false, false) |
2232 | , functionDecl(FunctionDecl) |
2233 | { |
2234 | } |
2235 | |
2236 | CleanupAttr *clone(ASTContext &C) const; |
2237 | void printPretty(raw_ostream &OS, |
2238 | const PrintingPolicy &Policy) const; |
2239 | const char *getSpelling() const; |
2240 | FunctionDecl * getFunctionDecl() const { |
2241 | return functionDecl; |
2242 | } |
2243 | |
2244 | |
2245 | |
2246 | static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; } |
2247 | }; |
2248 | |
2249 | class CodeSegAttr : public InheritableAttr { |
2250 | unsigned nameLength; |
2251 | char *name; |
2252 | |
2253 | public: |
2254 | static CodeSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) { |
2255 | auto *A = new (Ctx) CodeSegAttr |
---|