Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Attribute classes' member function definitions *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 0 : AMDGPUFlatWorkGroupSizeAttr *AMDGPUFlatWorkGroupSizeAttr::clone(ASTContext &C) const {
10 0 : auto *A = new (C) AMDGPUFlatWorkGroupSizeAttr(getLocation(), C, min, max, getSpellingListIndex());
11 0 : A->Inherited = Inherited;
12 0 : A->IsPackExpansion = IsPackExpansion;
13 0 : A->Implicit = Implicit;
14 0 : return A;
15 : }
16 :
17 0 : void AMDGPUFlatWorkGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
18 0 : switch (SpellingListIndex) {
19 0 : default:
20 0 : llvm_unreachable("Unknown attribute spelling!");
21 : break;
22 0 : case 0 : {
23 0 : OS << " __attribute__((amdgpu_flat_work_group_size(" << getMin() << ", " << getMax() << ")))";
24 0 : break;
25 : }
26 0 : case 1 : {
27 0 : OS << " [[clang::amdgpu_flat_work_group_size(" << getMin() << ", " << getMax() << ")]]";
28 0 : break;
29 : }
30 : }
31 0 : }
32 :
33 1 : const char *AMDGPUFlatWorkGroupSizeAttr::getSpelling() const {
34 1 : switch (SpellingListIndex) {
35 0 : default:
36 0 : llvm_unreachable("Unknown attribute spelling!");
37 : return "(No spelling)";
38 : case 0:
39 : return "amdgpu_flat_work_group_size";
40 : case 1:
41 : return "amdgpu_flat_work_group_size";
42 : }
43 : }
44 :
45 0 : AMDGPUNumSGPRAttr *AMDGPUNumSGPRAttr::clone(ASTContext &C) const {
46 0 : auto *A = new (C) AMDGPUNumSGPRAttr(getLocation(), C, numSGPR, getSpellingListIndex());
47 0 : A->Inherited = Inherited;
48 0 : A->IsPackExpansion = IsPackExpansion;
49 0 : A->Implicit = Implicit;
50 0 : return A;
51 : }
52 :
53 0 : void AMDGPUNumSGPRAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
54 0 : switch (SpellingListIndex) {
55 0 : default:
56 0 : llvm_unreachable("Unknown attribute spelling!");
57 : break;
58 0 : case 0 : {
59 0 : OS << " __attribute__((amdgpu_num_sgpr(" << getNumSGPR() << ")))";
60 0 : break;
61 : }
62 0 : case 1 : {
63 0 : OS << " [[clang::amdgpu_num_sgpr(" << getNumSGPR() << ")]]";
64 0 : break;
65 : }
66 : }
67 0 : }
68 :
69 1 : const char *AMDGPUNumSGPRAttr::getSpelling() const {
70 1 : switch (SpellingListIndex) {
71 0 : default:
72 0 : llvm_unreachable("Unknown attribute spelling!");
73 : return "(No spelling)";
74 : case 0:
75 : return "amdgpu_num_sgpr";
76 : case 1:
77 : return "amdgpu_num_sgpr";
78 : }
79 : }
80 :
81 0 : AMDGPUNumVGPRAttr *AMDGPUNumVGPRAttr::clone(ASTContext &C) const {
82 0 : auto *A = new (C) AMDGPUNumVGPRAttr(getLocation(), C, numVGPR, getSpellingListIndex());
83 0 : A->Inherited = Inherited;
84 0 : A->IsPackExpansion = IsPackExpansion;
85 0 : A->Implicit = Implicit;
86 0 : return A;
87 : }
88 :
89 0 : void AMDGPUNumVGPRAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
90 0 : switch (SpellingListIndex) {
91 0 : default:
92 0 : llvm_unreachable("Unknown attribute spelling!");
93 : break;
94 0 : case 0 : {
95 0 : OS << " __attribute__((amdgpu_num_vgpr(" << getNumVGPR() << ")))";
96 0 : break;
97 : }
98 0 : case 1 : {
99 0 : OS << " [[clang::amdgpu_num_vgpr(" << getNumVGPR() << ")]]";
100 0 : break;
101 : }
102 : }
103 0 : }
104 :
105 1 : const char *AMDGPUNumVGPRAttr::getSpelling() const {
106 1 : switch (SpellingListIndex) {
107 0 : default:
108 0 : llvm_unreachable("Unknown attribute spelling!");
109 : return "(No spelling)";
110 : case 0:
111 : return "amdgpu_num_vgpr";
112 : case 1:
113 : return "amdgpu_num_vgpr";
114 : }
115 : }
116 :
117 0 : AMDGPUWavesPerEUAttr *AMDGPUWavesPerEUAttr::clone(ASTContext &C) const {
118 0 : auto *A = new (C) AMDGPUWavesPerEUAttr(getLocation(), C, min, max, getSpellingListIndex());
119 0 : A->Inherited = Inherited;
120 0 : A->IsPackExpansion = IsPackExpansion;
121 0 : A->Implicit = Implicit;
122 0 : return A;
123 : }
124 :
125 0 : void AMDGPUWavesPerEUAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
126 0 : switch (SpellingListIndex) {
127 0 : default:
128 0 : llvm_unreachable("Unknown attribute spelling!");
129 : break;
130 0 : case 0 : {
131 0 : OS << " __attribute__((amdgpu_waves_per_eu(" << getMin() << ", " << getMax() << ")))";
132 0 : break;
133 : }
134 0 : case 1 : {
135 0 : OS << " [[clang::amdgpu_waves_per_eu(" << getMin() << ", " << getMax() << ")]]";
136 0 : break;
137 : }
138 : }
139 0 : }
140 :
141 2 : const char *AMDGPUWavesPerEUAttr::getSpelling() const {
142 2 : switch (SpellingListIndex) {
143 0 : default:
144 0 : llvm_unreachable("Unknown attribute spelling!");
145 : return "(No spelling)";
146 : case 0:
147 : return "amdgpu_waves_per_eu";
148 : case 1:
149 : return "amdgpu_waves_per_eu";
150 : }
151 : }
152 :
153 0 : ARMInterruptAttr *ARMInterruptAttr::clone(ASTContext &C) const {
154 0 : auto *A = new (C) ARMInterruptAttr(getLocation(), C, interrupt, getSpellingListIndex());
155 0 : A->Inherited = Inherited;
156 0 : A->IsPackExpansion = IsPackExpansion;
157 0 : A->Implicit = Implicit;
158 0 : return A;
159 : }
160 :
161 0 : void ARMInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
162 0 : switch (SpellingListIndex) {
163 0 : default:
164 0 : llvm_unreachable("Unknown attribute spelling!");
165 : break;
166 0 : case 0 : {
167 0 : OS << " __attribute__((interrupt(\"" << ARMInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")))";
168 0 : break;
169 : }
170 0 : case 1 : {
171 0 : OS << " [[gnu::interrupt(\"" << ARMInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")]]";
172 0 : break;
173 : }
174 : }
175 0 : }
176 :
177 0 : const char *ARMInterruptAttr::getSpelling() const {
178 0 : switch (SpellingListIndex) {
179 0 : default:
180 0 : llvm_unreachable("Unknown attribute spelling!");
181 : return "(No spelling)";
182 : case 0:
183 : return "interrupt";
184 : case 1:
185 : return "interrupt";
186 : }
187 : }
188 :
189 0 : AVRInterruptAttr *AVRInterruptAttr::clone(ASTContext &C) const {
190 : auto *A = new (C) AVRInterruptAttr(getLocation(), C, getSpellingListIndex());
191 0 : A->Inherited = Inherited;
192 0 : A->IsPackExpansion = IsPackExpansion;
193 0 : A->Implicit = Implicit;
194 0 : return A;
195 : }
196 :
197 0 : void AVRInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
198 0 : switch (SpellingListIndex) {
199 0 : default:
200 0 : llvm_unreachable("Unknown attribute spelling!");
201 : break;
202 0 : case 0 : {
203 0 : OS << " __attribute__((interrupt))";
204 0 : break;
205 : }
206 0 : case 1 : {
207 0 : OS << " [[gnu::interrupt]]";
208 0 : break;
209 : }
210 : }
211 0 : }
212 :
213 0 : const char *AVRInterruptAttr::getSpelling() const {
214 0 : switch (SpellingListIndex) {
215 0 : default:
216 0 : llvm_unreachable("Unknown attribute spelling!");
217 : return "(No spelling)";
218 : case 0:
219 : return "interrupt";
220 : case 1:
221 : return "interrupt";
222 : }
223 : }
224 :
225 0 : AVRSignalAttr *AVRSignalAttr::clone(ASTContext &C) const {
226 : auto *A = new (C) AVRSignalAttr(getLocation(), C, getSpellingListIndex());
227 0 : A->Inherited = Inherited;
228 0 : A->IsPackExpansion = IsPackExpansion;
229 0 : A->Implicit = Implicit;
230 0 : return A;
231 : }
232 :
233 0 : void AVRSignalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
234 0 : switch (SpellingListIndex) {
235 0 : default:
236 0 : llvm_unreachable("Unknown attribute spelling!");
237 : break;
238 0 : case 0 : {
239 0 : OS << " __attribute__((signal))";
240 0 : break;
241 : }
242 0 : case 1 : {
243 0 : OS << " [[gnu::signal]]";
244 0 : break;
245 : }
246 : }
247 0 : }
248 :
249 0 : const char *AVRSignalAttr::getSpelling() const {
250 0 : switch (SpellingListIndex) {
251 0 : default:
252 0 : llvm_unreachable("Unknown attribute spelling!");
253 : return "(No spelling)";
254 : case 0:
255 : return "signal";
256 : case 1:
257 : return "signal";
258 : }
259 : }
260 :
261 911 : AbiTagAttr *AbiTagAttr::clone(ASTContext &C) const {
262 911 : auto *A = new (C) AbiTagAttr(getLocation(), C, tags_, tags_Size, getSpellingListIndex());
263 911 : A->Inherited = Inherited;
264 911 : A->IsPackExpansion = IsPackExpansion;
265 911 : A->Implicit = Implicit;
266 911 : return A;
267 : }
268 :
269 0 : void AbiTagAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
270 0 : switch (SpellingListIndex) {
271 0 : default:
272 0 : llvm_unreachable("Unknown attribute spelling!");
273 : break;
274 0 : case 0 : {
275 0 : OS << " __attribute__((abi_tag(";
276 : bool isFirst = true;
277 0 : for (const auto &Val : tags()) {
278 0 : if (isFirst) isFirst = false;
279 0 : else OS << ", ";
280 0 : OS << "\"" << Val << "\"";
281 : }
282 0 : OS << ")))";
283 0 : break;
284 : }
285 0 : case 1 : {
286 0 : OS << " [[gnu::abi_tag(";
287 : bool isFirst = true;
288 0 : for (const auto &Val : tags()) {
289 0 : if (isFirst) isFirst = false;
290 0 : else OS << ", ";
291 0 : OS << "\"" << Val << "\"";
292 : }
293 0 : OS << ")]]";
294 0 : break;
295 : }
296 : }
297 0 : }
298 :
299 0 : const char *AbiTagAttr::getSpelling() const {
300 0 : switch (SpellingListIndex) {
301 0 : default:
302 0 : llvm_unreachable("Unknown attribute spelling!");
303 : return "(No spelling)";
304 : case 0:
305 : return "abi_tag";
306 : case 1:
307 : return "abi_tag";
308 : }
309 : }
310 :
311 50 : AcquireCapabilityAttr *AcquireCapabilityAttr::clone(ASTContext &C) const {
312 50 : auto *A = new (C) AcquireCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
313 50 : A->Inherited = Inherited;
314 50 : A->IsPackExpansion = IsPackExpansion;
315 50 : A->Implicit = Implicit;
316 50 : return A;
317 : }
318 :
319 0 : void AcquireCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
320 0 : switch (SpellingListIndex) {
321 0 : default:
322 0 : llvm_unreachable("Unknown attribute spelling!");
323 : break;
324 0 : case 0 : {
325 0 : OS << " __attribute__((acquire_capability(";
326 : bool isFirst = true;
327 0 : for (const auto &Val : args()) {
328 0 : if (isFirst) isFirst = false;
329 0 : else OS << ", ";
330 0 : OS << Val;
331 : }
332 0 : OS << ")))";
333 0 : break;
334 : }
335 0 : case 1 : {
336 0 : OS << " [[clang::acquire_capability(";
337 : bool isFirst = true;
338 0 : for (const auto &Val : args()) {
339 0 : if (isFirst) isFirst = false;
340 0 : else OS << ", ";
341 0 : OS << Val;
342 : }
343 0 : OS << ")]]";
344 0 : break;
345 : }
346 0 : case 2 : {
347 0 : OS << " __attribute__((acquire_shared_capability(";
348 : bool isFirst = true;
349 0 : for (const auto &Val : args()) {
350 0 : if (isFirst) isFirst = false;
351 0 : else OS << ", ";
352 0 : OS << Val;
353 : }
354 0 : OS << ")))";
355 0 : break;
356 : }
357 0 : case 3 : {
358 0 : OS << " [[clang::acquire_shared_capability(";
359 : bool isFirst = true;
360 0 : for (const auto &Val : args()) {
361 0 : if (isFirst) isFirst = false;
362 0 : else OS << ", ";
363 0 : OS << Val;
364 : }
365 0 : OS << ")]]";
366 0 : break;
367 : }
368 0 : case 4 : {
369 0 : OS << " __attribute__((exclusive_lock_function(";
370 : bool isFirst = true;
371 0 : for (const auto &Val : args()) {
372 0 : if (isFirst) isFirst = false;
373 0 : else OS << ", ";
374 0 : OS << Val;
375 : }
376 0 : OS << ")))";
377 0 : break;
378 : }
379 0 : case 5 : {
380 0 : OS << " __attribute__((shared_lock_function(";
381 : bool isFirst = true;
382 0 : for (const auto &Val : args()) {
383 0 : if (isFirst) isFirst = false;
384 0 : else OS << ", ";
385 0 : OS << Val;
386 : }
387 0 : OS << ")))";
388 0 : break;
389 : }
390 : }
391 0 : }
392 :
393 0 : const char *AcquireCapabilityAttr::getSpelling() const {
394 0 : switch (SpellingListIndex) {
395 0 : default:
396 0 : llvm_unreachable("Unknown attribute spelling!");
397 : return "(No spelling)";
398 : case 0:
399 : return "acquire_capability";
400 : case 1:
401 : return "acquire_capability";
402 0 : case 2:
403 0 : return "acquire_shared_capability";
404 0 : case 3:
405 0 : return "acquire_shared_capability";
406 0 : case 4:
407 0 : return "exclusive_lock_function";
408 0 : case 5:
409 0 : return "shared_lock_function";
410 : }
411 : }
412 :
413 0 : AcquiredAfterAttr *AcquiredAfterAttr::clone(ASTContext &C) const {
414 0 : auto *A = new (C) AcquiredAfterAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
415 0 : A->Inherited = Inherited;
416 0 : A->IsPackExpansion = IsPackExpansion;
417 0 : A->Implicit = Implicit;
418 0 : return A;
419 : }
420 :
421 0 : void AcquiredAfterAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
422 0 : switch (SpellingListIndex) {
423 0 : default:
424 0 : llvm_unreachable("Unknown attribute spelling!");
425 : break;
426 0 : case 0 : {
427 0 : OS << " __attribute__((acquired_after(";
428 : bool isFirst = true;
429 0 : for (const auto &Val : args()) {
430 0 : if (isFirst) isFirst = false;
431 0 : else OS << ", ";
432 0 : OS << Val;
433 : }
434 0 : OS << ")))";
435 : break;
436 : }
437 : }
438 0 : }
439 :
440 0 : const char *AcquiredAfterAttr::getSpelling() const {
441 0 : switch (SpellingListIndex) {
442 0 : default:
443 0 : llvm_unreachable("Unknown attribute spelling!");
444 : return "(No spelling)";
445 0 : case 0:
446 : return "acquired_after";
447 : }
448 : }
449 :
450 0 : AcquiredBeforeAttr *AcquiredBeforeAttr::clone(ASTContext &C) const {
451 0 : auto *A = new (C) AcquiredBeforeAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
452 0 : A->Inherited = Inherited;
453 0 : A->IsPackExpansion = IsPackExpansion;
454 0 : A->Implicit = Implicit;
455 0 : return A;
456 : }
457 :
458 0 : void AcquiredBeforeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
459 0 : switch (SpellingListIndex) {
460 0 : default:
461 0 : llvm_unreachable("Unknown attribute spelling!");
462 : break;
463 0 : case 0 : {
464 0 : OS << " __attribute__((acquired_before(";
465 : bool isFirst = true;
466 0 : for (const auto &Val : args()) {
467 0 : if (isFirst) isFirst = false;
468 0 : else OS << ", ";
469 0 : OS << Val;
470 : }
471 0 : OS << ")))";
472 : break;
473 : }
474 : }
475 0 : }
476 :
477 0 : const char *AcquiredBeforeAttr::getSpelling() const {
478 0 : switch (SpellingListIndex) {
479 0 : default:
480 0 : llvm_unreachable("Unknown attribute spelling!");
481 : return "(No spelling)";
482 0 : case 0:
483 : return "acquired_before";
484 : }
485 : }
486 :
487 0 : AddressSpaceAttr *AddressSpaceAttr::clone(ASTContext &C) const {
488 0 : auto *A = new (C) AddressSpaceAttr(getLocation(), C, addressSpace, getSpellingListIndex());
489 0 : A->Inherited = Inherited;
490 0 : A->IsPackExpansion = IsPackExpansion;
491 0 : A->Implicit = Implicit;
492 0 : return A;
493 : }
494 :
495 0 : void AddressSpaceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
496 0 : switch (SpellingListIndex) {
497 0 : default:
498 0 : llvm_unreachable("Unknown attribute spelling!");
499 : break;
500 0 : case 0 : {
501 0 : OS << " __attribute__((address_space(" << getAddressSpace() << ")))";
502 0 : break;
503 : }
504 0 : case 1 : {
505 0 : OS << " [[clang::address_space(" << getAddressSpace() << ")]]";
506 0 : break;
507 : }
508 0 : case 2 : {
509 0 : OS << " [[clang::address_space(" << getAddressSpace() << ")]]";
510 0 : break;
511 : }
512 : }
513 0 : }
514 :
515 0 : const char *AddressSpaceAttr::getSpelling() const {
516 0 : switch (SpellingListIndex) {
517 0 : default:
518 0 : llvm_unreachable("Unknown attribute spelling!");
519 : return "(No spelling)";
520 : case 0:
521 : return "address_space";
522 : case 1:
523 : return "address_space";
524 : case 2:
525 : return "address_space";
526 : }
527 : }
528 :
529 0 : AliasAttr *AliasAttr::clone(ASTContext &C) const {
530 0 : auto *A = new (C) AliasAttr(getLocation(), C, getAliasee(), getSpellingListIndex());
531 0 : A->Inherited = Inherited;
532 0 : A->IsPackExpansion = IsPackExpansion;
533 0 : A->Implicit = Implicit;
534 0 : return A;
535 : }
536 :
537 0 : void AliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
538 0 : switch (SpellingListIndex) {
539 0 : default:
540 0 : llvm_unreachable("Unknown attribute spelling!");
541 : break;
542 0 : case 0 : {
543 0 : OS << " __attribute__((alias(\"" << getAliasee() << "\")))";
544 0 : break;
545 : }
546 0 : case 1 : {
547 0 : OS << " [[gnu::alias(\"" << getAliasee() << "\")]]";
548 0 : break;
549 : }
550 : }
551 0 : }
552 :
553 0 : const char *AliasAttr::getSpelling() const {
554 0 : switch (SpellingListIndex) {
555 0 : default:
556 0 : llvm_unreachable("Unknown attribute spelling!");
557 : return "(No spelling)";
558 : case 0:
559 : return "alias";
560 : case 1:
561 : return "alias";
562 : }
563 : }
564 :
565 0 : AlignMac68kAttr *AlignMac68kAttr::clone(ASTContext &C) const {
566 : auto *A = new (C) AlignMac68kAttr(getLocation(), C, getSpellingListIndex());
567 0 : A->Inherited = Inherited;
568 0 : A->IsPackExpansion = IsPackExpansion;
569 0 : A->Implicit = Implicit;
570 0 : return A;
571 : }
572 :
573 0 : void AlignMac68kAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
574 0 : }
575 :
576 0 : const char *AlignMac68kAttr::getSpelling() const {
577 0 : return "(No spelling)";
578 : }
579 :
580 0 : AlignValueAttr *AlignValueAttr::clone(ASTContext &C) const {
581 0 : auto *A = new (C) AlignValueAttr(getLocation(), C, alignment, getSpellingListIndex());
582 0 : A->Inherited = Inherited;
583 0 : A->IsPackExpansion = IsPackExpansion;
584 0 : A->Implicit = Implicit;
585 0 : return A;
586 : }
587 :
588 0 : void AlignValueAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
589 0 : switch (SpellingListIndex) {
590 0 : default:
591 0 : llvm_unreachable("Unknown attribute spelling!");
592 : break;
593 0 : case 0 : {
594 0 : OS << " __attribute__((align_value(" << getAlignment() << ")))";
595 : break;
596 : }
597 : }
598 0 : }
599 :
600 1 : const char *AlignValueAttr::getSpelling() const {
601 1 : switch (SpellingListIndex) {
602 0 : default:
603 0 : llvm_unreachable("Unknown attribute spelling!");
604 : return "(No spelling)";
605 1 : case 0:
606 : return "align_value";
607 : }
608 : }
609 :
610 23651 : bool AlignedAttr::isAlignmentDependent() const {
611 23651 : if (isalignmentExpr)
612 23651 : return alignmentExpr && (alignmentExpr->isValueDependent() || alignmentExpr->isTypeDependent());
613 : else
614 0 : return alignmentType->getType()->isDependentType();
615 : }
616 26174 : unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
617 : assert(!isAlignmentDependent());
618 26174 : if (isalignmentExpr)
619 78330 : return alignmentExpr ? alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() * Ctx.getCharWidth() : Ctx.getTargetDefaultAlignForAttributeAligned();
620 : else
621 : return 0; // FIXME
622 : }
623 4927 : AlignedAttr *AlignedAttr::clone(ASTContext &C) const {
624 4927 : auto *A = new (C) AlignedAttr(getLocation(), C, isalignmentExpr, isalignmentExpr ? static_cast<void*>(alignmentExpr) : alignmentType, getSpellingListIndex());
625 4927 : A->Inherited = Inherited;
626 4927 : A->IsPackExpansion = IsPackExpansion;
627 4927 : A->Implicit = Implicit;
628 4927 : return A;
629 : }
630 :
631 62 : void AlignedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
632 62 : switch (SpellingListIndex) {
633 0 : default:
634 0 : llvm_unreachable("Unknown attribute spelling!");
635 : break;
636 54 : case 0 : {
637 54 : OS << " __attribute__((aligned";
638 : unsigned TrailingOmittedArgs = 0;
639 54 : if (!isalignmentExpr || !alignmentExpr)
640 : ++TrailingOmittedArgs;
641 54 : OS << "";
642 54 : if (TrailingOmittedArgs < 1)
643 50 : OS << "(";
644 54 : OS << "";
645 54 : if (!(!isalignmentExpr || !alignmentExpr)) {
646 50 : OS << "";
647 100 : alignmentExpr->printPretty(OS, nullptr, Policy);
648 50 : OS << "";
649 : }
650 54 : OS << "";
651 54 : if (TrailingOmittedArgs < 1)
652 50 : OS << ")";
653 54 : OS << "))";
654 54 : break;
655 : }
656 1 : case 1 : {
657 1 : OS << " [[gnu::aligned";
658 : unsigned TrailingOmittedArgs = 0;
659 1 : if (!isalignmentExpr || !alignmentExpr)
660 : ++TrailingOmittedArgs;
661 1 : OS << "";
662 1 : if (TrailingOmittedArgs < 1)
663 1 : OS << "(";
664 1 : OS << "";
665 1 : if (!(!isalignmentExpr || !alignmentExpr)) {
666 1 : OS << "";
667 2 : alignmentExpr->printPretty(OS, nullptr, Policy);
668 1 : OS << "";
669 : }
670 1 : OS << "";
671 1 : if (TrailingOmittedArgs < 1)
672 1 : OS << ")";
673 1 : OS << "]]";
674 1 : break;
675 : }
676 3 : case 2 : {
677 3 : OS << " __declspec(align";
678 : unsigned TrailingOmittedArgs = 0;
679 3 : if (!isalignmentExpr || !alignmentExpr)
680 : ++TrailingOmittedArgs;
681 3 : OS << "";
682 3 : if (TrailingOmittedArgs < 1)
683 3 : OS << "(";
684 3 : OS << "";
685 3 : if (!(!isalignmentExpr || !alignmentExpr)) {
686 3 : OS << "";
687 6 : alignmentExpr->printPretty(OS, nullptr, Policy);
688 3 : OS << "";
689 : }
690 3 : OS << "";
691 3 : if (TrailingOmittedArgs < 1)
692 3 : OS << ")";
693 3 : OS << ")";
694 3 : break;
695 : }
696 3 : case 3 : {
697 3 : OS << " alignas";
698 : unsigned TrailingOmittedArgs = 0;
699 3 : if (!isalignmentExpr || !alignmentExpr)
700 : ++TrailingOmittedArgs;
701 3 : OS << "";
702 3 : if (TrailingOmittedArgs < 1)
703 3 : OS << "(";
704 3 : OS << "";
705 3 : if (!(!isalignmentExpr || !alignmentExpr)) {
706 3 : OS << "";
707 6 : alignmentExpr->printPretty(OS, nullptr, Policy);
708 3 : OS << "";
709 : }
710 3 : OS << "";
711 3 : if (TrailingOmittedArgs < 1)
712 3 : OS << ")";
713 3 : OS << "";
714 3 : break;
715 : }
716 1 : case 4 : {
717 1 : OS << " _Alignas";
718 : unsigned TrailingOmittedArgs = 0;
719 1 : if (!isalignmentExpr || !alignmentExpr)
720 : ++TrailingOmittedArgs;
721 1 : OS << "";
722 1 : if (TrailingOmittedArgs < 1)
723 1 : OS << "(";
724 1 : OS << "";
725 1 : if (!(!isalignmentExpr || !alignmentExpr)) {
726 1 : OS << "";
727 2 : alignmentExpr->printPretty(OS, nullptr, Policy);
728 1 : OS << "";
729 : }
730 1 : OS << "";
731 1 : if (TrailingOmittedArgs < 1)
732 1 : OS << ")";
733 1 : OS << "";
734 1 : break;
735 : }
736 : }
737 62 : }
738 :
739 47 : const char *AlignedAttr::getSpelling() const {
740 47 : switch (SpellingListIndex) {
741 0 : default:
742 0 : llvm_unreachable("Unknown attribute spelling!");
743 : return "(No spelling)";
744 : case 0:
745 : return "aligned";
746 : case 1:
747 : return "aligned";
748 0 : case 2:
749 0 : return "align";
750 26 : case 3:
751 26 : return "alignas";
752 8 : case 4:
753 8 : return "_Alignas";
754 : }
755 : }
756 :
757 0 : AllocAlignAttr *AllocAlignAttr::clone(ASTContext &C) const {
758 0 : auto *A = new (C) AllocAlignAttr(getLocation(), C, paramIndex, getSpellingListIndex());
759 0 : A->Inherited = Inherited;
760 0 : A->IsPackExpansion = IsPackExpansion;
761 0 : A->Implicit = Implicit;
762 0 : return A;
763 : }
764 :
765 4 : void AllocAlignAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
766 4 : switch (SpellingListIndex) {
767 0 : default:
768 0 : llvm_unreachable("Unknown attribute spelling!");
769 : break;
770 4 : case 0 : {
771 4 : OS << " __attribute__((alloc_align(" << getParamIndex().getSourceIndex() << ")))";
772 4 : break;
773 : }
774 0 : case 1 : {
775 0 : OS << " [[gnu::alloc_align(" << getParamIndex().getSourceIndex() << ")]]";
776 0 : break;
777 : }
778 : }
779 4 : }
780 :
781 10 : const char *AllocAlignAttr::getSpelling() const {
782 10 : switch (SpellingListIndex) {
783 0 : default:
784 0 : llvm_unreachable("Unknown attribute spelling!");
785 : return "(No spelling)";
786 : case 0:
787 : return "alloc_align";
788 : case 1:
789 : return "alloc_align";
790 : }
791 : }
792 :
793 0 : AllocSizeAttr *AllocSizeAttr::clone(ASTContext &C) const {
794 0 : auto *A = new (C) AllocSizeAttr(getLocation(), C, elemSizeParam, numElemsParam, getSpellingListIndex());
795 0 : A->Inherited = Inherited;
796 0 : A->IsPackExpansion = IsPackExpansion;
797 0 : A->Implicit = Implicit;
798 0 : return A;
799 : }
800 :
801 8 : void AllocSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
802 8 : switch (SpellingListIndex) {
803 0 : default:
804 0 : llvm_unreachable("Unknown attribute spelling!");
805 : break;
806 8 : case 0 : {
807 8 : OS << " __attribute__((alloc_size";
808 : unsigned TrailingOmittedArgs = 0;
809 16 : if (!getNumElemsParam().isValid())
810 : ++TrailingOmittedArgs;
811 8 : OS << "(" << getElemSizeParam().getSourceIndex() << "";
812 8 : if (1 < 2 - TrailingOmittedArgs)
813 4 : OS << ", ";
814 8 : OS << "";
815 16 : if (!(!getNumElemsParam().isValid())) {
816 4 : OS << "" << getNumElemsParam().getSourceIndex() << "";
817 : }
818 8 : OS << ")))";
819 8 : break;
820 : }
821 0 : case 1 : {
822 0 : OS << " [[gnu::alloc_size";
823 : unsigned TrailingOmittedArgs = 0;
824 0 : if (!getNumElemsParam().isValid())
825 : ++TrailingOmittedArgs;
826 0 : OS << "(" << getElemSizeParam().getSourceIndex() << "";
827 0 : if (1 < 2 - TrailingOmittedArgs)
828 0 : OS << ", ";
829 0 : OS << "";
830 0 : if (!(!getNumElemsParam().isValid())) {
831 0 : OS << "" << getNumElemsParam().getSourceIndex() << "";
832 : }
833 0 : OS << ")]]";
834 0 : break;
835 : }
836 : }
837 8 : }
838 :
839 0 : const char *AllocSizeAttr::getSpelling() const {
840 0 : switch (SpellingListIndex) {
841 0 : default:
842 0 : llvm_unreachable("Unknown attribute spelling!");
843 : return "(No spelling)";
844 : case 0:
845 : return "alloc_size";
846 : case 1:
847 : return "alloc_size";
848 : }
849 : }
850 :
851 0 : AlwaysDestroyAttr *AlwaysDestroyAttr::clone(ASTContext &C) const {
852 : auto *A = new (C) AlwaysDestroyAttr(getLocation(), C, getSpellingListIndex());
853 0 : A->Inherited = Inherited;
854 0 : A->IsPackExpansion = IsPackExpansion;
855 0 : A->Implicit = Implicit;
856 0 : return A;
857 : }
858 :
859 0 : void AlwaysDestroyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
860 0 : switch (SpellingListIndex) {
861 0 : default:
862 0 : llvm_unreachable("Unknown attribute spelling!");
863 : break;
864 0 : case 0 : {
865 0 : OS << " __attribute__((always_destroy))";
866 0 : break;
867 : }
868 0 : case 1 : {
869 0 : OS << " [[clang::always_destroy]]";
870 0 : break;
871 : }
872 : }
873 0 : }
874 :
875 2 : const char *AlwaysDestroyAttr::getSpelling() const {
876 2 : switch (SpellingListIndex) {
877 0 : default:
878 0 : llvm_unreachable("Unknown attribute spelling!");
879 : return "(No spelling)";
880 : case 0:
881 : return "always_destroy";
882 : case 1:
883 : return "always_destroy";
884 : }
885 : }
886 :
887 7033527 : AlwaysInlineAttr *AlwaysInlineAttr::clone(ASTContext &C) const {
888 : auto *A = new (C) AlwaysInlineAttr(getLocation(), C, getSpellingListIndex());
889 7033527 : A->Inherited = Inherited;
890 7033527 : A->IsPackExpansion = IsPackExpansion;
891 7033527 : A->Implicit = Implicit;
892 7033527 : return A;
893 : }
894 :
895 0 : void AlwaysInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
896 0 : switch (SpellingListIndex) {
897 0 : default:
898 0 : llvm_unreachable("Unknown attribute spelling!");
899 : break;
900 0 : case 0 : {
901 0 : OS << " __attribute__((always_inline))";
902 0 : break;
903 : }
904 0 : case 1 : {
905 0 : OS << " [[gnu::always_inline]]";
906 0 : break;
907 : }
908 0 : case 2 : {
909 0 : OS << " __forceinline";
910 0 : break;
911 : }
912 : }
913 0 : }
914 :
915 829915 : const char *AlwaysInlineAttr::getSpelling() const {
916 829915 : switch (SpellingListIndex) {
917 0 : default:
918 0 : llvm_unreachable("Unknown attribute spelling!");
919 : return "(No spelling)";
920 : case 0:
921 : return "always_inline";
922 : case 1:
923 : return "always_inline";
924 5 : case 2:
925 5 : return "__forceinline";
926 : }
927 : }
928 :
929 0 : AnalyzerNoReturnAttr *AnalyzerNoReturnAttr::clone(ASTContext &C) const {
930 : auto *A = new (C) AnalyzerNoReturnAttr(getLocation(), C, getSpellingListIndex());
931 0 : A->Inherited = Inherited;
932 0 : A->IsPackExpansion = IsPackExpansion;
933 0 : A->Implicit = Implicit;
934 0 : return A;
935 : }
936 :
937 0 : void AnalyzerNoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
938 0 : switch (SpellingListIndex) {
939 0 : default:
940 0 : llvm_unreachable("Unknown attribute spelling!");
941 : break;
942 0 : case 0 : {
943 0 : OS << " __attribute__((analyzer_noreturn))";
944 : break;
945 : }
946 : }
947 0 : }
948 :
949 0 : const char *AnalyzerNoReturnAttr::getSpelling() const {
950 0 : switch (SpellingListIndex) {
951 0 : default:
952 0 : llvm_unreachable("Unknown attribute spelling!");
953 : return "(No spelling)";
954 0 : case 0:
955 : return "analyzer_noreturn";
956 : }
957 : }
958 :
959 47 : AnnotateAttr *AnnotateAttr::clone(ASTContext &C) const {
960 94 : auto *A = new (C) AnnotateAttr(getLocation(), C, getAnnotation(), getSpellingListIndex());
961 47 : A->Inherited = Inherited;
962 47 : A->IsPackExpansion = IsPackExpansion;
963 47 : A->Implicit = Implicit;
964 47 : return A;
965 : }
966 :
967 0 : void AnnotateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
968 0 : switch (SpellingListIndex) {
969 0 : default:
970 0 : llvm_unreachable("Unknown attribute spelling!");
971 : break;
972 0 : case 0 : {
973 0 : OS << " __attribute__((annotate(\"" << getAnnotation() << "\")))";
974 0 : break;
975 : }
976 0 : case 1 : {
977 0 : OS << " [[clang::annotate(\"" << getAnnotation() << "\")]]";
978 0 : break;
979 : }
980 0 : case 2 : {
981 0 : OS << " [[clang::annotate(\"" << getAnnotation() << "\")]]";
982 0 : break;
983 : }
984 : }
985 0 : }
986 :
987 0 : const char *AnnotateAttr::getSpelling() const {
988 0 : switch (SpellingListIndex) {
989 0 : default:
990 0 : llvm_unreachable("Unknown attribute spelling!");
991 : return "(No spelling)";
992 : case 0:
993 : return "annotate";
994 : case 1:
995 : return "annotate";
996 : case 2:
997 : return "annotate";
998 : }
999 : }
1000 :
1001 5 : AnyX86InterruptAttr *AnyX86InterruptAttr::clone(ASTContext &C) const {
1002 : auto *A = new (C) AnyX86InterruptAttr(getLocation(), C, getSpellingListIndex());
1003 5 : A->Inherited = Inherited;
1004 5 : A->IsPackExpansion = IsPackExpansion;
1005 5 : A->Implicit = Implicit;
1006 5 : return A;
1007 : }
1008 :
1009 0 : void AnyX86InterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1010 0 : switch (SpellingListIndex) {
1011 0 : default:
1012 0 : llvm_unreachable("Unknown attribute spelling!");
1013 : break;
1014 0 : case 0 : {
1015 0 : OS << " __attribute__((interrupt))";
1016 0 : break;
1017 : }
1018 0 : case 1 : {
1019 0 : OS << " [[gnu::interrupt]]";
1020 0 : break;
1021 : }
1022 : }
1023 0 : }
1024 :
1025 0 : const char *AnyX86InterruptAttr::getSpelling() const {
1026 0 : switch (SpellingListIndex) {
1027 0 : default:
1028 0 : llvm_unreachable("Unknown attribute spelling!");
1029 : return "(No spelling)";
1030 : case 0:
1031 : return "interrupt";
1032 : case 1:
1033 : return "interrupt";
1034 : }
1035 : }
1036 :
1037 0 : AnyX86NoCallerSavedRegistersAttr *AnyX86NoCallerSavedRegistersAttr::clone(ASTContext &C) const {
1038 : auto *A = new (C) AnyX86NoCallerSavedRegistersAttr(getLocation(), C, getSpellingListIndex());
1039 0 : A->Inherited = Inherited;
1040 0 : A->IsPackExpansion = IsPackExpansion;
1041 0 : A->Implicit = Implicit;
1042 0 : return A;
1043 : }
1044 :
1045 0 : void AnyX86NoCallerSavedRegistersAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1046 0 : switch (SpellingListIndex) {
1047 0 : default:
1048 0 : llvm_unreachable("Unknown attribute spelling!");
1049 : break;
1050 0 : case 0 : {
1051 0 : OS << " __attribute__((no_caller_saved_registers))";
1052 0 : break;
1053 : }
1054 0 : case 1 : {
1055 0 : OS << " [[gnu::no_caller_saved_registers]]";
1056 0 : break;
1057 : }
1058 : }
1059 0 : }
1060 :
1061 2 : const char *AnyX86NoCallerSavedRegistersAttr::getSpelling() const {
1062 2 : switch (SpellingListIndex) {
1063 0 : default:
1064 0 : llvm_unreachable("Unknown attribute spelling!");
1065 : return "(No spelling)";
1066 : case 0:
1067 : return "no_caller_saved_registers";
1068 : case 1:
1069 : return "no_caller_saved_registers";
1070 : }
1071 : }
1072 :
1073 0 : AnyX86NoCfCheckAttr *AnyX86NoCfCheckAttr::clone(ASTContext &C) const {
1074 : auto *A = new (C) AnyX86NoCfCheckAttr(getLocation(), C, getSpellingListIndex());
1075 0 : A->Inherited = Inherited;
1076 0 : A->IsPackExpansion = IsPackExpansion;
1077 0 : A->Implicit = Implicit;
1078 0 : return A;
1079 : }
1080 :
1081 0 : void AnyX86NoCfCheckAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1082 0 : switch (SpellingListIndex) {
1083 0 : default:
1084 0 : llvm_unreachable("Unknown attribute spelling!");
1085 : break;
1086 0 : case 0 : {
1087 0 : OS << " __attribute__((nocf_check))";
1088 0 : break;
1089 : }
1090 0 : case 1 : {
1091 0 : OS << " [[gnu::nocf_check]]";
1092 0 : break;
1093 : }
1094 : }
1095 0 : }
1096 :
1097 0 : const char *AnyX86NoCfCheckAttr::getSpelling() const {
1098 0 : switch (SpellingListIndex) {
1099 0 : default:
1100 0 : llvm_unreachable("Unknown attribute spelling!");
1101 : return "(No spelling)";
1102 : case 0:
1103 : return "nocf_check";
1104 : case 1:
1105 : return "nocf_check";
1106 : }
1107 : }
1108 :
1109 0 : ArcWeakrefUnavailableAttr *ArcWeakrefUnavailableAttr::clone(ASTContext &C) const {
1110 : auto *A = new (C) ArcWeakrefUnavailableAttr(getLocation(), C, getSpellingListIndex());
1111 0 : A->Inherited = Inherited;
1112 0 : A->IsPackExpansion = IsPackExpansion;
1113 0 : A->Implicit = Implicit;
1114 0 : return A;
1115 : }
1116 :
1117 0 : void ArcWeakrefUnavailableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1118 0 : switch (SpellingListIndex) {
1119 0 : default:
1120 0 : llvm_unreachable("Unknown attribute spelling!");
1121 : break;
1122 0 : case 0 : {
1123 0 : OS << " __attribute__((objc_arc_weak_reference_unavailable))";
1124 0 : break;
1125 : }
1126 0 : case 1 : {
1127 0 : OS << " [[clang::objc_arc_weak_reference_unavailable]]";
1128 0 : break;
1129 : }
1130 0 : case 2 : {
1131 0 : OS << " [[clang::objc_arc_weak_reference_unavailable]]";
1132 0 : break;
1133 : }
1134 : }
1135 0 : }
1136 :
1137 0 : const char *ArcWeakrefUnavailableAttr::getSpelling() const {
1138 0 : switch (SpellingListIndex) {
1139 0 : default:
1140 0 : llvm_unreachable("Unknown attribute spelling!");
1141 : return "(No spelling)";
1142 : case 0:
1143 : return "objc_arc_weak_reference_unavailable";
1144 : case 1:
1145 : return "objc_arc_weak_reference_unavailable";
1146 : case 2:
1147 : return "objc_arc_weak_reference_unavailable";
1148 : }
1149 : }
1150 :
1151 0 : ArgumentWithTypeTagAttr *ArgumentWithTypeTagAttr::clone(ASTContext &C) const {
1152 0 : auto *A = new (C) ArgumentWithTypeTagAttr(getLocation(), C, argumentKind, argumentIdx, typeTagIdx, isPointer, getSpellingListIndex());
1153 0 : A->Inherited = Inherited;
1154 0 : A->IsPackExpansion = IsPackExpansion;
1155 0 : A->Implicit = Implicit;
1156 0 : return A;
1157 : }
1158 :
1159 8 : void ArgumentWithTypeTagAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1160 8 : switch (SpellingListIndex) {
1161 0 : default:
1162 0 : llvm_unreachable("Unknown attribute spelling!");
1163 : break;
1164 4 : case 0 : {
1165 8 : OS << " __attribute__((argument_with_type_tag(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getArgumentIdx().getSourceIndex() << ", " << getTypeTagIdx().getSourceIndex() << ")))";
1166 4 : break;
1167 : }
1168 0 : case 1 : {
1169 0 : OS << " [[clang::argument_with_type_tag(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getArgumentIdx().getSourceIndex() << ", " << getTypeTagIdx().getSourceIndex() << ")]]";
1170 0 : break;
1171 : }
1172 0 : case 2 : {
1173 0 : OS << " [[clang::argument_with_type_tag(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getArgumentIdx().getSourceIndex() << ", " << getTypeTagIdx().getSourceIndex() << ")]]";
1174 0 : break;
1175 : }
1176 4 : case 3 : {
1177 8 : OS << " __attribute__((pointer_with_type_tag(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getArgumentIdx().getSourceIndex() << ", " << getTypeTagIdx().getSourceIndex() << ")))";
1178 4 : break;
1179 : }
1180 0 : case 4 : {
1181 0 : OS << " [[clang::pointer_with_type_tag(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getArgumentIdx().getSourceIndex() << ", " << getTypeTagIdx().getSourceIndex() << ")]]";
1182 0 : break;
1183 : }
1184 0 : case 5 : {
1185 0 : OS << " [[clang::pointer_with_type_tag(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getArgumentIdx().getSourceIndex() << ", " << getTypeTagIdx().getSourceIndex() << ")]]";
1186 0 : break;
1187 : }
1188 : }
1189 8 : }
1190 :
1191 3 : const char *ArgumentWithTypeTagAttr::getSpelling() const {
1192 3 : switch (SpellingListIndex) {
1193 0 : default:
1194 0 : llvm_unreachable("Unknown attribute spelling!");
1195 : return "(No spelling)";
1196 : case 0:
1197 : return "argument_with_type_tag";
1198 : case 1:
1199 : return "argument_with_type_tag";
1200 : case 2:
1201 : return "argument_with_type_tag";
1202 3 : case 3:
1203 3 : return "pointer_with_type_tag";
1204 0 : case 4:
1205 0 : return "pointer_with_type_tag";
1206 0 : case 5:
1207 0 : return "pointer_with_type_tag";
1208 : }
1209 : }
1210 :
1211 0 : ArtificialAttr *ArtificialAttr::clone(ASTContext &C) const {
1212 : auto *A = new (C) ArtificialAttr(getLocation(), C, getSpellingListIndex());
1213 0 : A->Inherited = Inherited;
1214 0 : A->IsPackExpansion = IsPackExpansion;
1215 0 : A->Implicit = Implicit;
1216 0 : return A;
1217 : }
1218 :
1219 0 : void ArtificialAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1220 0 : switch (SpellingListIndex) {
1221 0 : default:
1222 0 : llvm_unreachable("Unknown attribute spelling!");
1223 : break;
1224 0 : case 0 : {
1225 0 : OS << " __attribute__((artificial))";
1226 0 : break;
1227 : }
1228 0 : case 1 : {
1229 0 : OS << " [[gnu::artificial]]";
1230 0 : break;
1231 : }
1232 : }
1233 0 : }
1234 :
1235 0 : const char *ArtificialAttr::getSpelling() const {
1236 0 : switch (SpellingListIndex) {
1237 0 : default:
1238 0 : llvm_unreachable("Unknown attribute spelling!");
1239 : return "(No spelling)";
1240 : case 0:
1241 : return "artificial";
1242 : case 1:
1243 : return "artificial";
1244 : }
1245 : }
1246 :
1247 14 : AsmLabelAttr *AsmLabelAttr::clone(ASTContext &C) const {
1248 28 : auto *A = new (C) AsmLabelAttr(getLocation(), C, getLabel(), getSpellingListIndex());
1249 14 : A->Inherited = Inherited;
1250 14 : A->IsPackExpansion = IsPackExpansion;
1251 14 : A->Implicit = Implicit;
1252 14 : return A;
1253 : }
1254 :
1255 0 : void AsmLabelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1256 0 : switch (SpellingListIndex) {
1257 0 : default:
1258 0 : llvm_unreachable("Unknown attribute spelling!");
1259 : break;
1260 0 : case 0 : {
1261 0 : OS << " asm(\"" << getLabel() << "\")";
1262 0 : break;
1263 : }
1264 0 : case 1 : {
1265 0 : OS << " __asm__(\"" << getLabel() << "\")";
1266 0 : break;
1267 : }
1268 : }
1269 0 : }
1270 :
1271 0 : const char *AsmLabelAttr::getSpelling() const {
1272 0 : switch (SpellingListIndex) {
1273 0 : default:
1274 0 : llvm_unreachable("Unknown attribute spelling!");
1275 : return "(No spelling)";
1276 : case 0:
1277 : return "asm";
1278 0 : case 1:
1279 0 : return "__asm__";
1280 : }
1281 : }
1282 :
1283 12 : AssertCapabilityAttr *AssertCapabilityAttr::clone(ASTContext &C) const {
1284 12 : auto *A = new (C) AssertCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
1285 12 : A->Inherited = Inherited;
1286 12 : A->IsPackExpansion = IsPackExpansion;
1287 12 : A->Implicit = Implicit;
1288 12 : return A;
1289 : }
1290 :
1291 0 : void AssertCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1292 0 : switch (SpellingListIndex) {
1293 0 : default:
1294 0 : llvm_unreachable("Unknown attribute spelling!");
1295 : break;
1296 0 : case 0 : {
1297 0 : OS << " __attribute__((assert_capability(";
1298 : bool isFirst = true;
1299 0 : for (const auto &Val : args()) {
1300 0 : if (isFirst) isFirst = false;
1301 0 : else OS << ", ";
1302 0 : OS << Val;
1303 : }
1304 0 : OS << ")))";
1305 0 : break;
1306 : }
1307 0 : case 1 : {
1308 0 : OS << " [[clang::assert_capability(";
1309 : bool isFirst = true;
1310 0 : for (const auto &Val : args()) {
1311 0 : if (isFirst) isFirst = false;
1312 0 : else OS << ", ";
1313 0 : OS << Val;
1314 : }
1315 0 : OS << ")]]";
1316 0 : break;
1317 : }
1318 0 : case 2 : {
1319 0 : OS << " __attribute__((assert_shared_capability(";
1320 : bool isFirst = true;
1321 0 : for (const auto &Val : args()) {
1322 0 : if (isFirst) isFirst = false;
1323 0 : else OS << ", ";
1324 0 : OS << Val;
1325 : }
1326 0 : OS << ")))";
1327 0 : break;
1328 : }
1329 0 : case 3 : {
1330 0 : OS << " [[clang::assert_shared_capability(";
1331 : bool isFirst = true;
1332 0 : for (const auto &Val : args()) {
1333 0 : if (isFirst) isFirst = false;
1334 0 : else OS << ", ";
1335 0 : OS << Val;
1336 : }
1337 0 : OS << ")]]";
1338 0 : break;
1339 : }
1340 : }
1341 0 : }
1342 :
1343 0 : const char *AssertCapabilityAttr::getSpelling() const {
1344 0 : switch (SpellingListIndex) {
1345 0 : default:
1346 0 : llvm_unreachable("Unknown attribute spelling!");
1347 : return "(No spelling)";
1348 : case 0:
1349 : return "assert_capability";
1350 : case 1:
1351 : return "assert_capability";
1352 0 : case 2:
1353 0 : return "assert_shared_capability";
1354 0 : case 3:
1355 0 : return "assert_shared_capability";
1356 : }
1357 : }
1358 :
1359 6 : AssertExclusiveLockAttr *AssertExclusiveLockAttr::clone(ASTContext &C) const {
1360 6 : auto *A = new (C) AssertExclusiveLockAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
1361 6 : A->Inherited = Inherited;
1362 6 : A->IsPackExpansion = IsPackExpansion;
1363 6 : A->Implicit = Implicit;
1364 6 : return A;
1365 : }
1366 :
1367 0 : void AssertExclusiveLockAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1368 0 : switch (SpellingListIndex) {
1369 0 : default:
1370 0 : llvm_unreachable("Unknown attribute spelling!");
1371 : break;
1372 0 : case 0 : {
1373 0 : OS << " __attribute__((assert_exclusive_lock(";
1374 : bool isFirst = true;
1375 0 : for (const auto &Val : args()) {
1376 0 : if (isFirst) isFirst = false;
1377 0 : else OS << ", ";
1378 0 : OS << Val;
1379 : }
1380 0 : OS << ")))";
1381 : break;
1382 : }
1383 : }
1384 0 : }
1385 :
1386 0 : const char *AssertExclusiveLockAttr::getSpelling() const {
1387 0 : switch (SpellingListIndex) {
1388 0 : default:
1389 0 : llvm_unreachable("Unknown attribute spelling!");
1390 : return "(No spelling)";
1391 0 : case 0:
1392 : return "assert_exclusive_lock";
1393 : }
1394 : }
1395 :
1396 6 : AssertSharedLockAttr *AssertSharedLockAttr::clone(ASTContext &C) const {
1397 6 : auto *A = new (C) AssertSharedLockAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
1398 6 : A->Inherited = Inherited;
1399 6 : A->IsPackExpansion = IsPackExpansion;
1400 6 : A->Implicit = Implicit;
1401 6 : return A;
1402 : }
1403 :
1404 0 : void AssertSharedLockAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1405 0 : switch (SpellingListIndex) {
1406 0 : default:
1407 0 : llvm_unreachable("Unknown attribute spelling!");
1408 : break;
1409 0 : case 0 : {
1410 0 : OS << " __attribute__((assert_shared_lock(";
1411 : bool isFirst = true;
1412 0 : for (const auto &Val : args()) {
1413 0 : if (isFirst) isFirst = false;
1414 0 : else OS << ", ";
1415 0 : OS << Val;
1416 : }
1417 0 : OS << ")))";
1418 : break;
1419 : }
1420 : }
1421 0 : }
1422 :
1423 0 : const char *AssertSharedLockAttr::getSpelling() const {
1424 0 : switch (SpellingListIndex) {
1425 0 : default:
1426 0 : llvm_unreachable("Unknown attribute spelling!");
1427 : return "(No spelling)";
1428 0 : case 0:
1429 : return "assert_shared_lock";
1430 : }
1431 : }
1432 :
1433 4 : AssumeAlignedAttr *AssumeAlignedAttr::clone(ASTContext &C) const {
1434 4 : auto *A = new (C) AssumeAlignedAttr(getLocation(), C, alignment, offset, getSpellingListIndex());
1435 4 : A->Inherited = Inherited;
1436 4 : A->IsPackExpansion = IsPackExpansion;
1437 4 : A->Implicit = Implicit;
1438 4 : return A;
1439 : }
1440 :
1441 0 : void AssumeAlignedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1442 0 : switch (SpellingListIndex) {
1443 0 : default:
1444 0 : llvm_unreachable("Unknown attribute spelling!");
1445 : break;
1446 0 : case 0 : {
1447 0 : OS << " __attribute__((assume_aligned(" << getAlignment() << ", " << getOffset() << ")))";
1448 0 : break;
1449 : }
1450 0 : case 1 : {
1451 0 : OS << " [[gnu::assume_aligned(" << getAlignment() << ", " << getOffset() << ")]]";
1452 0 : break;
1453 : }
1454 : }
1455 0 : }
1456 :
1457 3 : const char *AssumeAlignedAttr::getSpelling() const {
1458 3 : switch (SpellingListIndex) {
1459 0 : default:
1460 0 : llvm_unreachable("Unknown attribute spelling!");
1461 : return "(No spelling)";
1462 : case 0:
1463 : return "assume_aligned";
1464 : case 1:
1465 : return "assume_aligned";
1466 : }
1467 : }
1468 :
1469 112 : AvailabilityAttr *AvailabilityAttr::clone(ASTContext &C) const {
1470 672 : auto *A = new (C) AvailabilityAttr(getLocation(), C, platform, getIntroduced(), getDeprecated(), getObsoleted(), unavailable, getMessage(), strict, getReplacement(), getSpellingListIndex());
1471 112 : A->Inherited = Inherited;
1472 112 : A->IsPackExpansion = IsPackExpansion;
1473 112 : A->Implicit = Implicit;
1474 112 : return A;
1475 : }
1476 :
1477 6 : void AvailabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1478 6 : switch (SpellingListIndex) {
1479 0 : default:
1480 0 : llvm_unreachable("Unknown attribute spelling!");
1481 : break;
1482 6 : case 0 : {
1483 12 : OS << " __attribute__((availability(" << getPlatform()->getName();
1484 6 : if (getStrict()) OS << ", strict";
1485 6 : if (!getIntroduced().empty()) OS << ", introduced=" << getIntroduced();
1486 7 : if (!getDeprecated().empty()) OS << ", deprecated=" << getDeprecated();
1487 12 : if (!getObsoleted().empty()) OS << ", obsoleted=" << getObsoleted();
1488 6 : if (getUnavailable()) OS << ", unavailable";
1489 6 : OS << ")))";
1490 6 : break;
1491 : }
1492 0 : case 1 : {
1493 0 : OS << " [[clang::availability(" << (getPlatform() ? getPlatform()->getName() : "") << ", introduced=" << getIntroduced() << ", deprecated=" << getDeprecated() << ", obsoleted=" << getObsoleted() << ", " << getUnavailable() << ", \"" << getMessage() << "\", " << getStrict() << ", \"" << getReplacement() << "\")]]";
1494 0 : break;
1495 : }
1496 0 : case 2 : {
1497 0 : OS << " [[clang::availability(" << (getPlatform() ? getPlatform()->getName() : "") << ", introduced=" << getIntroduced() << ", deprecated=" << getDeprecated() << ", obsoleted=" << getObsoleted() << ", " << getUnavailable() << ", \"" << getMessage() << "\", " << getStrict() << ", \"" << getReplacement() << "\")]]";
1498 0 : break;
1499 : }
1500 : }
1501 6 : }
1502 :
1503 0 : const char *AvailabilityAttr::getSpelling() const {
1504 0 : switch (SpellingListIndex) {
1505 0 : default:
1506 0 : llvm_unreachable("Unknown attribute spelling!");
1507 : return "(No spelling)";
1508 : case 0:
1509 : return "availability";
1510 : case 1:
1511 : return "availability";
1512 : case 2:
1513 : return "availability";
1514 : }
1515 : }
1516 :
1517 3 : BlocksAttr *BlocksAttr::clone(ASTContext &C) const {
1518 3 : auto *A = new (C) BlocksAttr(getLocation(), C, type, getSpellingListIndex());
1519 3 : A->Inherited = Inherited;
1520 3 : A->IsPackExpansion = IsPackExpansion;
1521 3 : A->Implicit = Implicit;
1522 3 : return A;
1523 : }
1524 :
1525 2 : void BlocksAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1526 2 : switch (SpellingListIndex) {
1527 0 : default:
1528 0 : llvm_unreachable("Unknown attribute spelling!");
1529 : break;
1530 2 : case 0 : {
1531 2 : OS << " __attribute__((blocks(\"" << BlocksAttr::ConvertBlockTypeToStr(getType()) << "\")))";
1532 2 : break;
1533 : }
1534 0 : case 1 : {
1535 0 : OS << " [[clang::blocks(\"" << BlocksAttr::ConvertBlockTypeToStr(getType()) << "\")]]";
1536 0 : break;
1537 : }
1538 0 : case 2 : {
1539 0 : OS << " [[clang::blocks(\"" << BlocksAttr::ConvertBlockTypeToStr(getType()) << "\")]]";
1540 0 : break;
1541 : }
1542 : }
1543 2 : }
1544 :
1545 0 : const char *BlocksAttr::getSpelling() const {
1546 0 : switch (SpellingListIndex) {
1547 0 : default:
1548 0 : llvm_unreachable("Unknown attribute spelling!");
1549 : return "(No spelling)";
1550 : case 0:
1551 : return "blocks";
1552 : case 1:
1553 : return "blocks";
1554 : case 2:
1555 : return "blocks";
1556 : }
1557 : }
1558 :
1559 7 : C11NoReturnAttr *C11NoReturnAttr::clone(ASTContext &C) const {
1560 : auto *A = new (C) C11NoReturnAttr(getLocation(), C, getSpellingListIndex());
1561 7 : A->Inherited = Inherited;
1562 7 : A->IsPackExpansion = IsPackExpansion;
1563 7 : A->Implicit = Implicit;
1564 7 : return A;
1565 : }
1566 :
1567 0 : void C11NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1568 0 : switch (SpellingListIndex) {
1569 0 : default:
1570 0 : llvm_unreachable("Unknown attribute spelling!");
1571 : break;
1572 0 : case 0 : {
1573 0 : OS << " _Noreturn";
1574 : break;
1575 : }
1576 : }
1577 0 : }
1578 :
1579 0 : const char *C11NoReturnAttr::getSpelling() const {
1580 0 : switch (SpellingListIndex) {
1581 0 : default:
1582 0 : llvm_unreachable("Unknown attribute spelling!");
1583 : return "(No spelling)";
1584 0 : case 0:
1585 : return "_Noreturn";
1586 : }
1587 : }
1588 :
1589 0 : CDeclAttr *CDeclAttr::clone(ASTContext &C) const {
1590 : auto *A = new (C) CDeclAttr(getLocation(), C, getSpellingListIndex());
1591 0 : A->Inherited = Inherited;
1592 0 : A->IsPackExpansion = IsPackExpansion;
1593 0 : A->Implicit = Implicit;
1594 0 : return A;
1595 : }
1596 :
1597 0 : void CDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1598 0 : switch (SpellingListIndex) {
1599 0 : default:
1600 0 : llvm_unreachable("Unknown attribute spelling!");
1601 : break;
1602 0 : case 0 : {
1603 0 : OS << " __attribute__((cdecl))";
1604 0 : break;
1605 : }
1606 0 : case 1 : {
1607 0 : OS << " [[gnu::cdecl]]";
1608 0 : break;
1609 : }
1610 0 : case 2 : {
1611 0 : OS << " __cdecl";
1612 0 : break;
1613 : }
1614 0 : case 3 : {
1615 0 : OS << " _cdecl";
1616 0 : break;
1617 : }
1618 : }
1619 0 : }
1620 :
1621 0 : const char *CDeclAttr::getSpelling() const {
1622 0 : switch (SpellingListIndex) {
1623 0 : default:
1624 0 : llvm_unreachable("Unknown attribute spelling!");
1625 : return "(No spelling)";
1626 : case 0:
1627 : return "cdecl";
1628 : case 1:
1629 : return "cdecl";
1630 0 : case 2:
1631 0 : return "__cdecl";
1632 0 : case 3:
1633 0 : return "_cdecl";
1634 : }
1635 : }
1636 :
1637 0 : CFAuditedTransferAttr *CFAuditedTransferAttr::clone(ASTContext &C) const {
1638 : auto *A = new (C) CFAuditedTransferAttr(getLocation(), C, getSpellingListIndex());
1639 0 : A->Inherited = Inherited;
1640 0 : A->IsPackExpansion = IsPackExpansion;
1641 0 : A->Implicit = Implicit;
1642 0 : return A;
1643 : }
1644 :
1645 0 : void CFAuditedTransferAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1646 0 : switch (SpellingListIndex) {
1647 0 : default:
1648 0 : llvm_unreachable("Unknown attribute spelling!");
1649 : break;
1650 0 : case 0 : {
1651 0 : OS << " __attribute__((cf_audited_transfer))";
1652 0 : break;
1653 : }
1654 0 : case 1 : {
1655 0 : OS << " [[clang::cf_audited_transfer]]";
1656 0 : break;
1657 : }
1658 0 : case 2 : {
1659 0 : OS << " [[clang::cf_audited_transfer]]";
1660 0 : break;
1661 : }
1662 : }
1663 0 : }
1664 :
1665 0 : const char *CFAuditedTransferAttr::getSpelling() const {
1666 0 : switch (SpellingListIndex) {
1667 0 : default:
1668 0 : llvm_unreachable("Unknown attribute spelling!");
1669 : return "(No spelling)";
1670 : case 0:
1671 : return "cf_audited_transfer";
1672 : case 1:
1673 : return "cf_audited_transfer";
1674 : case 2:
1675 : return "cf_audited_transfer";
1676 : }
1677 : }
1678 :
1679 5 : CFConsumedAttr *CFConsumedAttr::clone(ASTContext &C) const {
1680 : auto *A = new (C) CFConsumedAttr(getLocation(), C, getSpellingListIndex());
1681 5 : A->Inherited = Inherited;
1682 5 : A->IsPackExpansion = IsPackExpansion;
1683 5 : A->Implicit = Implicit;
1684 5 : return A;
1685 : }
1686 :
1687 0 : void CFConsumedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1688 0 : switch (SpellingListIndex) {
1689 0 : default:
1690 0 : llvm_unreachable("Unknown attribute spelling!");
1691 : break;
1692 0 : case 0 : {
1693 0 : OS << " __attribute__((cf_consumed))";
1694 0 : break;
1695 : }
1696 0 : case 1 : {
1697 0 : OS << " [[clang::cf_consumed]]";
1698 0 : break;
1699 : }
1700 0 : case 2 : {
1701 0 : OS << " [[clang::cf_consumed]]";
1702 0 : break;
1703 : }
1704 : }
1705 0 : }
1706 :
1707 0 : const char *CFConsumedAttr::getSpelling() const {
1708 0 : switch (SpellingListIndex) {
1709 0 : default:
1710 0 : llvm_unreachable("Unknown attribute spelling!");
1711 : return "(No spelling)";
1712 : case 0:
1713 : return "cf_consumed";
1714 : case 1:
1715 : return "cf_consumed";
1716 : case 2:
1717 : return "cf_consumed";
1718 : }
1719 : }
1720 :
1721 5 : CFReturnsNotRetainedAttr *CFReturnsNotRetainedAttr::clone(ASTContext &C) const {
1722 : auto *A = new (C) CFReturnsNotRetainedAttr(getLocation(), C, getSpellingListIndex());
1723 5 : A->Inherited = Inherited;
1724 5 : A->IsPackExpansion = IsPackExpansion;
1725 5 : A->Implicit = Implicit;
1726 5 : return A;
1727 : }
1728 :
1729 0 : void CFReturnsNotRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1730 0 : switch (SpellingListIndex) {
1731 0 : default:
1732 0 : llvm_unreachable("Unknown attribute spelling!");
1733 : break;
1734 0 : case 0 : {
1735 0 : OS << " __attribute__((cf_returns_not_retained))";
1736 0 : break;
1737 : }
1738 0 : case 1 : {
1739 0 : OS << " [[clang::cf_returns_not_retained]]";
1740 0 : break;
1741 : }
1742 0 : case 2 : {
1743 0 : OS << " [[clang::cf_returns_not_retained]]";
1744 0 : break;
1745 : }
1746 : }
1747 0 : }
1748 :
1749 0 : const char *CFReturnsNotRetainedAttr::getSpelling() const {
1750 0 : switch (SpellingListIndex) {
1751 0 : default:
1752 0 : llvm_unreachable("Unknown attribute spelling!");
1753 : return "(No spelling)";
1754 : case 0:
1755 : return "cf_returns_not_retained";
1756 : case 1:
1757 : return "cf_returns_not_retained";
1758 : case 2:
1759 : return "cf_returns_not_retained";
1760 : }
1761 : }
1762 :
1763 15 : CFReturnsRetainedAttr *CFReturnsRetainedAttr::clone(ASTContext &C) const {
1764 : auto *A = new (C) CFReturnsRetainedAttr(getLocation(), C, getSpellingListIndex());
1765 15 : A->Inherited = Inherited;
1766 15 : A->IsPackExpansion = IsPackExpansion;
1767 15 : A->Implicit = Implicit;
1768 15 : return A;
1769 : }
1770 :
1771 0 : void CFReturnsRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1772 0 : switch (SpellingListIndex) {
1773 0 : default:
1774 0 : llvm_unreachable("Unknown attribute spelling!");
1775 : break;
1776 0 : case 0 : {
1777 0 : OS << " __attribute__((cf_returns_retained))";
1778 0 : break;
1779 : }
1780 0 : case 1 : {
1781 0 : OS << " [[clang::cf_returns_retained]]";
1782 0 : break;
1783 : }
1784 0 : case 2 : {
1785 0 : OS << " [[clang::cf_returns_retained]]";
1786 0 : break;
1787 : }
1788 : }
1789 0 : }
1790 :
1791 0 : const char *CFReturnsRetainedAttr::getSpelling() const {
1792 0 : switch (SpellingListIndex) {
1793 0 : default:
1794 0 : llvm_unreachable("Unknown attribute spelling!");
1795 : return "(No spelling)";
1796 : case 0:
1797 : return "cf_returns_retained";
1798 : case 1:
1799 : return "cf_returns_retained";
1800 : case 2:
1801 : return "cf_returns_retained";
1802 : }
1803 : }
1804 :
1805 0 : CFUnknownTransferAttr *CFUnknownTransferAttr::clone(ASTContext &C) const {
1806 : auto *A = new (C) CFUnknownTransferAttr(getLocation(), C, getSpellingListIndex());
1807 0 : A->Inherited = Inherited;
1808 0 : A->IsPackExpansion = IsPackExpansion;
1809 0 : A->Implicit = Implicit;
1810 0 : return A;
1811 : }
1812 :
1813 0 : void CFUnknownTransferAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1814 0 : switch (SpellingListIndex) {
1815 0 : default:
1816 0 : llvm_unreachable("Unknown attribute spelling!");
1817 : break;
1818 0 : case 0 : {
1819 0 : OS << " __attribute__((cf_unknown_transfer))";
1820 0 : break;
1821 : }
1822 0 : case 1 : {
1823 0 : OS << " [[clang::cf_unknown_transfer]]";
1824 0 : break;
1825 : }
1826 0 : case 2 : {
1827 0 : OS << " [[clang::cf_unknown_transfer]]";
1828 0 : break;
1829 : }
1830 : }
1831 0 : }
1832 :
1833 0 : const char *CFUnknownTransferAttr::getSpelling() const {
1834 0 : switch (SpellingListIndex) {
1835 0 : default:
1836 0 : llvm_unreachable("Unknown attribute spelling!");
1837 : return "(No spelling)";
1838 : case 0:
1839 : return "cf_unknown_transfer";
1840 : case 1:
1841 : return "cf_unknown_transfer";
1842 : case 2:
1843 : return "cf_unknown_transfer";
1844 : }
1845 : }
1846 :
1847 0 : CPUDispatchAttr *CPUDispatchAttr::clone(ASTContext &C) const {
1848 0 : auto *A = new (C) CPUDispatchAttr(getLocation(), C, cpus_, cpus_Size, getSpellingListIndex());
1849 0 : A->Inherited = Inherited;
1850 0 : A->IsPackExpansion = IsPackExpansion;
1851 0 : A->Implicit = Implicit;
1852 0 : return A;
1853 : }
1854 :
1855 0 : void CPUDispatchAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1856 0 : switch (SpellingListIndex) {
1857 0 : default:
1858 0 : llvm_unreachable("Unknown attribute spelling!");
1859 : break;
1860 0 : case 0 : {
1861 0 : OS << " __attribute__((cpu_dispatch(";
1862 : bool isFirst = true;
1863 0 : for (const auto &Val : cpus()) {
1864 0 : if (isFirst) isFirst = false;
1865 0 : else OS << ", ";
1866 0 : OS << Val;
1867 : }
1868 0 : OS << ")))";
1869 0 : break;
1870 : }
1871 0 : case 1 : {
1872 0 : OS << " [[clang::cpu_dispatch(";
1873 : bool isFirst = true;
1874 0 : for (const auto &Val : cpus()) {
1875 0 : if (isFirst) isFirst = false;
1876 0 : else OS << ", ";
1877 0 : OS << Val;
1878 : }
1879 0 : OS << ")]]";
1880 0 : break;
1881 : }
1882 0 : case 2 : {
1883 0 : OS << " [[clang::cpu_dispatch(";
1884 : bool isFirst = true;
1885 0 : for (const auto &Val : cpus()) {
1886 0 : if (isFirst) isFirst = false;
1887 0 : else OS << ", ";
1888 0 : OS << Val;
1889 : }
1890 0 : OS << ")]]";
1891 0 : break;
1892 : }
1893 : }
1894 0 : }
1895 :
1896 0 : const char *CPUDispatchAttr::getSpelling() const {
1897 0 : switch (SpellingListIndex) {
1898 0 : default:
1899 0 : llvm_unreachable("Unknown attribute spelling!");
1900 : return "(No spelling)";
1901 : case 0:
1902 : return "cpu_dispatch";
1903 : case 1:
1904 : return "cpu_dispatch";
1905 : case 2:
1906 : return "cpu_dispatch";
1907 : }
1908 : }
1909 :
1910 0 : CPUSpecificAttr *CPUSpecificAttr::clone(ASTContext &C) const {
1911 0 : auto *A = new (C) CPUSpecificAttr(getLocation(), C, cpus_, cpus_Size, getSpellingListIndex());
1912 0 : A->Inherited = Inherited;
1913 0 : A->IsPackExpansion = IsPackExpansion;
1914 0 : A->Implicit = Implicit;
1915 0 : return A;
1916 : }
1917 :
1918 0 : void CPUSpecificAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1919 0 : switch (SpellingListIndex) {
1920 0 : default:
1921 0 : llvm_unreachable("Unknown attribute spelling!");
1922 : break;
1923 0 : case 0 : {
1924 0 : OS << " __attribute__((cpu_specific(";
1925 : bool isFirst = true;
1926 0 : for (const auto &Val : cpus()) {
1927 0 : if (isFirst) isFirst = false;
1928 0 : else OS << ", ";
1929 0 : OS << Val;
1930 : }
1931 0 : OS << ")))";
1932 0 : break;
1933 : }
1934 0 : case 1 : {
1935 0 : OS << " [[clang::cpu_specific(";
1936 : bool isFirst = true;
1937 0 : for (const auto &Val : cpus()) {
1938 0 : if (isFirst) isFirst = false;
1939 0 : else OS << ", ";
1940 0 : OS << Val;
1941 : }
1942 0 : OS << ")]]";
1943 0 : break;
1944 : }
1945 0 : case 2 : {
1946 0 : OS << " [[clang::cpu_specific(";
1947 : bool isFirst = true;
1948 0 : for (const auto &Val : cpus()) {
1949 0 : if (isFirst) isFirst = false;
1950 0 : else OS << ", ";
1951 0 : OS << Val;
1952 : }
1953 0 : OS << ")]]";
1954 0 : break;
1955 : }
1956 : }
1957 0 : }
1958 :
1959 0 : const char *CPUSpecificAttr::getSpelling() const {
1960 0 : switch (SpellingListIndex) {
1961 0 : default:
1962 0 : llvm_unreachable("Unknown attribute spelling!");
1963 : return "(No spelling)";
1964 : case 0:
1965 : return "cpu_specific";
1966 : case 1:
1967 : return "cpu_specific";
1968 : case 2:
1969 : return "cpu_specific";
1970 : }
1971 : }
1972 :
1973 0 : CUDAConstantAttr *CUDAConstantAttr::clone(ASTContext &C) const {
1974 : auto *A = new (C) CUDAConstantAttr(getLocation(), C, getSpellingListIndex());
1975 0 : A->Inherited = Inherited;
1976 0 : A->IsPackExpansion = IsPackExpansion;
1977 0 : A->Implicit = Implicit;
1978 0 : return A;
1979 : }
1980 :
1981 0 : void CUDAConstantAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
1982 0 : switch (SpellingListIndex) {
1983 0 : default:
1984 0 : llvm_unreachable("Unknown attribute spelling!");
1985 : break;
1986 0 : case 0 : {
1987 0 : OS << " __attribute__((constant))";
1988 0 : break;
1989 : }
1990 0 : case 1 : {
1991 0 : OS << " __declspec(__constant__)";
1992 0 : break;
1993 : }
1994 : }
1995 0 : }
1996 :
1997 4 : const char *CUDAConstantAttr::getSpelling() const {
1998 4 : switch (SpellingListIndex) {
1999 0 : default:
2000 0 : llvm_unreachable("Unknown attribute spelling!");
2001 : return "(No spelling)";
2002 : case 0:
2003 : return "constant";
2004 0 : case 1:
2005 0 : return "__constant__";
2006 : }
2007 : }
2008 :
2009 129 : CUDADeviceAttr *CUDADeviceAttr::clone(ASTContext &C) const {
2010 : auto *A = new (C) CUDADeviceAttr(getLocation(), C, getSpellingListIndex());
2011 129 : A->Inherited = Inherited;
2012 129 : A->IsPackExpansion = IsPackExpansion;
2013 129 : A->Implicit = Implicit;
2014 129 : return A;
2015 : }
2016 :
2017 0 : void CUDADeviceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2018 0 : switch (SpellingListIndex) {
2019 0 : default:
2020 0 : llvm_unreachable("Unknown attribute spelling!");
2021 : break;
2022 0 : case 0 : {
2023 0 : OS << " __attribute__((device))";
2024 0 : break;
2025 : }
2026 0 : case 1 : {
2027 0 : OS << " __declspec(__device__)";
2028 0 : break;
2029 : }
2030 : }
2031 0 : }
2032 :
2033 2 : const char *CUDADeviceAttr::getSpelling() const {
2034 2 : switch (SpellingListIndex) {
2035 0 : default:
2036 0 : llvm_unreachable("Unknown attribute spelling!");
2037 : return "(No spelling)";
2038 : case 0:
2039 : return "device";
2040 0 : case 1:
2041 0 : return "__device__";
2042 : }
2043 : }
2044 :
2045 12 : CUDAGlobalAttr *CUDAGlobalAttr::clone(ASTContext &C) const {
2046 : auto *A = new (C) CUDAGlobalAttr(getLocation(), C, getSpellingListIndex());
2047 12 : A->Inherited = Inherited;
2048 12 : A->IsPackExpansion = IsPackExpansion;
2049 12 : A->Implicit = Implicit;
2050 12 : return A;
2051 : }
2052 :
2053 0 : void CUDAGlobalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2054 0 : switch (SpellingListIndex) {
2055 0 : default:
2056 0 : llvm_unreachable("Unknown attribute spelling!");
2057 : break;
2058 0 : case 0 : {
2059 0 : OS << " __attribute__((global))";
2060 0 : break;
2061 : }
2062 0 : case 1 : {
2063 0 : OS << " __declspec(__global__)";
2064 0 : break;
2065 : }
2066 : }
2067 0 : }
2068 :
2069 4 : const char *CUDAGlobalAttr::getSpelling() const {
2070 4 : switch (SpellingListIndex) {
2071 0 : default:
2072 0 : llvm_unreachable("Unknown attribute spelling!");
2073 : return "(No spelling)";
2074 : case 0:
2075 : return "global";
2076 0 : case 1:
2077 0 : return "__global__";
2078 : }
2079 : }
2080 :
2081 113 : CUDAHostAttr *CUDAHostAttr::clone(ASTContext &C) const {
2082 : auto *A = new (C) CUDAHostAttr(getLocation(), C, getSpellingListIndex());
2083 113 : A->Inherited = Inherited;
2084 113 : A->IsPackExpansion = IsPackExpansion;
2085 113 : A->Implicit = Implicit;
2086 113 : return A;
2087 : }
2088 :
2089 0 : void CUDAHostAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2090 0 : switch (SpellingListIndex) {
2091 0 : default:
2092 0 : llvm_unreachable("Unknown attribute spelling!");
2093 : break;
2094 0 : case 0 : {
2095 0 : OS << " __attribute__((host))";
2096 0 : break;
2097 : }
2098 0 : case 1 : {
2099 0 : OS << " __declspec(__host__)";
2100 0 : break;
2101 : }
2102 : }
2103 0 : }
2104 :
2105 2 : const char *CUDAHostAttr::getSpelling() const {
2106 2 : switch (SpellingListIndex) {
2107 0 : default:
2108 0 : llvm_unreachable("Unknown attribute spelling!");
2109 : return "(No spelling)";
2110 : case 0:
2111 : return "host";
2112 0 : case 1:
2113 0 : return "__host__";
2114 : }
2115 : }
2116 :
2117 0 : CUDAInvalidTargetAttr *CUDAInvalidTargetAttr::clone(ASTContext &C) const {
2118 : auto *A = new (C) CUDAInvalidTargetAttr(getLocation(), C, getSpellingListIndex());
2119 0 : A->Inherited = Inherited;
2120 0 : A->IsPackExpansion = IsPackExpansion;
2121 0 : A->Implicit = Implicit;
2122 0 : return A;
2123 : }
2124 :
2125 0 : void CUDAInvalidTargetAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2126 0 : }
2127 :
2128 0 : const char *CUDAInvalidTargetAttr::getSpelling() const {
2129 0 : return "(No spelling)";
2130 : }
2131 :
2132 0 : CUDALaunchBoundsAttr *CUDALaunchBoundsAttr::clone(ASTContext &C) const {
2133 0 : auto *A = new (C) CUDALaunchBoundsAttr(getLocation(), C, maxThreads, minBlocks, getSpellingListIndex());
2134 0 : A->Inherited = Inherited;
2135 0 : A->IsPackExpansion = IsPackExpansion;
2136 0 : A->Implicit = Implicit;
2137 0 : return A;
2138 : }
2139 :
2140 0 : void CUDALaunchBoundsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2141 0 : switch (SpellingListIndex) {
2142 0 : default:
2143 0 : llvm_unreachable("Unknown attribute spelling!");
2144 : break;
2145 0 : case 0 : {
2146 0 : OS << " __attribute__((launch_bounds(" << getMaxThreads() << ", " << getMinBlocks() << ")))";
2147 0 : break;
2148 : }
2149 0 : case 1 : {
2150 0 : OS << " __declspec(__launch_bounds__(" << getMaxThreads() << ", " << getMinBlocks() << "))";
2151 0 : break;
2152 : }
2153 : }
2154 0 : }
2155 :
2156 7 : const char *CUDALaunchBoundsAttr::getSpelling() const {
2157 7 : switch (SpellingListIndex) {
2158 0 : default:
2159 0 : llvm_unreachable("Unknown attribute spelling!");
2160 : return "(No spelling)";
2161 : case 0:
2162 : return "launch_bounds";
2163 0 : case 1:
2164 0 : return "__launch_bounds__";
2165 : }
2166 : }
2167 :
2168 2 : CUDASharedAttr *CUDASharedAttr::clone(ASTContext &C) const {
2169 : auto *A = new (C) CUDASharedAttr(getLocation(), C, getSpellingListIndex());
2170 2 : A->Inherited = Inherited;
2171 2 : A->IsPackExpansion = IsPackExpansion;
2172 2 : A->Implicit = Implicit;
2173 2 : return A;
2174 : }
2175 :
2176 0 : void CUDASharedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2177 0 : switch (SpellingListIndex) {
2178 0 : default:
2179 0 : llvm_unreachable("Unknown attribute spelling!");
2180 : break;
2181 0 : case 0 : {
2182 0 : OS << " __attribute__((shared))";
2183 0 : break;
2184 : }
2185 0 : case 1 : {
2186 0 : OS << " __declspec(__shared__)";
2187 0 : break;
2188 : }
2189 : }
2190 0 : }
2191 :
2192 2 : const char *CUDASharedAttr::getSpelling() const {
2193 2 : switch (SpellingListIndex) {
2194 0 : default:
2195 0 : llvm_unreachable("Unknown attribute spelling!");
2196 : return "(No spelling)";
2197 : case 0:
2198 : return "shared";
2199 0 : case 1:
2200 0 : return "__shared__";
2201 : }
2202 : }
2203 :
2204 25540 : CXX11NoReturnAttr *CXX11NoReturnAttr::clone(ASTContext &C) const {
2205 : auto *A = new (C) CXX11NoReturnAttr(getLocation(), C, getSpellingListIndex());
2206 25540 : A->Inherited = Inherited;
2207 25540 : A->IsPackExpansion = IsPackExpansion;
2208 25540 : A->Implicit = Implicit;
2209 25540 : return A;
2210 : }
2211 :
2212 1 : void CXX11NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2213 1 : switch (SpellingListIndex) {
2214 0 : default:
2215 0 : llvm_unreachable("Unknown attribute spelling!");
2216 : break;
2217 1 : case 0 : {
2218 1 : OS << " [[noreturn]]";
2219 : break;
2220 : }
2221 : }
2222 1 : }
2223 :
2224 0 : const char *CXX11NoReturnAttr::getSpelling() const {
2225 0 : switch (SpellingListIndex) {
2226 0 : default:
2227 0 : llvm_unreachable("Unknown attribute spelling!");
2228 : return "(No spelling)";
2229 0 : case 0:
2230 : return "noreturn";
2231 : }
2232 : }
2233 :
2234 6 : CallableWhenAttr *CallableWhenAttr::clone(ASTContext &C) const {
2235 6 : auto *A = new (C) CallableWhenAttr(getLocation(), C, callableStates_, callableStates_Size, getSpellingListIndex());
2236 6 : A->Inherited = Inherited;
2237 6 : A->IsPackExpansion = IsPackExpansion;
2238 6 : A->Implicit = Implicit;
2239 6 : return A;
2240 : }
2241 :
2242 1 : void CallableWhenAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2243 1 : switch (SpellingListIndex) {
2244 0 : default:
2245 0 : llvm_unreachable("Unknown attribute spelling!");
2246 : break;
2247 1 : case 0 : {
2248 1 : OS << " __attribute__((callable_when(";
2249 : bool isFirst = true;
2250 3 : for (const auto &Val : callableStates()) {
2251 2 : if (isFirst) isFirst = false;
2252 1 : else OS << ", ";
2253 4 : OS << "\"" << CallableWhenAttr::ConvertConsumedStateToStr(Val)<< "\"";
2254 : }
2255 1 : OS << ")))";
2256 1 : break;
2257 : }
2258 0 : case 1 : {
2259 0 : OS << " [[clang::callable_when(";
2260 : bool isFirst = true;
2261 0 : for (const auto &Val : callableStates()) {
2262 0 : if (isFirst) isFirst = false;
2263 0 : else OS << ", ";
2264 0 : OS << "\"" << CallableWhenAttr::ConvertConsumedStateToStr(Val)<< "\"";
2265 : }
2266 0 : OS << ")]]";
2267 0 : break;
2268 : }
2269 : }
2270 1 : }
2271 :
2272 0 : const char *CallableWhenAttr::getSpelling() const {
2273 0 : switch (SpellingListIndex) {
2274 0 : default:
2275 0 : llvm_unreachable("Unknown attribute spelling!");
2276 : return "(No spelling)";
2277 : case 0:
2278 : return "callable_when";
2279 : case 1:
2280 : return "callable_when";
2281 : }
2282 : }
2283 :
2284 0 : CapabilityAttr *CapabilityAttr::clone(ASTContext &C) const {
2285 0 : auto *A = new (C) CapabilityAttr(getLocation(), C, getName(), getSpellingListIndex());
2286 0 : A->Inherited = Inherited;
2287 0 : A->IsPackExpansion = IsPackExpansion;
2288 0 : A->Implicit = Implicit;
2289 0 : return A;
2290 : }
2291 :
2292 0 : void CapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2293 0 : switch (SpellingListIndex) {
2294 0 : default:
2295 0 : llvm_unreachable("Unknown attribute spelling!");
2296 : break;
2297 0 : case 0 : {
2298 0 : OS << " __attribute__((capability(\"" << getName() << "\")))";
2299 0 : break;
2300 : }
2301 0 : case 1 : {
2302 0 : OS << " [[clang::capability(\"" << getName() << "\")]]";
2303 0 : break;
2304 : }
2305 0 : case 2 : {
2306 0 : OS << " __attribute__((shared_capability(\"" << getName() << "\")))";
2307 0 : break;
2308 : }
2309 0 : case 3 : {
2310 0 : OS << " [[clang::shared_capability(\"" << getName() << "\")]]";
2311 0 : break;
2312 : }
2313 : }
2314 0 : }
2315 :
2316 1 : const char *CapabilityAttr::getSpelling() const {
2317 1 : switch (SpellingListIndex) {
2318 0 : default:
2319 0 : llvm_unreachable("Unknown attribute spelling!");
2320 : return "(No spelling)";
2321 : case 0:
2322 : return "capability";
2323 : case 1:
2324 : return "capability";
2325 0 : case 2:
2326 0 : return "shared_capability";
2327 0 : case 3:
2328 0 : return "shared_capability";
2329 : }
2330 : }
2331 :
2332 0 : CapturedRecordAttr *CapturedRecordAttr::clone(ASTContext &C) const {
2333 : auto *A = new (C) CapturedRecordAttr(getLocation(), C, getSpellingListIndex());
2334 0 : A->Inherited = Inherited;
2335 0 : A->IsPackExpansion = IsPackExpansion;
2336 0 : A->Implicit = Implicit;
2337 0 : return A;
2338 : }
2339 :
2340 0 : void CapturedRecordAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2341 0 : }
2342 :
2343 0 : const char *CapturedRecordAttr::getSpelling() const {
2344 0 : return "(No spelling)";
2345 : }
2346 :
2347 5 : CarriesDependencyAttr *CarriesDependencyAttr::clone(ASTContext &C) const {
2348 : auto *A = new (C) CarriesDependencyAttr(getLocation(), C, getSpellingListIndex());
2349 5 : A->Inherited = Inherited;
2350 5 : A->IsPackExpansion = IsPackExpansion;
2351 5 : A->Implicit = Implicit;
2352 5 : return A;
2353 : }
2354 :
2355 0 : void CarriesDependencyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2356 0 : switch (SpellingListIndex) {
2357 0 : default:
2358 0 : llvm_unreachable("Unknown attribute spelling!");
2359 : break;
2360 0 : case 0 : {
2361 0 : OS << " __attribute__((carries_dependency))";
2362 0 : break;
2363 : }
2364 0 : case 1 : {
2365 0 : OS << " [[carries_dependency]]";
2366 0 : break;
2367 : }
2368 : }
2369 0 : }
2370 :
2371 0 : const char *CarriesDependencyAttr::getSpelling() const {
2372 0 : switch (SpellingListIndex) {
2373 0 : default:
2374 0 : llvm_unreachable("Unknown attribute spelling!");
2375 : return "(No spelling)";
2376 : case 0:
2377 : return "carries_dependency";
2378 : case 1:
2379 : return "carries_dependency";
2380 : }
2381 : }
2382 :
2383 0 : CleanupAttr *CleanupAttr::clone(ASTContext &C) const {
2384 0 : auto *A = new (C) CleanupAttr(getLocation(), C, functionDecl, getSpellingListIndex());
2385 0 : A->Inherited = Inherited;
2386 0 : A->IsPackExpansion = IsPackExpansion;
2387 0 : A->Implicit = Implicit;
2388 0 : return A;
2389 : }
2390 :
2391 0 : void CleanupAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2392 0 : switch (SpellingListIndex) {
2393 0 : default:
2394 0 : llvm_unreachable("Unknown attribute spelling!");
2395 : break;
2396 0 : case 0 : {
2397 0 : OS << " __attribute__((cleanup(" << getFunctionDecl()->getNameInfo().getAsString() << ")))";
2398 0 : break;
2399 : }
2400 0 : case 1 : {
2401 0 : OS << " [[gnu::cleanup(" << getFunctionDecl()->getNameInfo().getAsString() << ")]]";
2402 0 : break;
2403 : }
2404 : }
2405 0 : }
2406 :
2407 0 : const char *CleanupAttr::getSpelling() const {
2408 0 : switch (SpellingListIndex) {
2409 0 : default:
2410 0 : llvm_unreachable("Unknown attribute spelling!");
2411 : return "(No spelling)";
2412 : case 0:
2413 : return "cleanup";
2414 : case 1:
2415 : return "cleanup";
2416 : }
2417 : }
2418 :
2419 120 : CodeSegAttr *CodeSegAttr::clone(ASTContext &C) const {
2420 240 : auto *A = new (C) CodeSegAttr(getLocation(), C, getName(), getSpellingListIndex());
2421 120 : A->Inherited = Inherited;
2422 120 : A->IsPackExpansion = IsPackExpansion;
2423 120 : A->Implicit = Implicit;
2424 120 : return A;
2425 : }
2426 :
2427 0 : void CodeSegAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2428 0 : switch (SpellingListIndex) {
2429 0 : default:
2430 0 : llvm_unreachable("Unknown attribute spelling!");
2431 : break;
2432 0 : case 0 : {
2433 0 : OS << " __declspec(code_seg(\"" << getName() << "\"))";
2434 : break;
2435 : }
2436 : }
2437 0 : }
2438 :
2439 0 : const char *CodeSegAttr::getSpelling() const {
2440 0 : switch (SpellingListIndex) {
2441 0 : default:
2442 0 : llvm_unreachable("Unknown attribute spelling!");
2443 : return "(No spelling)";
2444 0 : case 0:
2445 : return "code_seg";
2446 : }
2447 : }
2448 :
2449 1 : ColdAttr *ColdAttr::clone(ASTContext &C) const {
2450 : auto *A = new (C) ColdAttr(getLocation(), C, getSpellingListIndex());
2451 1 : A->Inherited = Inherited;
2452 1 : A->IsPackExpansion = IsPackExpansion;
2453 1 : A->Implicit = Implicit;
2454 1 : return A;
2455 : }
2456 :
2457 12 : void ColdAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2458 12 : switch (SpellingListIndex) {
2459 0 : default:
2460 0 : llvm_unreachable("Unknown attribute spelling!");
2461 : break;
2462 12 : case 0 : {
2463 12 : OS << " __attribute__((cold))";
2464 12 : break;
2465 : }
2466 0 : case 1 : {
2467 0 : OS << " [[gnu::cold]]";
2468 0 : break;
2469 : }
2470 : }
2471 12 : }
2472 :
2473 1 : const char *ColdAttr::getSpelling() const {
2474 1 : switch (SpellingListIndex) {
2475 0 : default:
2476 0 : llvm_unreachable("Unknown attribute spelling!");
2477 : return "(No spelling)";
2478 : case 0:
2479 : return "cold";
2480 : case 1:
2481 : return "cold";
2482 : }
2483 : }
2484 :
2485 0 : CommonAttr *CommonAttr::clone(ASTContext &C) const {
2486 : auto *A = new (C) CommonAttr(getLocation(), C, getSpellingListIndex());
2487 0 : A->Inherited = Inherited;
2488 0 : A->IsPackExpansion = IsPackExpansion;
2489 0 : A->Implicit = Implicit;
2490 0 : return A;
2491 : }
2492 :
2493 0 : void CommonAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2494 0 : switch (SpellingListIndex) {
2495 0 : default:
2496 0 : llvm_unreachable("Unknown attribute spelling!");
2497 : break;
2498 0 : case 0 : {
2499 0 : OS << " __attribute__((common))";
2500 0 : break;
2501 : }
2502 0 : case 1 : {
2503 0 : OS << " [[gnu::common]]";
2504 0 : break;
2505 : }
2506 : }
2507 0 : }
2508 :
2509 5 : const char *CommonAttr::getSpelling() const {
2510 5 : switch (SpellingListIndex) {
2511 0 : default:
2512 0 : llvm_unreachable("Unknown attribute spelling!");
2513 : return "(No spelling)";
2514 : case 0:
2515 : return "common";
2516 : case 1:
2517 : return "common";
2518 : }
2519 : }
2520 :
2521 1004 : ConstAttr *ConstAttr::clone(ASTContext &C) const {
2522 : auto *A = new (C) ConstAttr(getLocation(), C, getSpellingListIndex());
2523 1004 : A->Inherited = Inherited;
2524 1004 : A->IsPackExpansion = IsPackExpansion;
2525 1004 : A->Implicit = Implicit;
2526 1004 : return A;
2527 : }
2528 :
2529 6 : void ConstAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2530 6 : switch (SpellingListIndex) {
2531 0 : default:
2532 0 : llvm_unreachable("Unknown attribute spelling!");
2533 : break;
2534 3 : case 0 : {
2535 3 : OS << " __attribute__((const))";
2536 3 : break;
2537 : }
2538 0 : case 1 : {
2539 0 : OS << " [[gnu::const]]";
2540 0 : break;
2541 : }
2542 3 : case 2 : {
2543 3 : OS << " __attribute__((__const))";
2544 3 : break;
2545 : }
2546 0 : case 3 : {
2547 0 : OS << " [[gnu::__const]]";
2548 0 : break;
2549 : }
2550 : }
2551 6 : }
2552 :
2553 0 : const char *ConstAttr::getSpelling() const {
2554 0 : switch (SpellingListIndex) {
2555 0 : default:
2556 0 : llvm_unreachable("Unknown attribute spelling!");
2557 : return "(No spelling)";
2558 : case 0:
2559 : return "const";
2560 : case 1:
2561 : return "const";
2562 0 : case 2:
2563 0 : return "__const";
2564 0 : case 3:
2565 0 : return "__const";
2566 : }
2567 : }
2568 :
2569 19 : ConstructorAttr *ConstructorAttr::clone(ASTContext &C) const {
2570 19 : auto *A = new (C) ConstructorAttr(getLocation(), C, priority, getSpellingListIndex());
2571 19 : A->Inherited = Inherited;
2572 19 : A->IsPackExpansion = IsPackExpansion;
2573 19 : A->Implicit = Implicit;
2574 19 : return A;
2575 : }
2576 :
2577 0 : void ConstructorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2578 0 : switch (SpellingListIndex) {
2579 0 : default:
2580 0 : llvm_unreachable("Unknown attribute spelling!");
2581 : break;
2582 0 : case 0 : {
2583 0 : OS << " __attribute__((constructor(" << getPriority() << ")))";
2584 0 : break;
2585 : }
2586 0 : case 1 : {
2587 0 : OS << " [[gnu::constructor(" << getPriority() << ")]]";
2588 0 : break;
2589 : }
2590 : }
2591 0 : }
2592 :
2593 0 : const char *ConstructorAttr::getSpelling() const {
2594 0 : switch (SpellingListIndex) {
2595 0 : default:
2596 0 : llvm_unreachable("Unknown attribute spelling!");
2597 : return "(No spelling)";
2598 : case 0:
2599 : return "constructor";
2600 : case 1:
2601 : return "constructor";
2602 : }
2603 : }
2604 :
2605 2 : ConsumableAttr *ConsumableAttr::clone(ASTContext &C) const {
2606 2 : auto *A = new (C) ConsumableAttr(getLocation(), C, defaultState, getSpellingListIndex());
2607 2 : A->Inherited = Inherited;
2608 2 : A->IsPackExpansion = IsPackExpansion;
2609 2 : A->Implicit = Implicit;
2610 2 : return A;
2611 : }
2612 :
2613 1 : void ConsumableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2614 1 : switch (SpellingListIndex) {
2615 0 : default:
2616 0 : llvm_unreachable("Unknown attribute spelling!");
2617 : break;
2618 1 : case 0 : {
2619 1 : OS << " __attribute__((consumable(\"" << ConsumableAttr::ConvertConsumedStateToStr(getDefaultState()) << "\")))";
2620 1 : break;
2621 : }
2622 0 : case 1 : {
2623 0 : OS << " [[clang::consumable(\"" << ConsumableAttr::ConvertConsumedStateToStr(getDefaultState()) << "\")]]";
2624 0 : break;
2625 : }
2626 : }
2627 1 : }
2628 :
2629 0 : const char *ConsumableAttr::getSpelling() const {
2630 0 : switch (SpellingListIndex) {
2631 0 : default:
2632 0 : llvm_unreachable("Unknown attribute spelling!");
2633 : return "(No spelling)";
2634 : case 0:
2635 : return "consumable";
2636 : case 1:
2637 : return "consumable";
2638 : }
2639 : }
2640 :
2641 0 : ConsumableAutoCastAttr *ConsumableAutoCastAttr::clone(ASTContext &C) const {
2642 : auto *A = new (C) ConsumableAutoCastAttr(getLocation(), C, getSpellingListIndex());
2643 0 : A->Inherited = Inherited;
2644 0 : A->IsPackExpansion = IsPackExpansion;
2645 0 : A->Implicit = Implicit;
2646 0 : return A;
2647 : }
2648 :
2649 0 : void ConsumableAutoCastAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2650 0 : switch (SpellingListIndex) {
2651 0 : default:
2652 0 : llvm_unreachable("Unknown attribute spelling!");
2653 : break;
2654 0 : case 0 : {
2655 0 : OS << " __attribute__((consumable_auto_cast_state))";
2656 0 : break;
2657 : }
2658 0 : case 1 : {
2659 0 : OS << " [[clang::consumable_auto_cast_state]]";
2660 0 : break;
2661 : }
2662 : }
2663 0 : }
2664 :
2665 0 : const char *ConsumableAutoCastAttr::getSpelling() const {
2666 0 : switch (SpellingListIndex) {
2667 0 : default:
2668 0 : llvm_unreachable("Unknown attribute spelling!");
2669 : return "(No spelling)";
2670 : case 0:
2671 : return "consumable_auto_cast_state";
2672 : case 1:
2673 : return "consumable_auto_cast_state";
2674 : }
2675 : }
2676 :
2677 0 : ConsumableSetOnReadAttr *ConsumableSetOnReadAttr::clone(ASTContext &C) const {
2678 : auto *A = new (C) ConsumableSetOnReadAttr(getLocation(), C, getSpellingListIndex());
2679 0 : A->Inherited = Inherited;
2680 0 : A->IsPackExpansion = IsPackExpansion;
2681 0 : A->Implicit = Implicit;
2682 0 : return A;
2683 : }
2684 :
2685 0 : void ConsumableSetOnReadAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2686 0 : switch (SpellingListIndex) {
2687 0 : default:
2688 0 : llvm_unreachable("Unknown attribute spelling!");
2689 : break;
2690 0 : case 0 : {
2691 0 : OS << " __attribute__((consumable_set_state_on_read))";
2692 0 : break;
2693 : }
2694 0 : case 1 : {
2695 0 : OS << " [[clang::consumable_set_state_on_read]]";
2696 0 : break;
2697 : }
2698 : }
2699 0 : }
2700 :
2701 0 : const char *ConsumableSetOnReadAttr::getSpelling() const {
2702 0 : switch (SpellingListIndex) {
2703 0 : default:
2704 0 : llvm_unreachable("Unknown attribute spelling!");
2705 : return "(No spelling)";
2706 : case 0:
2707 : return "consumable_set_state_on_read";
2708 : case 1:
2709 : return "consumable_set_state_on_read";
2710 : }
2711 : }
2712 :
2713 0 : ConvergentAttr *ConvergentAttr::clone(ASTContext &C) const {
2714 : auto *A = new (C) ConvergentAttr(getLocation(), C, getSpellingListIndex());
2715 0 : A->Inherited = Inherited;
2716 0 : A->IsPackExpansion = IsPackExpansion;
2717 0 : A->Implicit = Implicit;
2718 0 : return A;
2719 : }
2720 :
2721 0 : void ConvergentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2722 0 : switch (SpellingListIndex) {
2723 0 : default:
2724 0 : llvm_unreachable("Unknown attribute spelling!");
2725 : break;
2726 0 : case 0 : {
2727 0 : OS << " __attribute__((convergent))";
2728 0 : break;
2729 : }
2730 0 : case 1 : {
2731 0 : OS << " [[clang::convergent]]";
2732 0 : break;
2733 : }
2734 0 : case 2 : {
2735 0 : OS << " [[clang::convergent]]";
2736 0 : break;
2737 : }
2738 : }
2739 0 : }
2740 :
2741 0 : const char *ConvergentAttr::getSpelling() const {
2742 0 : switch (SpellingListIndex) {
2743 0 : default:
2744 0 : llvm_unreachable("Unknown attribute spelling!");
2745 : return "(No spelling)";
2746 : case 0:
2747 : return "convergent";
2748 : case 1:
2749 : return "convergent";
2750 : case 2:
2751 : return "convergent";
2752 : }
2753 : }
2754 :
2755 2598 : DLLExportAttr *DLLExportAttr::clone(ASTContext &C) const {
2756 : auto *A = new (C) DLLExportAttr(getLocation(), C, getSpellingListIndex());
2757 2598 : A->Inherited = Inherited;
2758 2598 : A->IsPackExpansion = IsPackExpansion;
2759 2598 : A->Implicit = Implicit;
2760 2598 : return A;
2761 : }
2762 :
2763 0 : void DLLExportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2764 0 : switch (SpellingListIndex) {
2765 0 : default:
2766 0 : llvm_unreachable("Unknown attribute spelling!");
2767 : break;
2768 0 : case 0 : {
2769 0 : OS << " __declspec(dllexport)";
2770 0 : break;
2771 : }
2772 0 : case 1 : {
2773 0 : OS << " __attribute__((dllexport))";
2774 0 : break;
2775 : }
2776 0 : case 2 : {
2777 0 : OS << " [[gnu::dllexport]]";
2778 0 : break;
2779 : }
2780 : }
2781 0 : }
2782 :
2783 365 : const char *DLLExportAttr::getSpelling() const {
2784 365 : switch (SpellingListIndex) {
2785 0 : default:
2786 0 : llvm_unreachable("Unknown attribute spelling!");
2787 : return "(No spelling)";
2788 : case 0:
2789 : return "dllexport";
2790 : case 1:
2791 : return "dllexport";
2792 : case 2:
2793 : return "dllexport";
2794 : }
2795 : }
2796 :
2797 2267 : DLLImportAttr *DLLImportAttr::clone(ASTContext &C) const {
2798 : auto *A = new (C) DLLImportAttr(getLocation(), C, getSpellingListIndex());
2799 2267 : A->Inherited = Inherited;
2800 2267 : A->IsPackExpansion = IsPackExpansion;
2801 2267 : A->Implicit = Implicit;
2802 2267 : return A;
2803 : }
2804 :
2805 0 : void DLLImportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2806 0 : switch (SpellingListIndex) {
2807 0 : default:
2808 0 : llvm_unreachable("Unknown attribute spelling!");
2809 : break;
2810 0 : case 0 : {
2811 0 : OS << " __declspec(dllimport)";
2812 0 : break;
2813 : }
2814 0 : case 1 : {
2815 0 : OS << " __attribute__((dllimport))";
2816 0 : break;
2817 : }
2818 0 : case 2 : {
2819 0 : OS << " [[gnu::dllimport]]";
2820 0 : break;
2821 : }
2822 : }
2823 0 : }
2824 :
2825 830 : const char *DLLImportAttr::getSpelling() const {
2826 830 : switch (SpellingListIndex) {
2827 0 : default:
2828 0 : llvm_unreachable("Unknown attribute spelling!");
2829 : return "(No spelling)";
2830 : case 0:
2831 : return "dllimport";
2832 : case 1:
2833 : return "dllimport";
2834 : case 2:
2835 : return "dllimport";
2836 : }
2837 : }
2838 :
2839 245 : DeprecatedAttr *DeprecatedAttr::clone(ASTContext &C) const {
2840 735 : auto *A = new (C) DeprecatedAttr(getLocation(), C, getMessage(), getReplacement(), getSpellingListIndex());
2841 245 : A->Inherited = Inherited;
2842 245 : A->IsPackExpansion = IsPackExpansion;
2843 245 : A->Implicit = Implicit;
2844 245 : return A;
2845 : }
2846 :
2847 55 : void DeprecatedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2848 55 : switch (SpellingListIndex) {
2849 0 : default:
2850 0 : llvm_unreachable("Unknown attribute spelling!");
2851 : break;
2852 52 : case 0 : {
2853 52 : OS << " __attribute__((deprecated(\"" << getMessage() << "\"";
2854 104 : if (!getReplacement().empty()) OS << ", \"" << getReplacement() << "\"";
2855 52 : OS << ")))";
2856 52 : break;
2857 : }
2858 1 : case 1 : {
2859 1 : OS << " [[gnu::deprecated(\"" << getMessage() << "\"";
2860 1 : OS << ")]]";
2861 1 : break;
2862 : }
2863 1 : case 2 : {
2864 1 : OS << " __declspec(deprecated(\"" << getMessage() << "\"";
2865 1 : OS << "))";
2866 1 : break;
2867 : }
2868 1 : case 3 : {
2869 1 : OS << " [[deprecated(\"" << getMessage() << "\"";
2870 1 : OS << ")]]";
2871 1 : break;
2872 : }
2873 0 : case 4 : {
2874 0 : OS << " [[deprecated(\"" << getMessage() << "\"";
2875 0 : OS << ")]]";
2876 0 : break;
2877 : }
2878 : }
2879 55 : }
2880 :
2881 0 : const char *DeprecatedAttr::getSpelling() const {
2882 0 : switch (SpellingListIndex) {
2883 0 : default:
2884 0 : llvm_unreachable("Unknown attribute spelling!");
2885 : return "(No spelling)";
2886 : case 0:
2887 : return "deprecated";
2888 : case 1:
2889 : return "deprecated";
2890 : case 2:
2891 : return "deprecated";
2892 : case 3:
2893 : return "deprecated";
2894 : case 4:
2895 : return "deprecated";
2896 : }
2897 : }
2898 :
2899 11 : DestructorAttr *DestructorAttr::clone(ASTContext &C) const {
2900 11 : auto *A = new (C) DestructorAttr(getLocation(), C, priority, getSpellingListIndex());
2901 11 : A->Inherited = Inherited;
2902 11 : A->IsPackExpansion = IsPackExpansion;
2903 11 : A->Implicit = Implicit;
2904 11 : return A;
2905 : }
2906 :
2907 0 : void DestructorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2908 0 : switch (SpellingListIndex) {
2909 0 : default:
2910 0 : llvm_unreachable("Unknown attribute spelling!");
2911 : break;
2912 0 : case 0 : {
2913 0 : OS << " __attribute__((destructor(" << getPriority() << ")))";
2914 0 : break;
2915 : }
2916 0 : case 1 : {
2917 0 : OS << " [[gnu::destructor(" << getPriority() << ")]]";
2918 0 : break;
2919 : }
2920 : }
2921 0 : }
2922 :
2923 0 : const char *DestructorAttr::getSpelling() const {
2924 0 : switch (SpellingListIndex) {
2925 0 : default:
2926 0 : llvm_unreachable("Unknown attribute spelling!");
2927 : return "(No spelling)";
2928 : case 0:
2929 : return "destructor";
2930 : case 1:
2931 : return "destructor";
2932 : }
2933 : }
2934 :
2935 4 : DiagnoseIfAttr *DiagnoseIfAttr::clone(ASTContext &C) const {
2936 8 : auto *A = new (C) DiagnoseIfAttr(getLocation(), C, cond, getMessage(), diagnosticType, argDependent, parent, getSpellingListIndex());
2937 4 : A->Inherited = Inherited;
2938 4 : A->IsPackExpansion = IsPackExpansion;
2939 4 : A->Implicit = Implicit;
2940 4 : return A;
2941 : }
2942 :
2943 0 : void DiagnoseIfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2944 0 : switch (SpellingListIndex) {
2945 0 : default:
2946 0 : llvm_unreachable("Unknown attribute spelling!");
2947 : break;
2948 0 : case 0 : {
2949 0 : OS << " __attribute__((diagnose_if(" << getCond() << ", \"" << getMessage() << "\", \"" << DiagnoseIfAttr::ConvertDiagnosticTypeToStr(getDiagnosticType()) << "\")))";
2950 : break;
2951 : }
2952 : }
2953 0 : }
2954 :
2955 0 : const char *DiagnoseIfAttr::getSpelling() const {
2956 0 : switch (SpellingListIndex) {
2957 0 : default:
2958 0 : llvm_unreachable("Unknown attribute spelling!");
2959 : return "(No spelling)";
2960 0 : case 0:
2961 : return "diagnose_if";
2962 : }
2963 : }
2964 :
2965 0 : DisableTailCallsAttr *DisableTailCallsAttr::clone(ASTContext &C) const {
2966 : auto *A = new (C) DisableTailCallsAttr(getLocation(), C, getSpellingListIndex());
2967 0 : A->Inherited = Inherited;
2968 0 : A->IsPackExpansion = IsPackExpansion;
2969 0 : A->Implicit = Implicit;
2970 0 : return A;
2971 : }
2972 :
2973 0 : void DisableTailCallsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
2974 0 : switch (SpellingListIndex) {
2975 0 : default:
2976 0 : llvm_unreachable("Unknown attribute spelling!");
2977 : break;
2978 0 : case 0 : {
2979 0 : OS << " __attribute__((disable_tail_calls))";
2980 0 : break;
2981 : }
2982 0 : case 1 : {
2983 0 : OS << " [[clang::disable_tail_calls]]";
2984 0 : break;
2985 : }
2986 0 : case 2 : {
2987 0 : OS << " [[clang::disable_tail_calls]]";
2988 0 : break;
2989 : }
2990 : }
2991 0 : }
2992 :
2993 1 : const char *DisableTailCallsAttr::getSpelling() const {
2994 1 : switch (SpellingListIndex) {
2995 0 : default:
2996 0 : llvm_unreachable("Unknown attribute spelling!");
2997 : return "(No spelling)";
2998 : case 0:
2999 : return "disable_tail_calls";
3000 : case 1:
3001 : return "disable_tail_calls";
3002 : case 2:
3003 : return "disable_tail_calls";
3004 : }
3005 : }
3006 :
3007 0 : EmptyBasesAttr *EmptyBasesAttr::clone(ASTContext &C) const {
3008 : auto *A = new (C) EmptyBasesAttr(getLocation(), C, getSpellingListIndex());
3009 0 : A->Inherited = Inherited;
3010 0 : A->IsPackExpansion = IsPackExpansion;
3011 0 : A->Implicit = Implicit;
3012 0 : return A;
3013 : }
3014 :
3015 0 : void EmptyBasesAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3016 0 : switch (SpellingListIndex) {
3017 0 : default:
3018 0 : llvm_unreachable("Unknown attribute spelling!");
3019 : break;
3020 0 : case 0 : {
3021 0 : OS << " __declspec(empty_bases)";
3022 : break;
3023 : }
3024 : }
3025 0 : }
3026 :
3027 0 : const char *EmptyBasesAttr::getSpelling() const {
3028 0 : switch (SpellingListIndex) {
3029 0 : default:
3030 0 : llvm_unreachable("Unknown attribute spelling!");
3031 : return "(No spelling)";
3032 0 : case 0:
3033 : return "empty_bases";
3034 : }
3035 : }
3036 :
3037 0 : EnableIfAttr *EnableIfAttr::clone(ASTContext &C) const {
3038 0 : auto *A = new (C) EnableIfAttr(getLocation(), C, cond, getMessage(), getSpellingListIndex());
3039 0 : A->Inherited = Inherited;
3040 0 : A->IsPackExpansion = IsPackExpansion;
3041 0 : A->Implicit = Implicit;
3042 0 : return A;
3043 : }
3044 :
3045 0 : void EnableIfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3046 0 : switch (SpellingListIndex) {
3047 0 : default:
3048 0 : llvm_unreachable("Unknown attribute spelling!");
3049 : break;
3050 0 : case 0 : {
3051 0 : OS << " __attribute__((enable_if(" << getCond() << ", \"" << getMessage() << "\")))";
3052 : break;
3053 : }
3054 : }
3055 0 : }
3056 :
3057 0 : const char *EnableIfAttr::getSpelling() const {
3058 0 : switch (SpellingListIndex) {
3059 0 : default:
3060 0 : llvm_unreachable("Unknown attribute spelling!");
3061 : return "(No spelling)";
3062 0 : case 0:
3063 : return "enable_if";
3064 : }
3065 : }
3066 :
3067 2 : EnumExtensibilityAttr *EnumExtensibilityAttr::clone(ASTContext &C) const {
3068 2 : auto *A = new (C) EnumExtensibilityAttr(getLocation(), C, extensibility, getSpellingListIndex());
3069 2 : A->Inherited = Inherited;
3070 2 : A->IsPackExpansion = IsPackExpansion;
3071 2 : A->Implicit = Implicit;
3072 2 : return A;
3073 : }
3074 :
3075 0 : void EnumExtensibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3076 0 : switch (SpellingListIndex) {
3077 0 : default:
3078 0 : llvm_unreachable("Unknown attribute spelling!");
3079 : break;
3080 0 : case 0 : {
3081 0 : OS << " __attribute__((enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")))";
3082 0 : break;
3083 : }
3084 0 : case 1 : {
3085 0 : OS << " [[clang::enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")]]";
3086 0 : break;
3087 : }
3088 0 : case 2 : {
3089 0 : OS << " [[clang::enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")]]";
3090 0 : break;
3091 : }
3092 : }
3093 0 : }
3094 :
3095 0 : const char *EnumExtensibilityAttr::getSpelling() const {
3096 0 : switch (SpellingListIndex) {
3097 0 : default:
3098 0 : llvm_unreachable("Unknown attribute spelling!");
3099 : return "(No spelling)";
3100 : case 0:
3101 : return "enum_extensibility";
3102 : case 1:
3103 : return "enum_extensibility";
3104 : case 2:
3105 : return "enum_extensibility";
3106 : }
3107 : }
3108 :
3109 49 : ExcludeFromExplicitInstantiationAttr *ExcludeFromExplicitInstantiationAttr::clone(ASTContext &C) const {
3110 : auto *A = new (C) ExcludeFromExplicitInstantiationAttr(getLocation(), C, getSpellingListIndex());
3111 49 : A->Inherited = Inherited;
3112 49 : A->IsPackExpansion = IsPackExpansion;
3113 49 : A->Implicit = Implicit;
3114 49 : return A;
3115 : }
3116 :
3117 0 : void ExcludeFromExplicitInstantiationAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3118 0 : switch (SpellingListIndex) {
3119 0 : default:
3120 0 : llvm_unreachable("Unknown attribute spelling!");
3121 : break;
3122 0 : case 0 : {
3123 0 : OS << " __attribute__((exclude_from_explicit_instantiation))";
3124 0 : break;
3125 : }
3126 0 : case 1 : {
3127 0 : OS << " [[clang::exclude_from_explicit_instantiation]]";
3128 0 : break;
3129 : }
3130 0 : case 2 : {
3131 0 : OS << " [[clang::exclude_from_explicit_instantiation]]";
3132 0 : break;
3133 : }
3134 : }
3135 0 : }
3136 :
3137 0 : const char *ExcludeFromExplicitInstantiationAttr::getSpelling() const {
3138 0 : switch (SpellingListIndex) {
3139 0 : default:
3140 0 : llvm_unreachable("Unknown attribute spelling!");
3141 : return "(No spelling)";
3142 : case 0:
3143 : return "exclude_from_explicit_instantiation";
3144 : case 1:
3145 : return "exclude_from_explicit_instantiation";
3146 : case 2:
3147 : return "exclude_from_explicit_instantiation";
3148 : }
3149 : }
3150 :
3151 9 : ExclusiveTrylockFunctionAttr *ExclusiveTrylockFunctionAttr::clone(ASTContext &C) const {
3152 9 : auto *A = new (C) ExclusiveTrylockFunctionAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
3153 9 : A->Inherited = Inherited;
3154 9 : A->IsPackExpansion = IsPackExpansion;
3155 9 : A->Implicit = Implicit;
3156 9 : return A;
3157 : }
3158 :
3159 0 : void ExclusiveTrylockFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3160 0 : switch (SpellingListIndex) {
3161 0 : default:
3162 0 : llvm_unreachable("Unknown attribute spelling!");
3163 : break;
3164 0 : case 0 : {
3165 0 : OS << " __attribute__((exclusive_trylock_function(" << getSuccessValue() << ", ";
3166 : bool isFirst = true;
3167 0 : for (const auto &Val : args()) {
3168 0 : if (isFirst) isFirst = false;
3169 0 : else OS << ", ";
3170 0 : OS << Val;
3171 : }
3172 0 : OS << ")))";
3173 : break;
3174 : }
3175 : }
3176 0 : }
3177 :
3178 0 : const char *ExclusiveTrylockFunctionAttr::getSpelling() const {
3179 0 : switch (SpellingListIndex) {
3180 0 : default:
3181 0 : llvm_unreachable("Unknown attribute spelling!");
3182 : return "(No spelling)";
3183 0 : case 0:
3184 : return "exclusive_trylock_function";
3185 : }
3186 : }
3187 :
3188 0 : ExternalSourceSymbolAttr *ExternalSourceSymbolAttr::clone(ASTContext &C) const {
3189 0 : auto *A = new (C) ExternalSourceSymbolAttr(getLocation(), C, getLanguage(), getDefinedIn(), generatedDeclaration, getSpellingListIndex());
3190 0 : A->Inherited = Inherited;
3191 0 : A->IsPackExpansion = IsPackExpansion;
3192 0 : A->Implicit = Implicit;
3193 0 : return A;
3194 : }
3195 :
3196 0 : void ExternalSourceSymbolAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3197 0 : switch (SpellingListIndex) {
3198 0 : default:
3199 0 : llvm_unreachable("Unknown attribute spelling!");
3200 : break;
3201 0 : case 0 : {
3202 0 : OS << " __attribute__((external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")))";
3203 0 : break;
3204 : }
3205 0 : case 1 : {
3206 0 : OS << " [[clang::external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")]]";
3207 0 : break;
3208 : }
3209 0 : case 2 : {
3210 0 : OS << " [[clang::external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")]]";
3211 0 : break;
3212 : }
3213 : }
3214 0 : }
3215 :
3216 0 : const char *ExternalSourceSymbolAttr::getSpelling() const {
3217 0 : switch (SpellingListIndex) {
3218 0 : default:
3219 0 : llvm_unreachable("Unknown attribute spelling!");
3220 : return "(No spelling)";
3221 : case 0:
3222 : return "external_source_symbol";
3223 : case 1:
3224 : return "external_source_symbol";
3225 : case 2:
3226 : return "external_source_symbol";
3227 : }
3228 : }
3229 :
3230 0 : FallThroughAttr *FallThroughAttr::clone(ASTContext &C) const {
3231 : auto *A = new (C) FallThroughAttr(getLocation(), C, getSpellingListIndex());
3232 0 : A->Inherited = Inherited;
3233 0 : A->IsPackExpansion = IsPackExpansion;
3234 0 : A->Implicit = Implicit;
3235 0 : return A;
3236 : }
3237 :
3238 3 : void FallThroughAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3239 3 : switch (SpellingListIndex) {
3240 0 : default:
3241 0 : llvm_unreachable("Unknown attribute spelling!");
3242 : break;
3243 0 : case 0 : {
3244 0 : OS << " [[fallthrough]]";
3245 0 : break;
3246 : }
3247 0 : case 1 : {
3248 0 : OS << " [[fallthrough]]";
3249 0 : break;
3250 : }
3251 3 : case 2 : {
3252 3 : OS << " [[clang::fallthrough]]";
3253 3 : break;
3254 : }
3255 : }
3256 3 : }
3257 :
3258 6 : const char *FallThroughAttr::getSpelling() const {
3259 6 : switch (SpellingListIndex) {
3260 0 : default:
3261 0 : llvm_unreachable("Unknown attribute spelling!");
3262 : return "(No spelling)";
3263 : case 0:
3264 : return "fallthrough";
3265 : case 1:
3266 : return "fallthrough";
3267 : case 2:
3268 : return "fallthrough";
3269 : }
3270 : }
3271 :
3272 0 : FastCallAttr *FastCallAttr::clone(ASTContext &C) const {
3273 : auto *A = new (C) FastCallAttr(getLocation(), C, getSpellingListIndex());
3274 0 : A->Inherited = Inherited;
3275 0 : A->IsPackExpansion = IsPackExpansion;
3276 0 : A->Implicit = Implicit;
3277 0 : return A;
3278 : }
3279 :
3280 0 : void FastCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3281 0 : switch (SpellingListIndex) {
3282 0 : default:
3283 0 : llvm_unreachable("Unknown attribute spelling!");
3284 : break;
3285 0 : case 0 : {
3286 0 : OS << " __attribute__((fastcall))";
3287 0 : break;
3288 : }
3289 0 : case 1 : {
3290 0 : OS << " [[gnu::fastcall]]";
3291 0 : break;
3292 : }
3293 0 : case 2 : {
3294 0 : OS << " __fastcall";
3295 0 : break;
3296 : }
3297 0 : case 3 : {
3298 0 : OS << " _fastcall";
3299 0 : break;
3300 : }
3301 : }
3302 0 : }
3303 :
3304 0 : const char *FastCallAttr::getSpelling() const {
3305 0 : switch (SpellingListIndex) {
3306 0 : default:
3307 0 : llvm_unreachable("Unknown attribute spelling!");
3308 : return "(No spelling)";
3309 : case 0:
3310 : return "fastcall";
3311 : case 1:
3312 : return "fastcall";
3313 0 : case 2:
3314 0 : return "__fastcall";
3315 0 : case 3:
3316 0 : return "_fastcall";
3317 : }
3318 : }
3319 :
3320 120 : FinalAttr *FinalAttr::clone(ASTContext &C) const {
3321 : auto *A = new (C) FinalAttr(getLocation(), C, getSpellingListIndex());
3322 120 : A->Inherited = Inherited;
3323 120 : A->IsPackExpansion = IsPackExpansion;
3324 120 : A->Implicit = Implicit;
3325 120 : return A;
3326 : }
3327 :
3328 0 : void FinalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3329 0 : switch (SpellingListIndex) {
3330 0 : default:
3331 0 : llvm_unreachable("Unknown attribute spelling!");
3332 : break;
3333 0 : case 0 : {
3334 0 : OS << " final";
3335 0 : break;
3336 : }
3337 0 : case 1 : {
3338 0 : OS << " sealed";
3339 0 : break;
3340 : }
3341 : }
3342 0 : }
3343 :
3344 0 : const char *FinalAttr::getSpelling() const {
3345 0 : switch (SpellingListIndex) {
3346 0 : default:
3347 0 : llvm_unreachable("Unknown attribute spelling!");
3348 : return "(No spelling)";
3349 : case 0:
3350 : return "final";
3351 0 : case 1:
3352 0 : return "sealed";
3353 : }
3354 : }
3355 :
3356 2 : FlagEnumAttr *FlagEnumAttr::clone(ASTContext &C) const {
3357 : auto *A = new (C) FlagEnumAttr(getLocation(), C, getSpellingListIndex());
3358 2 : A->Inherited = Inherited;
3359 2 : A->IsPackExpansion = IsPackExpansion;
3360 2 : A->Implicit = Implicit;
3361 2 : return A;
3362 : }
3363 :
3364 0 : void FlagEnumAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3365 0 : switch (SpellingListIndex) {
3366 0 : default:
3367 0 : llvm_unreachable("Unknown attribute spelling!");
3368 : break;
3369 0 : case 0 : {
3370 0 : OS << " __attribute__((flag_enum))";
3371 0 : break;
3372 : }
3373 0 : case 1 : {
3374 0 : OS << " [[clang::flag_enum]]";
3375 0 : break;
3376 : }
3377 0 : case 2 : {
3378 0 : OS << " [[clang::flag_enum]]";
3379 0 : break;
3380 : }
3381 : }
3382 0 : }
3383 :
3384 0 : const char *FlagEnumAttr::getSpelling() const {
3385 0 : switch (SpellingListIndex) {
3386 0 : default:
3387 0 : llvm_unreachable("Unknown attribute spelling!");
3388 : return "(No spelling)";
3389 : case 0:
3390 : return "flag_enum";
3391 : case 1:
3392 : return "flag_enum";
3393 : case 2:
3394 : return "flag_enum";
3395 : }
3396 : }
3397 :
3398 0 : FlattenAttr *FlattenAttr::clone(ASTContext &C) const {
3399 : auto *A = new (C) FlattenAttr(getLocation(), C, getSpellingListIndex());
3400 0 : A->Inherited = Inherited;
3401 0 : A->IsPackExpansion = IsPackExpansion;
3402 0 : A->Implicit = Implicit;
3403 0 : return A;
3404 : }
3405 :
3406 0 : void FlattenAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3407 0 : switch (SpellingListIndex) {
3408 0 : default:
3409 0 : llvm_unreachable("Unknown attribute spelling!");
3410 : break;
3411 0 : case 0 : {
3412 0 : OS << " __attribute__((flatten))";
3413 0 : break;
3414 : }
3415 0 : case 1 : {
3416 0 : OS << " [[gnu::flatten]]";
3417 0 : break;
3418 : }
3419 : }
3420 0 : }
3421 :
3422 0 : const char *FlattenAttr::getSpelling() const {
3423 0 : switch (SpellingListIndex) {
3424 0 : default:
3425 0 : llvm_unreachable("Unknown attribute spelling!");
3426 : return "(No spelling)";
3427 : case 0:
3428 : return "flatten";
3429 : case 1:
3430 : return "flatten";
3431 : }
3432 : }
3433 :
3434 3 : FormatAttr *FormatAttr::clone(ASTContext &C) const {
3435 3 : auto *A = new (C) FormatAttr(getLocation(), C, type, formatIdx, firstArg, getSpellingListIndex());
3436 3 : A->Inherited = Inherited;
3437 3 : A->IsPackExpansion = IsPackExpansion;
3438 3 : A->Implicit = Implicit;
3439 3 : return A;
3440 : }
3441 :
3442 5 : void FormatAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3443 5 : switch (SpellingListIndex) {
3444 0 : default:
3445 0 : llvm_unreachable("Unknown attribute spelling!");
3446 : break;
3447 5 : case 0 : {
3448 10 : OS << " __attribute__((format(" << (getType() ? getType()->getName() : "") << ", " << getFormatIdx() << ", " << getFirstArg() << ")))";
3449 5 : break;
3450 : }
3451 0 : case 1 : {
3452 0 : OS << " [[gnu::format(" << (getType() ? getType()->getName() : "") << ", " << getFormatIdx() << ", " << getFirstArg() << ")]]";
3453 0 : break;
3454 : }
3455 : }
3456 5 : }
3457 :
3458 0 : const char *FormatAttr::getSpelling() const {
3459 0 : switch (SpellingListIndex) {
3460 0 : default:
3461 0 : llvm_unreachable("Unknown attribute spelling!");
3462 : return "(No spelling)";
3463 : case 0:
3464 : return "format";
3465 : case 1:
3466 : return "format";
3467 : }
3468 : }
3469 :
3470 0 : FormatArgAttr *FormatArgAttr::clone(ASTContext &C) const {
3471 0 : auto *A = new (C) FormatArgAttr(getLocation(), C, formatIdx, getSpellingListIndex());
3472 0 : A->Inherited = Inherited;
3473 0 : A->IsPackExpansion = IsPackExpansion;
3474 0 : A->Implicit = Implicit;
3475 0 : return A;
3476 : }
3477 :
3478 4 : void FormatArgAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3479 4 : switch (SpellingListIndex) {
3480 0 : default:
3481 0 : llvm_unreachable("Unknown attribute spelling!");
3482 : break;
3483 4 : case 0 : {
3484 4 : OS << " __attribute__((format_arg(" << getFormatIdx().getSourceIndex() << ")))";
3485 4 : break;
3486 : }
3487 0 : case 1 : {
3488 0 : OS << " [[gnu::format_arg(" << getFormatIdx().getSourceIndex() << ")]]";
3489 0 : break;
3490 : }
3491 : }
3492 4 : }
3493 :
3494 0 : const char *FormatArgAttr::getSpelling() const {
3495 0 : switch (SpellingListIndex) {
3496 0 : default:
3497 0 : llvm_unreachable("Unknown attribute spelling!");
3498 : return "(No spelling)";
3499 : case 0:
3500 : return "format_arg";
3501 : case 1:
3502 : return "format_arg";
3503 : }
3504 : }
3505 :
3506 3 : GNUInlineAttr *GNUInlineAttr::clone(ASTContext &C) const {
3507 : auto *A = new (C) GNUInlineAttr(getLocation(), C, getSpellingListIndex());
3508 3 : A->Inherited = Inherited;
3509 3 : A->IsPackExpansion = IsPackExpansion;
3510 3 : A->Implicit = Implicit;
3511 3 : return A;
3512 : }
3513 :
3514 2 : void GNUInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3515 2 : switch (SpellingListIndex) {
3516 0 : default:
3517 0 : llvm_unreachable("Unknown attribute spelling!");
3518 : break;
3519 1 : case 0 : {
3520 1 : OS << " __attribute__((gnu_inline))";
3521 1 : break;
3522 : }
3523 1 : case 1 : {
3524 1 : OS << " [[gnu::gnu_inline]]";
3525 1 : break;
3526 : }
3527 : }
3528 2 : }
3529 :
3530 0 : const char *GNUInlineAttr::getSpelling() const {
3531 0 : switch (SpellingListIndex) {
3532 0 : default:
3533 0 : llvm_unreachable("Unknown attribute spelling!");
3534 : return "(No spelling)";
3535 : case 0:
3536 : return "gnu_inline";
3537 : case 1:
3538 : return "gnu_inline";
3539 : }
3540 : }
3541 :
3542 0 : GuardedByAttr *GuardedByAttr::clone(ASTContext &C) const {
3543 0 : auto *A = new (C) GuardedByAttr(getLocation(), C, arg, getSpellingListIndex());
3544 0 : A->Inherited = Inherited;
3545 0 : A->IsPackExpansion = IsPackExpansion;
3546 0 : A->Implicit = Implicit;
3547 0 : return A;
3548 : }
3549 :
3550 0 : void GuardedByAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3551 0 : switch (SpellingListIndex) {
3552 0 : default:
3553 0 : llvm_unreachable("Unknown attribute spelling!");
3554 : break;
3555 0 : case 0 : {
3556 0 : OS << " __attribute__((guarded_by(" << getArg() << ")))";
3557 : break;
3558 : }
3559 : }
3560 0 : }
3561 :
3562 0 : const char *GuardedByAttr::getSpelling() const {
3563 0 : switch (SpellingListIndex) {
3564 0 : default:
3565 0 : llvm_unreachable("Unknown attribute spelling!");
3566 : return "(No spelling)";
3567 0 : case 0:
3568 : return "guarded_by";
3569 : }
3570 : }
3571 :
3572 0 : GuardedVarAttr *GuardedVarAttr::clone(ASTContext &C) const {
3573 : auto *A = new (C) GuardedVarAttr(getLocation(), C, getSpellingListIndex());
3574 0 : A->Inherited = Inherited;
3575 0 : A->IsPackExpansion = IsPackExpansion;
3576 0 : A->Implicit = Implicit;
3577 0 : return A;
3578 : }
3579 :
3580 0 : void GuardedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3581 0 : switch (SpellingListIndex) {
3582 0 : default:
3583 0 : llvm_unreachable("Unknown attribute spelling!");
3584 : break;
3585 0 : case 0 : {
3586 0 : OS << " __attribute__((guarded_var))";
3587 0 : break;
3588 : }
3589 0 : case 1 : {
3590 0 : OS << " [[clang::guarded_var]]";
3591 0 : break;
3592 : }
3593 : }
3594 0 : }
3595 :
3596 0 : const char *GuardedVarAttr::getSpelling() const {
3597 0 : switch (SpellingListIndex) {
3598 0 : default:
3599 0 : llvm_unreachable("Unknown attribute spelling!");
3600 : return "(No spelling)";
3601 : case 0:
3602 : return "guarded_var";
3603 : case 1:
3604 : return "guarded_var";
3605 : }
3606 : }
3607 :
3608 0 : HotAttr *HotAttr::clone(ASTContext &C) const {
3609 : auto *A = new (C) HotAttr(getLocation(), C, getSpellingListIndex());
3610 0 : A->Inherited = Inherited;
3611 0 : A->IsPackExpansion = IsPackExpansion;
3612 0 : A->Implicit = Implicit;
3613 0 : return A;
3614 : }
3615 :
3616 0 : void HotAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3617 0 : switch (SpellingListIndex) {
3618 0 : default:
3619 0 : llvm_unreachable("Unknown attribute spelling!");
3620 : break;
3621 0 : case 0 : {
3622 0 : OS << " __attribute__((hot))";
3623 0 : break;
3624 : }
3625 0 : case 1 : {
3626 0 : OS << " [[gnu::hot]]";
3627 0 : break;
3628 : }
3629 : }
3630 0 : }
3631 :
3632 1 : const char *HotAttr::getSpelling() const {
3633 1 : switch (SpellingListIndex) {
3634 0 : default:
3635 0 : llvm_unreachable("Unknown attribute spelling!");
3636 : return "(No spelling)";
3637 : case 0:
3638 : return "hot";
3639 : case 1:
3640 : return "hot";
3641 : }
3642 : }
3643 :
3644 0 : IBActionAttr *IBActionAttr::clone(ASTContext &C) const {
3645 : auto *A = new (C) IBActionAttr(getLocation(), C, getSpellingListIndex());
3646 0 : A->Inherited = Inherited;
3647 0 : A->IsPackExpansion = IsPackExpansion;
3648 0 : A->Implicit = Implicit;
3649 0 : return A;
3650 : }
3651 :
3652 0 : void IBActionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3653 0 : switch (SpellingListIndex) {
3654 0 : default:
3655 0 : llvm_unreachable("Unknown attribute spelling!");
3656 : break;
3657 0 : case 0 : {
3658 0 : OS << " __attribute__((ibaction))";
3659 0 : break;
3660 : }
3661 0 : case 1 : {
3662 0 : OS << " [[clang::ibaction]]";
3663 0 : break;
3664 : }
3665 0 : case 2 : {
3666 0 : OS << " [[clang::ibaction]]";
3667 0 : break;
3668 : }
3669 : }
3670 0 : }
3671 :
3672 0 : const char *IBActionAttr::getSpelling() const {
3673 0 : switch (SpellingListIndex) {
3674 0 : default:
3675 0 : llvm_unreachable("Unknown attribute spelling!");
3676 : return "(No spelling)";
3677 : case 0:
3678 : return "ibaction";
3679 : case 1:
3680 : return "ibaction";
3681 : case 2:
3682 : return "ibaction";
3683 : }
3684 : }
3685 :
3686 0 : IBOutletAttr *IBOutletAttr::clone(ASTContext &C) const {
3687 : auto *A = new (C) IBOutletAttr(getLocation(), C, getSpellingListIndex());
3688 0 : A->Inherited = Inherited;
3689 0 : A->IsPackExpansion = IsPackExpansion;
3690 0 : A->Implicit = Implicit;
3691 0 : return A;
3692 : }
3693 :
3694 0 : void IBOutletAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3695 0 : switch (SpellingListIndex) {
3696 0 : default:
3697 0 : llvm_unreachable("Unknown attribute spelling!");
3698 : break;
3699 0 : case 0 : {
3700 0 : OS << " __attribute__((iboutlet))";
3701 0 : break;
3702 : }
3703 0 : case 1 : {
3704 0 : OS << " [[clang::iboutlet]]";
3705 0 : break;
3706 : }
3707 0 : case 2 : {
3708 0 : OS << " [[clang::iboutlet]]";
3709 0 : break;
3710 : }
3711 : }
3712 0 : }
3713 :
3714 0 : const char *IBOutletAttr::getSpelling() const {
3715 0 : switch (SpellingListIndex) {
3716 0 : default:
3717 0 : llvm_unreachable("Unknown attribute spelling!");
3718 : return "(No spelling)";
3719 : case 0:
3720 : return "iboutlet";
3721 : case 1:
3722 : return "iboutlet";
3723 : case 2:
3724 : return "iboutlet";
3725 : }
3726 : }
3727 :
3728 0 : IBOutletCollectionAttr *IBOutletCollectionAttr::clone(ASTContext &C) const {
3729 0 : auto *A = new (C) IBOutletCollectionAttr(getLocation(), C, interface_, getSpellingListIndex());
3730 0 : A->Inherited = Inherited;
3731 0 : A->IsPackExpansion = IsPackExpansion;
3732 0 : A->Implicit = Implicit;
3733 0 : return A;
3734 : }
3735 :
3736 0 : void IBOutletCollectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3737 0 : switch (SpellingListIndex) {
3738 0 : default:
3739 0 : llvm_unreachable("Unknown attribute spelling!");
3740 : break;
3741 0 : case 0 : {
3742 0 : OS << " __attribute__((iboutletcollection(" << getInterface().getAsString() << ")))";
3743 0 : break;
3744 : }
3745 0 : case 1 : {
3746 0 : OS << " [[clang::iboutletcollection(" << getInterface().getAsString() << ")]]";
3747 0 : break;
3748 : }
3749 0 : case 2 : {
3750 0 : OS << " [[clang::iboutletcollection(" << getInterface().getAsString() << ")]]";
3751 0 : break;
3752 : }
3753 : }
3754 0 : }
3755 :
3756 0 : const char *IBOutletCollectionAttr::getSpelling() const {
3757 0 : switch (SpellingListIndex) {
3758 0 : default:
3759 0 : llvm_unreachable("Unknown attribute spelling!");
3760 : return "(No spelling)";
3761 : case 0:
3762 : return "iboutletcollection";
3763 : case 1:
3764 : return "iboutletcollection";
3765 : case 2:
3766 : return "iboutletcollection";
3767 : }
3768 : }
3769 :
3770 0 : IFuncAttr *IFuncAttr::clone(ASTContext &C) const {
3771 0 : auto *A = new (C) IFuncAttr(getLocation(), C, getResolver(), getSpellingListIndex());
3772 0 : A->Inherited = Inherited;
3773 0 : A->IsPackExpansion = IsPackExpansion;
3774 0 : A->Implicit = Implicit;
3775 0 : return A;
3776 : }
3777 :
3778 0 : void IFuncAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3779 0 : switch (SpellingListIndex) {
3780 0 : default:
3781 0 : llvm_unreachable("Unknown attribute spelling!");
3782 : break;
3783 0 : case 0 : {
3784 0 : OS << " __attribute__((ifunc(\"" << getResolver() << "\")))";
3785 0 : break;
3786 : }
3787 0 : case 1 : {
3788 0 : OS << " [[gnu::ifunc(\"" << getResolver() << "\")]]";
3789 0 : break;
3790 : }
3791 : }
3792 0 : }
3793 :
3794 0 : const char *IFuncAttr::getSpelling() const {
3795 0 : switch (SpellingListIndex) {
3796 0 : default:
3797 0 : llvm_unreachable("Unknown attribute spelling!");
3798 : return "(No spelling)";
3799 : case 0:
3800 : return "ifunc";
3801 : case 1:
3802 : return "ifunc";
3803 : }
3804 : }
3805 :
3806 0 : InitPriorityAttr *InitPriorityAttr::clone(ASTContext &C) const {
3807 0 : auto *A = new (C) InitPriorityAttr(getLocation(), C, priority, getSpellingListIndex());
3808 0 : A->Inherited = Inherited;
3809 0 : A->IsPackExpansion = IsPackExpansion;
3810 0 : A->Implicit = Implicit;
3811 0 : return A;
3812 : }
3813 :
3814 0 : void InitPriorityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3815 0 : switch (SpellingListIndex) {
3816 0 : default:
3817 0 : llvm_unreachable("Unknown attribute spelling!");
3818 : break;
3819 0 : case 0 : {
3820 0 : OS << " __attribute__((init_priority(" << getPriority() << ")))";
3821 0 : break;
3822 : }
3823 0 : case 1 : {
3824 0 : OS << " [[gnu::init_priority(" << getPriority() << ")]]";
3825 0 : break;
3826 : }
3827 : }
3828 0 : }
3829 :
3830 0 : const char *InitPriorityAttr::getSpelling() const {
3831 0 : switch (SpellingListIndex) {
3832 0 : default:
3833 0 : llvm_unreachable("Unknown attribute spelling!");
3834 : return "(No spelling)";
3835 : case 0:
3836 : return "init_priority";
3837 : case 1:
3838 : return "init_priority";
3839 : }
3840 : }
3841 :
3842 2 : InitSegAttr *InitSegAttr::clone(ASTContext &C) const {
3843 4 : auto *A = new (C) InitSegAttr(getLocation(), C, getSection(), getSpellingListIndex());
3844 2 : A->Inherited = Inherited;
3845 2 : A->IsPackExpansion = IsPackExpansion;
3846 2 : A->Implicit = Implicit;
3847 2 : return A;
3848 : }
3849 :
3850 1 : void InitSegAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3851 1 : switch (SpellingListIndex) {
3852 0 : default:
3853 0 : llvm_unreachable("Unknown attribute spelling!");
3854 : break;
3855 1 : case 0 : {
3856 1 : OS << "#pragma init_seg";
3857 1 : printPrettyPragma(OS, Policy);
3858 1 : OS << "\n"; break;
3859 : }
3860 : }
3861 1 : }
3862 :
3863 0 : const char *InitSegAttr::getSpelling() const {
3864 0 : switch (SpellingListIndex) {
3865 0 : default:
3866 0 : llvm_unreachable("Unknown attribute spelling!");
3867 : return "(No spelling)";
3868 0 : case 0:
3869 : return "init_seg";
3870 : }
3871 : }
3872 :
3873 0 : IntelOclBiccAttr *IntelOclBiccAttr::clone(ASTContext &C) const {
3874 : auto *A = new (C) IntelOclBiccAttr(getLocation(), C, getSpellingListIndex());
3875 0 : A->Inherited = Inherited;
3876 0 : A->IsPackExpansion = IsPackExpansion;
3877 0 : A->Implicit = Implicit;
3878 0 : return A;
3879 : }
3880 :
3881 0 : void IntelOclBiccAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3882 0 : switch (SpellingListIndex) {
3883 0 : default:
3884 0 : llvm_unreachable("Unknown attribute spelling!");
3885 : break;
3886 0 : case 0 : {
3887 0 : OS << " __attribute__((intel_ocl_bicc))";
3888 0 : break;
3889 : }
3890 0 : case 1 : {
3891 0 : OS << " [[clang::intel_ocl_bicc]]";
3892 0 : break;
3893 : }
3894 : }
3895 0 : }
3896 :
3897 0 : const char *IntelOclBiccAttr::getSpelling() const {
3898 0 : switch (SpellingListIndex) {
3899 0 : default:
3900 0 : llvm_unreachable("Unknown attribute spelling!");
3901 : return "(No spelling)";
3902 : case 0:
3903 : return "intel_ocl_bicc";
3904 : case 1:
3905 : return "intel_ocl_bicc";
3906 : }
3907 : }
3908 :
3909 0 : InternalLinkageAttr *InternalLinkageAttr::clone(ASTContext &C) const {
3910 : auto *A = new (C) InternalLinkageAttr(getLocation(), C, getSpellingListIndex());
3911 0 : A->Inherited = Inherited;
3912 0 : A->IsPackExpansion = IsPackExpansion;
3913 0 : A->Implicit = Implicit;
3914 0 : return A;
3915 : }
3916 :
3917 0 : void InternalLinkageAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3918 0 : switch (SpellingListIndex) {
3919 0 : default:
3920 0 : llvm_unreachable("Unknown attribute spelling!");
3921 : break;
3922 0 : case 0 : {
3923 0 : OS << " __attribute__((internal_linkage))";
3924 0 : break;
3925 : }
3926 0 : case 1 : {
3927 0 : OS << " [[clang::internal_linkage]]";
3928 0 : break;
3929 : }
3930 0 : case 2 : {
3931 0 : OS << " [[clang::internal_linkage]]";
3932 0 : break;
3933 : }
3934 : }
3935 0 : }
3936 :
3937 3 : const char *InternalLinkageAttr::getSpelling() const {
3938 3 : switch (SpellingListIndex) {
3939 0 : default:
3940 0 : llvm_unreachable("Unknown attribute spelling!");
3941 : return "(No spelling)";
3942 : case 0:
3943 : return "internal_linkage";
3944 : case 1:
3945 : return "internal_linkage";
3946 : case 2:
3947 : return "internal_linkage";
3948 : }
3949 : }
3950 :
3951 0 : LTOVisibilityPublicAttr *LTOVisibilityPublicAttr::clone(ASTContext &C) const {
3952 : auto *A = new (C) LTOVisibilityPublicAttr(getLocation(), C, getSpellingListIndex());
3953 0 : A->Inherited = Inherited;
3954 0 : A->IsPackExpansion = IsPackExpansion;
3955 0 : A->Implicit = Implicit;
3956 0 : return A;
3957 : }
3958 :
3959 0 : void LTOVisibilityPublicAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
3960 0 : switch (SpellingListIndex) {
3961 0 : default:
3962 0 : llvm_unreachable("Unknown attribute spelling!");
3963 : break;
3964 0 : case 0 : {
3965 0 : OS << " __attribute__((lto_visibility_public))";
3966 0 : break;
3967 : }
3968 0 : case 1 : {
3969 0 : OS << " [[clang::lto_visibility_public]]";
3970 0 : break;
3971 : }
3972 0 : case 2 : {
3973 0 : OS << " [[clang::lto_visibility_public]]";
3974 0 : break;
3975 : }
3976 : }
3977 0 : }
3978 :
3979 0 : const char *LTOVisibilityPublicAttr::getSpelling() const {
3980 0 : switch (SpellingListIndex) {
3981 0 : default:
3982 0 : llvm_unreachable("Unknown attribute spelling!");
3983 : return "(No spelling)";
3984 : case 0:
3985 : return "lto_visibility_public";
3986 : case 1:
3987 : return "lto_visibility_public";
3988 : case 2:
3989 : return "lto_visibility_public";
3990 : }
3991 : }
3992 :
3993 0 : LayoutVersionAttr *LayoutVersionAttr::clone(ASTContext &C) const {
3994 0 : auto *A = new (C) LayoutVersionAttr(getLocation(), C, version, getSpellingListIndex());
3995 0 : A->Inherited = Inherited;
3996 0 : A->IsPackExpansion = IsPackExpansion;
3997 0 : A->Implicit = Implicit;
3998 0 : return A;
3999 : }
4000 :
4001 0 : void LayoutVersionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4002 0 : switch (SpellingListIndex) {
4003 0 : default:
4004 0 : llvm_unreachable("Unknown attribute spelling!");
4005 : break;
4006 0 : case 0 : {
4007 0 : OS << " __declspec(layout_version(" << getVersion() << "))";
4008 : break;
4009 : }
4010 : }
4011 0 : }
4012 :
4013 0 : const char *LayoutVersionAttr::getSpelling() const {
4014 0 : switch (SpellingListIndex) {
4015 0 : default:
4016 0 : llvm_unreachable("Unknown attribute spelling!");
4017 : return "(No spelling)";
4018 0 : case 0:
4019 : return "layout_version";
4020 : }
4021 : }
4022 :
4023 3 : LifetimeBoundAttr *LifetimeBoundAttr::clone(ASTContext &C) const {
4024 : auto *A = new (C) LifetimeBoundAttr(getLocation(), C, getSpellingListIndex());
4025 3 : A->Inherited = Inherited;
4026 3 : A->IsPackExpansion = IsPackExpansion;
4027 3 : A->Implicit = Implicit;
4028 3 : return A;
4029 : }
4030 :
4031 0 : void LifetimeBoundAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4032 0 : switch (SpellingListIndex) {
4033 0 : default:
4034 0 : llvm_unreachable("Unknown attribute spelling!");
4035 : break;
4036 0 : case 0 : {
4037 0 : OS << " __attribute__((lifetimebound))";
4038 0 : break;
4039 : }
4040 0 : case 1 : {
4041 0 : OS << " [[clang::lifetimebound]]";
4042 0 : break;
4043 : }
4044 : }
4045 0 : }
4046 :
4047 0 : const char *LifetimeBoundAttr::getSpelling() const {
4048 0 : switch (SpellingListIndex) {
4049 0 : default:
4050 0 : llvm_unreachable("Unknown attribute spelling!");
4051 : return "(No spelling)";
4052 : case 0:
4053 : return "lifetimebound";
4054 : case 1:
4055 : return "lifetimebound";
4056 : }
4057 : }
4058 :
4059 3 : LockReturnedAttr *LockReturnedAttr::clone(ASTContext &C) const {
4060 3 : auto *A = new (C) LockReturnedAttr(getLocation(), C, arg, getSpellingListIndex());
4061 3 : A->Inherited = Inherited;
4062 3 : A->IsPackExpansion = IsPackExpansion;
4063 3 : A->Implicit = Implicit;
4064 3 : return A;
4065 : }
4066 :
4067 0 : void LockReturnedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4068 0 : switch (SpellingListIndex) {
4069 0 : default:
4070 0 : llvm_unreachable("Unknown attribute spelling!");
4071 : break;
4072 0 : case 0 : {
4073 0 : OS << " __attribute__((lock_returned(" << getArg() << ")))";
4074 : break;
4075 : }
4076 : }
4077 0 : }
4078 :
4079 0 : const char *LockReturnedAttr::getSpelling() const {
4080 0 : switch (SpellingListIndex) {
4081 0 : default:
4082 0 : llvm_unreachable("Unknown attribute spelling!");
4083 : return "(No spelling)";
4084 0 : case 0:
4085 : return "lock_returned";
4086 : }
4087 : }
4088 :
4089 19 : LocksExcludedAttr *LocksExcludedAttr::clone(ASTContext &C) const {
4090 19 : auto *A = new (C) LocksExcludedAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
4091 19 : A->Inherited = Inherited;
4092 19 : A->IsPackExpansion = IsPackExpansion;
4093 19 : A->Implicit = Implicit;
4094 19 : return A;
4095 : }
4096 :
4097 0 : void LocksExcludedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4098 0 : switch (SpellingListIndex) {
4099 0 : default:
4100 0 : llvm_unreachable("Unknown attribute spelling!");
4101 : break;
4102 0 : case 0 : {
4103 0 : OS << " __attribute__((locks_excluded(";
4104 : bool isFirst = true;
4105 0 : for (const auto &Val : args()) {
4106 0 : if (isFirst) isFirst = false;
4107 0 : else OS << ", ";
4108 0 : OS << Val;
4109 : }
4110 0 : OS << ")))";
4111 : break;
4112 : }
4113 : }
4114 0 : }
4115 :
4116 0 : const char *LocksExcludedAttr::getSpelling() const {
4117 0 : switch (SpellingListIndex) {
4118 0 : default:
4119 0 : llvm_unreachable("Unknown attribute spelling!");
4120 : return "(No spelling)";
4121 0 : case 0:
4122 : return "locks_excluded";
4123 : }
4124 : }
4125 :
4126 2 : LoopHintAttr *LoopHintAttr::clone(ASTContext &C) const {
4127 2 : auto *A = new (C) LoopHintAttr(getLocation(), C, option, state, value, getSpellingListIndex());
4128 2 : A->Inherited = Inherited;
4129 2 : A->IsPackExpansion = IsPackExpansion;
4130 2 : A->Implicit = Implicit;
4131 2 : return A;
4132 : }
4133 :
4134 42 : void LoopHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4135 42 : switch (SpellingListIndex) {
4136 0 : default:
4137 0 : llvm_unreachable("Unknown attribute spelling!");
4138 : break;
4139 39 : case 0 : {
4140 39 : OS << "#pragma clang loop";
4141 39 : printPrettyPragma(OS, Policy);
4142 39 : OS << "\n"; break;
4143 : }
4144 2 : case 1 : {
4145 2 : OS << "#pragma unroll";
4146 2 : printPrettyPragma(OS, Policy);
4147 2 : OS << "\n"; break;
4148 : }
4149 1 : case 2 : {
4150 1 : OS << "#pragma nounroll";
4151 1 : printPrettyPragma(OS, Policy);
4152 1 : OS << "\n"; break;
4153 : }
4154 0 : case 3 : {
4155 0 : OS << "#pragma unroll_and_jam";
4156 0 : printPrettyPragma(OS, Policy);
4157 0 : OS << "\n"; break;
4158 : }
4159 0 : case 4 : {
4160 0 : OS << "#pragma nounroll_and_jam";
4161 0 : printPrettyPragma(OS, Policy);
4162 0 : OS << "\n"; break;
4163 : }
4164 : }
4165 42 : }
4166 :
4167 1 : const char *LoopHintAttr::getSpelling() const {
4168 1 : switch (SpellingListIndex) {
4169 0 : default:
4170 0 : llvm_unreachable("Unknown attribute spelling!");
4171 : return "(No spelling)";
4172 : case 0:
4173 : return "loop";
4174 1 : case 1:
4175 1 : return "unroll";
4176 0 : case 2:
4177 0 : return "nounroll";
4178 0 : case 3:
4179 0 : return "unroll_and_jam";
4180 0 : case 4:
4181 0 : return "nounroll_and_jam";
4182 : }
4183 : }
4184 :
4185 0 : MSABIAttr *MSABIAttr::clone(ASTContext &C) const {
4186 : auto *A = new (C) MSABIAttr(getLocation(), C, getSpellingListIndex());
4187 0 : A->Inherited = Inherited;
4188 0 : A->IsPackExpansion = IsPackExpansion;
4189 0 : A->Implicit = Implicit;
4190 0 : return A;
4191 : }
4192 :
4193 0 : void MSABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4194 0 : switch (SpellingListIndex) {
4195 0 : default:
4196 0 : llvm_unreachable("Unknown attribute spelling!");
4197 : break;
4198 0 : case 0 : {
4199 0 : OS << " __attribute__((ms_abi))";
4200 0 : break;
4201 : }
4202 0 : case 1 : {
4203 0 : OS << " [[gnu::ms_abi]]";
4204 0 : break;
4205 : }
4206 : }
4207 0 : }
4208 :
4209 0 : const char *MSABIAttr::getSpelling() const {
4210 0 : switch (SpellingListIndex) {
4211 0 : default:
4212 0 : llvm_unreachable("Unknown attribute spelling!");
4213 : return "(No spelling)";
4214 : case 0:
4215 : return "ms_abi";
4216 : case 1:
4217 : return "ms_abi";
4218 : }
4219 : }
4220 :
4221 0 : MSInheritanceAttr *MSInheritanceAttr::clone(ASTContext &C) const {
4222 0 : auto *A = new (C) MSInheritanceAttr(getLocation(), C, bestCase, getSpellingListIndex());
4223 0 : A->Inherited = Inherited;
4224 0 : A->IsPackExpansion = IsPackExpansion;
4225 0 : A->Implicit = Implicit;
4226 0 : return A;
4227 : }
4228 :
4229 3 : void MSInheritanceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4230 3 : switch (SpellingListIndex) {
4231 0 : default:
4232 0 : llvm_unreachable("Unknown attribute spelling!");
4233 : break;
4234 1 : case 0 : {
4235 1 : OS << " __single_inheritance";
4236 1 : break;
4237 : }
4238 1 : case 1 : {
4239 1 : OS << " __multiple_inheritance";
4240 1 : break;
4241 : }
4242 1 : case 2 : {
4243 1 : OS << " __virtual_inheritance";
4244 1 : break;
4245 : }
4246 0 : case 3 : {
4247 0 : OS << " __unspecified_inheritance";
4248 0 : break;
4249 : }
4250 : }
4251 3 : }
4252 :
4253 0 : const char *MSInheritanceAttr::getSpelling() const {
4254 0 : switch (SpellingListIndex) {
4255 0 : default:
4256 0 : llvm_unreachable("Unknown attribute spelling!");
4257 : return "(No spelling)";
4258 : case 0:
4259 : return "__single_inheritance";
4260 0 : case 1:
4261 0 : return "__multiple_inheritance";
4262 0 : case 2:
4263 0 : return "__virtual_inheritance";
4264 0 : case 3:
4265 0 : return "__unspecified_inheritance";
4266 : }
4267 : }
4268 :
4269 0 : MSNoVTableAttr *MSNoVTableAttr::clone(ASTContext &C) const {
4270 : auto *A = new (C) MSNoVTableAttr(getLocation(), C, getSpellingListIndex());
4271 0 : A->Inherited = Inherited;
4272 0 : A->IsPackExpansion = IsPackExpansion;
4273 0 : A->Implicit = Implicit;
4274 0 : return A;
4275 : }
4276 :
4277 0 : void MSNoVTableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4278 0 : switch (SpellingListIndex) {
4279 0 : default:
4280 0 : llvm_unreachable("Unknown attribute spelling!");
4281 : break;
4282 0 : case 0 : {
4283 0 : OS << " __declspec(novtable)";
4284 : break;
4285 : }
4286 : }
4287 0 : }
4288 :
4289 0 : const char *MSNoVTableAttr::getSpelling() const {
4290 0 : switch (SpellingListIndex) {
4291 0 : default:
4292 0 : llvm_unreachable("Unknown attribute spelling!");
4293 : return "(No spelling)";
4294 0 : case 0:
4295 : return "novtable";
4296 : }
4297 : }
4298 :
4299 0 : MSP430InterruptAttr *MSP430InterruptAttr::clone(ASTContext &C) const {
4300 0 : auto *A = new (C) MSP430InterruptAttr(getLocation(), C, number, getSpellingListIndex());
4301 0 : A->Inherited = Inherited;
4302 0 : A->IsPackExpansion = IsPackExpansion;
4303 0 : A->Implicit = Implicit;
4304 0 : return A;
4305 : }
4306 :
4307 0 : void MSP430InterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4308 0 : switch (SpellingListIndex) {
4309 0 : default:
4310 0 : llvm_unreachable("Unknown attribute spelling!");
4311 : break;
4312 0 : case 0 : {
4313 0 : OS << " __attribute__((interrupt(" << getNumber() << ")))";
4314 0 : break;
4315 : }
4316 0 : case 1 : {
4317 0 : OS << " [[gnu::interrupt(" << getNumber() << ")]]";
4318 0 : break;
4319 : }
4320 : }
4321 0 : }
4322 :
4323 0 : const char *MSP430InterruptAttr::getSpelling() const {
4324 0 : switch (SpellingListIndex) {
4325 0 : default:
4326 0 : llvm_unreachable("Unknown attribute spelling!");
4327 : return "(No spelling)";
4328 : case 0:
4329 : return "interrupt";
4330 : case 1:
4331 : return "interrupt";
4332 : }
4333 : }
4334 :
4335 1 : MSStructAttr *MSStructAttr::clone(ASTContext &C) const {
4336 : auto *A = new (C) MSStructAttr(getLocation(), C, getSpellingListIndex());
4337 1 : A->Inherited = Inherited;
4338 1 : A->IsPackExpansion = IsPackExpansion;
4339 1 : A->Implicit = Implicit;
4340 1 : return A;
4341 : }
4342 :
4343 0 : void MSStructAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4344 0 : switch (SpellingListIndex) {
4345 0 : default:
4346 0 : llvm_unreachable("Unknown attribute spelling!");
4347 : break;
4348 0 : case 0 : {
4349 0 : OS << " __attribute__((ms_struct))";
4350 0 : break;
4351 : }
4352 0 : case 1 : {
4353 0 : OS << " [[gnu::ms_struct]]";
4354 0 : break;
4355 : }
4356 : }
4357 0 : }
4358 :
4359 0 : const char *MSStructAttr::getSpelling() const {
4360 0 : switch (SpellingListIndex) {
4361 0 : default:
4362 0 : llvm_unreachable("Unknown attribute spelling!");
4363 : return "(No spelling)";
4364 : case 0:
4365 : return "ms_struct";
4366 : case 1:
4367 : return "ms_struct";
4368 : }
4369 : }
4370 :
4371 2 : MSVtorDispAttr *MSVtorDispAttr::clone(ASTContext &C) const {
4372 2 : auto *A = new (C) MSVtorDispAttr(getLocation(), C, vdm, getSpellingListIndex());
4373 2 : A->Inherited = Inherited;
4374 2 : A->IsPackExpansion = IsPackExpansion;
4375 2 : A->Implicit = Implicit;
4376 2 : return A;
4377 : }
4378 :
4379 0 : void MSVtorDispAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4380 0 : }
4381 :
4382 0 : const char *MSVtorDispAttr::getSpelling() const {
4383 0 : return "(No spelling)";
4384 : }
4385 :
4386 1 : MaxFieldAlignmentAttr *MaxFieldAlignmentAttr::clone(ASTContext &C) const {
4387 1 : auto *A = new (C) MaxFieldAlignmentAttr(getLocation(), C, alignment, getSpellingListIndex());
4388 1 : A->Inherited = Inherited;
4389 1 : A->IsPackExpansion = IsPackExpansion;
4390 1 : A->Implicit = Implicit;
4391 1 : return A;
4392 : }
4393 :
4394 0 : void MaxFieldAlignmentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4395 0 : }
4396 :
4397 0 : const char *MaxFieldAlignmentAttr::getSpelling() const {
4398 0 : return "(No spelling)";
4399 : }
4400 :
4401 14 : MayAliasAttr *MayAliasAttr::clone(ASTContext &C) const {
4402 : auto *A = new (C) MayAliasAttr(getLocation(), C, getSpellingListIndex());
4403 14 : A->Inherited = Inherited;
4404 14 : A->IsPackExpansion = IsPackExpansion;
4405 14 : A->Implicit = Implicit;
4406 14 : return A;
4407 : }
4408 :
4409 16 : void MayAliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4410 16 : switch (SpellingListIndex) {
4411 0 : default:
4412 0 : llvm_unreachable("Unknown attribute spelling!");
4413 : break;
4414 16 : case 0 : {
4415 16 : OS << " __attribute__((may_alias))";
4416 16 : break;
4417 : }
4418 0 : case 1 : {
4419 0 : OS << " [[gnu::may_alias]]";
4420 0 : break;
4421 : }
4422 : }
4423 16 : }
4424 :
4425 0 : const char *MayAliasAttr::getSpelling() const {
4426 0 : switch (SpellingListIndex) {
4427 0 : default:
4428 0 : llvm_unreachable("Unknown attribute spelling!");
4429 : return "(No spelling)";
4430 : case 0:
4431 : return "may_alias";
4432 : case 1:
4433 : return "may_alias";
4434 : }
4435 : }
4436 :
4437 0 : MicroMipsAttr *MicroMipsAttr::clone(ASTContext &C) const {
4438 : auto *A = new (C) MicroMipsAttr(getLocation(), C, getSpellingListIndex());
4439 0 : A->Inherited = Inherited;
4440 0 : A->IsPackExpansion = IsPackExpansion;
4441 0 : A->Implicit = Implicit;
4442 0 : return A;
4443 : }
4444 :
4445 0 : void MicroMipsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4446 0 : switch (SpellingListIndex) {
4447 0 : default:
4448 0 : llvm_unreachable("Unknown attribute spelling!");
4449 : break;
4450 0 : case 0 : {
4451 0 : OS << " __attribute__((micromips))";
4452 0 : break;
4453 : }
4454 0 : case 1 : {
4455 0 : OS << " [[gnu::micromips]]";
4456 0 : break;
4457 : }
4458 : }
4459 0 : }
4460 :
4461 1 : const char *MicroMipsAttr::getSpelling() const {
4462 1 : switch (SpellingListIndex) {
4463 0 : default:
4464 0 : llvm_unreachable("Unknown attribute spelling!");
4465 : return "(No spelling)";
4466 : case 0:
4467 : return "micromips";
4468 : case 1:
4469 : return "micromips";
4470 : }
4471 : }
4472 :
4473 12 : MinSizeAttr *MinSizeAttr::clone(ASTContext &C) const {
4474 : auto *A = new (C) MinSizeAttr(getLocation(), C, getSpellingListIndex());
4475 12 : A->Inherited = Inherited;
4476 12 : A->IsPackExpansion = IsPackExpansion;
4477 12 : A->Implicit = Implicit;
4478 12 : return A;
4479 : }
4480 :
4481 0 : void MinSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4482 0 : switch (SpellingListIndex) {
4483 0 : default:
4484 0 : llvm_unreachable("Unknown attribute spelling!");
4485 : break;
4486 0 : case 0 : {
4487 0 : OS << " __attribute__((minsize))";
4488 0 : break;
4489 : }
4490 0 : case 1 : {
4491 0 : OS << " [[clang::minsize]]";
4492 0 : break;
4493 : }
4494 0 : case 2 : {
4495 0 : OS << " [[clang::minsize]]";
4496 0 : break;
4497 : }
4498 : }
4499 0 : }
4500 :
4501 3 : const char *MinSizeAttr::getSpelling() const {
4502 3 : switch (SpellingListIndex) {
4503 0 : default:
4504 0 : llvm_unreachable("Unknown attribute spelling!");
4505 : return "(No spelling)";
4506 : case 0:
4507 : return "minsize";
4508 : case 1:
4509 : return "minsize";
4510 : case 2:
4511 : return "minsize";
4512 : }
4513 : }
4514 :
4515 0 : MinVectorWidthAttr *MinVectorWidthAttr::clone(ASTContext &C) const {
4516 0 : auto *A = new (C) MinVectorWidthAttr(getLocation(), C, vectorWidth, getSpellingListIndex());
4517 0 : A->Inherited = Inherited;
4518 0 : A->IsPackExpansion = IsPackExpansion;
4519 0 : A->Implicit = Implicit;
4520 0 : return A;
4521 : }
4522 :
4523 0 : void MinVectorWidthAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4524 0 : switch (SpellingListIndex) {
4525 0 : default:
4526 0 : llvm_unreachable("Unknown attribute spelling!");
4527 : break;
4528 0 : case 0 : {
4529 0 : OS << " __attribute__((min_vector_width(" << getVectorWidth() << ")))";
4530 0 : break;
4531 : }
4532 0 : case 1 : {
4533 0 : OS << " [[clang::min_vector_width(" << getVectorWidth() << ")]]";
4534 0 : break;
4535 : }
4536 0 : case 2 : {
4537 0 : OS << " [[clang::min_vector_width(" << getVectorWidth() << ")]]";
4538 0 : break;
4539 : }
4540 : }
4541 0 : }
4542 :
4543 0 : const char *MinVectorWidthAttr::getSpelling() const {
4544 0 : switch (SpellingListIndex) {
4545 0 : default:
4546 0 : llvm_unreachable("Unknown attribute spelling!");
4547 : return "(No spelling)";
4548 : case 0:
4549 : return "min_vector_width";
4550 : case 1:
4551 : return "min_vector_width";
4552 : case 2:
4553 : return "min_vector_width";
4554 : }
4555 : }
4556 :
4557 1 : Mips16Attr *Mips16Attr::clone(ASTContext &C) const {
4558 : auto *A = new (C) Mips16Attr(getLocation(), C, getSpellingListIndex());
4559 1 : A->Inherited = Inherited;
4560 1 : A->IsPackExpansion = IsPackExpansion;
4561 1 : A->Implicit = Implicit;
4562 1 : return A;
4563 : }
4564 :
4565 0 : void Mips16Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4566 0 : switch (SpellingListIndex) {
4567 0 : default:
4568 0 : llvm_unreachable("Unknown attribute spelling!");
4569 : break;
4570 0 : case 0 : {
4571 0 : OS << " __attribute__((mips16))";
4572 0 : break;
4573 : }
4574 0 : case 1 : {
4575 0 : OS << " [[gnu::mips16]]";
4576 0 : break;
4577 : }
4578 : }
4579 0 : }
4580 :
4581 4 : const char *Mips16Attr::getSpelling() const {
4582 4 : switch (SpellingListIndex) {
4583 0 : default:
4584 0 : llvm_unreachable("Unknown attribute spelling!");
4585 : return "(No spelling)";
4586 : case 0:
4587 : return "mips16";
4588 : case 1:
4589 : return "mips16";
4590 : }
4591 : }
4592 :
4593 0 : MipsInterruptAttr *MipsInterruptAttr::clone(ASTContext &C) const {
4594 0 : auto *A = new (C) MipsInterruptAttr(getLocation(), C, interrupt, getSpellingListIndex());
4595 0 : A->Inherited = Inherited;
4596 0 : A->IsPackExpansion = IsPackExpansion;
4597 0 : A->Implicit = Implicit;
4598 0 : return A;
4599 : }
4600 :
4601 0 : void MipsInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4602 0 : switch (SpellingListIndex) {
4603 0 : default:
4604 0 : llvm_unreachable("Unknown attribute spelling!");
4605 : break;
4606 0 : case 0 : {
4607 0 : OS << " __attribute__((interrupt(\"" << MipsInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")))";
4608 0 : break;
4609 : }
4610 0 : case 1 : {
4611 0 : OS << " [[gnu::interrupt(\"" << MipsInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")]]";
4612 0 : break;
4613 : }
4614 : }
4615 0 : }
4616 :
4617 2 : const char *MipsInterruptAttr::getSpelling() const {
4618 2 : switch (SpellingListIndex) {
4619 0 : default:
4620 0 : llvm_unreachable("Unknown attribute spelling!");
4621 : return "(No spelling)";
4622 : case 0:
4623 : return "interrupt";
4624 : case 1:
4625 : return "interrupt";
4626 : }
4627 : }
4628 :
4629 0 : MipsLongCallAttr *MipsLongCallAttr::clone(ASTContext &C) const {
4630 : auto *A = new (C) MipsLongCallAttr(getLocation(), C, getSpellingListIndex());
4631 0 : A->Inherited = Inherited;
4632 0 : A->IsPackExpansion = IsPackExpansion;
4633 0 : A->Implicit = Implicit;
4634 0 : return A;
4635 : }
4636 :
4637 0 : void MipsLongCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4638 0 : switch (SpellingListIndex) {
4639 0 : default:
4640 0 : llvm_unreachable("Unknown attribute spelling!");
4641 : break;
4642 0 : case 0 : {
4643 0 : OS << " __attribute__((long_call))";
4644 0 : break;
4645 : }
4646 0 : case 1 : {
4647 0 : OS << " [[gnu::long_call]]";
4648 0 : break;
4649 : }
4650 0 : case 2 : {
4651 0 : OS << " __attribute__((far))";
4652 0 : break;
4653 : }
4654 0 : case 3 : {
4655 0 : OS << " [[gnu::far]]";
4656 0 : break;
4657 : }
4658 : }
4659 0 : }
4660 :
4661 2 : const char *MipsLongCallAttr::getSpelling() const {
4662 2 : switch (SpellingListIndex) {
4663 0 : default:
4664 0 : llvm_unreachable("Unknown attribute spelling!");
4665 : return "(No spelling)";
4666 : case 0:
4667 : return "long_call";
4668 : case 1:
4669 : return "long_call";
4670 2 : case 2:
4671 2 : return "far";
4672 0 : case 3:
4673 0 : return "far";
4674 : }
4675 : }
4676 :
4677 0 : MipsShortCallAttr *MipsShortCallAttr::clone(ASTContext &C) const {
4678 : auto *A = new (C) MipsShortCallAttr(getLocation(), C, getSpellingListIndex());
4679 0 : A->Inherited = Inherited;
4680 0 : A->IsPackExpansion = IsPackExpansion;
4681 0 : A->Implicit = Implicit;
4682 0 : return A;
4683 : }
4684 :
4685 0 : void MipsShortCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4686 0 : switch (SpellingListIndex) {
4687 0 : default:
4688 0 : llvm_unreachable("Unknown attribute spelling!");
4689 : break;
4690 0 : case 0 : {
4691 0 : OS << " __attribute__((short_call))";
4692 0 : break;
4693 : }
4694 0 : case 1 : {
4695 0 : OS << " [[gnu::short_call]]";
4696 0 : break;
4697 : }
4698 0 : case 2 : {
4699 0 : OS << " __attribute__((near))";
4700 0 : break;
4701 : }
4702 0 : case 3 : {
4703 0 : OS << " [[gnu::near]]";
4704 0 : break;
4705 : }
4706 : }
4707 0 : }
4708 :
4709 2 : const char *MipsShortCallAttr::getSpelling() const {
4710 2 : switch (SpellingListIndex) {
4711 0 : default:
4712 0 : llvm_unreachable("Unknown attribute spelling!");
4713 : return "(No spelling)";
4714 : case 0:
4715 : return "short_call";
4716 : case 1:
4717 : return "short_call";
4718 0 : case 2:
4719 0 : return "near";
4720 0 : case 3:
4721 0 : return "near";
4722 : }
4723 : }
4724 :
4725 0 : ModeAttr *ModeAttr::clone(ASTContext &C) const {
4726 0 : auto *A = new (C) ModeAttr(getLocation(), C, mode, getSpellingListIndex());
4727 0 : A->Inherited = Inherited;
4728 0 : A->IsPackExpansion = IsPackExpansion;
4729 0 : A->Implicit = Implicit;
4730 0 : return A;
4731 : }
4732 :
4733 3 : void ModeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4734 3 : switch (SpellingListIndex) {
4735 0 : default:
4736 0 : llvm_unreachable("Unknown attribute spelling!");
4737 : break;
4738 2 : case 0 : {
4739 4 : OS << " __attribute__((mode(" << (getMode() ? getMode()->getName() : "") << ")))";
4740 2 : break;
4741 : }
4742 1 : case 1 : {
4743 2 : OS << " [[gnu::mode(" << (getMode() ? getMode()->getName() : "") << ")]]";
4744 1 : break;
4745 : }
4746 : }
4747 3 : }
4748 :
4749 0 : const char *ModeAttr::getSpelling() const {
4750 0 : switch (SpellingListIndex) {
4751 0 : default:
4752 0 : llvm_unreachable("Unknown attribute spelling!");
4753 : return "(No spelling)";
4754 : case 0:
4755 : return "mode";
4756 : case 1:
4757 : return "mode";
4758 : }
4759 : }
4760 :
4761 6 : NSConsumedAttr *NSConsumedAttr::clone(ASTContext &C) const {
4762 : auto *A = new (C) NSConsumedAttr(getLocation(), C, getSpellingListIndex());
4763 6 : A->Inherited = Inherited;
4764 6 : A->IsPackExpansion = IsPackExpansion;
4765 6 : A->Implicit = Implicit;
4766 6 : return A;
4767 : }
4768 :
4769 0 : void NSConsumedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4770 0 : switch (SpellingListIndex) {
4771 0 : default:
4772 0 : llvm_unreachable("Unknown attribute spelling!");
4773 : break;
4774 0 : case 0 : {
4775 0 : OS << " __attribute__((ns_consumed))";
4776 0 : break;
4777 : }
4778 0 : case 1 : {
4779 0 : OS << " [[clang::ns_consumed]]";
4780 0 : break;
4781 : }
4782 0 : case 2 : {
4783 0 : OS << " [[clang::ns_consumed]]";
4784 0 : break;
4785 : }
4786 : }
4787 0 : }
4788 :
4789 0 : const char *NSConsumedAttr::getSpelling() const {
4790 0 : switch (SpellingListIndex) {
4791 0 : default:
4792 0 : llvm_unreachable("Unknown attribute spelling!");
4793 : return "(No spelling)";
4794 : case 0:
4795 : return "ns_consumed";
4796 : case 1:
4797 : return "ns_consumed";
4798 : case 2:
4799 : return "ns_consumed";
4800 : }
4801 : }
4802 :
4803 137 : NSConsumesSelfAttr *NSConsumesSelfAttr::clone(ASTContext &C) const {
4804 : auto *A = new (C) NSConsumesSelfAttr(getLocation(), C, getSpellingListIndex());
4805 137 : A->Inherited = Inherited;
4806 137 : A->IsPackExpansion = IsPackExpansion;
4807 137 : A->Implicit = Implicit;
4808 137 : return A;
4809 : }
4810 :
4811 0 : void NSConsumesSelfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4812 0 : switch (SpellingListIndex) {
4813 0 : default:
4814 0 : llvm_unreachable("Unknown attribute spelling!");
4815 : break;
4816 0 : case 0 : {
4817 0 : OS << " __attribute__((ns_consumes_self))";
4818 0 : break;
4819 : }
4820 0 : case 1 : {
4821 0 : OS << " [[clang::ns_consumes_self]]";
4822 0 : break;
4823 : }
4824 0 : case 2 : {
4825 0 : OS << " [[clang::ns_consumes_self]]";
4826 0 : break;
4827 : }
4828 : }
4829 0 : }
4830 :
4831 0 : const char *NSConsumesSelfAttr::getSpelling() const {
4832 0 : switch (SpellingListIndex) {
4833 0 : default:
4834 0 : llvm_unreachable("Unknown attribute spelling!");
4835 : return "(No spelling)";
4836 : case 0:
4837 : return "ns_consumes_self";
4838 : case 1:
4839 : return "ns_consumes_self";
4840 : case 2:
4841 : return "ns_consumes_self";
4842 : }
4843 : }
4844 :
4845 0 : NSReturnsAutoreleasedAttr *NSReturnsAutoreleasedAttr::clone(ASTContext &C) const {
4846 : auto *A = new (C) NSReturnsAutoreleasedAttr(getLocation(), C, getSpellingListIndex());
4847 0 : A->Inherited = Inherited;
4848 0 : A->IsPackExpansion = IsPackExpansion;
4849 0 : A->Implicit = Implicit;
4850 0 : return A;
4851 : }
4852 :
4853 0 : void NSReturnsAutoreleasedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4854 0 : switch (SpellingListIndex) {
4855 0 : default:
4856 0 : llvm_unreachable("Unknown attribute spelling!");
4857 : break;
4858 0 : case 0 : {
4859 0 : OS << " __attribute__((ns_returns_autoreleased))";
4860 0 : break;
4861 : }
4862 0 : case 1 : {
4863 0 : OS << " [[clang::ns_returns_autoreleased]]";
4864 0 : break;
4865 : }
4866 0 : case 2 : {
4867 0 : OS << " [[clang::ns_returns_autoreleased]]";
4868 0 : break;
4869 : }
4870 : }
4871 0 : }
4872 :
4873 0 : const char *NSReturnsAutoreleasedAttr::getSpelling() const {
4874 0 : switch (SpellingListIndex) {
4875 0 : default:
4876 0 : llvm_unreachable("Unknown attribute spelling!");
4877 : return "(No spelling)";
4878 : case 0:
4879 : return "ns_returns_autoreleased";
4880 : case 1:
4881 : return "ns_returns_autoreleased";
4882 : case 2:
4883 : return "ns_returns_autoreleased";
4884 : }
4885 : }
4886 :
4887 8 : NSReturnsNotRetainedAttr *NSReturnsNotRetainedAttr::clone(ASTContext &C) const {
4888 : auto *A = new (C) NSReturnsNotRetainedAttr(getLocation(), C, getSpellingListIndex());
4889 8 : A->Inherited = Inherited;
4890 8 : A->IsPackExpansion = IsPackExpansion;
4891 8 : A->Implicit = Implicit;
4892 8 : return A;
4893 : }
4894 :
4895 0 : void NSReturnsNotRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4896 0 : switch (SpellingListIndex) {
4897 0 : default:
4898 0 : llvm_unreachable("Unknown attribute spelling!");
4899 : break;
4900 0 : case 0 : {
4901 0 : OS << " __attribute__((ns_returns_not_retained))";
4902 0 : break;
4903 : }
4904 0 : case 1 : {
4905 0 : OS << " [[clang::ns_returns_not_retained]]";
4906 0 : break;
4907 : }
4908 0 : case 2 : {
4909 0 : OS << " [[clang::ns_returns_not_retained]]";
4910 0 : break;
4911 : }
4912 : }
4913 0 : }
4914 :
4915 0 : const char *NSReturnsNotRetainedAttr::getSpelling() const {
4916 0 : switch (SpellingListIndex) {
4917 0 : default:
4918 0 : llvm_unreachable("Unknown attribute spelling!");
4919 : return "(No spelling)";
4920 : case 0:
4921 : return "ns_returns_not_retained";
4922 : case 1:
4923 : return "ns_returns_not_retained";
4924 : case 2:
4925 : return "ns_returns_not_retained";
4926 : }
4927 : }
4928 :
4929 174 : NSReturnsRetainedAttr *NSReturnsRetainedAttr::clone(ASTContext &C) const {
4930 : auto *A = new (C) NSReturnsRetainedAttr(getLocation(), C, getSpellingListIndex());
4931 174 : A->Inherited = Inherited;
4932 174 : A->IsPackExpansion = IsPackExpansion;
4933 174 : A->Implicit = Implicit;
4934 174 : return A;
4935 : }
4936 :
4937 0 : void NSReturnsRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4938 0 : switch (SpellingListIndex) {
4939 0 : default:
4940 0 : llvm_unreachable("Unknown attribute spelling!");
4941 : break;
4942 0 : case 0 : {
4943 0 : OS << " __attribute__((ns_returns_retained))";
4944 0 : break;
4945 : }
4946 0 : case 1 : {
4947 0 : OS << " [[clang::ns_returns_retained]]";
4948 0 : break;
4949 : }
4950 0 : case 2 : {
4951 0 : OS << " [[clang::ns_returns_retained]]";
4952 0 : break;
4953 : }
4954 : }
4955 0 : }
4956 :
4957 0 : const char *NSReturnsRetainedAttr::getSpelling() const {
4958 0 : switch (SpellingListIndex) {
4959 0 : default:
4960 0 : llvm_unreachable("Unknown attribute spelling!");
4961 : return "(No spelling)";
4962 : case 0:
4963 : return "ns_returns_retained";
4964 : case 1:
4965 : return "ns_returns_retained";
4966 : case 2:
4967 : return "ns_returns_retained";
4968 : }
4969 : }
4970 :
4971 1 : NakedAttr *NakedAttr::clone(ASTContext &C) const {
4972 : auto *A = new (C) NakedAttr(getLocation(), C, getSpellingListIndex());
4973 1 : A->Inherited = Inherited;
4974 1 : A->IsPackExpansion = IsPackExpansion;
4975 1 : A->Implicit = Implicit;
4976 1 : return A;
4977 : }
4978 :
4979 0 : void NakedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
4980 0 : switch (SpellingListIndex) {
4981 0 : default:
4982 0 : llvm_unreachable("Unknown attribute spelling!");
4983 : break;
4984 0 : case 0 : {
4985 0 : OS << " __attribute__((naked))";
4986 0 : break;
4987 : }
4988 0 : case 1 : {
4989 0 : OS << " [[gnu::naked]]";
4990 0 : break;
4991 : }
4992 0 : case 2 : {
4993 0 : OS << " __declspec(naked)";
4994 0 : break;
4995 : }
4996 : }
4997 0 : }
4998 :
4999 1 : const char *NakedAttr::getSpelling() const {
5000 1 : switch (SpellingListIndex) {
5001 0 : default:
5002 0 : llvm_unreachable("Unknown attribute spelling!");
5003 : return "(No spelling)";
5004 : case 0:
5005 : return "naked";
5006 : case 1:
5007 : return "naked";
5008 : case 2:
5009 : return "naked";
5010 : }
5011 : }
5012 :
5013 0 : NoAliasAttr *NoAliasAttr::clone(ASTContext &C) const {
5014 : auto *A = new (C) NoAliasAttr(getLocation(), C, getSpellingListIndex());
5015 0 : A->Inherited = Inherited;
5016 0 : A->IsPackExpansion = IsPackExpansion;
5017 0 : A->Implicit = Implicit;
5018 0 : return A;
5019 : }
5020 :
5021 0 : void NoAliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5022 0 : switch (SpellingListIndex) {
5023 0 : default:
5024 0 : llvm_unreachable("Unknown attribute spelling!");
5025 : break;
5026 0 : case 0 : {
5027 0 : OS << " __declspec(noalias)";
5028 : break;
5029 : }
5030 : }
5031 0 : }
5032 :
5033 0 : const char *NoAliasAttr::getSpelling() const {
5034 0 : switch (SpellingListIndex) {
5035 0 : default:
5036 0 : llvm_unreachable("Unknown attribute spelling!");
5037 : return "(No spelling)";
5038 0 : case 0:
5039 : return "noalias";
5040 : }
5041 : }
5042 :
5043 0 : NoCommonAttr *NoCommonAttr::clone(ASTContext &C) const {
5044 : auto *A = new (C) NoCommonAttr(getLocation(), C, getSpellingListIndex());
5045 0 : A->Inherited = Inherited;
5046 0 : A->IsPackExpansion = IsPackExpansion;
5047 0 : A->Implicit = Implicit;
5048 0 : return A;
5049 : }
5050 :
5051 0 : void NoCommonAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5052 0 : switch (SpellingListIndex) {
5053 0 : default:
5054 0 : llvm_unreachable("Unknown attribute spelling!");
5055 : break;
5056 0 : case 0 : {
5057 0 : OS << " __attribute__((nocommon))";
5058 0 : break;
5059 : }
5060 0 : case 1 : {
5061 0 : OS << " [[gnu::nocommon]]";
5062 0 : break;
5063 : }
5064 : }
5065 0 : }
5066 :
5067 0 : const char *NoCommonAttr::getSpelling() const {
5068 0 : switch (SpellingListIndex) {
5069 0 : default:
5070 0 : llvm_unreachable("Unknown attribute spelling!");
5071 : return "(No spelling)";
5072 : case 0:
5073 : return "nocommon";
5074 : case 1:
5075 : return "nocommon";
5076 : }
5077 : }
5078 :
5079 4 : NoDebugAttr *NoDebugAttr::clone(ASTContext &C) const {
5080 : auto *A = new (C) NoDebugAttr(getLocation(), C, getSpellingListIndex());
5081 4 : A->Inherited = Inherited;
5082 4 : A->IsPackExpansion = IsPackExpansion;
5083 4 : A->Implicit = Implicit;
5084 4 : return A;
5085 : }
5086 :
5087 0 : void NoDebugAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5088 0 : switch (SpellingListIndex) {
5089 0 : default:
5090 0 : llvm_unreachable("Unknown attribute spelling!");
5091 : break;
5092 0 : case 0 : {
5093 0 : OS << " __attribute__((nodebug))";
5094 0 : break;
5095 : }
5096 0 : case 1 : {
5097 0 : OS << " [[gnu::nodebug]]";
5098 0 : break;
5099 : }
5100 : }
5101 0 : }
5102 :
5103 0 : const char *NoDebugAttr::getSpelling() const {
5104 0 : switch (SpellingListIndex) {
5105 0 : default:
5106 0 : llvm_unreachable("Unknown attribute spelling!");
5107 : return "(No spelling)";
5108 : case 0:
5109 : return "nodebug";
5110 : case 1:
5111 : return "nodebug";
5112 : }
5113 : }
5114 :
5115 0 : NoDestroyAttr *NoDestroyAttr::clone(ASTContext &C) const {
5116 : auto *A = new (C) NoDestroyAttr(getLocation(), C, getSpellingListIndex());
5117 0 : A->Inherited = Inherited;
5118 0 : A->IsPackExpansion = IsPackExpansion;
5119 0 : A->Implicit = Implicit;
5120 0 : return A;
5121 : }
5122 :
5123 0 : void NoDestroyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5124 0 : switch (SpellingListIndex) {
5125 0 : default:
5126 0 : llvm_unreachable("Unknown attribute spelling!");
5127 : break;
5128 0 : case 0 : {
5129 0 : OS << " __attribute__((no_destroy))";
5130 0 : break;
5131 : }
5132 0 : case 1 : {
5133 0 : OS << " [[clang::no_destroy]]";
5134 0 : break;
5135 : }
5136 : }
5137 0 : }
5138 :
5139 2 : const char *NoDestroyAttr::getSpelling() const {
5140 2 : switch (SpellingListIndex) {
5141 0 : default:
5142 0 : llvm_unreachable("Unknown attribute spelling!");
5143 : return "(No spelling)";
5144 : case 0:
5145 : return "no_destroy";
5146 : case 1:
5147 : return "no_destroy";
5148 : }
5149 : }
5150 :
5151 0 : NoDuplicateAttr *NoDuplicateAttr::clone(ASTContext &C) const {
5152 : auto *A = new (C) NoDuplicateAttr(getLocation(), C, getSpellingListIndex());
5153 0 : A->Inherited = Inherited;
5154 0 : A->IsPackExpansion = IsPackExpansion;
5155 0 : A->Implicit = Implicit;
5156 0 : return A;
5157 : }
5158 :
5159 0 : void NoDuplicateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5160 0 : switch (SpellingListIndex) {
5161 0 : default:
5162 0 : llvm_unreachable("Unknown attribute spelling!");
5163 : break;
5164 0 : case 0 : {
5165 0 : OS << " __attribute__((noduplicate))";
5166 0 : break;
5167 : }
5168 0 : case 1 : {
5169 0 : OS << " [[clang::noduplicate]]";
5170 0 : break;
5171 : }
5172 0 : case 2 : {
5173 0 : OS << " [[clang::noduplicate]]";
5174 0 : break;
5175 : }
5176 : }
5177 0 : }
5178 :
5179 0 : const char *NoDuplicateAttr::getSpelling() const {
5180 0 : switch (SpellingListIndex) {
5181 0 : default:
5182 0 : llvm_unreachable("Unknown attribute spelling!");
5183 : return "(No spelling)";
5184 : case 0:
5185 : return "noduplicate";
5186 : case 1:
5187 : return "noduplicate";
5188 : case 2:
5189 : return "noduplicate";
5190 : }
5191 : }
5192 :
5193 0 : NoEscapeAttr *NoEscapeAttr::clone(ASTContext &C) const {
5194 : auto *A = new (C) NoEscapeAttr(getLocation(), C, getSpellingListIndex());
5195 0 : A->Inherited = Inherited;
5196 0 : A->IsPackExpansion = IsPackExpansion;
5197 0 : A->Implicit = Implicit;
5198 0 : return A;
5199 : }
5200 :
5201 0 : void NoEscapeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5202 0 : switch (SpellingListIndex) {
5203 0 : default:
5204 0 : llvm_unreachable("Unknown attribute spelling!");
5205 : break;
5206 0 : case 0 : {
5207 0 : OS << " __attribute__((noescape))";
5208 0 : break;
5209 : }
5210 0 : case 1 : {
5211 0 : OS << " [[clang::noescape]]";
5212 0 : break;
5213 : }
5214 0 : case 2 : {
5215 0 : OS << " [[clang::noescape]]";
5216 0 : break;
5217 : }
5218 : }
5219 0 : }
5220 :
5221 0 : const char *NoEscapeAttr::getSpelling() const {
5222 0 : switch (SpellingListIndex) {
5223 0 : default:
5224 0 : llvm_unreachable("Unknown attribute spelling!");
5225 : return "(No spelling)";
5226 : case 0:
5227 : return "noescape";
5228 : case 1:
5229 : return "noescape";
5230 : case 2:
5231 : return "noescape";
5232 : }
5233 : }
5234 :
5235 100 : NoInlineAttr *NoInlineAttr::clone(ASTContext &C) const {
5236 : auto *A = new (C) NoInlineAttr(getLocation(), C, getSpellingListIndex());
5237 100 : A->Inherited = Inherited;
5238 100 : A->IsPackExpansion = IsPackExpansion;
5239 100 : A->Implicit = Implicit;
5240 100 : return A;
5241 : }
5242 :
5243 1 : void NoInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5244 1 : switch (SpellingListIndex) {
5245 0 : default:
5246 0 : llvm_unreachable("Unknown attribute spelling!");
5247 : break;
5248 1 : case 0 : {
5249 1 : OS << " __attribute__((noinline))";
5250 1 : break;
5251 : }
5252 0 : case 1 : {
5253 0 : OS << " [[gnu::noinline]]";
5254 0 : break;
5255 : }
5256 0 : case 2 : {
5257 0 : OS << " __declspec(noinline)";
5258 0 : break;
5259 : }
5260 : }
5261 1 : }
5262 :
5263 0 : const char *NoInlineAttr::getSpelling() const {
5264 0 : switch (SpellingListIndex) {
5265 0 : default:
5266 0 : llvm_unreachable("Unknown attribute spelling!");
5267 : return "(No spelling)";
5268 : case 0:
5269 : return "noinline";
5270 : case 1:
5271 : return "noinline";
5272 : case 2:
5273 : return "noinline";
5274 : }
5275 : }
5276 :
5277 3 : NoInstrumentFunctionAttr *NoInstrumentFunctionAttr::clone(ASTContext &C) const {
5278 : auto *A = new (C) NoInstrumentFunctionAttr(getLocation(), C, getSpellingListIndex());
5279 3 : A->Inherited = Inherited;
5280 3 : A->IsPackExpansion = IsPackExpansion;
5281 3 : A->Implicit = Implicit;
5282 3 : return A;
5283 : }
5284 :
5285 0 : void NoInstrumentFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5286 0 : switch (SpellingListIndex) {
5287 0 : default:
5288 0 : llvm_unreachable("Unknown attribute spelling!");
5289 : break;
5290 0 : case 0 : {
5291 0 : OS << " __attribute__((no_instrument_function))";
5292 0 : break;
5293 : }
5294 0 : case 1 : {
5295 0 : OS << " [[gnu::no_instrument_function]]";
5296 0 : break;
5297 : }
5298 : }
5299 0 : }
5300 :
5301 0 : const char *NoInstrumentFunctionAttr::getSpelling() const {
5302 0 : switch (SpellingListIndex) {
5303 0 : default:
5304 0 : llvm_unreachable("Unknown attribute spelling!");
5305 : return "(No spelling)";
5306 : case 0:
5307 : return "no_instrument_function";
5308 : case 1:
5309 : return "no_instrument_function";
5310 : }
5311 : }
5312 :
5313 0 : NoMicroMipsAttr *NoMicroMipsAttr::clone(ASTContext &C) const {
5314 : auto *A = new (C) NoMicroMipsAttr(getLocation(), C, getSpellingListIndex());
5315 0 : A->Inherited = Inherited;
5316 0 : A->IsPackExpansion = IsPackExpansion;
5317 0 : A->Implicit = Implicit;
5318 0 : return A;
5319 : }
5320 :
5321 0 : void NoMicroMipsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5322 0 : switch (SpellingListIndex) {
5323 0 : default:
5324 0 : llvm_unreachable("Unknown attribute spelling!");
5325 : break;
5326 0 : case 0 : {
5327 0 : OS << " __attribute__((nomicromips))";
5328 0 : break;
5329 : }
5330 0 : case 1 : {
5331 0 : OS << " [[gnu::nomicromips]]";
5332 0 : break;
5333 : }
5334 : }
5335 0 : }
5336 :
5337 0 : const char *NoMicroMipsAttr::getSpelling() const {
5338 0 : switch (SpellingListIndex) {
5339 0 : default:
5340 0 : llvm_unreachable("Unknown attribute spelling!");
5341 : return "(No spelling)";
5342 : case 0:
5343 : return "nomicromips";
5344 : case 1:
5345 : return "nomicromips";
5346 : }
5347 : }
5348 :
5349 2 : NoMips16Attr *NoMips16Attr::clone(ASTContext &C) const {
5350 : auto *A = new (C) NoMips16Attr(getLocation(), C, getSpellingListIndex());
5351 2 : A->Inherited = Inherited;
5352 2 : A->IsPackExpansion = IsPackExpansion;
5353 2 : A->Implicit = Implicit;
5354 2 : return A;
5355 : }
5356 :
5357 0 : void NoMips16Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5358 0 : switch (SpellingListIndex) {
5359 0 : default:
5360 0 : llvm_unreachable("Unknown attribute spelling!");
5361 : break;
5362 0 : case 0 : {
5363 0 : OS << " __attribute__((nomips16))";
5364 0 : break;
5365 : }
5366 0 : case 1 : {
5367 0 : OS << " [[gnu::nomips16]]";
5368 0 : break;
5369 : }
5370 : }
5371 0 : }
5372 :
5373 0 : const char *NoMips16Attr::getSpelling() const {
5374 0 : switch (SpellingListIndex) {
5375 0 : default:
5376 0 : llvm_unreachable("Unknown attribute spelling!");
5377 : return "(No spelling)";
5378 : case 0:
5379 : return "nomips16";
5380 : case 1:
5381 : return "nomips16";
5382 : }
5383 : }
5384 :
5385 0 : NoReturnAttr *NoReturnAttr::clone(ASTContext &C) const {
5386 : auto *A = new (C) NoReturnAttr(getLocation(), C, getSpellingListIndex());
5387 0 : A->Inherited = Inherited;
5388 0 : A->IsPackExpansion = IsPackExpansion;
5389 0 : A->Implicit = Implicit;
5390 0 : return A;
5391 : }
5392 :
5393 0 : void NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5394 0 : switch (SpellingListIndex) {
5395 0 : default:
5396 0 : llvm_unreachable("Unknown attribute spelling!");
5397 : break;
5398 0 : case 0 : {
5399 0 : OS << " __attribute__((noreturn))";
5400 0 : break;
5401 : }
5402 0 : case 1 : {
5403 0 : OS << " [[gnu::noreturn]]";
5404 0 : break;
5405 : }
5406 0 : case 2 : {
5407 0 : OS << " __declspec(noreturn)";
5408 0 : break;
5409 : }
5410 : }
5411 0 : }
5412 :
5413 0 : const char *NoReturnAttr::getSpelling() const {
5414 0 : switch (SpellingListIndex) {
5415 0 : default:
5416 0 : llvm_unreachable("Unknown attribute spelling!");
5417 : return "(No spelling)";
5418 : case 0:
5419 : return "noreturn";
5420 : case 1:
5421 : return "noreturn";
5422 : case 2:
5423 : return "noreturn";
5424 : }
5425 : }
5426 :
5427 87370 : NoSanitizeAttr *NoSanitizeAttr::clone(ASTContext &C) const {
5428 87370 : auto *A = new (C) NoSanitizeAttr(getLocation(), C, sanitizers_, sanitizers_Size, getSpellingListIndex());
5429 87370 : A->Inherited = Inherited;
5430 87370 : A->IsPackExpansion = IsPackExpansion;
5431 87370 : A->Implicit = Implicit;
5432 87370 : return A;
5433 : }
5434 :
5435 5 : void NoSanitizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5436 5 : switch (SpellingListIndex) {
5437 0 : default:
5438 0 : llvm_unreachable("Unknown attribute spelling!");
5439 : break;
5440 3 : case 0 : {
5441 3 : OS << " __attribute__((no_sanitize(";
5442 : bool isFirst = true;
5443 8 : for (const auto &Val : sanitizers()) {
5444 5 : if (isFirst) isFirst = false;
5445 2 : else OS << ", ";
5446 5 : OS << "\"" << Val << "\"";
5447 : }
5448 3 : OS << ")))";
5449 3 : break;
5450 : }
5451 2 : case 1 : {
5452 2 : OS << " [[clang::no_sanitize(";
5453 : bool isFirst = true;
5454 4 : for (const auto &Val : sanitizers()) {
5455 2 : if (isFirst) isFirst = false;
5456 0 : else OS << ", ";
5457 2 : OS << "\"" << Val << "\"";
5458 : }
5459 2 : OS << ")]]";
5460 2 : break;
5461 : }
5462 0 : case 2 : {
5463 0 : OS << " [[clang::no_sanitize(";
5464 : bool isFirst = true;
5465 0 : for (const auto &Val : sanitizers()) {
5466 0 : if (isFirst) isFirst = false;
5467 0 : else OS << ", ";
5468 0 : OS << "\"" << Val << "\"";
5469 : }
5470 0 : OS << ")]]";
5471 0 : break;
5472 : }
5473 : }
5474 5 : }
5475 :
5476 0 : const char *NoSanitizeAttr::getSpelling() const {
5477 0 : switch (SpellingListIndex) {
5478 0 : default:
5479 0 : llvm_unreachable("Unknown attribute spelling!");
5480 : return "(No spelling)";
5481 : case 0:
5482 : return "no_sanitize";
5483 : case 1:
5484 : return "no_sanitize";
5485 : case 2:
5486 : return "no_sanitize";
5487 : }
5488 : }
5489 :
5490 2 : NoSplitStackAttr *NoSplitStackAttr::clone(ASTContext &C) const {
5491 : auto *A = new (C) NoSplitStackAttr(getLocation(), C, getSpellingListIndex());
5492 2 : A->Inherited = Inherited;
5493 2 : A->IsPackExpansion = IsPackExpansion;
5494 2 : A->Implicit = Implicit;
5495 2 : return A;
5496 : }
5497 :
5498 0 : void NoSplitStackAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5499 0 : switch (SpellingListIndex) {
5500 0 : default:
5501 0 : llvm_unreachable("Unknown attribute spelling!");
5502 : break;
5503 0 : case 0 : {
5504 0 : OS << " __attribute__((no_split_stack))";
5505 0 : break;
5506 : }
5507 0 : case 1 : {
5508 0 : OS << " [[gnu::no_split_stack]]";
5509 0 : break;
5510 : }
5511 : }
5512 0 : }
5513 :
5514 0 : const char *NoSplitStackAttr::getSpelling() const {
5515 0 : switch (SpellingListIndex) {
5516 0 : default:
5517 0 : llvm_unreachable("Unknown attribute spelling!");
5518 : return "(No spelling)";
5519 : case 0:
5520 : return "no_split_stack";
5521 : case 1:
5522 : return "no_split_stack";
5523 : }
5524 : }
5525 :
5526 0 : NoStackProtectorAttr *NoStackProtectorAttr::clone(ASTContext &C) const {
5527 : auto *A = new (C) NoStackProtectorAttr(getLocation(), C, getSpellingListIndex());
5528 0 : A->Inherited = Inherited;
5529 0 : A->IsPackExpansion = IsPackExpansion;
5530 0 : A->Implicit = Implicit;
5531 0 : return A;
5532 : }
5533 :
5534 0 : void NoStackProtectorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5535 0 : switch (SpellingListIndex) {
5536 0 : default:
5537 0 : llvm_unreachable("Unknown attribute spelling!");
5538 : break;
5539 0 : case 0 : {
5540 0 : OS << " __attribute__((no_stack_protector))";
5541 0 : break;
5542 : }
5543 0 : case 1 : {
5544 0 : OS << " [[clang::no_stack_protector]]";
5545 0 : break;
5546 : }
5547 0 : case 2 : {
5548 0 : OS << " [[clang::no_stack_protector]]";
5549 0 : break;
5550 : }
5551 : }
5552 0 : }
5553 :
5554 0 : const char *NoStackProtectorAttr::getSpelling() const {
5555 0 : switch (SpellingListIndex) {
5556 0 : default:
5557 0 : llvm_unreachable("Unknown attribute spelling!");
5558 : return "(No spelling)";
5559 : case 0:
5560 : return "no_stack_protector";
5561 : case 1:
5562 : return "no_stack_protector";
5563 : case 2:
5564 : return "no_stack_protector";
5565 : }
5566 : }
5567 :
5568 27 : NoThreadSafetyAnalysisAttr *NoThreadSafetyAnalysisAttr::clone(ASTContext &C) const {
5569 : auto *A = new (C) NoThreadSafetyAnalysisAttr(getLocation(), C, getSpellingListIndex());
5570 27 : A->Inherited = Inherited;
5571 27 : A->IsPackExpansion = IsPackExpansion;
5572 27 : A->Implicit = Implicit;
5573 27 : return A;
5574 : }
5575 :
5576 0 : void NoThreadSafetyAnalysisAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5577 0 : switch (SpellingListIndex) {
5578 0 : default:
5579 0 : llvm_unreachable("Unknown attribute spelling!");
5580 : break;
5581 0 : case 0 : {
5582 0 : OS << " __attribute__((no_thread_safety_analysis))";
5583 0 : break;
5584 : }
5585 0 : case 1 : {
5586 0 : OS << " [[clang::no_thread_safety_analysis]]";
5587 0 : break;
5588 : }
5589 0 : case 2 : {
5590 0 : OS << " [[clang::no_thread_safety_analysis]]";
5591 0 : break;
5592 : }
5593 : }
5594 0 : }
5595 :
5596 0 : const char *NoThreadSafetyAnalysisAttr::getSpelling() const {
5597 0 : switch (SpellingListIndex) {
5598 0 : default:
5599 0 : llvm_unreachable("Unknown attribute spelling!");
5600 : return "(No spelling)";
5601 : case 0:
5602 : return "no_thread_safety_analysis";
5603 : case 1:
5604 : return "no_thread_safety_analysis";
5605 : case 2:
5606 : return "no_thread_safety_analysis";
5607 : }
5608 : }
5609 :
5610 2577 : NoThrowAttr *NoThrowAttr::clone(ASTContext &C) const {
5611 : auto *A = new (C) NoThrowAttr(getLocation(), C, getSpellingListIndex());
5612 2577 : A->Inherited = Inherited;
5613 2577 : A->IsPackExpansion = IsPackExpansion;
5614 2577 : A->Implicit = Implicit;
5615 2577 : return A;
5616 : }
5617 :
5618 0 : void NoThrowAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5619 0 : switch (SpellingListIndex) {
5620 0 : default:
5621 0 : llvm_unreachable("Unknown attribute spelling!");
5622 : break;
5623 0 : case 0 : {
5624 0 : OS << " __attribute__((nothrow))";
5625 0 : break;
5626 : }
5627 0 : case 1 : {
5628 0 : OS << " [[gnu::nothrow]]";
5629 0 : break;
5630 : }
5631 0 : case 2 : {
5632 0 : OS << " __declspec(nothrow)";
5633 0 : break;
5634 : }
5635 : }
5636 0 : }
5637 :
5638 0 : const char *NoThrowAttr::getSpelling() const {
5639 0 : switch (SpellingListIndex) {
5640 0 : default:
5641 0 : llvm_unreachable("Unknown attribute spelling!");
5642 : return "(No spelling)";
5643 : case 0:
5644 : return "nothrow";
5645 : case 1:
5646 : return "nothrow";
5647 : case 2:
5648 : return "nothrow";
5649 : }
5650 : }
5651 :
5652 2525 : NonNullAttr *NonNullAttr::clone(ASTContext &C) const {
5653 2525 : auto *A = new (C) NonNullAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
5654 2525 : A->Inherited = Inherited;
5655 2525 : A->IsPackExpansion = IsPackExpansion;
5656 2525 : A->Implicit = Implicit;
5657 2525 : return A;
5658 : }
5659 :
5660 4 : void NonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5661 4 : switch (SpellingListIndex) {
5662 0 : default:
5663 0 : llvm_unreachable("Unknown attribute spelling!");
5664 : break;
5665 4 : case 0 : {
5666 4 : OS << " __attribute__((nonnull(";
5667 : bool isFirst = true;
5668 12 : for (const auto &Val : args()) {
5669 8 : if (isFirst) isFirst = false;
5670 4 : else OS << ", ";
5671 : OS << Val.getSourceIndex();
5672 : }
5673 4 : OS << ")))";
5674 4 : break;
5675 : }
5676 0 : case 1 : {
5677 0 : OS << " [[gnu::nonnull(";
5678 : bool isFirst = true;
5679 0 : for (const auto &Val : args()) {
5680 0 : if (isFirst) isFirst = false;
5681 0 : else OS << ", ";
5682 : OS << Val.getSourceIndex();
5683 : }
5684 0 : OS << ")]]";
5685 0 : break;
5686 : }
5687 : }
5688 4 : }
5689 :
5690 0 : const char *NonNullAttr::getSpelling() const {
5691 0 : switch (SpellingListIndex) {
5692 0 : default:
5693 0 : llvm_unreachable("Unknown attribute spelling!");
5694 : return "(No spelling)";
5695 : case 0:
5696 : return "nonnull";
5697 : case 1:
5698 : return "nonnull";
5699 : }
5700 : }
5701 :
5702 0 : NotTailCalledAttr *NotTailCalledAttr::clone(ASTContext &C) const {
5703 : auto *A = new (C) NotTailCalledAttr(getLocation(), C, getSpellingListIndex());
5704 0 : A->Inherited = Inherited;
5705 0 : A->IsPackExpansion = IsPackExpansion;
5706 0 : A->Implicit = Implicit;
5707 0 : return A;
5708 : }
5709 :
5710 0 : void NotTailCalledAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5711 0 : switch (SpellingListIndex) {
5712 0 : default:
5713 0 : llvm_unreachable("Unknown attribute spelling!");
5714 : break;
5715 0 : case 0 : {
5716 0 : OS << " __attribute__((not_tail_called))";
5717 0 : break;
5718 : }
5719 0 : case 1 : {
5720 0 : OS << " [[clang::not_tail_called]]";
5721 0 : break;
5722 : }
5723 0 : case 2 : {
5724 0 : OS << " [[clang::not_tail_called]]";
5725 0 : break;
5726 : }
5727 : }
5728 0 : }
5729 :
5730 3 : const char *NotTailCalledAttr::getSpelling() const {
5731 3 : switch (SpellingListIndex) {
5732 0 : default:
5733 0 : llvm_unreachable("Unknown attribute spelling!");
5734 : return "(No spelling)";
5735 : case 0:
5736 : return "not_tail_called";
5737 : case 1:
5738 : return "not_tail_called";
5739 : case 2:
5740 : return "not_tail_called";
5741 : }
5742 : }
5743 :
5744 0 : OMPCaptureKindAttr *OMPCaptureKindAttr::clone(ASTContext &C) const {
5745 0 : auto *A = new (C) OMPCaptureKindAttr(getLocation(), C, captureKind, getSpellingListIndex());
5746 0 : A->Inherited = Inherited;
5747 0 : A->IsPackExpansion = IsPackExpansion;
5748 0 : A->Implicit = Implicit;
5749 0 : return A;
5750 : }
5751 :
5752 0 : void OMPCaptureKindAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5753 0 : }
5754 :
5755 0 : const char *OMPCaptureKindAttr::getSpelling() const {
5756 0 : return "(No spelling)";
5757 : }
5758 :
5759 0 : OMPCaptureNoInitAttr *OMPCaptureNoInitAttr::clone(ASTContext &C) const {
5760 : auto *A = new (C) OMPCaptureNoInitAttr(getLocation(), C, getSpellingListIndex());
5761 0 : A->Inherited = Inherited;
5762 0 : A->IsPackExpansion = IsPackExpansion;
5763 0 : A->Implicit = Implicit;
5764 0 : return A;
5765 : }
5766 :
5767 0 : void OMPCaptureNoInitAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5768 0 : }
5769 :
5770 0 : const char *OMPCaptureNoInitAttr::getSpelling() const {
5771 0 : return "(No spelling)";
5772 : }
5773 :
5774 0 : OMPDeclareSimdDeclAttr *OMPDeclareSimdDeclAttr::clone(ASTContext &C) const {
5775 0 : auto *A = new (C) OMPDeclareSimdDeclAttr(getLocation(), C, branchState, simdlen, uniforms_, uniforms_Size, aligneds_, aligneds_Size, alignments_, alignments_Size, linears_, linears_Size, modifiers_, modifiers_Size, steps_, steps_Size, getSpellingListIndex());
5776 0 : A->Inherited = Inherited;
5777 0 : A->IsPackExpansion = IsPackExpansion;
5778 0 : A->Implicit = Implicit;
5779 0 : return A;
5780 : }
5781 :
5782 92 : void OMPDeclareSimdDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5783 92 : switch (SpellingListIndex) {
5784 0 : default:
5785 0 : llvm_unreachable("Unknown attribute spelling!");
5786 : break;
5787 92 : case 0 : {
5788 92 : OS << "#pragma omp declare simd";
5789 92 : printPrettyPragma(OS, Policy);
5790 92 : OS << "\n"; break;
5791 : }
5792 : }
5793 92 : }
5794 :
5795 0 : const char *OMPDeclareSimdDeclAttr::getSpelling() const {
5796 0 : switch (SpellingListIndex) {
5797 0 : default:
5798 0 : llvm_unreachable("Unknown attribute spelling!");
5799 : return "(No spelling)";
5800 0 : case 0:
5801 : return "declare simd";
5802 : }
5803 : }
5804 :
5805 44 : OMPDeclareTargetDeclAttr *OMPDeclareTargetDeclAttr::clone(ASTContext &C) const {
5806 44 : auto *A = new (C) OMPDeclareTargetDeclAttr(getLocation(), C, mapType, getSpellingListIndex());
5807 44 : A->Inherited = Inherited;
5808 44 : A->IsPackExpansion = IsPackExpansion;
5809 44 : A->Implicit = Implicit;
5810 44 : return A;
5811 : }
5812 :
5813 124 : void OMPDeclareTargetDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5814 124 : switch (SpellingListIndex) {
5815 0 : default:
5816 0 : llvm_unreachable("Unknown attribute spelling!");
5817 : break;
5818 124 : case 0 : {
5819 124 : OS << "#pragma omp declare target";
5820 124 : printPrettyPragma(OS, Policy);
5821 124 : OS << "\n"; break;
5822 : }
5823 : }
5824 124 : }
5825 :
5826 0 : const char *OMPDeclareTargetDeclAttr::getSpelling() const {
5827 0 : switch (SpellingListIndex) {
5828 0 : default:
5829 0 : llvm_unreachable("Unknown attribute spelling!");
5830 : return "(No spelling)";
5831 0 : case 0:
5832 : return "declare target";
5833 : }
5834 : }
5835 :
5836 0 : OMPReferencedVarAttr *OMPReferencedVarAttr::clone(ASTContext &C) const {
5837 0 : auto *A = new (C) OMPReferencedVarAttr(getLocation(), C, ref, getSpellingListIndex());
5838 0 : A->Inherited = Inherited;
5839 0 : A->IsPackExpansion = IsPackExpansion;
5840 0 : A->Implicit = Implicit;
5841 0 : return A;
5842 : }
5843 :
5844 0 : void OMPReferencedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5845 0 : }
5846 :
5847 0 : const char *OMPReferencedVarAttr::getSpelling() const {
5848 0 : return "(No spelling)";
5849 : }
5850 :
5851 44 : OMPThreadPrivateDeclAttr *OMPThreadPrivateDeclAttr::clone(ASTContext &C) const {
5852 : auto *A = new (C) OMPThreadPrivateDeclAttr(getLocation(), C, getSpellingListIndex());
5853 44 : A->Inherited = Inherited;
5854 44 : A->IsPackExpansion = IsPackExpansion;
5855 44 : A->Implicit = Implicit;
5856 44 : return A;
5857 : }
5858 :
5859 0 : void OMPThreadPrivateDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5860 0 : }
5861 :
5862 0 : const char *OMPThreadPrivateDeclAttr::getSpelling() const {
5863 0 : return "(No spelling)";
5864 : }
5865 :
5866 0 : ObjCBoxableAttr *ObjCBoxableAttr::clone(ASTContext &C) const {
5867 : auto *A = new (C) ObjCBoxableAttr(getLocation(), C, getSpellingListIndex());
5868 0 : A->Inherited = Inherited;
5869 0 : A->IsPackExpansion = IsPackExpansion;
5870 0 : A->Implicit = Implicit;
5871 0 : return A;
5872 : }
5873 :
5874 0 : void ObjCBoxableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5875 0 : switch (SpellingListIndex) {
5876 0 : default:
5877 0 : llvm_unreachable("Unknown attribute spelling!");
5878 : break;
5879 0 : case 0 : {
5880 0 : OS << " __attribute__((objc_boxable))";
5881 0 : break;
5882 : }
5883 0 : case 1 : {
5884 0 : OS << " [[clang::objc_boxable]]";
5885 0 : break;
5886 : }
5887 0 : case 2 : {
5888 0 : OS << " [[clang::objc_boxable]]";
5889 0 : break;
5890 : }
5891 : }
5892 0 : }
5893 :
5894 0 : const char *ObjCBoxableAttr::getSpelling() const {
5895 0 : switch (SpellingListIndex) {
5896 0 : default:
5897 0 : llvm_unreachable("Unknown attribute spelling!");
5898 : return "(No spelling)";
5899 : case 0:
5900 : return "objc_boxable";
5901 : case 1:
5902 : return "objc_boxable";
5903 : case 2:
5904 : return "objc_boxable";
5905 : }
5906 : }
5907 :
5908 4 : ObjCBridgeAttr *ObjCBridgeAttr::clone(ASTContext &C) const {
5909 4 : auto *A = new (C) ObjCBridgeAttr(getLocation(), C, bridgedType, getSpellingListIndex());
5910 4 : A->Inherited = Inherited;
5911 4 : A->IsPackExpansion = IsPackExpansion;
5912 4 : A->Implicit = Implicit;
5913 4 : return A;
5914 : }
5915 :
5916 0 : void ObjCBridgeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5917 0 : switch (SpellingListIndex) {
5918 0 : default:
5919 0 : llvm_unreachable("Unknown attribute spelling!");
5920 : break;
5921 0 : case 0 : {
5922 0 : OS << " __attribute__((objc_bridge(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")))";
5923 0 : break;
5924 : }
5925 0 : case 1 : {
5926 0 : OS << " [[clang::objc_bridge(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
5927 0 : break;
5928 : }
5929 0 : case 2 : {
5930 0 : OS << " [[clang::objc_bridge(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
5931 0 : break;
5932 : }
5933 : }
5934 0 : }
5935 :
5936 0 : const char *ObjCBridgeAttr::getSpelling() const {
5937 0 : switch (SpellingListIndex) {
5938 0 : default:
5939 0 : llvm_unreachable("Unknown attribute spelling!");
5940 : return "(No spelling)";
5941 : case 0:
5942 : return "objc_bridge";
5943 : case 1:
5944 : return "objc_bridge";
5945 : case 2:
5946 : return "objc_bridge";
5947 : }
5948 : }
5949 :
5950 1 : ObjCBridgeMutableAttr *ObjCBridgeMutableAttr::clone(ASTContext &C) const {
5951 1 : auto *A = new (C) ObjCBridgeMutableAttr(getLocation(), C, bridgedType, getSpellingListIndex());
5952 1 : A->Inherited = Inherited;
5953 1 : A->IsPackExpansion = IsPackExpansion;
5954 1 : A->Implicit = Implicit;
5955 1 : return A;
5956 : }
5957 :
5958 0 : void ObjCBridgeMutableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
5959 0 : switch (SpellingListIndex) {
5960 0 : default:
5961 0 : llvm_unreachable("Unknown attribute spelling!");
5962 : break;
5963 0 : case 0 : {
5964 0 : OS << " __attribute__((objc_bridge_mutable(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")))";
5965 0 : break;
5966 : }
5967 0 : case 1 : {
5968 0 : OS << " [[clang::objc_bridge_mutable(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
5969 0 : break;
5970 : }
5971 0 : case 2 : {
5972 0 : OS << " [[clang::objc_bridge_mutable(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
5973 0 : break;
5974 : }
5975 : }
5976 0 : }
5977 :
5978 0 : const char *ObjCBridgeMutableAttr::getSpelling() const {
5979 0 : switch (SpellingListIndex) {
5980 0 : default:
5981 0 : llvm_unreachable("Unknown attribute spelling!");
5982 : return "(No spelling)";
5983 : case 0:
5984 : return "objc_bridge_mutable";
5985 : case 1:
5986 : return "objc_bridge_mutable";
5987 : case 2:
5988 : return "objc_bridge_mutable";
5989 : }
5990 : }
5991 :
5992 0 : ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttr::clone(ASTContext &C) const {
5993 0 : auto *A = new (C) ObjCBridgeRelatedAttr(getLocation(), C, relatedClass, classMethod, instanceMethod, getSpellingListIndex());
5994 0 : A->Inherited = Inherited;
5995 0 : A->IsPackExpansion = IsPackExpansion;
5996 0 : A->Implicit = Implicit;
5997 0 : return A;
5998 : }
5999 :
6000 1 : void ObjCBridgeRelatedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6001 1 : switch (SpellingListIndex) {
6002 0 : default:
6003 0 : llvm_unreachable("Unknown attribute spelling!");
6004 : break;
6005 1 : case 0 : {
6006 2 : OS << " __attribute__((objc_bridge_related(" << (getRelatedClass() ? getRelatedClass()->getName() : "") << ", " << (getClassMethod() ? getClassMethod()->getName() : "") << ", " << (getInstanceMethod() ? getInstanceMethod()->getName() : "") << ")))";
6007 1 : break;
6008 : }
6009 0 : case 1 : {
6010 0 : OS << " [[clang::objc_bridge_related(" << (getRelatedClass() ? getRelatedClass()->getName() : "") << ", " << (getClassMethod() ? getClassMethod()->getName() : "") << ", " << (getInstanceMethod() ? getInstanceMethod()->getName() : "") << ")]]";
6011 0 : break;
6012 : }
6013 0 : case 2 : {
6014 0 : OS << " [[clang::objc_bridge_related(" << (getRelatedClass() ? getRelatedClass()->getName() : "") << ", " << (getClassMethod() ? getClassMethod()->getName() : "") << ", " << (getInstanceMethod() ? getInstanceMethod()->getName() : "") << ")]]";
6015 0 : break;
6016 : }
6017 : }
6018 1 : }
6019 :
6020 0 : const char *ObjCBridgeRelatedAttr::getSpelling() const {
6021 0 : switch (SpellingListIndex) {
6022 0 : default:
6023 0 : llvm_unreachable("Unknown attribute spelling!");
6024 : return "(No spelling)";
6025 : case 0:
6026 : return "objc_bridge_related";
6027 : case 1:
6028 : return "objc_bridge_related";
6029 : case 2:
6030 : return "objc_bridge_related";
6031 : }
6032 : }
6033 :
6034 0 : ObjCDesignatedInitializerAttr *ObjCDesignatedInitializerAttr::clone(ASTContext &C) const {
6035 : auto *A = new (C) ObjCDesignatedInitializerAttr(getLocation(), C, getSpellingListIndex());
6036 0 : A->Inherited = Inherited;
6037 0 : A->IsPackExpansion = IsPackExpansion;
6038 0 : A->Implicit = Implicit;
6039 0 : return A;
6040 : }
6041 :
6042 0 : void ObjCDesignatedInitializerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6043 0 : switch (SpellingListIndex) {
6044 0 : default:
6045 0 : llvm_unreachable("Unknown attribute spelling!");
6046 : break;
6047 0 : case 0 : {
6048 0 : OS << " __attribute__((objc_designated_initializer))";
6049 0 : break;
6050 : }
6051 0 : case 1 : {
6052 0 : OS << " [[clang::objc_designated_initializer]]";
6053 0 : break;
6054 : }
6055 0 : case 2 : {
6056 0 : OS << " [[clang::objc_designated_initializer]]";
6057 0 : break;
6058 : }
6059 : }
6060 0 : }
6061 :
6062 0 : const char *ObjCDesignatedInitializerAttr::getSpelling() const {
6063 0 : switch (SpellingListIndex) {
6064 0 : default:
6065 0 : llvm_unreachable("Unknown attribute spelling!");
6066 : return "(No spelling)";
6067 : case 0:
6068 : return "objc_designated_initializer";
6069 : case 1:
6070 : return "objc_designated_initializer";
6071 : case 2:
6072 : return "objc_designated_initializer";
6073 : }
6074 : }
6075 :
6076 0 : ObjCExceptionAttr *ObjCExceptionAttr::clone(ASTContext &C) const {
6077 : auto *A = new (C) ObjCExceptionAttr(getLocation(), C, getSpellingListIndex());
6078 0 : A->Inherited = Inherited;
6079 0 : A->IsPackExpansion = IsPackExpansion;
6080 0 : A->Implicit = Implicit;
6081 0 : return A;
6082 : }
6083 :
6084 0 : void ObjCExceptionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6085 0 : switch (SpellingListIndex) {
6086 0 : default:
6087 0 : llvm_unreachable("Unknown attribute spelling!");
6088 : break;
6089 0 : case 0 : {
6090 0 : OS << " __attribute__((objc_exception))";
6091 0 : break;
6092 : }
6093 0 : case 1 : {
6094 0 : OS << " [[clang::objc_exception]]";
6095 0 : break;
6096 : }
6097 0 : case 2 : {
6098 0 : OS << " [[clang::objc_exception]]";
6099 0 : break;
6100 : }
6101 : }
6102 0 : }
6103 :
6104 0 : const char *ObjCExceptionAttr::getSpelling() const {
6105 0 : switch (SpellingListIndex) {
6106 0 : default:
6107 0 : llvm_unreachable("Unknown attribute spelling!");
6108 : return "(No spelling)";
6109 : case 0:
6110 : return "objc_exception";
6111 : case 1:
6112 : return "objc_exception";
6113 : case 2:
6114 : return "objc_exception";
6115 : }
6116 : }
6117 :
6118 0 : ObjCExplicitProtocolImplAttr *ObjCExplicitProtocolImplAttr::clone(ASTContext &C) const {
6119 : auto *A = new (C) ObjCExplicitProtocolImplAttr(getLocation(), C, getSpellingListIndex());
6120 0 : A->Inherited = Inherited;
6121 0 : A->IsPackExpansion = IsPackExpansion;
6122 0 : A->Implicit = Implicit;
6123 0 : return A;
6124 : }
6125 :
6126 0 : void ObjCExplicitProtocolImplAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6127 0 : switch (SpellingListIndex) {
6128 0 : default:
6129 0 : llvm_unreachable("Unknown attribute spelling!");
6130 : break;
6131 0 : case 0 : {
6132 0 : OS << " __attribute__((objc_protocol_requires_explicit_implementation))";
6133 0 : break;
6134 : }
6135 0 : case 1 : {
6136 0 : OS << " [[clang::objc_protocol_requires_explicit_implementation]]";
6137 0 : break;
6138 : }
6139 0 : case 2 : {
6140 0 : OS << " [[clang::objc_protocol_requires_explicit_implementation]]";
6141 0 : break;
6142 : }
6143 : }
6144 0 : }
6145 :
6146 0 : const char *ObjCExplicitProtocolImplAttr::getSpelling() const {
6147 0 : switch (SpellingListIndex) {
6148 0 : default:
6149 0 : llvm_unreachable("Unknown attribute spelling!");
6150 : return "(No spelling)";
6151 : case 0:
6152 : return "objc_protocol_requires_explicit_implementation";
6153 : case 1:
6154 : return "objc_protocol_requires_explicit_implementation";
6155 : case 2:
6156 : return "objc_protocol_requires_explicit_implementation";
6157 : }
6158 : }
6159 :
6160 0 : ObjCGCAttr *ObjCGCAttr::clone(ASTContext &C) const {
6161 0 : auto *A = new (C) ObjCGCAttr(getLocation(), C, kind, getSpellingListIndex());
6162 0 : A->Inherited = Inherited;
6163 0 : A->IsPackExpansion = IsPackExpansion;
6164 0 : A->Implicit = Implicit;
6165 0 : return A;
6166 : }
6167 :
6168 0 : void ObjCGCAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6169 0 : switch (SpellingListIndex) {
6170 0 : default:
6171 0 : llvm_unreachable("Unknown attribute spelling!");
6172 : break;
6173 0 : case 0 : {
6174 0 : OS << " __attribute__((objc_gc(" << (getKind() ? getKind()->getName() : "") << ")))";
6175 0 : break;
6176 : }
6177 0 : case 1 : {
6178 0 : OS << " [[clang::objc_gc(" << (getKind() ? getKind()->getName() : "") << ")]]";
6179 0 : break;
6180 : }
6181 0 : case 2 : {
6182 0 : OS << " [[clang::objc_gc(" << (getKind() ? getKind()->getName() : "") << ")]]";
6183 0 : break;
6184 : }
6185 : }
6186 0 : }
6187 :
6188 0 : const char *ObjCGCAttr::getSpelling() const {
6189 0 : switch (SpellingListIndex) {
6190 0 : default:
6191 0 : llvm_unreachable("Unknown attribute spelling!");
6192 : return "(No spelling)";
6193 : case 0:
6194 : return "objc_gc";
6195 : case 1:
6196 : return "objc_gc";
6197 : case 2:
6198 : return "objc_gc";
6199 : }
6200 : }
6201 :
6202 0 : ObjCIndependentClassAttr *ObjCIndependentClassAttr::clone(ASTContext &C) const {
6203 : auto *A = new (C) ObjCIndependentClassAttr(getLocation(), C, getSpellingListIndex());
6204 0 : A->Inherited = Inherited;
6205 0 : A->IsPackExpansion = IsPackExpansion;
6206 0 : A->Implicit = Implicit;
6207 0 : return A;
6208 : }
6209 :
6210 0 : void ObjCIndependentClassAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6211 0 : switch (SpellingListIndex) {
6212 0 : default:
6213 0 : llvm_unreachable("Unknown attribute spelling!");
6214 : break;
6215 0 : case 0 : {
6216 0 : OS << " __attribute__((objc_independent_class))";
6217 0 : break;
6218 : }
6219 0 : case 1 : {
6220 0 : OS << " [[clang::objc_independent_class]]";
6221 0 : break;
6222 : }
6223 0 : case 2 : {
6224 0 : OS << " [[clang::objc_independent_class]]";
6225 0 : break;
6226 : }
6227 : }
6228 0 : }
6229 :
6230 0 : const char *ObjCIndependentClassAttr::getSpelling() const {
6231 0 : switch (SpellingListIndex) {
6232 0 : default:
6233 0 : llvm_unreachable("Unknown attribute spelling!");
6234 : return "(No spelling)";
6235 : case 0:
6236 : return "objc_independent_class";
6237 : case 1:
6238 : return "objc_independent_class";
6239 : case 2:
6240 : return "objc_independent_class";
6241 : }
6242 : }
6243 :
6244 0 : ObjCInertUnsafeUnretainedAttr *ObjCInertUnsafeUnretainedAttr::clone(ASTContext &C) const {
6245 : auto *A = new (C) ObjCInertUnsafeUnretainedAttr(getLocation(), C, getSpellingListIndex());
6246 0 : A->Inherited = Inherited;
6247 0 : A->IsPackExpansion = IsPackExpansion;
6248 0 : A->Implicit = Implicit;
6249 0 : return A;
6250 : }
6251 :
6252 0 : void ObjCInertUnsafeUnretainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6253 0 : switch (SpellingListIndex) {
6254 0 : default:
6255 0 : llvm_unreachable("Unknown attribute spelling!");
6256 : break;
6257 0 : case 0 : {
6258 0 : OS << " __unsafe_unretained";
6259 : break;
6260 : }
6261 : }
6262 0 : }
6263 :
6264 0 : const char *ObjCInertUnsafeUnretainedAttr::getSpelling() const {
6265 0 : switch (SpellingListIndex) {
6266 0 : default:
6267 0 : llvm_unreachable("Unknown attribute spelling!");
6268 : return "(No spelling)";
6269 0 : case 0:
6270 : return "__unsafe_unretained";
6271 : }
6272 : }
6273 :
6274 0 : ObjCKindOfAttr *ObjCKindOfAttr::clone(ASTContext &C) const {
6275 : auto *A = new (C) ObjCKindOfAttr(getLocation(), C, getSpellingListIndex());
6276 0 : A->Inherited = Inherited;
6277 0 : A->IsPackExpansion = IsPackExpansion;
6278 0 : A->Implicit = Implicit;
6279 0 : return A;
6280 : }
6281 :
6282 0 : void ObjCKindOfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6283 0 : switch (SpellingListIndex) {
6284 0 : default:
6285 0 : llvm_unreachable("Unknown attribute spelling!");
6286 : break;
6287 0 : case 0 : {
6288 0 : OS << " __kindof";
6289 : break;
6290 : }
6291 : }
6292 0 : }
6293 :
6294 0 : const char *ObjCKindOfAttr::getSpelling() const {
6295 0 : switch (SpellingListIndex) {
6296 0 : default:
6297 0 : llvm_unreachable("Unknown attribute spelling!");
6298 : return "(No spelling)";
6299 0 : case 0:
6300 : return "__kindof";
6301 : }
6302 : }
6303 :
6304 9 : ObjCMethodFamilyAttr *ObjCMethodFamilyAttr::clone(ASTContext &C) const {
6305 9 : auto *A = new (C) ObjCMethodFamilyAttr(getLocation(), C, family, getSpellingListIndex());
6306 9 : A->Inherited = Inherited;
6307 9 : A->IsPackExpansion = IsPackExpansion;
6308 9 : A->Implicit = Implicit;
6309 9 : return A;
6310 : }
6311 :
6312 0 : void ObjCMethodFamilyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6313 0 : switch (SpellingListIndex) {
6314 0 : default:
6315 0 : llvm_unreachable("Unknown attribute spelling!");
6316 : break;
6317 0 : case 0 : {
6318 0 : OS << " __attribute__((objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")))";
6319 0 : break;
6320 : }
6321 0 : case 1 : {
6322 0 : OS << " [[clang::objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")]]";
6323 0 : break;
6324 : }
6325 0 : case 2 : {
6326 0 : OS << " [[clang::objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")]]";
6327 0 : break;
6328 : }
6329 : }
6330 0 : }
6331 :
6332 0 : const char *ObjCMethodFamilyAttr::getSpelling() const {
6333 0 : switch (SpellingListIndex) {
6334 0 : default:
6335 0 : llvm_unreachable("Unknown attribute spelling!");
6336 : return "(No spelling)";
6337 : case 0:
6338 : return "objc_method_family";
6339 : case 1:
6340 : return "objc_method_family";
6341 : case 2:
6342 : return "objc_method_family";
6343 : }
6344 : }
6345 :
6346 0 : ObjCNSObjectAttr *ObjCNSObjectAttr::clone(ASTContext &C) const {
6347 : auto *A = new (C) ObjCNSObjectAttr(getLocation(), C, getSpellingListIndex());
6348 0 : A->Inherited = Inherited;
6349 0 : A->IsPackExpansion = IsPackExpansion;
6350 0 : A->Implicit = Implicit;
6351 0 : return A;
6352 : }
6353 :
6354 0 : void ObjCNSObjectAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6355 0 : switch (SpellingListIndex) {
6356 0 : default:
6357 0 : llvm_unreachable("Unknown attribute spelling!");
6358 : break;
6359 0 : case 0 : {
6360 0 : OS << " __attribute__((NSObject))";
6361 0 : break;
6362 : }
6363 0 : case 1 : {
6364 0 : OS << " [[clang::NSObject]]";
6365 0 : break;
6366 : }
6367 0 : case 2 : {
6368 0 : OS << " [[clang::NSObject]]";
6369 0 : break;
6370 : }
6371 : }
6372 0 : }
6373 :
6374 0 : const char *ObjCNSObjectAttr::getSpelling() const {
6375 0 : switch (SpellingListIndex) {
6376 0 : default:
6377 0 : llvm_unreachable("Unknown attribute spelling!");
6378 : return "(No spelling)";
6379 : case 0:
6380 : return "NSObject";
6381 : case 1:
6382 : return "NSObject";
6383 : case 2:
6384 : return "NSObject";
6385 : }
6386 : }
6387 :
6388 0 : ObjCOwnershipAttr *ObjCOwnershipAttr::clone(ASTContext &C) const {
6389 0 : auto *A = new (C) ObjCOwnershipAttr(getLocation(), C, kind, getSpellingListIndex());
6390 0 : A->Inherited = Inherited;
6391 0 : A->IsPackExpansion = IsPackExpansion;
6392 0 : A->Implicit = Implicit;
6393 0 : return A;
6394 : }
6395 :
6396 0 : void ObjCOwnershipAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6397 0 : switch (SpellingListIndex) {
6398 0 : default:
6399 0 : llvm_unreachable("Unknown attribute spelling!");
6400 : break;
6401 0 : case 0 : {
6402 0 : OS << " __attribute__((objc_ownership(" << (getKind() ? getKind()->getName() : "") << ")))";
6403 0 : break;
6404 : }
6405 0 : case 1 : {
6406 0 : OS << " [[clang::objc_ownership(" << (getKind() ? getKind()->getName() : "") << ")]]";
6407 0 : break;
6408 : }
6409 0 : case 2 : {
6410 0 : OS << " [[clang::objc_ownership(" << (getKind() ? getKind()->getName() : "") << ")]]";
6411 0 : break;
6412 : }
6413 : }
6414 0 : }
6415 :
6416 0 : const char *ObjCOwnershipAttr::getSpelling() const {
6417 0 : switch (SpellingListIndex) {
6418 0 : default:
6419 0 : llvm_unreachable("Unknown attribute spelling!");
6420 : return "(No spelling)";
6421 : case 0:
6422 : return "objc_ownership";
6423 : case 1:
6424 : return "objc_ownership";
6425 : case 2:
6426 : return "objc_ownership";
6427 : }
6428 : }
6429 :
6430 0 : ObjCPreciseLifetimeAttr *ObjCPreciseLifetimeAttr::clone(ASTContext &C) const {
6431 : auto *A = new (C) ObjCPreciseLifetimeAttr(getLocation(), C, getSpellingListIndex());
6432 0 : A->Inherited = Inherited;
6433 0 : A->IsPackExpansion = IsPackExpansion;
6434 0 : A->Implicit = Implicit;
6435 0 : return A;
6436 : }
6437 :
6438 0 : void ObjCPreciseLifetimeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6439 0 : switch (SpellingListIndex) {
6440 0 : default:
6441 0 : llvm_unreachable("Unknown attribute spelling!");
6442 : break;
6443 0 : case 0 : {
6444 0 : OS << " __attribute__((objc_precise_lifetime))";
6445 0 : break;
6446 : }
6447 0 : case 1 : {
6448 0 : OS << " [[clang::objc_precise_lifetime]]";
6449 0 : break;
6450 : }
6451 0 : case 2 : {
6452 0 : OS << " [[clang::objc_precise_lifetime]]";
6453 0 : break;
6454 : }
6455 : }
6456 0 : }
6457 :
6458 0 : const char *ObjCPreciseLifetimeAttr::getSpelling() const {
6459 0 : switch (SpellingListIndex) {
6460 0 : default:
6461 0 : llvm_unreachable("Unknown attribute spelling!");
6462 : return "(No spelling)";
6463 : case 0:
6464 : return "objc_precise_lifetime";
6465 : case 1:
6466 : return "objc_precise_lifetime";
6467 : case 2:
6468 : return "objc_precise_lifetime";
6469 : }
6470 : }
6471 :
6472 0 : ObjCRequiresPropertyDefsAttr *ObjCRequiresPropertyDefsAttr::clone(ASTContext &C) const {
6473 : auto *A = new (C) ObjCRequiresPropertyDefsAttr(getLocation(), C, getSpellingListIndex());
6474 0 : A->Inherited = Inherited;
6475 0 : A->IsPackExpansion = IsPackExpansion;
6476 0 : A->Implicit = Implicit;
6477 0 : return A;
6478 : }
6479 :
6480 0 : void ObjCRequiresPropertyDefsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6481 0 : switch (SpellingListIndex) {
6482 0 : default:
6483 0 : llvm_unreachable("Unknown attribute spelling!");
6484 : break;
6485 0 : case 0 : {
6486 0 : OS << " __attribute__((objc_requires_property_definitions))";
6487 0 : break;
6488 : }
6489 0 : case 1 : {
6490 0 : OS << " [[clang::objc_requires_property_definitions]]";
6491 0 : break;
6492 : }
6493 0 : case 2 : {
6494 0 : OS << " [[clang::objc_requires_property_definitions]]";
6495 0 : break;
6496 : }
6497 : }
6498 0 : }
6499 :
6500 0 : const char *ObjCRequiresPropertyDefsAttr::getSpelling() const {
6501 0 : switch (SpellingListIndex) {
6502 0 : default:
6503 0 : llvm_unreachable("Unknown attribute spelling!");
6504 : return "(No spelling)";
6505 : case 0:
6506 : return "objc_requires_property_definitions";
6507 : case 1:
6508 : return "objc_requires_property_definitions";
6509 : case 2:
6510 : return "objc_requires_property_definitions";
6511 : }
6512 : }
6513 :
6514 12 : ObjCRequiresSuperAttr *ObjCRequiresSuperAttr::clone(ASTContext &C) const {
6515 : auto *A = new (C) ObjCRequiresSuperAttr(getLocation(), C, getSpellingListIndex());
6516 12 : A->Inherited = Inherited;
6517 12 : A->IsPackExpansion = IsPackExpansion;
6518 12 : A->Implicit = Implicit;
6519 12 : return A;
6520 : }
6521 :
6522 0 : void ObjCRequiresSuperAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6523 0 : switch (SpellingListIndex) {
6524 0 : default:
6525 0 : llvm_unreachable("Unknown attribute spelling!");
6526 : break;
6527 0 : case 0 : {
6528 0 : OS << " __attribute__((objc_requires_super))";
6529 0 : break;
6530 : }
6531 0 : case 1 : {
6532 0 : OS << " [[clang::objc_requires_super]]";
6533 0 : break;
6534 : }
6535 0 : case 2 : {
6536 0 : OS << " [[clang::objc_requires_super]]";
6537 0 : break;
6538 : }
6539 : }
6540 0 : }
6541 :
6542 0 : const char *ObjCRequiresSuperAttr::getSpelling() const {
6543 0 : switch (SpellingListIndex) {
6544 0 : default:
6545 0 : llvm_unreachable("Unknown attribute spelling!");
6546 : return "(No spelling)";
6547 : case 0:
6548 : return "objc_requires_super";
6549 : case 1:
6550 : return "objc_requires_super";
6551 : case 2:
6552 : return "objc_requires_super";
6553 : }
6554 : }
6555 :
6556 0 : ObjCReturnsInnerPointerAttr *ObjCReturnsInnerPointerAttr::clone(ASTContext &C) const {
6557 : auto *A = new (C) ObjCReturnsInnerPointerAttr(getLocation(), C, getSpellingListIndex());
6558 0 : A->Inherited = Inherited;
6559 0 : A->IsPackExpansion = IsPackExpansion;
6560 0 : A->Implicit = Implicit;
6561 0 : return A;
6562 : }
6563 :
6564 0 : void ObjCReturnsInnerPointerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6565 0 : switch (SpellingListIndex) {
6566 0 : default:
6567 0 : llvm_unreachable("Unknown attribute spelling!");
6568 : break;
6569 0 : case 0 : {
6570 0 : OS << " __attribute__((objc_returns_inner_pointer))";
6571 0 : break;
6572 : }
6573 0 : case 1 : {
6574 0 : OS << " [[clang::objc_returns_inner_pointer]]";
6575 0 : break;
6576 : }
6577 0 : case 2 : {
6578 0 : OS << " [[clang::objc_returns_inner_pointer]]";
6579 0 : break;
6580 : }
6581 : }
6582 0 : }
6583 :
6584 0 : const char *ObjCReturnsInnerPointerAttr::getSpelling() const {
6585 0 : switch (SpellingListIndex) {
6586 0 : default:
6587 0 : llvm_unreachable("Unknown attribute spelling!");
6588 : return "(No spelling)";
6589 : case 0:
6590 : return "objc_returns_inner_pointer";
6591 : case 1:
6592 : return "objc_returns_inner_pointer";
6593 : case 2:
6594 : return "objc_returns_inner_pointer";
6595 : }
6596 : }
6597 :
6598 0 : ObjCRootClassAttr *ObjCRootClassAttr::clone(ASTContext &C) const {
6599 : auto *A = new (C) ObjCRootClassAttr(getLocation(), C, getSpellingListIndex());
6600 0 : A->Inherited = Inherited;
6601 0 : A->IsPackExpansion = IsPackExpansion;
6602 0 : A->Implicit = Implicit;
6603 0 : return A;
6604 : }
6605 :
6606 0 : void ObjCRootClassAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6607 0 : switch (SpellingListIndex) {
6608 0 : default:
6609 0 : llvm_unreachable("Unknown attribute spelling!");
6610 : break;
6611 0 : case 0 : {
6612 0 : OS << " __attribute__((objc_root_class))";
6613 0 : break;
6614 : }
6615 0 : case 1 : {
6616 0 : OS << " [[clang::objc_root_class]]";
6617 0 : break;
6618 : }
6619 0 : case 2 : {
6620 0 : OS << " [[clang::objc_root_class]]";
6621 0 : break;
6622 : }
6623 : }
6624 0 : }
6625 :
6626 0 : const char *ObjCRootClassAttr::getSpelling() const {
6627 0 : switch (SpellingListIndex) {
6628 0 : default:
6629 0 : llvm_unreachable("Unknown attribute spelling!");
6630 : return "(No spelling)";
6631 : case 0:
6632 : return "objc_root_class";
6633 : case 1:
6634 : return "objc_root_class";
6635 : case 2:
6636 : return "objc_root_class";
6637 : }
6638 : }
6639 :
6640 0 : ObjCRuntimeNameAttr *ObjCRuntimeNameAttr::clone(ASTContext &C) const {
6641 0 : auto *A = new (C) ObjCRuntimeNameAttr(getLocation(), C, getMetadataName(), getSpellingListIndex());
6642 0 : A->Inherited = Inherited;
6643 0 : A->IsPackExpansion = IsPackExpansion;
6644 0 : A->Implicit = Implicit;
6645 0 : return A;
6646 : }
6647 :
6648 0 : void ObjCRuntimeNameAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6649 0 : switch (SpellingListIndex) {
6650 0 : default:
6651 0 : llvm_unreachable("Unknown attribute spelling!");
6652 : break;
6653 0 : case 0 : {
6654 0 : OS << " __attribute__((objc_runtime_name(\"" << getMetadataName() << "\")))";
6655 0 : break;
6656 : }
6657 0 : case 1 : {
6658 0 : OS << " [[clang::objc_runtime_name(\"" << getMetadataName() << "\")]]";
6659 0 : break;
6660 : }
6661 0 : case 2 : {
6662 0 : OS << " [[clang::objc_runtime_name(\"" << getMetadataName() << "\")]]";
6663 0 : break;
6664 : }
6665 : }
6666 0 : }
6667 :
6668 0 : const char *ObjCRuntimeNameAttr::getSpelling() const {
6669 0 : switch (SpellingListIndex) {
6670 0 : default:
6671 0 : llvm_unreachable("Unknown attribute spelling!");
6672 : return "(No spelling)";
6673 : case 0:
6674 : return "objc_runtime_name";
6675 : case 1:
6676 : return "objc_runtime_name";
6677 : case 2:
6678 : return "objc_runtime_name";
6679 : }
6680 : }
6681 :
6682 0 : ObjCRuntimeVisibleAttr *ObjCRuntimeVisibleAttr::clone(ASTContext &C) const {
6683 : auto *A = new (C) ObjCRuntimeVisibleAttr(getLocation(), C, getSpellingListIndex());
6684 0 : A->Inherited = Inherited;
6685 0 : A->IsPackExpansion = IsPackExpansion;
6686 0 : A->Implicit = Implicit;
6687 0 : return A;
6688 : }
6689 :
6690 0 : void ObjCRuntimeVisibleAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6691 0 : switch (SpellingListIndex) {
6692 0 : default:
6693 0 : llvm_unreachable("Unknown attribute spelling!");
6694 : break;
6695 0 : case 0 : {
6696 0 : OS << " __attribute__((objc_runtime_visible))";
6697 0 : break;
6698 : }
6699 0 : case 1 : {
6700 0 : OS << " [[clang::objc_runtime_visible]]";
6701 0 : break;
6702 : }
6703 0 : case 2 : {
6704 0 : OS << " [[clang::objc_runtime_visible]]";
6705 0 : break;
6706 : }
6707 : }
6708 0 : }
6709 :
6710 0 : const char *ObjCRuntimeVisibleAttr::getSpelling() const {
6711 0 : switch (SpellingListIndex) {
6712 0 : default:
6713 0 : llvm_unreachable("Unknown attribute spelling!");
6714 : return "(No spelling)";
6715 : case 0:
6716 : return "objc_runtime_visible";
6717 : case 1:
6718 : return "objc_runtime_visible";
6719 : case 2:
6720 : return "objc_runtime_visible";
6721 : }
6722 : }
6723 :
6724 0 : ObjCSubclassingRestrictedAttr *ObjCSubclassingRestrictedAttr::clone(ASTContext &C) const {
6725 : auto *A = new (C) ObjCSubclassingRestrictedAttr(getLocation(), C, getSpellingListIndex());
6726 0 : A->Inherited = Inherited;
6727 0 : A->IsPackExpansion = IsPackExpansion;
6728 0 : A->Implicit = Implicit;
6729 0 : return A;
6730 : }
6731 :
6732 0 : void ObjCSubclassingRestrictedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6733 0 : switch (SpellingListIndex) {
6734 0 : default:
6735 0 : llvm_unreachable("Unknown attribute spelling!");
6736 : break;
6737 0 : case 0 : {
6738 0 : OS << " __attribute__((objc_subclassing_restricted))";
6739 0 : break;
6740 : }
6741 0 : case 1 : {
6742 0 : OS << " [[clang::objc_subclassing_restricted]]";
6743 0 : break;
6744 : }
6745 0 : case 2 : {
6746 0 : OS << " [[clang::objc_subclassing_restricted]]";
6747 0 : break;
6748 : }
6749 : }
6750 0 : }
6751 :
6752 0 : const char *ObjCSubclassingRestrictedAttr::getSpelling() const {
6753 0 : switch (SpellingListIndex) {
6754 0 : default:
6755 0 : llvm_unreachable("Unknown attribute spelling!");
6756 : return "(No spelling)";
6757 : case 0:
6758 : return "objc_subclassing_restricted";
6759 : case 1:
6760 : return "objc_subclassing_restricted";
6761 : case 2:
6762 : return "objc_subclassing_restricted";
6763 : }
6764 : }
6765 :
6766 0 : OpenCLAccessAttr *OpenCLAccessAttr::clone(ASTContext &C) const {
6767 : auto *A = new (C) OpenCLAccessAttr(getLocation(), C, getSpellingListIndex());
6768 0 : A->Inherited = Inherited;
6769 0 : A->IsPackExpansion = IsPackExpansion;
6770 0 : A->Implicit = Implicit;
6771 0 : return A;
6772 : }
6773 :
6774 0 : void OpenCLAccessAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6775 0 : switch (SpellingListIndex) {
6776 0 : default:
6777 0 : llvm_unreachable("Unknown attribute spelling!");
6778 : break;
6779 0 : case 0 : {
6780 0 : OS << " __read_only";
6781 0 : break;
6782 : }
6783 0 : case 1 : {
6784 0 : OS << " read_only";
6785 0 : break;
6786 : }
6787 0 : case 2 : {
6788 0 : OS << " __write_only";
6789 0 : break;
6790 : }
6791 0 : case 3 : {
6792 0 : OS << " write_only";
6793 0 : break;
6794 : }
6795 0 : case 4 : {
6796 0 : OS << " __read_write";
6797 0 : break;
6798 : }
6799 0 : case 5 : {
6800 0 : OS << " read_write";
6801 0 : break;
6802 : }
6803 : }
6804 0 : }
6805 :
6806 3 : const char *OpenCLAccessAttr::getSpelling() const {
6807 3 : switch (SpellingListIndex) {
6808 0 : default:
6809 0 : llvm_unreachable("Unknown attribute spelling!");
6810 : return "(No spelling)";
6811 : case 0:
6812 : return "__read_only";
6813 2 : case 1:
6814 2 : return "read_only";
6815 0 : case 2:
6816 0 : return "__write_only";
6817 1 : case 3:
6818 1 : return "write_only";
6819 0 : case 4:
6820 0 : return "__read_write";
6821 0 : case 5:
6822 0 : return "read_write";
6823 : }
6824 : }
6825 :
6826 0 : OpenCLConstantAddressSpaceAttr *OpenCLConstantAddressSpaceAttr::clone(ASTContext &C) const {
6827 : auto *A = new (C) OpenCLConstantAddressSpaceAttr(getLocation(), C, getSpellingListIndex());
6828 0 : A->Inherited = Inherited;
6829 0 : A->IsPackExpansion = IsPackExpansion;
6830 0 : A->Implicit = Implicit;
6831 0 : return A;
6832 : }
6833 :
6834 0 : void OpenCLConstantAddressSpaceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6835 0 : switch (SpellingListIndex) {
6836 0 : default:
6837 0 : llvm_unreachable("Unknown attribute spelling!");
6838 : break;
6839 0 : case 0 : {
6840 0 : OS << " __constant";
6841 0 : break;
6842 : }
6843 0 : case 1 : {
6844 0 : OS << " constant";
6845 0 : break;
6846 : }
6847 : }
6848 0 : }
6849 :
6850 0 : const char *OpenCLConstantAddressSpaceAttr::getSpelling() const {
6851 0 : switch (SpellingListIndex) {
6852 0 : default:
6853 0 : llvm_unreachable("Unknown attribute spelling!");
6854 : return "(No spelling)";
6855 : case 0:
6856 : return "__constant";
6857 0 : case 1:
6858 0 : return "constant";
6859 : }
6860 : }
6861 :
6862 0 : OpenCLGenericAddressSpaceAttr *OpenCLGenericAddressSpaceAttr::clone(ASTContext &C) const {
6863 : auto *A = new (C) OpenCLGenericAddressSpaceAttr(getLocation(), C, getSpellingListIndex());
6864 0 : A->Inherited = Inherited;
6865 0 : A->IsPackExpansion = IsPackExpansion;
6866 0 : A->Implicit = Implicit;
6867 0 : return A;
6868 : }
6869 :
6870 0 : void OpenCLGenericAddressSpaceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6871 0 : switch (SpellingListIndex) {
6872 0 : default:
6873 0 : llvm_unreachable("Unknown attribute spelling!");
6874 : break;
6875 0 : case 0 : {
6876 0 : OS << " __generic";
6877 0 : break;
6878 : }
6879 0 : case 1 : {
6880 0 : OS << " generic";
6881 0 : break;
6882 : }
6883 : }
6884 0 : }
6885 :
6886 0 : const char *OpenCLGenericAddressSpaceAttr::getSpelling() const {
6887 0 : switch (SpellingListIndex) {
6888 0 : default:
6889 0 : llvm_unreachable("Unknown attribute spelling!");
6890 : return "(No spelling)";
6891 : case 0:
6892 : return "__generic";
6893 0 : case 1:
6894 0 : return "generic";
6895 : }
6896 : }
6897 :
6898 0 : OpenCLGlobalAddressSpaceAttr *OpenCLGlobalAddressSpaceAttr::clone(ASTContext &C) const {
6899 : auto *A = new (C) OpenCLGlobalAddressSpaceAttr(getLocation(), C, getSpellingListIndex());
6900 0 : A->Inherited = Inherited;
6901 0 : A->IsPackExpansion = IsPackExpansion;
6902 0 : A->Implicit = Implicit;
6903 0 : return A;
6904 : }
6905 :
6906 0 : void OpenCLGlobalAddressSpaceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6907 0 : switch (SpellingListIndex) {
6908 0 : default:
6909 0 : llvm_unreachable("Unknown attribute spelling!");
6910 : break;
6911 0 : case 0 : {
6912 0 : OS << " __global";
6913 0 : break;
6914 : }
6915 0 : case 1 : {
6916 0 : OS << " global";
6917 0 : break;
6918 : }
6919 : }
6920 0 : }
6921 :
6922 0 : const char *OpenCLGlobalAddressSpaceAttr::getSpelling() const {
6923 0 : switch (SpellingListIndex) {
6924 0 : default:
6925 0 : llvm_unreachable("Unknown attribute spelling!");
6926 : return "(No spelling)";
6927 : case 0:
6928 : return "__global";
6929 0 : case 1:
6930 0 : return "global";
6931 : }
6932 : }
6933 :
6934 0 : OpenCLIntelReqdSubGroupSizeAttr *OpenCLIntelReqdSubGroupSizeAttr::clone(ASTContext &C) const {
6935 0 : auto *A = new (C) OpenCLIntelReqdSubGroupSizeAttr(getLocation(), C, subGroupSize, getSpellingListIndex());
6936 0 : A->Inherited = Inherited;
6937 0 : A->IsPackExpansion = IsPackExpansion;
6938 0 : A->Implicit = Implicit;
6939 0 : return A;
6940 : }
6941 :
6942 0 : void OpenCLIntelReqdSubGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6943 0 : switch (SpellingListIndex) {
6944 0 : default:
6945 0 : llvm_unreachable("Unknown attribute spelling!");
6946 : break;
6947 0 : case 0 : {
6948 0 : OS << " __attribute__((intel_reqd_sub_group_size(" << getSubGroupSize() << ")))";
6949 : break;
6950 : }
6951 : }
6952 0 : }
6953 :
6954 2 : const char *OpenCLIntelReqdSubGroupSizeAttr::getSpelling() const {
6955 2 : switch (SpellingListIndex) {
6956 0 : default:
6957 0 : llvm_unreachable("Unknown attribute spelling!");
6958 : return "(No spelling)";
6959 2 : case 0:
6960 : return "intel_reqd_sub_group_size";
6961 : }
6962 : }
6963 :
6964 0 : OpenCLKernelAttr *OpenCLKernelAttr::clone(ASTContext &C) const {
6965 : auto *A = new (C) OpenCLKernelAttr(getLocation(), C, getSpellingListIndex());
6966 0 : A->Inherited = Inherited;
6967 0 : A->IsPackExpansion = IsPackExpansion;
6968 0 : A->Implicit = Implicit;
6969 0 : return A;
6970 : }
6971 :
6972 0 : void OpenCLKernelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
6973 0 : switch (SpellingListIndex) {
6974 0 : default:
6975 0 : llvm_unreachable("Unknown attribute spelling!");
6976 : break;
6977 0 : case 0 : {
6978 0 : OS << " __kernel";
6979 0 : break;
6980 : }
6981 0 : case 1 : {
6982 0 : OS << " kernel";
6983 0 : break;
6984 : }
6985 : }
6986 0 : }
6987 :
6988 0 : const char *OpenCLKernelAttr::getSpelling() const {
6989 0 : switch (SpellingListIndex) {
6990 0 : default:
6991 0 : llvm_unreachable("Unknown attribute spelling!");
6992 : return "(No spelling)";
6993 : case 0:
6994 : return "__kernel";
6995 0 : case 1:
6996 0 : return "kernel";
6997 : }
6998 : }
6999 :
7000 0 : OpenCLLocalAddressSpaceAttr *OpenCLLocalAddressSpaceAttr::clone(ASTContext &C) const {
7001 : auto *A = new (C) OpenCLLocalAddressSpaceAttr(getLocation(), C, getSpellingListIndex());
7002 0 : A->Inherited = Inherited;
7003 0 : A->IsPackExpansion = IsPackExpansion;
7004 0 : A->Implicit = Implicit;
7005 0 : return A;
7006 : }
7007 :
7008 0 : void OpenCLLocalAddressSpaceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7009 0 : switch (SpellingListIndex) {
7010 0 : default:
7011 0 : llvm_unreachable("Unknown attribute spelling!");
7012 : break;
7013 0 : case 0 : {
7014 0 : OS << " __local";
7015 0 : break;
7016 : }
7017 0 : case 1 : {
7018 0 : OS << " local";
7019 0 : break;
7020 : }
7021 : }
7022 0 : }
7023 :
7024 0 : const char *OpenCLLocalAddressSpaceAttr::getSpelling() const {
7025 0 : switch (SpellingListIndex) {
7026 0 : default:
7027 0 : llvm_unreachable("Unknown attribute spelling!");
7028 : return "(No spelling)";
7029 : case 0:
7030 : return "__local";
7031 0 : case 1:
7032 0 : return "local";
7033 : }
7034 : }
7035 :
7036 0 : OpenCLPrivateAddressSpaceAttr *OpenCLPrivateAddressSpaceAttr::clone(ASTContext &C) const {
7037 : auto *A = new (C) OpenCLPrivateAddressSpaceAttr(getLocation(), C, getSpellingListIndex());
7038 0 : A->Inherited = Inherited;
7039 0 : A->IsPackExpansion = IsPackExpansion;
7040 0 : A->Implicit = Implicit;
7041 0 : return A;
7042 : }
7043 :
7044 0 : void OpenCLPrivateAddressSpaceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7045 0 : switch (SpellingListIndex) {
7046 0 : default:
7047 0 : llvm_unreachable("Unknown attribute spelling!");
7048 : break;
7049 0 : case 0 : {
7050 0 : OS << " __private";
7051 0 : break;
7052 : }
7053 0 : case 1 : {
7054 0 : OS << " private";
7055 0 : break;
7056 : }
7057 : }
7058 0 : }
7059 :
7060 0 : const char *OpenCLPrivateAddressSpaceAttr::getSpelling() const {
7061 0 : switch (SpellingListIndex) {
7062 0 : default:
7063 0 : llvm_unreachable("Unknown attribute spelling!");
7064 : return "(No spelling)";
7065 : case 0:
7066 : return "__private";
7067 0 : case 1:
7068 0 : return "private";
7069 : }
7070 : }
7071 :
7072 0 : OpenCLUnrollHintAttr *OpenCLUnrollHintAttr::clone(ASTContext &C) const {
7073 0 : auto *A = new (C) OpenCLUnrollHintAttr(getLocation(), C, unrollHint, getSpellingListIndex());
7074 0 : A->Inherited = Inherited;
7075 0 : A->IsPackExpansion = IsPackExpansion;
7076 0 : A->Implicit = Implicit;
7077 0 : return A;
7078 : }
7079 :
7080 0 : void OpenCLUnrollHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7081 0 : switch (SpellingListIndex) {
7082 0 : default:
7083 0 : llvm_unreachable("Unknown attribute spelling!");
7084 : break;
7085 0 : case 0 : {
7086 0 : OS << " __attribute__((opencl_unroll_hint(" << getUnrollHint() << ")))";
7087 : break;
7088 : }
7089 : }
7090 0 : }
7091 :
7092 0 : const char *OpenCLUnrollHintAttr::getSpelling() const {
7093 0 : switch (SpellingListIndex) {
7094 0 : default:
7095 0 : llvm_unreachable("Unknown attribute spelling!");
7096 : return "(No spelling)";
7097 0 : case 0:
7098 : return "opencl_unroll_hint";
7099 : }
7100 : }
7101 :
7102 9 : OptimizeNoneAttr *OptimizeNoneAttr::clone(ASTContext &C) const {
7103 : auto *A = new (C) OptimizeNoneAttr(getLocation(), C, getSpellingListIndex());
7104 9 : A->Inherited = Inherited;
7105 9 : A->IsPackExpansion = IsPackExpansion;
7106 9 : A->Implicit = Implicit;
7107 9 : return A;
7108 : }
7109 :
7110 0 : void OptimizeNoneAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7111 0 : switch (SpellingListIndex) {
7112 0 : default:
7113 0 : llvm_unreachable("Unknown attribute spelling!");
7114 : break;
7115 0 : case 0 : {
7116 0 : OS << " __attribute__((optnone))";
7117 0 : break;
7118 : }
7119 0 : case 1 : {
7120 0 : OS << " [[clang::optnone]]";
7121 0 : break;
7122 : }
7123 0 : case 2 : {
7124 0 : OS << " [[clang::optnone]]";
7125 0 : break;
7126 : }
7127 : }
7128 0 : }
7129 :
7130 0 : const char *OptimizeNoneAttr::getSpelling() const {
7131 0 : switch (SpellingListIndex) {
7132 0 : default:
7133 0 : llvm_unreachable("Unknown attribute spelling!");
7134 : return "(No spelling)";
7135 : case 0:
7136 : return "optnone";
7137 : case 1:
7138 : return "optnone";
7139 : case 2:
7140 : return "optnone";
7141 : }
7142 : }
7143 :
7144 0 : OverloadableAttr *OverloadableAttr::clone(ASTContext &C) const {
7145 : auto *A = new (C) OverloadableAttr(getLocation(), C, getSpellingListIndex());
7146 0 : A->Inherited = Inherited;
7147 0 : A->IsPackExpansion = IsPackExpansion;
7148 0 : A->Implicit = Implicit;
7149 0 : return A;
7150 : }
7151 :
7152 0 : void OverloadableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7153 0 : switch (SpellingListIndex) {
7154 0 : default:
7155 0 : llvm_unreachable("Unknown attribute spelling!");
7156 : break;
7157 0 : case 0 : {
7158 0 : OS << " __attribute__((overloadable))";
7159 0 : break;
7160 : }
7161 0 : case 1 : {
7162 0 : OS << " [[clang::overloadable]]";
7163 0 : break;
7164 : }
7165 0 : case 2 : {
7166 0 : OS << " [[clang::overloadable]]";
7167 0 : break;
7168 : }
7169 : }
7170 0 : }
7171 :
7172 0 : const char *OverloadableAttr::getSpelling() const {
7173 0 : switch (SpellingListIndex) {
7174 0 : default:
7175 0 : llvm_unreachable("Unknown attribute spelling!");
7176 : return "(No spelling)";
7177 : case 0:
7178 : return "overloadable";
7179 : case 1:
7180 : return "overloadable";
7181 : case 2:
7182 : return "overloadable";
7183 : }
7184 : }
7185 :
7186 29 : OverrideAttr *OverrideAttr::clone(ASTContext &C) const {
7187 : auto *A = new (C) OverrideAttr(getLocation(), C, getSpellingListIndex());
7188 29 : A->Inherited = Inherited;
7189 29 : A->IsPackExpansion = IsPackExpansion;
7190 29 : A->Implicit = Implicit;
7191 29 : return A;
7192 : }
7193 :
7194 0 : void OverrideAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7195 0 : switch (SpellingListIndex) {
7196 0 : default:
7197 0 : llvm_unreachable("Unknown attribute spelling!");
7198 : break;
7199 0 : case 0 : {
7200 0 : OS << " override";
7201 : break;
7202 : }
7203 : }
7204 0 : }
7205 :
7206 0 : const char *OverrideAttr::getSpelling() const {
7207 0 : switch (SpellingListIndex) {
7208 0 : default:
7209 0 : llvm_unreachable("Unknown attribute spelling!");
7210 : return "(No spelling)";
7211 0 : case 0:
7212 : return "override";
7213 : }
7214 : }
7215 :
7216 0 : OwnershipAttr *OwnershipAttr::clone(ASTContext &C) const {
7217 0 : auto *A = new (C) OwnershipAttr(getLocation(), C, module, args_, args_Size, getSpellingListIndex());
7218 0 : A->Inherited = Inherited;
7219 0 : A->IsPackExpansion = IsPackExpansion;
7220 0 : A->Implicit = Implicit;
7221 0 : return A;
7222 : }
7223 :
7224 12 : void OwnershipAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7225 12 : switch (SpellingListIndex) {
7226 0 : default:
7227 0 : llvm_unreachable("Unknown attribute spelling!");
7228 : break;
7229 4 : case 0 : {
7230 8 : OS << " __attribute__((ownership_holds(" << (getModule() ? getModule()->getName() : "") << ", ";
7231 : bool isFirst = true;
7232 12 : for (const auto &Val : args()) {
7233 8 : if (isFirst) isFirst = false;
7234 4 : else OS << ", ";
7235 : OS << Val.getSourceIndex();
7236 : }
7237 4 : OS << ")))";
7238 4 : break;
7239 : }
7240 0 : case 1 : {
7241 0 : OS << " [[clang::ownership_holds(" << (getModule() ? getModule()->getName() : "") << ", ";
7242 : bool isFirst = true;
7243 0 : for (const auto &Val : args()) {
7244 0 : if (isFirst) isFirst = false;
7245 0 : else OS << ", ";
7246 : OS << Val.getSourceIndex();
7247 : }
7248 0 : OS << ")]]";
7249 0 : break;
7250 : }
7251 0 : case 2 : {
7252 0 : OS << " [[clang::ownership_holds(" << (getModule() ? getModule()->getName() : "") << ", ";
7253 : bool isFirst = true;
7254 0 : for (const auto &Val : args()) {
7255 0 : if (isFirst) isFirst = false;
7256 0 : else OS << ", ";
7257 : OS << Val.getSourceIndex();
7258 : }
7259 0 : OS << ")]]";
7260 0 : break;
7261 : }
7262 4 : case 3 : {
7263 8 : OS << " __attribute__((ownership_returns(" << (getModule() ? getModule()->getName() : "") << ", ";
7264 : bool isFirst = true;
7265 8 : for (const auto &Val : args()) {
7266 4 : if (isFirst) isFirst = false;
7267 0 : else OS << ", ";
7268 : OS << Val.getSourceIndex();
7269 : }
7270 4 : OS << ")))";
7271 4 : break;
7272 : }
7273 0 : case 4 : {
7274 0 : OS << " [[clang::ownership_returns(" << (getModule() ? getModule()->getName() : "") << ", ";
7275 : bool isFirst = true;
7276 0 : for (const auto &Val : args()) {
7277 0 : if (isFirst) isFirst = false;
7278 0 : else OS << ", ";
7279 : OS << Val.getSourceIndex();
7280 : }
7281 0 : OS << ")]]";
7282 0 : break;
7283 : }
7284 0 : case 5 : {
7285 0 : OS << " [[clang::ownership_returns(" << (getModule() ? getModule()->getName() : "") << ", ";
7286 : bool isFirst = true;
7287 0 : for (const auto &Val : args()) {
7288 0 : if (isFirst) isFirst = false;
7289 0 : else OS << ", ";
7290 : OS << Val.getSourceIndex();
7291 : }
7292 0 : OS << ")]]";
7293 0 : break;
7294 : }
7295 4 : case 6 : {
7296 8 : OS << " __attribute__((ownership_takes(" << (getModule() ? getModule()->getName() : "") << ", ";
7297 : bool isFirst = true;
7298 12 : for (const auto &Val : args()) {
7299 8 : if (isFirst) isFirst = false;
7300 4 : else OS << ", ";
7301 : OS << Val.getSourceIndex();
7302 : }
7303 4 : OS << ")))";
7304 4 : break;
7305 : }
7306 0 : case 7 : {
7307 0 : OS << " [[clang::ownership_takes(" << (getModule() ? getModule()->getName() : "") << ", ";
7308 : bool isFirst = true;
7309 0 : for (const auto &Val : args()) {
7310 0 : if (isFirst) isFirst = false;
7311 0 : else OS << ", ";
7312 : OS << Val.getSourceIndex();
7313 : }
7314 0 : OS << ")]]";
7315 0 : break;
7316 : }
7317 0 : case 8 : {
7318 0 : OS << " [[clang::ownership_takes(" << (getModule() ? getModule()->getName() : "") << ", ";
7319 : bool isFirst = true;
7320 0 : for (const auto &Val : args()) {
7321 0 : if (isFirst) isFirst = false;
7322 0 : else OS << ", ";
7323 : OS << Val.getSourceIndex();
7324 : }
7325 0 : OS << ")]]";
7326 0 : break;
7327 : }
7328 : }
7329 12 : }
7330 :
7331 1 : const char *OwnershipAttr::getSpelling() const {
7332 1 : switch (SpellingListIndex) {
7333 0 : default:
7334 0 : llvm_unreachable("Unknown attribute spelling!");
7335 : return "(No spelling)";
7336 : case 0:
7337 : return "ownership_holds";
7338 : case 1:
7339 : return "ownership_holds";
7340 : case 2:
7341 : return "ownership_holds";
7342 0 : case 3:
7343 0 : return "ownership_returns";
7344 0 : case 4:
7345 0 : return "ownership_returns";
7346 0 : case 5:
7347 0 : return "ownership_returns";
7348 0 : case 6:
7349 0 : return "ownership_takes";
7350 0 : case 7:
7351 0 : return "ownership_takes";
7352 0 : case 8:
7353 0 : return "ownership_takes";
7354 : }
7355 : }
7356 :
7357 17 : PackedAttr *PackedAttr::clone(ASTContext &C) const {
7358 : auto *A = new (C) PackedAttr(getLocation(), C, getSpellingListIndex());
7359 17 : A->Inherited = Inherited;
7360 17 : A->IsPackExpansion = IsPackExpansion;
7361 17 : A->Implicit = Implicit;
7362 17 : return A;
7363 : }
7364 :
7365 0 : void PackedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7366 0 : switch (SpellingListIndex) {
7367 0 : default:
7368 0 : llvm_unreachable("Unknown attribute spelling!");
7369 : break;
7370 0 : case 0 : {
7371 0 : OS << " __attribute__((packed))";
7372 0 : break;
7373 : }
7374 0 : case 1 : {
7375 0 : OS << " [[gnu::packed]]";
7376 0 : break;
7377 : }
7378 : }
7379 0 : }
7380 :
7381 0 : const char *PackedAttr::getSpelling() const {
7382 0 : switch (SpellingListIndex) {
7383 0 : default:
7384 0 : llvm_unreachable("Unknown attribute spelling!");
7385 : return "(No spelling)";
7386 : case 0:
7387 : return "packed";
7388 : case 1:
7389 : return "packed";
7390 : }
7391 : }
7392 :
7393 0 : ParamTypestateAttr *ParamTypestateAttr::clone(ASTContext &C) const {
7394 0 : auto *A = new (C) ParamTypestateAttr(getLocation(), C, paramState, getSpellingListIndex());
7395 0 : A->Inherited = Inherited;
7396 0 : A->IsPackExpansion = IsPackExpansion;
7397 0 : A->Implicit = Implicit;
7398 0 : return A;
7399 : }
7400 :
7401 0 : void ParamTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7402 0 : switch (SpellingListIndex) {
7403 0 : default:
7404 0 : llvm_unreachable("Unknown attribute spelling!");
7405 : break;
7406 0 : case 0 : {
7407 0 : OS << " __attribute__((param_typestate(\"" << ParamTypestateAttr::ConvertConsumedStateToStr(getParamState()) << "\")))";
7408 0 : break;
7409 : }
7410 0 : case 1 : {
7411 0 : OS << " [[clang::param_typestate(\"" << ParamTypestateAttr::ConvertConsumedStateToStr(getParamState()) << "\")]]";
7412 0 : break;
7413 : }
7414 : }
7415 0 : }
7416 :
7417 0 : const char *ParamTypestateAttr::getSpelling() const {
7418 0 : switch (SpellingListIndex) {
7419 0 : default:
7420 0 : llvm_unreachable("Unknown attribute spelling!");
7421 : return "(No spelling)";
7422 : case 0:
7423 : return "param_typestate";
7424 : case 1:
7425 : return "param_typestate";
7426 : }
7427 : }
7428 :
7429 0 : PascalAttr *PascalAttr::clone(ASTContext &C) const {
7430 : auto *A = new (C) PascalAttr(getLocation(), C, getSpellingListIndex());
7431 0 : A->Inherited = Inherited;
7432 0 : A->IsPackExpansion = IsPackExpansion;
7433 0 : A->Implicit = Implicit;
7434 0 : return A;
7435 : }
7436 :
7437 0 : void PascalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7438 0 : switch (SpellingListIndex) {
7439 0 : default:
7440 0 : llvm_unreachable("Unknown attribute spelling!");
7441 : break;
7442 0 : case 0 : {
7443 0 : OS << " __attribute__((pascal))";
7444 0 : break;
7445 : }
7446 0 : case 1 : {
7447 0 : OS << " [[clang::pascal]]";
7448 0 : break;
7449 : }
7450 0 : case 2 : {
7451 0 : OS << " [[clang::pascal]]";
7452 0 : break;
7453 : }
7454 0 : case 3 : {
7455 0 : OS << " __pascal";
7456 0 : break;
7457 : }
7458 0 : case 4 : {
7459 0 : OS << " _pascal";
7460 0 : break;
7461 : }
7462 : }
7463 0 : }
7464 :
7465 0 : const char *PascalAttr::getSpelling() const {
7466 0 : switch (SpellingListIndex) {
7467 0 : default:
7468 0 : llvm_unreachable("Unknown attribute spelling!");
7469 : return "(No spelling)";
7470 : case 0:
7471 : return "pascal";
7472 : case 1:
7473 : return "pascal";
7474 : case 2:
7475 : return "pascal";
7476 0 : case 3:
7477 0 : return "__pascal";
7478 0 : case 4:
7479 0 : return "_pascal";
7480 : }
7481 : }
7482 :
7483 31 : PassObjectSizeAttr *PassObjectSizeAttr::clone(ASTContext &C) const {
7484 31 : auto *A = new (C) PassObjectSizeAttr(getLocation(), C, type, getSpellingListIndex());
7485 31 : A->Inherited = Inherited;
7486 31 : A->IsPackExpansion = IsPackExpansion;
7487 31 : A->Implicit = Implicit;
7488 31 : return A;
7489 : }
7490 :
7491 0 : void PassObjectSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7492 0 : switch (SpellingListIndex) {
7493 0 : default:
7494 0 : llvm_unreachable("Unknown attribute spelling!");
7495 : break;
7496 0 : case 0 : {
7497 0 : OS << " __attribute__((pass_object_size(" << getType() << ")))";
7498 0 : break;
7499 : }
7500 0 : case 1 : {
7501 0 : OS << " [[clang::pass_object_size(" << getType() << ")]]";
7502 0 : break;
7503 : }
7504 0 : case 2 : {
7505 0 : OS << " [[clang::pass_object_size(" << getType() << ")]]";
7506 0 : break;
7507 : }
7508 : }
7509 0 : }
7510 :
7511 1 : const char *PassObjectSizeAttr::getSpelling() const {
7512 1 : switch (SpellingListIndex) {
7513 0 : default:
7514 0 : llvm_unreachable("Unknown attribute spelling!");
7515 : return "(No spelling)";
7516 : case 0:
7517 : return "pass_object_size";
7518 : case 1:
7519 : return "pass_object_size";
7520 : case 2:
7521 : return "pass_object_size";
7522 : }
7523 : }
7524 :
7525 0 : PcsAttr *PcsAttr::clone(ASTContext &C) const {
7526 0 : auto *A = new (C) PcsAttr(getLocation(), C, pCS, getSpellingListIndex());
7527 0 : A->Inherited = Inherited;
7528 0 : A->IsPackExpansion = IsPackExpansion;
7529 0 : A->Implicit = Implicit;
7530 0 : return A;
7531 : }
7532 :
7533 0 : void PcsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7534 0 : switch (SpellingListIndex) {
7535 0 : default:
7536 0 : llvm_unreachable("Unknown attribute spelling!");
7537 : break;
7538 0 : case 0 : {
7539 0 : OS << " __attribute__((pcs(\"" << PcsAttr::ConvertPCSTypeToStr(getPCS()) << "\")))";
7540 0 : break;
7541 : }
7542 0 : case 1 : {
7543 0 : OS << " [[gnu::pcs(\"" << PcsAttr::ConvertPCSTypeToStr(getPCS()) << "\")]]";
7544 0 : break;
7545 : }
7546 : }
7547 0 : }
7548 :
7549 0 : const char *PcsAttr::getSpelling() const {
7550 0 : switch (SpellingListIndex) {
7551 0 : default:
7552 0 : llvm_unreachable("Unknown attribute spelling!");
7553 : return "(No spelling)";
7554 : case 0:
7555 : return "pcs";
7556 : case 1:
7557 : return "pcs";
7558 : }
7559 : }
7560 :
7561 5 : PragmaClangBSSSectionAttr *PragmaClangBSSSectionAttr::clone(ASTContext &C) const {
7562 10 : auto *A = new (C) PragmaClangBSSSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
7563 5 : A->Inherited = Inherited;
7564 5 : A->IsPackExpansion = IsPackExpansion;
7565 5 : A->Implicit = Implicit;
7566 5 : return A;
7567 : }
7568 :
7569 0 : void PragmaClangBSSSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7570 0 : }
7571 :
7572 0 : const char *PragmaClangBSSSectionAttr::getSpelling() const {
7573 0 : return "(No spelling)";
7574 : }
7575 :
7576 0 : PragmaClangDataSectionAttr *PragmaClangDataSectionAttr::clone(ASTContext &C) const {
7577 0 : auto *A = new (C) PragmaClangDataSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
7578 0 : A->Inherited = Inherited;
7579 0 : A->IsPackExpansion = IsPackExpansion;
7580 0 : A->Implicit = Implicit;
7581 0 : return A;
7582 : }
7583 :
7584 0 : void PragmaClangDataSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7585 0 : }
7586 :
7587 0 : const char *PragmaClangDataSectionAttr::getSpelling() const {
7588 0 : return "(No spelling)";
7589 : }
7590 :
7591 2 : PragmaClangRodataSectionAttr *PragmaClangRodataSectionAttr::clone(ASTContext &C) const {
7592 4 : auto *A = new (C) PragmaClangRodataSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
7593 2 : A->Inherited = Inherited;
7594 2 : A->IsPackExpansion = IsPackExpansion;
7595 2 : A->Implicit = Implicit;
7596 2 : return A;
7597 : }
7598 :
7599 0 : void PragmaClangRodataSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7600 0 : }
7601 :
7602 0 : const char *PragmaClangRodataSectionAttr::getSpelling() const {
7603 0 : return "(No spelling)";
7604 : }
7605 :
7606 0 : PragmaClangTextSectionAttr *PragmaClangTextSectionAttr::clone(ASTContext &C) const {
7607 0 : auto *A = new (C) PragmaClangTextSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
7608 0 : A->Inherited = Inherited;
7609 0 : A->IsPackExpansion = IsPackExpansion;
7610 0 : A->Implicit = Implicit;
7611 0 : return A;
7612 : }
7613 :
7614 0 : void PragmaClangTextSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7615 0 : }
7616 :
7617 0 : const char *PragmaClangTextSectionAttr::getSpelling() const {
7618 0 : return "(No spelling)";
7619 : }
7620 :
7621 0 : PreserveAllAttr *PreserveAllAttr::clone(ASTContext &C) const {
7622 : auto *A = new (C) PreserveAllAttr(getLocation(), C, getSpellingListIndex());
7623 0 : A->Inherited = Inherited;
7624 0 : A->IsPackExpansion = IsPackExpansion;
7625 0 : A->Implicit = Implicit;
7626 0 : return A;
7627 : }
7628 :
7629 0 : void PreserveAllAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7630 0 : switch (SpellingListIndex) {
7631 0 : default:
7632 0 : llvm_unreachable("Unknown attribute spelling!");
7633 : break;
7634 0 : case 0 : {
7635 0 : OS << " __attribute__((preserve_all))";
7636 0 : break;
7637 : }
7638 0 : case 1 : {
7639 0 : OS << " [[clang::preserve_all]]";
7640 0 : break;
7641 : }
7642 0 : case 2 : {
7643 0 : OS << " [[clang::preserve_all]]";
7644 0 : break;
7645 : }
7646 : }
7647 0 : }
7648 :
7649 0 : const char *PreserveAllAttr::getSpelling() const {
7650 0 : switch (SpellingListIndex) {
7651 0 : default:
7652 0 : llvm_unreachable("Unknown attribute spelling!");
7653 : return "(No spelling)";
7654 : case 0:
7655 : return "preserve_all";
7656 : case 1:
7657 : return "preserve_all";
7658 : case 2:
7659 : return "preserve_all";
7660 : }
7661 : }
7662 :
7663 0 : PreserveMostAttr *PreserveMostAttr::clone(ASTContext &C) const {
7664 : auto *A = new (C) PreserveMostAttr(getLocation(), C, getSpellingListIndex());
7665 0 : A->Inherited = Inherited;
7666 0 : A->IsPackExpansion = IsPackExpansion;
7667 0 : A->Implicit = Implicit;
7668 0 : return A;
7669 : }
7670 :
7671 0 : void PreserveMostAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7672 0 : switch (SpellingListIndex) {
7673 0 : default:
7674 0 : llvm_unreachable("Unknown attribute spelling!");
7675 : break;
7676 0 : case 0 : {
7677 0 : OS << " __attribute__((preserve_most))";
7678 0 : break;
7679 : }
7680 0 : case 1 : {
7681 0 : OS << " [[clang::preserve_most]]";
7682 0 : break;
7683 : }
7684 0 : case 2 : {
7685 0 : OS << " [[clang::preserve_most]]";
7686 0 : break;
7687 : }
7688 : }
7689 0 : }
7690 :
7691 0 : const char *PreserveMostAttr::getSpelling() const {
7692 0 : switch (SpellingListIndex) {
7693 0 : default:
7694 0 : llvm_unreachable("Unknown attribute spelling!");
7695 : return "(No spelling)";
7696 : case 0:
7697 : return "preserve_most";
7698 : case 1:
7699 : return "preserve_most";
7700 : case 2:
7701 : return "preserve_most";
7702 : }
7703 : }
7704 :
7705 0 : PtGuardedByAttr *PtGuardedByAttr::clone(ASTContext &C) const {
7706 0 : auto *A = new (C) PtGuardedByAttr(getLocation(), C, arg, getSpellingListIndex());
7707 0 : A->Inherited = Inherited;
7708 0 : A->IsPackExpansion = IsPackExpansion;
7709 0 : A->Implicit = Implicit;
7710 0 : return A;
7711 : }
7712 :
7713 0 : void PtGuardedByAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7714 0 : switch (SpellingListIndex) {
7715 0 : default:
7716 0 : llvm_unreachable("Unknown attribute spelling!");
7717 : break;
7718 0 : case 0 : {
7719 0 : OS << " __attribute__((pt_guarded_by(" << getArg() << ")))";
7720 : break;
7721 : }
7722 : }
7723 0 : }
7724 :
7725 0 : const char *PtGuardedByAttr::getSpelling() const {
7726 0 : switch (SpellingListIndex) {
7727 0 : default:
7728 0 : llvm_unreachable("Unknown attribute spelling!");
7729 : return "(No spelling)";
7730 0 : case 0:
7731 : return "pt_guarded_by";
7732 : }
7733 : }
7734 :
7735 0 : PtGuardedVarAttr *PtGuardedVarAttr::clone(ASTContext &C) const {
7736 : auto *A = new (C) PtGuardedVarAttr(getLocation(), C, getSpellingListIndex());
7737 0 : A->Inherited = Inherited;
7738 0 : A->IsPackExpansion = IsPackExpansion;
7739 0 : A->Implicit = Implicit;
7740 0 : return A;
7741 : }
7742 :
7743 0 : void PtGuardedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7744 0 : switch (SpellingListIndex) {
7745 0 : default:
7746 0 : llvm_unreachable("Unknown attribute spelling!");
7747 : break;
7748 0 : case 0 : {
7749 0 : OS << " __attribute__((pt_guarded_var))";
7750 0 : break;
7751 : }
7752 0 : case 1 : {
7753 0 : OS << " [[clang::pt_guarded_var]]";
7754 0 : break;
7755 : }
7756 : }
7757 0 : }
7758 :
7759 0 : const char *PtGuardedVarAttr::getSpelling() const {
7760 0 : switch (SpellingListIndex) {
7761 0 : default:
7762 0 : llvm_unreachable("Unknown attribute spelling!");
7763 : return "(No spelling)";
7764 : case 0:
7765 : return "pt_guarded_var";
7766 : case 1:
7767 : return "pt_guarded_var";
7768 : }
7769 : }
7770 :
7771 0 : Ptr32Attr *Ptr32Attr::clone(ASTContext &C) const {
7772 : auto *A = new (C) Ptr32Attr(getLocation(), C, getSpellingListIndex());
7773 0 : A->Inherited = Inherited;
7774 0 : A->IsPackExpansion = IsPackExpansion;
7775 0 : A->Implicit = Implicit;
7776 0 : return A;
7777 : }
7778 :
7779 0 : void Ptr32Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7780 0 : switch (SpellingListIndex) {
7781 0 : default:
7782 0 : llvm_unreachable("Unknown attribute spelling!");
7783 : break;
7784 0 : case 0 : {
7785 0 : OS << " __ptr32";
7786 : break;
7787 : }
7788 : }
7789 0 : }
7790 :
7791 0 : const char *Ptr32Attr::getSpelling() const {
7792 0 : switch (SpellingListIndex) {
7793 0 : default:
7794 0 : llvm_unreachable("Unknown attribute spelling!");
7795 : return "(No spelling)";
7796 0 : case 0:
7797 : return "__ptr32";
7798 : }
7799 : }
7800 :
7801 0 : Ptr64Attr *Ptr64Attr::clone(ASTContext &C) const {
7802 : auto *A = new (C) Ptr64Attr(getLocation(), C, getSpellingListIndex());
7803 0 : A->Inherited = Inherited;
7804 0 : A->IsPackExpansion = IsPackExpansion;
7805 0 : A->Implicit = Implicit;
7806 0 : return A;
7807 : }
7808 :
7809 0 : void Ptr64Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7810 0 : switch (SpellingListIndex) {
7811 0 : default:
7812 0 : llvm_unreachable("Unknown attribute spelling!");
7813 : break;
7814 0 : case 0 : {
7815 0 : OS << " __ptr64";
7816 : break;
7817 : }
7818 : }
7819 0 : }
7820 :
7821 0 : const char *Ptr64Attr::getSpelling() const {
7822 0 : switch (SpellingListIndex) {
7823 0 : default:
7824 0 : llvm_unreachable("Unknown attribute spelling!");
7825 : return "(No spelling)";
7826 0 : case 0:
7827 : return "__ptr64";
7828 : }
7829 : }
7830 :
7831 1035 : PureAttr *PureAttr::clone(ASTContext &C) const {
7832 : auto *A = new (C) PureAttr(getLocation(), C, getSpellingListIndex());
7833 1035 : A->Inherited = Inherited;
7834 1035 : A->IsPackExpansion = IsPackExpansion;
7835 1035 : A->Implicit = Implicit;
7836 1035 : return A;
7837 : }
7838 :
7839 5 : void PureAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7840 5 : switch (SpellingListIndex) {
7841 0 : default:
7842 0 : llvm_unreachable("Unknown attribute spelling!");
7843 : break;
7844 3 : case 0 : {
7845 3 : OS << " __attribute__((pure))";
7846 3 : break;
7847 : }
7848 2 : case 1 : {
7849 2 : OS << " [[gnu::pure]]";
7850 2 : break;
7851 : }
7852 : }
7853 5 : }
7854 :
7855 0 : const char *PureAttr::getSpelling() const {
7856 0 : switch (SpellingListIndex) {
7857 0 : default:
7858 0 : llvm_unreachable("Unknown attribute spelling!");
7859 : return "(No spelling)";
7860 : case 0:
7861 : return "pure";
7862 : case 1:
7863 : return "pure";
7864 : }
7865 : }
7866 :
7867 0 : RISCVInterruptAttr *RISCVInterruptAttr::clone(ASTContext &C) const {
7868 0 : auto *A = new (C) RISCVInterruptAttr(getLocation(), C, interrupt, getSpellingListIndex());
7869 0 : A->Inherited = Inherited;
7870 0 : A->IsPackExpansion = IsPackExpansion;
7871 0 : A->Implicit = Implicit;
7872 0 : return A;
7873 : }
7874 :
7875 0 : void RISCVInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7876 0 : switch (SpellingListIndex) {
7877 0 : default:
7878 0 : llvm_unreachable("Unknown attribute spelling!");
7879 : break;
7880 0 : case 0 : {
7881 0 : OS << " __attribute__((interrupt(\"" << RISCVInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")))";
7882 0 : break;
7883 : }
7884 0 : case 1 : {
7885 0 : OS << " [[gnu::interrupt(\"" << RISCVInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")]]";
7886 0 : break;
7887 : }
7888 : }
7889 0 : }
7890 :
7891 0 : const char *RISCVInterruptAttr::getSpelling() const {
7892 0 : switch (SpellingListIndex) {
7893 0 : default:
7894 0 : llvm_unreachable("Unknown attribute spelling!");
7895 : return "(No spelling)";
7896 : case 0:
7897 : return "interrupt";
7898 : case 1:
7899 : return "interrupt";
7900 : }
7901 : }
7902 :
7903 0 : RegCallAttr *RegCallAttr::clone(ASTContext &C) const {
7904 : auto *A = new (C) RegCallAttr(getLocation(), C, getSpellingListIndex());
7905 0 : A->Inherited = Inherited;
7906 0 : A->IsPackExpansion = IsPackExpansion;
7907 0 : A->Implicit = Implicit;
7908 0 : return A;
7909 : }
7910 :
7911 0 : void RegCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7912 0 : switch (SpellingListIndex) {
7913 0 : default:
7914 0 : llvm_unreachable("Unknown attribute spelling!");
7915 : break;
7916 0 : case 0 : {
7917 0 : OS << " __attribute__((regcall))";
7918 0 : break;
7919 : }
7920 0 : case 1 : {
7921 0 : OS << " [[gnu::regcall]]";
7922 0 : break;
7923 : }
7924 0 : case 2 : {
7925 0 : OS << " __regcall";
7926 0 : break;
7927 : }
7928 : }
7929 0 : }
7930 :
7931 0 : const char *RegCallAttr::getSpelling() const {
7932 0 : switch (SpellingListIndex) {
7933 0 : default:
7934 0 : llvm_unreachable("Unknown attribute spelling!");
7935 : return "(No spelling)";
7936 : case 0:
7937 : return "regcall";
7938 : case 1:
7939 : return "regcall";
7940 0 : case 2:
7941 0 : return "__regcall";
7942 : }
7943 : }
7944 :
7945 1 : ReinitializesAttr *ReinitializesAttr::clone(ASTContext &C) const {
7946 : auto *A = new (C) ReinitializesAttr(getLocation(), C, getSpellingListIndex());
7947 1 : A->Inherited = Inherited;
7948 1 : A->IsPackExpansion = IsPackExpansion;
7949 1 : A->Implicit = Implicit;
7950 1 : return A;
7951 : }
7952 :
7953 0 : void ReinitializesAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7954 0 : switch (SpellingListIndex) {
7955 0 : default:
7956 0 : llvm_unreachable("Unknown attribute spelling!");
7957 : break;
7958 0 : case 0 : {
7959 0 : OS << " __attribute__((reinitializes))";
7960 0 : break;
7961 : }
7962 0 : case 1 : {
7963 0 : OS << " [[clang::reinitializes]]";
7964 0 : break;
7965 : }
7966 : }
7967 0 : }
7968 :
7969 0 : const char *ReinitializesAttr::getSpelling() const {
7970 0 : switch (SpellingListIndex) {
7971 0 : default:
7972 0 : llvm_unreachable("Unknown attribute spelling!");
7973 : return "(No spelling)";
7974 : case 0:
7975 : return "reinitializes";
7976 : case 1:
7977 : return "reinitializes";
7978 : }
7979 : }
7980 :
7981 35 : ReleaseCapabilityAttr *ReleaseCapabilityAttr::clone(ASTContext &C) const {
7982 35 : auto *A = new (C) ReleaseCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
7983 35 : A->Inherited = Inherited;
7984 35 : A->IsPackExpansion = IsPackExpansion;
7985 35 : A->Implicit = Implicit;
7986 35 : return A;
7987 : }
7988 :
7989 0 : void ReleaseCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
7990 0 : switch (SpellingListIndex) {
7991 0 : default:
7992 0 : llvm_unreachable("Unknown attribute spelling!");
7993 : break;
7994 0 : case 0 : {
7995 0 : OS << " __attribute__((release_capability(";
7996 : bool isFirst = true;
7997 0 : for (const auto &Val : args()) {
7998 0 : if (isFirst) isFirst = false;
7999 0 : else OS << ", ";
8000 0 : OS << Val;
8001 : }
8002 0 : OS << ")))";
8003 0 : break;
8004 : }
8005 0 : case 1 : {
8006 0 : OS << " [[clang::release_capability(";
8007 : bool isFirst = true;
8008 0 : for (const auto &Val : args()) {
8009 0 : if (isFirst) isFirst = false;
8010 0 : else OS << ", ";
8011 0 : OS << Val;
8012 : }
8013 0 : OS << ")]]";
8014 0 : break;
8015 : }
8016 0 : case 2 : {
8017 0 : OS << " __attribute__((release_shared_capability(";
8018 : bool isFirst = true;
8019 0 : for (const auto &Val : args()) {
8020 0 : if (isFirst) isFirst = false;
8021 0 : else OS << ", ";
8022 0 : OS << Val;
8023 : }
8024 0 : OS << ")))";
8025 0 : break;
8026 : }
8027 0 : case 3 : {
8028 0 : OS << " [[clang::release_shared_capability(";
8029 : bool isFirst = true;
8030 0 : for (const auto &Val : args()) {
8031 0 : if (isFirst) isFirst = false;
8032 0 : else OS << ", ";
8033 0 : OS << Val;
8034 : }
8035 0 : OS << ")]]";
8036 0 : break;
8037 : }
8038 0 : case 4 : {
8039 0 : OS << " __attribute__((release_generic_capability(";
8040 : bool isFirst = true;
8041 0 : for (const auto &Val : args()) {
8042 0 : if (isFirst) isFirst = false;
8043 0 : else OS << ", ";
8044 0 : OS << Val;
8045 : }
8046 0 : OS << ")))";
8047 0 : break;
8048 : }
8049 0 : case 5 : {
8050 0 : OS << " [[clang::release_generic_capability(";
8051 : bool isFirst = true;
8052 0 : for (const auto &Val : args()) {
8053 0 : if (isFirst) isFirst = false;
8054 0 : else OS << ", ";
8055 0 : OS << Val;
8056 : }
8057 0 : OS << ")]]";
8058 0 : break;
8059 : }
8060 0 : case 6 : {
8061 0 : OS << " __attribute__((unlock_function(";
8062 : bool isFirst = true;
8063 0 : for (const auto &Val : args()) {
8064 0 : if (isFirst) isFirst = false;
8065 0 : else OS << ", ";
8066 0 : OS << Val;
8067 : }
8068 0 : OS << ")))";
8069 0 : break;
8070 : }
8071 0 : case 7 : {
8072 0 : OS << " [[clang::unlock_function(";
8073 : bool isFirst = true;
8074 0 : for (const auto &Val : args()) {
8075 0 : if (isFirst) isFirst = false;
8076 0 : else OS << ", ";
8077 0 : OS << Val;
8078 : }
8079 0 : OS << ")]]";
8080 0 : break;
8081 : }
8082 : }
8083 0 : }
8084 :
8085 0 : const char *ReleaseCapabilityAttr::getSpelling() const {
8086 0 : switch (SpellingListIndex) {
8087 0 : default:
8088 0 : llvm_unreachable("Unknown attribute spelling!");
8089 : return "(No spelling)";
8090 : case 0:
8091 : return "release_capability";
8092 : case 1:
8093 : return "release_capability";
8094 0 : case 2:
8095 0 : return "release_shared_capability";
8096 0 : case 3:
8097 0 : return "release_shared_capability";
8098 0 : case 4:
8099 0 : return "release_generic_capability";
8100 0 : case 5:
8101 0 : return "release_generic_capability";
8102 0 : case 6:
8103 0 : return "unlock_function";
8104 0 : case 7:
8105 0 : return "unlock_function";
8106 : }
8107 : }
8108 :
8109 0 : RenderScriptKernelAttr *RenderScriptKernelAttr::clone(ASTContext &C) const {
8110 : auto *A = new (C) RenderScriptKernelAttr(getLocation(), C, getSpellingListIndex());
8111 0 : A->Inherited = Inherited;
8112 0 : A->IsPackExpansion = IsPackExpansion;
8113 0 : A->Implicit = Implicit;
8114 0 : return A;
8115 : }
8116 :
8117 0 : void RenderScriptKernelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8118 0 : switch (SpellingListIndex) {
8119 0 : default:
8120 0 : llvm_unreachable("Unknown attribute spelling!");
8121 : break;
8122 0 : case 0 : {
8123 0 : OS << " __attribute__((kernel))";
8124 : break;
8125 : }
8126 : }
8127 0 : }
8128 :
8129 0 : const char *RenderScriptKernelAttr::getSpelling() const {
8130 0 : switch (SpellingListIndex) {
8131 0 : default:
8132 0 : llvm_unreachable("Unknown attribute spelling!");
8133 : return "(No spelling)";
8134 0 : case 0:
8135 : return "kernel";
8136 : }
8137 : }
8138 :
8139 0 : ReqdWorkGroupSizeAttr *ReqdWorkGroupSizeAttr::clone(ASTContext &C) const {
8140 0 : auto *A = new (C) ReqdWorkGroupSizeAttr(getLocation(), C, xDim, yDim, zDim, getSpellingListIndex());
8141 0 : A->Inherited = Inherited;
8142 0 : A->IsPackExpansion = IsPackExpansion;
8143 0 : A->Implicit = Implicit;
8144 0 : return A;
8145 : }
8146 :
8147 0 : void ReqdWorkGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8148 0 : switch (SpellingListIndex) {
8149 0 : default:
8150 0 : llvm_unreachable("Unknown attribute spelling!");
8151 : break;
8152 0 : case 0 : {
8153 0 : OS << " __attribute__((reqd_work_group_size(" << getXDim() << ", " << getYDim() << ", " << getZDim() << ")))";
8154 : break;
8155 : }
8156 : }
8157 0 : }
8158 :
8159 2 : const char *ReqdWorkGroupSizeAttr::getSpelling() const {
8160 2 : switch (SpellingListIndex) {
8161 0 : default:
8162 0 : llvm_unreachable("Unknown attribute spelling!");
8163 : return "(No spelling)";
8164 2 : case 0:
8165 : return "reqd_work_group_size";
8166 : }
8167 : }
8168 :
8169 22 : RequireConstantInitAttr *RequireConstantInitAttr::clone(ASTContext &C) const {
8170 : auto *A = new (C) RequireConstantInitAttr(getLocation(), C, getSpellingListIndex());
8171 22 : A->Inherited = Inherited;
8172 22 : A->IsPackExpansion = IsPackExpansion;
8173 22 : A->Implicit = Implicit;
8174 22 : return A;
8175 : }
8176 :
8177 0 : void RequireConstantInitAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8178 0 : switch (SpellingListIndex) {
8179 0 : default:
8180 0 : llvm_unreachable("Unknown attribute spelling!");
8181 : break;
8182 0 : case 0 : {
8183 0 : OS << " __attribute__((require_constant_initialization))";
8184 0 : break;
8185 : }
8186 0 : case 1 : {
8187 0 : OS << " [[clang::require_constant_initialization]]";
8188 0 : break;
8189 : }
8190 : }
8191 0 : }
8192 :
8193 0 : const char *RequireConstantInitAttr::getSpelling() const {
8194 0 : switch (SpellingListIndex) {
8195 0 : default:
8196 0 : llvm_unreachable("Unknown attribute spelling!");
8197 : return "(No spelling)";
8198 : case 0:
8199 : return "require_constant_initialization";
8200 : case 1:
8201 : return "require_constant_initialization";
8202 : }
8203 : }
8204 :
8205 134 : RequiresCapabilityAttr *RequiresCapabilityAttr::clone(ASTContext &C) const {
8206 134 : auto *A = new (C) RequiresCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
8207 134 : A->Inherited = Inherited;
8208 134 : A->IsPackExpansion = IsPackExpansion;
8209 134 : A->Implicit = Implicit;
8210 134 : return A;
8211 : }
8212 :
8213 0 : void RequiresCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8214 0 : switch (SpellingListIndex) {
8215 0 : default:
8216 0 : llvm_unreachable("Unknown attribute spelling!");
8217 : break;
8218 0 : case 0 : {
8219 0 : OS << " __attribute__((requires_capability(";
8220 : bool isFirst = true;
8221 0 : for (const auto &Val : args()) {
8222 0 : if (isFirst) isFirst = false;
8223 0 : else OS << ", ";
8224 0 : OS << Val;
8225 : }
8226 0 : OS << ")))";
8227 0 : break;
8228 : }
8229 0 : case 1 : {
8230 0 : OS << " [[clang::requires_capability(";
8231 : bool isFirst = true;
8232 0 : for (const auto &Val : args()) {
8233 0 : if (isFirst) isFirst = false;
8234 0 : else OS << ", ";
8235 0 : OS << Val;
8236 : }
8237 0 : OS << ")]]";
8238 0 : break;
8239 : }
8240 0 : case 2 : {
8241 0 : OS << " __attribute__((exclusive_locks_required(";
8242 : bool isFirst = true;
8243 0 : for (const auto &Val : args()) {
8244 0 : if (isFirst) isFirst = false;
8245 0 : else OS << ", ";
8246 0 : OS << Val;
8247 : }
8248 0 : OS << ")))";
8249 0 : break;
8250 : }
8251 0 : case 3 : {
8252 0 : OS << " [[clang::exclusive_locks_required(";
8253 : bool isFirst = true;
8254 0 : for (const auto &Val : args()) {
8255 0 : if (isFirst) isFirst = false;
8256 0 : else OS << ", ";
8257 0 : OS << Val;
8258 : }
8259 0 : OS << ")]]";
8260 0 : break;
8261 : }
8262 0 : case 4 : {
8263 0 : OS << " __attribute__((requires_shared_capability(";
8264 : bool isFirst = true;
8265 0 : for (const auto &Val : args()) {
8266 0 : if (isFirst) isFirst = false;
8267 0 : else OS << ", ";
8268 0 : OS << Val;
8269 : }
8270 0 : OS << ")))";
8271 0 : break;
8272 : }
8273 0 : case 5 : {
8274 0 : OS << " [[clang::requires_shared_capability(";
8275 : bool isFirst = true;
8276 0 : for (const auto &Val : args()) {
8277 0 : if (isFirst) isFirst = false;
8278 0 : else OS << ", ";
8279 0 : OS << Val;
8280 : }
8281 0 : OS << ")]]";
8282 0 : break;
8283 : }
8284 0 : case 6 : {
8285 0 : OS << " __attribute__((shared_locks_required(";
8286 : bool isFirst = true;
8287 0 : for (const auto &Val : args()) {
8288 0 : if (isFirst) isFirst = false;
8289 0 : else OS << ", ";
8290 0 : OS << Val;
8291 : }
8292 0 : OS << ")))";
8293 0 : break;
8294 : }
8295 0 : case 7 : {
8296 0 : OS << " [[clang::shared_locks_required(";
8297 : bool isFirst = true;
8298 0 : for (const auto &Val : args()) {
8299 0 : if (isFirst) isFirst = false;
8300 0 : else OS << ", ";
8301 0 : OS << Val;
8302 : }
8303 0 : OS << ")]]";
8304 0 : break;
8305 : }
8306 : }
8307 0 : }
8308 :
8309 0 : const char *RequiresCapabilityAttr::getSpelling() const {
8310 0 : switch (SpellingListIndex) {
8311 0 : default:
8312 0 : llvm_unreachable("Unknown attribute spelling!");
8313 : return "(No spelling)";
8314 : case 0:
8315 : return "requires_capability";
8316 : case 1:
8317 : return "requires_capability";
8318 0 : case 2:
8319 0 : return "exclusive_locks_required";
8320 0 : case 3:
8321 0 : return "exclusive_locks_required";
8322 0 : case 4:
8323 0 : return "requires_shared_capability";
8324 0 : case 5:
8325 0 : return "requires_shared_capability";
8326 0 : case 6:
8327 0 : return "shared_locks_required";
8328 0 : case 7:
8329 0 : return "shared_locks_required";
8330 : }
8331 : }
8332 :
8333 14 : RestrictAttr *RestrictAttr::clone(ASTContext &C) const {
8334 : auto *A = new (C) RestrictAttr(getLocation(), C, getSpellingListIndex());
8335 14 : A->Inherited = Inherited;
8336 14 : A->IsPackExpansion = IsPackExpansion;
8337 14 : A->Implicit = Implicit;
8338 14 : return A;
8339 : }
8340 :
8341 1 : void RestrictAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8342 1 : switch (SpellingListIndex) {
8343 0 : default:
8344 0 : llvm_unreachable("Unknown attribute spelling!");
8345 : break;
8346 0 : case 0 : {
8347 0 : OS << " __declspec(restrict)";
8348 0 : break;
8349 : }
8350 1 : case 1 : {
8351 1 : OS << " __attribute__((malloc))";
8352 1 : break;
8353 : }
8354 0 : case 2 : {
8355 0 : OS << " [[gnu::malloc]]";
8356 0 : break;
8357 : }
8358 : }
8359 1 : }
8360 :
8361 0 : const char *RestrictAttr::getSpelling() const {
8362 0 : switch (SpellingListIndex) {
8363 0 : default:
8364 0 : llvm_unreachable("Unknown attribute spelling!");
8365 : return "(No spelling)";
8366 : case 0:
8367 : return "restrict";
8368 0 : case 1:
8369 0 : return "malloc";
8370 0 : case 2:
8371 0 : return "malloc";
8372 : }
8373 : }
8374 :
8375 6 : ReturnTypestateAttr *ReturnTypestateAttr::clone(ASTContext &C) const {
8376 6 : auto *A = new (C) ReturnTypestateAttr(getLocation(), C, state, getSpellingListIndex());
8377 6 : A->Inherited = Inherited;
8378 6 : A->IsPackExpansion = IsPackExpansion;
8379 6 : A->Implicit = Implicit;
8380 6 : return A;
8381 : }
8382 :
8383 0 : void ReturnTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8384 0 : switch (SpellingListIndex) {
8385 0 : default:
8386 0 : llvm_unreachable("Unknown attribute spelling!");
8387 : break;
8388 0 : case 0 : {
8389 0 : OS << " __attribute__((return_typestate(\"" << ReturnTypestateAttr::ConvertConsumedStateToStr(getState()) << "\")))";
8390 0 : break;
8391 : }
8392 0 : case 1 : {
8393 0 : OS << " [[clang::return_typestate(\"" << ReturnTypestateAttr::ConvertConsumedStateToStr(getState()) << "\")]]";
8394 0 : break;
8395 : }
8396 : }
8397 0 : }
8398 :
8399 0 : const char *ReturnTypestateAttr::getSpelling() const {
8400 0 : switch (SpellingListIndex) {
8401 0 : default:
8402 0 : llvm_unreachable("Unknown attribute spelling!");
8403 : return "(No spelling)";
8404 : case 0:
8405 : return "return_typestate";
8406 : case 1:
8407 : return "return_typestate";
8408 : }
8409 : }
8410 :
8411 1 : ReturnsNonNullAttr *ReturnsNonNullAttr::clone(ASTContext &C) const {
8412 : auto *A = new (C) ReturnsNonNullAttr(getLocation(), C, getSpellingListIndex());
8413 1 : A->Inherited = Inherited;
8414 1 : A->IsPackExpansion = IsPackExpansion;
8415 1 : A->Implicit = Implicit;
8416 1 : return A;
8417 : }
8418 :
8419 0 : void ReturnsNonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8420 0 : switch (SpellingListIndex) {
8421 0 : default:
8422 0 : llvm_unreachable("Unknown attribute spelling!");
8423 : break;
8424 0 : case 0 : {
8425 0 : OS << " __attribute__((returns_nonnull))";
8426 0 : break;
8427 : }
8428 0 : case 1 : {
8429 0 : OS << " [[gnu::returns_nonnull]]";
8430 0 : break;
8431 : }
8432 : }
8433 0 : }
8434 :
8435 0 : const char *ReturnsNonNullAttr::getSpelling() const {
8436 0 : switch (SpellingListIndex) {
8437 0 : default:
8438 0 : llvm_unreachable("Unknown attribute spelling!");
8439 : return "(No spelling)";
8440 : case 0:
8441 : return "returns_nonnull";
8442 : case 1:
8443 : return "returns_nonnull";
8444 : }
8445 : }
8446 :
8447 114 : ReturnsTwiceAttr *ReturnsTwiceAttr::clone(ASTContext &C) const {
8448 : auto *A = new (C) ReturnsTwiceAttr(getLocation(), C, getSpellingListIndex());
8449 114 : A->Inherited = Inherited;
8450 114 : A->IsPackExpansion = IsPackExpansion;
8451 114 : A->Implicit = Implicit;
8452 114 : return A;
8453 : }
8454 :
8455 0 : void ReturnsTwiceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8456 0 : switch (SpellingListIndex) {
8457 0 : default:
8458 0 : llvm_unreachable("Unknown attribute spelling!");
8459 : break;
8460 0 : case 0 : {
8461 0 : OS << " __attribute__((returns_twice))";
8462 0 : break;
8463 : }
8464 0 : case 1 : {
8465 0 : OS << " [[gnu::returns_twice]]";
8466 0 : break;
8467 : }
8468 : }
8469 0 : }
8470 :
8471 0 : const char *ReturnsTwiceAttr::getSpelling() const {
8472 0 : switch (SpellingListIndex) {
8473 0 : default:
8474 0 : llvm_unreachable("Unknown attribute spelling!");
8475 : return "(No spelling)";
8476 : case 0:
8477 : return "returns_twice";
8478 : case 1:
8479 : return "returns_twice";
8480 : }
8481 : }
8482 :
8483 0 : SPtrAttr *SPtrAttr::clone(ASTContext &C) const {
8484 : auto *A = new (C) SPtrAttr(getLocation(), C, getSpellingListIndex());
8485 0 : A->Inherited = Inherited;
8486 0 : A->IsPackExpansion = IsPackExpansion;
8487 0 : A->Implicit = Implicit;
8488 0 : return A;
8489 : }
8490 :
8491 0 : void SPtrAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8492 0 : switch (SpellingListIndex) {
8493 0 : default:
8494 0 : llvm_unreachable("Unknown attribute spelling!");
8495 : break;
8496 0 : case 0 : {
8497 0 : OS << " __sptr";
8498 : break;
8499 : }
8500 : }
8501 0 : }
8502 :
8503 0 : const char *SPtrAttr::getSpelling() const {
8504 0 : switch (SpellingListIndex) {
8505 0 : default:
8506 0 : llvm_unreachable("Unknown attribute spelling!");
8507 : return "(No spelling)";
8508 0 : case 0:
8509 : return "__sptr";
8510 : }
8511 : }
8512 :
8513 9 : ScopedLockableAttr *ScopedLockableAttr::clone(ASTContext &C) const {
8514 : auto *A = new (C) ScopedLockableAttr(getLocation(), C, getSpellingListIndex());
8515 9 : A->Inherited = Inherited;
8516 9 : A->IsPackExpansion = IsPackExpansion;
8517 9 : A->Implicit = Implicit;
8518 9 : return A;
8519 : }
8520 :
8521 0 : void ScopedLockableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8522 0 : switch (SpellingListIndex) {
8523 0 : default:
8524 0 : llvm_unreachable("Unknown attribute spelling!");
8525 : break;
8526 0 : case 0 : {
8527 0 : OS << " __attribute__((scoped_lockable))";
8528 0 : break;
8529 : }
8530 0 : case 1 : {
8531 0 : OS << " [[clang::scoped_lockable]]";
8532 0 : break;
8533 : }
8534 : }
8535 0 : }
8536 :
8537 0 : const char *ScopedLockableAttr::getSpelling() const {
8538 0 : switch (SpellingListIndex) {
8539 0 : default:
8540 0 : llvm_unreachable("Unknown attribute spelling!");
8541 : return "(No spelling)";
8542 : case 0:
8543 : return "scoped_lockable";
8544 : case 1:
8545 : return "scoped_lockable";
8546 : }
8547 : }
8548 :
8549 9 : SectionAttr *SectionAttr::clone(ASTContext &C) const {
8550 18 : auto *A = new (C) SectionAttr(getLocation(), C, getName(), getSpellingListIndex());
8551 9 : A->Inherited = Inherited;
8552 9 : A->IsPackExpansion = IsPackExpansion;
8553 9 : A->Implicit = Implicit;
8554 9 : return A;
8555 : }
8556 :
8557 0 : void SectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8558 0 : switch (SpellingListIndex) {
8559 0 : default:
8560 0 : llvm_unreachable("Unknown attribute spelling!");
8561 : break;
8562 0 : case 0 : {
8563 0 : OS << " __attribute__((section(\"" << getName() << "\")))";
8564 0 : break;
8565 : }
8566 0 : case 1 : {
8567 0 : OS << " [[gnu::section(\"" << getName() << "\")]]";
8568 0 : break;
8569 : }
8570 0 : case 2 : {
8571 0 : OS << " __declspec(allocate(\"" << getName() << "\"))";
8572 0 : break;
8573 : }
8574 : }
8575 0 : }
8576 :
8577 0 : const char *SectionAttr::getSpelling() const {
8578 0 : switch (SpellingListIndex) {
8579 0 : default:
8580 0 : llvm_unreachable("Unknown attribute spelling!");
8581 : return "(No spelling)";
8582 : case 0:
8583 : return "section";
8584 : case 1:
8585 : return "section";
8586 0 : case 2:
8587 0 : return "allocate";
8588 : }
8589 : }
8590 :
8591 3 : SelectAnyAttr *SelectAnyAttr::clone(ASTContext &C) const {
8592 : auto *A = new (C) SelectAnyAttr(getLocation(), C, getSpellingListIndex());
8593 3 : A->Inherited = Inherited;
8594 3 : A->IsPackExpansion = IsPackExpansion;
8595 3 : A->Implicit = Implicit;
8596 3 : return A;
8597 : }
8598 :
8599 0 : void SelectAnyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8600 0 : switch (SpellingListIndex) {
8601 0 : default:
8602 0 : llvm_unreachable("Unknown attribute spelling!");
8603 : break;
8604 0 : case 0 : {
8605 0 : OS << " __declspec(selectany)";
8606 0 : break;
8607 : }
8608 0 : case 1 : {
8609 0 : OS << " __attribute__((selectany))";
8610 0 : break;
8611 : }
8612 0 : case 2 : {
8613 0 : OS << " [[gnu::selectany]]";
8614 0 : break;
8615 : }
8616 : }
8617 0 : }
8618 :
8619 0 : const char *SelectAnyAttr::getSpelling() const {
8620 0 : switch (SpellingListIndex) {
8621 0 : default:
8622 0 : llvm_unreachable("Unknown attribute spelling!");
8623 : return "(No spelling)";
8624 : case 0:
8625 : return "selectany";
8626 : case 1:
8627 : return "selectany";
8628 : case 2:
8629 : return "selectany";
8630 : }
8631 : }
8632 :
8633 0 : SentinelAttr *SentinelAttr::clone(ASTContext &C) const {
8634 0 : auto *A = new (C) SentinelAttr(getLocation(), C, sentinel, nullPos, getSpellingListIndex());
8635 0 : A->Inherited = Inherited;
8636 0 : A->IsPackExpansion = IsPackExpansion;
8637 0 : A->Implicit = Implicit;
8638 0 : return A;
8639 : }
8640 :
8641 0 : void SentinelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8642 0 : switch (SpellingListIndex) {
8643 0 : default:
8644 0 : llvm_unreachable("Unknown attribute spelling!");
8645 : break;
8646 0 : case 0 : {
8647 0 : OS << " __attribute__((sentinel(" << getSentinel() << ", " << getNullPos() << ")))";
8648 0 : break;
8649 : }
8650 0 : case 1 : {
8651 0 : OS << " [[gnu::sentinel(" << getSentinel() << ", " << getNullPos() << ")]]";
8652 0 : break;
8653 : }
8654 : }
8655 0 : }
8656 :
8657 0 : const char *SentinelAttr::getSpelling() const {
8658 0 : switch (SpellingListIndex) {
8659 0 : default:
8660 0 : llvm_unreachable("Unknown attribute spelling!");
8661 : return "(No spelling)";
8662 : case 0:
8663 : return "sentinel";
8664 : case 1:
8665 : return "sentinel";
8666 : }
8667 : }
8668 :
8669 8 : SetTypestateAttr *SetTypestateAttr::clone(ASTContext &C) const {
8670 8 : auto *A = new (C) SetTypestateAttr(getLocation(), C, newState, getSpellingListIndex());
8671 8 : A->Inherited = Inherited;
8672 8 : A->IsPackExpansion = IsPackExpansion;
8673 8 : A->Implicit = Implicit;
8674 8 : return A;
8675 : }
8676 :
8677 0 : void SetTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8678 0 : switch (SpellingListIndex) {
8679 0 : default:
8680 0 : llvm_unreachable("Unknown attribute spelling!");
8681 : break;
8682 0 : case 0 : {
8683 0 : OS << " __attribute__((set_typestate(\"" << SetTypestateAttr::ConvertConsumedStateToStr(getNewState()) << "\")))";
8684 0 : break;
8685 : }
8686 0 : case 1 : {
8687 0 : OS << " [[clang::set_typestate(\"" << SetTypestateAttr::ConvertConsumedStateToStr(getNewState()) << "\")]]";
8688 0 : break;
8689 : }
8690 : }
8691 0 : }
8692 :
8693 0 : const char *SetTypestateAttr::getSpelling() const {
8694 0 : switch (SpellingListIndex) {
8695 0 : default:
8696 0 : llvm_unreachable("Unknown attribute spelling!");
8697 : return "(No spelling)";
8698 : case 0:
8699 : return "set_typestate";
8700 : case 1:
8701 : return "set_typestate";
8702 : }
8703 : }
8704 :
8705 7 : SharedTrylockFunctionAttr *SharedTrylockFunctionAttr::clone(ASTContext &C) const {
8706 7 : auto *A = new (C) SharedTrylockFunctionAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
8707 7 : A->Inherited = Inherited;
8708 7 : A->IsPackExpansion = IsPackExpansion;
8709 7 : A->Implicit = Implicit;
8710 7 : return A;
8711 : }
8712 :
8713 0 : void SharedTrylockFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8714 0 : switch (SpellingListIndex) {
8715 0 : default:
8716 0 : llvm_unreachable("Unknown attribute spelling!");
8717 : break;
8718 0 : case 0 : {
8719 0 : OS << " __attribute__((shared_trylock_function(" << getSuccessValue() << ", ";
8720 : bool isFirst = true;
8721 0 : for (const auto &Val : args()) {
8722 0 : if (isFirst) isFirst = false;
8723 0 : else OS << ", ";
8724 0 : OS << Val;
8725 : }
8726 0 : OS << ")))";
8727 : break;
8728 : }
8729 : }
8730 0 : }
8731 :
8732 0 : const char *SharedTrylockFunctionAttr::getSpelling() const {
8733 0 : switch (SpellingListIndex) {
8734 0 : default:
8735 0 : llvm_unreachable("Unknown attribute spelling!");
8736 : return "(No spelling)";
8737 0 : case 0:
8738 : return "shared_trylock_function";
8739 : }
8740 : }
8741 :
8742 0 : StdCallAttr *StdCallAttr::clone(ASTContext &C) const {
8743 : auto *A = new (C) StdCallAttr(getLocation(), C, getSpellingListIndex());
8744 0 : A->Inherited = Inherited;
8745 0 : A->IsPackExpansion = IsPackExpansion;
8746 0 : A->Implicit = Implicit;
8747 0 : return A;
8748 : }
8749 :
8750 0 : void StdCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8751 0 : switch (SpellingListIndex) {
8752 0 : default:
8753 0 : llvm_unreachable("Unknown attribute spelling!");
8754 : break;
8755 0 : case 0 : {
8756 0 : OS << " __attribute__((stdcall))";
8757 0 : break;
8758 : }
8759 0 : case 1 : {
8760 0 : OS << " [[gnu::stdcall]]";
8761 0 : break;
8762 : }
8763 0 : case 2 : {
8764 0 : OS << " __stdcall";
8765 0 : break;
8766 : }
8767 0 : case 3 : {
8768 0 : OS << " _stdcall";
8769 0 : break;
8770 : }
8771 : }
8772 0 : }
8773 :
8774 0 : const char *StdCallAttr::getSpelling() const {
8775 0 : switch (SpellingListIndex) {
8776 0 : default:
8777 0 : llvm_unreachable("Unknown attribute spelling!");
8778 : return "(No spelling)";
8779 : case 0:
8780 : return "stdcall";
8781 : case 1:
8782 : return "stdcall";
8783 0 : case 2:
8784 0 : return "__stdcall";
8785 0 : case 3:
8786 0 : return "_stdcall";
8787 : }
8788 : }
8789 :
8790 0 : SuppressAttr *SuppressAttr::clone(ASTContext &C) const {
8791 0 : auto *A = new (C) SuppressAttr(getLocation(), C, diagnosticIdentifiers_, diagnosticIdentifiers_Size, getSpellingListIndex());
8792 0 : A->Inherited = Inherited;
8793 0 : A->IsPackExpansion = IsPackExpansion;
8794 0 : A->Implicit = Implicit;
8795 0 : return A;
8796 : }
8797 :
8798 0 : void SuppressAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8799 0 : switch (SpellingListIndex) {
8800 0 : default:
8801 0 : llvm_unreachable("Unknown attribute spelling!");
8802 : break;
8803 0 : case 0 : {
8804 0 : OS << " [[gsl::suppress(";
8805 : bool isFirst = true;
8806 0 : for (const auto &Val : diagnosticIdentifiers()) {
8807 0 : if (isFirst) isFirst = false;
8808 0 : else OS << ", ";
8809 0 : OS << "\"" << Val << "\"";
8810 : }
8811 0 : OS << ")]]";
8812 : break;
8813 : }
8814 : }
8815 0 : }
8816 :
8817 0 : const char *SuppressAttr::getSpelling() const {
8818 0 : switch (SpellingListIndex) {
8819 0 : default:
8820 0 : llvm_unreachable("Unknown attribute spelling!");
8821 : return "(No spelling)";
8822 0 : case 0:
8823 : return "suppress";
8824 : }
8825 : }
8826 :
8827 0 : SwiftCallAttr *SwiftCallAttr::clone(ASTContext &C) const {
8828 : auto *A = new (C) SwiftCallAttr(getLocation(), C, getSpellingListIndex());
8829 0 : A->Inherited = Inherited;
8830 0 : A->IsPackExpansion = IsPackExpansion;
8831 0 : A->Implicit = Implicit;
8832 0 : return A;
8833 : }
8834 :
8835 0 : void SwiftCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8836 0 : switch (SpellingListIndex) {
8837 0 : default:
8838 0 : llvm_unreachable("Unknown attribute spelling!");
8839 : break;
8840 0 : case 0 : {
8841 0 : OS << " __attribute__((swiftcall))";
8842 0 : break;
8843 : }
8844 0 : case 1 : {
8845 0 : OS << " [[clang::swiftcall]]";
8846 0 : break;
8847 : }
8848 0 : case 2 : {
8849 0 : OS << " [[clang::swiftcall]]";
8850 0 : break;
8851 : }
8852 : }
8853 0 : }
8854 :
8855 0 : const char *SwiftCallAttr::getSpelling() const {
8856 0 : switch (SpellingListIndex) {
8857 0 : default:
8858 0 : llvm_unreachable("Unknown attribute spelling!");
8859 : return "(No spelling)";
8860 : case 0:
8861 : return "swiftcall";
8862 : case 1:
8863 : return "swiftcall";
8864 : case 2:
8865 : return "swiftcall";
8866 : }
8867 : }
8868 :
8869 0 : SwiftContextAttr *SwiftContextAttr::clone(ASTContext &C) const {
8870 : auto *A = new (C) SwiftContextAttr(getLocation(), C, getSpellingListIndex());
8871 0 : A->Inherited = Inherited;
8872 0 : A->IsPackExpansion = IsPackExpansion;
8873 0 : A->Implicit = Implicit;
8874 0 : return A;
8875 : }
8876 :
8877 0 : void SwiftContextAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8878 0 : switch (SpellingListIndex) {
8879 0 : default:
8880 0 : llvm_unreachable("Unknown attribute spelling!");
8881 : break;
8882 0 : case 0 : {
8883 0 : OS << " __attribute__((swift_context))";
8884 0 : break;
8885 : }
8886 0 : case 1 : {
8887 0 : OS << " [[clang::swift_context]]";
8888 0 : break;
8889 : }
8890 0 : case 2 : {
8891 0 : OS << " [[clang::swift_context]]";
8892 0 : break;
8893 : }
8894 : }
8895 0 : }
8896 :
8897 0 : const char *SwiftContextAttr::getSpelling() const {
8898 0 : switch (SpellingListIndex) {
8899 0 : default:
8900 0 : llvm_unreachable("Unknown attribute spelling!");
8901 : return "(No spelling)";
8902 : case 0:
8903 : return "swift_context";
8904 : case 1:
8905 : return "swift_context";
8906 : case 2:
8907 : return "swift_context";
8908 : }
8909 : }
8910 :
8911 0 : SwiftErrorResultAttr *SwiftErrorResultAttr::clone(ASTContext &C) const {
8912 : auto *A = new (C) SwiftErrorResultAttr(getLocation(), C, getSpellingListIndex());
8913 0 : A->Inherited = Inherited;
8914 0 : A->IsPackExpansion = IsPackExpansion;
8915 0 : A->Implicit = Implicit;
8916 0 : return A;
8917 : }
8918 :
8919 0 : void SwiftErrorResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8920 0 : switch (SpellingListIndex) {
8921 0 : default:
8922 0 : llvm_unreachable("Unknown attribute spelling!");
8923 : break;
8924 0 : case 0 : {
8925 0 : OS << " __attribute__((swift_error_result))";
8926 0 : break;
8927 : }
8928 0 : case 1 : {
8929 0 : OS << " [[clang::swift_error_result]]";
8930 0 : break;
8931 : }
8932 0 : case 2 : {
8933 0 : OS << " [[clang::swift_error_result]]";
8934 0 : break;
8935 : }
8936 : }
8937 0 : }
8938 :
8939 0 : const char *SwiftErrorResultAttr::getSpelling() const {
8940 0 : switch (SpellingListIndex) {
8941 0 : default:
8942 0 : llvm_unreachable("Unknown attribute spelling!");
8943 : return "(No spelling)";
8944 : case 0:
8945 : return "swift_error_result";
8946 : case 1:
8947 : return "swift_error_result";
8948 : case 2:
8949 : return "swift_error_result";
8950 : }
8951 : }
8952 :
8953 0 : SwiftIndirectResultAttr *SwiftIndirectResultAttr::clone(ASTContext &C) const {
8954 : auto *A = new (C) SwiftIndirectResultAttr(getLocation(), C, getSpellingListIndex());
8955 0 : A->Inherited = Inherited;
8956 0 : A->IsPackExpansion = IsPackExpansion;
8957 0 : A->Implicit = Implicit;
8958 0 : return A;
8959 : }
8960 :
8961 0 : void SwiftIndirectResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
8962 0 : switch (SpellingListIndex) {
8963 0 : default:
8964 0 : llvm_unreachable("Unknown attribute spelling!");
8965 : break;
8966 0 : case 0 : {
8967 0 : OS << " __attribute__((swift_indirect_result))";
8968 0 : break;
8969 : }
8970 0 : case 1 : {
8971 0 : OS << " [[clang::swift_indirect_result]]";
8972 0 : break;
8973 : }
8974 0 : case 2 : {
8975 0 : OS << " [[clang::swift_indirect_result]]";
8976 0 : break;
8977 : }
8978 : }
8979 0 : }
8980 :
8981 0 : const char *SwiftIndirectResultAttr::getSpelling() const {
8982 0 : switch (SpellingListIndex) {
8983 0 : default:
8984 0 : llvm_unreachable("Unknown attribute spelling!");
8985 : return "(No spelling)";
8986 : case 0:
8987 : return "swift_indirect_result";
8988 : case 1:
8989 : return "swift_indirect_result";
8990 : case 2:
8991 : return "swift_indirect_result";
8992 : }
8993 : }
8994 :
8995 0 : SysVABIAttr *SysVABIAttr::clone(ASTContext &C) const {
8996 : auto *A = new (C) SysVABIAttr(getLocation(), C, getSpellingListIndex());
8997 0 : A->Inherited = Inherited;
8998 0 : A->IsPackExpansion = IsPackExpansion;
8999 0 : A->Implicit = Implicit;
9000 0 : return A;
9001 : }
9002 :
9003 0 : void SysVABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9004 0 : switch (SpellingListIndex) {
9005 0 : default:
9006 0 : llvm_unreachable("Unknown attribute spelling!");
9007 : break;
9008 0 : case 0 : {
9009 0 : OS << " __attribute__((sysv_abi))";
9010 0 : break;
9011 : }
9012 0 : case 1 : {
9013 0 : OS << " [[gnu::sysv_abi]]";
9014 0 : break;
9015 : }
9016 : }
9017 0 : }
9018 :
9019 0 : const char *SysVABIAttr::getSpelling() const {
9020 0 : switch (SpellingListIndex) {
9021 0 : default:
9022 0 : llvm_unreachable("Unknown attribute spelling!");
9023 : return "(No spelling)";
9024 : case 0:
9025 : return "sysv_abi";
9026 : case 1:
9027 : return "sysv_abi";
9028 : }
9029 : }
9030 :
9031 3 : TLSModelAttr *TLSModelAttr::clone(ASTContext &C) const {
9032 6 : auto *A = new (C) TLSModelAttr(getLocation(), C, getModel(), getSpellingListIndex());
9033 3 : A->Inherited = Inherited;
9034 3 : A->IsPackExpansion = IsPackExpansion;
9035 3 : A->Implicit = Implicit;
9036 3 : return A;
9037 : }
9038 :
9039 0 : void TLSModelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9040 0 : switch (SpellingListIndex) {
9041 0 : default:
9042 0 : llvm_unreachable("Unknown attribute spelling!");
9043 : break;
9044 0 : case 0 : {
9045 0 : OS << " __attribute__((tls_model(\"" << getModel() << "\")))";
9046 0 : break;
9047 : }
9048 0 : case 1 : {
9049 0 : OS << " [[gnu::tls_model(\"" << getModel() << "\")]]";
9050 0 : break;
9051 : }
9052 : }
9053 0 : }
9054 :
9055 0 : const char *TLSModelAttr::getSpelling() const {
9056 0 : switch (SpellingListIndex) {
9057 0 : default:
9058 0 : llvm_unreachable("Unknown attribute spelling!");
9059 : return "(No spelling)";
9060 : case 0:
9061 : return "tls_model";
9062 : case 1:
9063 : return "tls_model";
9064 : }
9065 : }
9066 :
9067 15 : TargetAttr *TargetAttr::clone(ASTContext &C) const {
9068 30 : auto *A = new (C) TargetAttr(getLocation(), C, getFeaturesStr(), getSpellingListIndex());
9069 15 : A->Inherited = Inherited;
9070 15 : A->IsPackExpansion = IsPackExpansion;
9071 15 : A->Implicit = Implicit;
9072 15 : return A;
9073 : }
9074 :
9075 0 : void TargetAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9076 0 : switch (SpellingListIndex) {
9077 0 : default:
9078 0 : llvm_unreachable("Unknown attribute spelling!");
9079 : break;
9080 0 : case 0 : {
9081 0 : OS << " __attribute__((target(\"" << getFeaturesStr() << "\")))";
9082 0 : break;
9083 : }
9084 0 : case 1 : {
9085 0 : OS << " [[gnu::target(\"" << getFeaturesStr() << "\")]]";
9086 0 : break;
9087 : }
9088 : }
9089 0 : }
9090 :
9091 0 : const char *TargetAttr::getSpelling() const {
9092 0 : switch (SpellingListIndex) {
9093 0 : default:
9094 0 : llvm_unreachable("Unknown attribute spelling!");
9095 : return "(No spelling)";
9096 : case 0:
9097 : return "target";
9098 : case 1:
9099 : return "target";
9100 : }
9101 : }
9102 :
9103 8 : TestTypestateAttr *TestTypestateAttr::clone(ASTContext &C) const {
9104 8 : auto *A = new (C) TestTypestateAttr(getLocation(), C, testState, getSpellingListIndex());
9105 8 : A->Inherited = Inherited;
9106 8 : A->IsPackExpansion = IsPackExpansion;
9107 8 : A->Implicit = Implicit;
9108 8 : return A;
9109 : }
9110 :
9111 0 : void TestTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9112 0 : switch (SpellingListIndex) {
9113 0 : default:
9114 0 : llvm_unreachable("Unknown attribute spelling!");
9115 : break;
9116 0 : case 0 : {
9117 0 : OS << " __attribute__((test_typestate(\"" << TestTypestateAttr::ConvertConsumedStateToStr(getTestState()) << "\")))";
9118 0 : break;
9119 : }
9120 0 : case 1 : {
9121 0 : OS << " [[clang::test_typestate(\"" << TestTypestateAttr::ConvertConsumedStateToStr(getTestState()) << "\")]]";
9122 0 : break;
9123 : }
9124 : }
9125 0 : }
9126 :
9127 0 : const char *TestTypestateAttr::getSpelling() const {
9128 0 : switch (SpellingListIndex) {
9129 0 : default:
9130 0 : llvm_unreachable("Unknown attribute spelling!");
9131 : return "(No spelling)";
9132 : case 0:
9133 : return "test_typestate";
9134 : case 1:
9135 : return "test_typestate";
9136 : }
9137 : }
9138 :
9139 0 : ThisCallAttr *ThisCallAttr::clone(ASTContext &C) const {
9140 : auto *A = new (C) ThisCallAttr(getLocation(), C, getSpellingListIndex());
9141 0 : A->Inherited = Inherited;
9142 0 : A->IsPackExpansion = IsPackExpansion;
9143 0 : A->Implicit = Implicit;
9144 0 : return A;
9145 : }
9146 :
9147 0 : void ThisCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9148 0 : switch (SpellingListIndex) {
9149 0 : default:
9150 0 : llvm_unreachable("Unknown attribute spelling!");
9151 : break;
9152 0 : case 0 : {
9153 0 : OS << " __attribute__((thiscall))";
9154 0 : break;
9155 : }
9156 0 : case 1 : {
9157 0 : OS << " [[gnu::thiscall]]";
9158 0 : break;
9159 : }
9160 0 : case 2 : {
9161 0 : OS << " __thiscall";
9162 0 : break;
9163 : }
9164 0 : case 3 : {
9165 0 : OS << " _thiscall";
9166 0 : break;
9167 : }
9168 : }
9169 0 : }
9170 :
9171 0 : const char *ThisCallAttr::getSpelling() const {
9172 0 : switch (SpellingListIndex) {
9173 0 : default:
9174 0 : llvm_unreachable("Unknown attribute spelling!");
9175 : return "(No spelling)";
9176 : case 0:
9177 : return "thiscall";
9178 : case 1:
9179 : return "thiscall";
9180 0 : case 2:
9181 0 : return "__thiscall";
9182 0 : case 3:
9183 0 : return "_thiscall";
9184 : }
9185 : }
9186 :
9187 0 : ThreadAttr *ThreadAttr::clone(ASTContext &C) const {
9188 : auto *A = new (C) ThreadAttr(getLocation(), C, getSpellingListIndex());
9189 0 : A->Inherited = Inherited;
9190 0 : A->IsPackExpansion = IsPackExpansion;
9191 0 : A->Implicit = Implicit;
9192 0 : return A;
9193 : }
9194 :
9195 1 : void ThreadAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9196 1 : switch (SpellingListIndex) {
9197 0 : default:
9198 0 : llvm_unreachable("Unknown attribute spelling!");
9199 : break;
9200 1 : case 0 : {
9201 1 : OS << " __declspec(thread)";
9202 : break;
9203 : }
9204 : }
9205 1 : }
9206 :
9207 0 : const char *ThreadAttr::getSpelling() const {
9208 0 : switch (SpellingListIndex) {
9209 0 : default:
9210 0 : llvm_unreachable("Unknown attribute spelling!");
9211 : return "(No spelling)";
9212 0 : case 0:
9213 : return "thread";
9214 : }
9215 : }
9216 :
9217 0 : TransparentUnionAttr *TransparentUnionAttr::clone(ASTContext &C) const {
9218 : auto *A = new (C) TransparentUnionAttr(getLocation(), C, getSpellingListIndex());
9219 0 : A->Inherited = Inherited;
9220 0 : A->IsPackExpansion = IsPackExpansion;
9221 0 : A->Implicit = Implicit;
9222 0 : return A;
9223 : }
9224 :
9225 0 : void TransparentUnionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9226 0 : switch (SpellingListIndex) {
9227 0 : default:
9228 0 : llvm_unreachable("Unknown attribute spelling!");
9229 : break;
9230 0 : case 0 : {
9231 0 : OS << " __attribute__((transparent_union))";
9232 0 : break;
9233 : }
9234 0 : case 1 : {
9235 0 : OS << " [[gnu::transparent_union]]";
9236 0 : break;
9237 : }
9238 : }
9239 0 : }
9240 :
9241 0 : const char *TransparentUnionAttr::getSpelling() const {
9242 0 : switch (SpellingListIndex) {
9243 0 : default:
9244 0 : llvm_unreachable("Unknown attribute spelling!");
9245 : return "(No spelling)";
9246 : case 0:
9247 : return "transparent_union";
9248 : case 1:
9249 : return "transparent_union";
9250 : }
9251 : }
9252 :
9253 6 : TrivialABIAttr *TrivialABIAttr::clone(ASTContext &C) const {
9254 : auto *A = new (C) TrivialABIAttr(getLocation(), C, getSpellingListIndex());
9255 6 : A->Inherited = Inherited;
9256 6 : A->IsPackExpansion = IsPackExpansion;
9257 6 : A->Implicit = Implicit;
9258 6 : return A;
9259 : }
9260 :
9261 0 : void TrivialABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9262 0 : switch (SpellingListIndex) {
9263 0 : default:
9264 0 : llvm_unreachable("Unknown attribute spelling!");
9265 : break;
9266 0 : case 0 : {
9267 0 : OS << " __attribute__((trivial_abi))";
9268 0 : break;
9269 : }
9270 0 : case 1 : {
9271 0 : OS << " [[clang::trivial_abi]]";
9272 0 : break;
9273 : }
9274 : }
9275 0 : }
9276 :
9277 0 : const char *TrivialABIAttr::getSpelling() const {
9278 0 : switch (SpellingListIndex) {
9279 0 : default:
9280 0 : llvm_unreachable("Unknown attribute spelling!");
9281 : return "(No spelling)";
9282 : case 0:
9283 : return "trivial_abi";
9284 : case 1:
9285 : return "trivial_abi";
9286 : }
9287 : }
9288 :
9289 10 : TryAcquireCapabilityAttr *TryAcquireCapabilityAttr::clone(ASTContext &C) const {
9290 10 : auto *A = new (C) TryAcquireCapabilityAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
9291 10 : A->Inherited = Inherited;
9292 10 : A->IsPackExpansion = IsPackExpansion;
9293 10 : A->Implicit = Implicit;
9294 10 : return A;
9295 : }
9296 :
9297 0 : void TryAcquireCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9298 0 : switch (SpellingListIndex) {
9299 0 : default:
9300 0 : llvm_unreachable("Unknown attribute spelling!");
9301 : break;
9302 0 : case 0 : {
9303 0 : OS << " __attribute__((try_acquire_capability(" << getSuccessValue() << ", ";
9304 : bool isFirst = true;
9305 0 : for (const auto &Val : args()) {
9306 0 : if (isFirst) isFirst = false;
9307 0 : else OS << ", ";
9308 0 : OS << Val;
9309 : }
9310 0 : OS << ")))";
9311 0 : break;
9312 : }
9313 0 : case 1 : {
9314 0 : OS << " [[clang::try_acquire_capability(" << getSuccessValue() << ", ";
9315 : bool isFirst = true;
9316 0 : for (const auto &Val : args()) {
9317 0 : if (isFirst) isFirst = false;
9318 0 : else OS << ", ";
9319 0 : OS << Val;
9320 : }
9321 0 : OS << ")]]";
9322 0 : break;
9323 : }
9324 0 : case 2 : {
9325 0 : OS << " __attribute__((try_acquire_shared_capability(" << getSuccessValue() << ", ";
9326 : bool isFirst = true;
9327 0 : for (const auto &Val : args()) {
9328 0 : if (isFirst) isFirst = false;
9329 0 : else OS << ", ";
9330 0 : OS << Val;
9331 : }
9332 0 : OS << ")))";
9333 0 : break;
9334 : }
9335 0 : case 3 : {
9336 0 : OS << " [[clang::try_acquire_shared_capability(" << getSuccessValue() << ", ";
9337 : bool isFirst = true;
9338 0 : for (const auto &Val : args()) {
9339 0 : if (isFirst) isFirst = false;
9340 0 : else OS << ", ";
9341 0 : OS << Val;
9342 : }
9343 0 : OS << ")]]";
9344 0 : break;
9345 : }
9346 : }
9347 0 : }
9348 :
9349 0 : const char *TryAcquireCapabilityAttr::getSpelling() const {
9350 0 : switch (SpellingListIndex) {
9351 0 : default:
9352 0 : llvm_unreachable("Unknown attribute spelling!");
9353 : return "(No spelling)";
9354 : case 0:
9355 : return "try_acquire_capability";
9356 : case 1:
9357 : return "try_acquire_capability";
9358 0 : case 2:
9359 0 : return "try_acquire_shared_capability";
9360 0 : case 3:
9361 0 : return "try_acquire_shared_capability";
9362 : }
9363 : }
9364 :
9365 0 : TypeNonNullAttr *TypeNonNullAttr::clone(ASTContext &C) const {
9366 : auto *A = new (C) TypeNonNullAttr(getLocation(), C, getSpellingListIndex());
9367 0 : A->Inherited = Inherited;
9368 0 : A->IsPackExpansion = IsPackExpansion;
9369 0 : A->Implicit = Implicit;
9370 0 : return A;
9371 : }
9372 :
9373 0 : void TypeNonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9374 0 : switch (SpellingListIndex) {
9375 0 : default:
9376 0 : llvm_unreachable("Unknown attribute spelling!");
9377 : break;
9378 0 : case 0 : {
9379 0 : OS << " _Nonnull";
9380 : break;
9381 : }
9382 : }
9383 0 : }
9384 :
9385 0 : const char *TypeNonNullAttr::getSpelling() const {
9386 0 : switch (SpellingListIndex) {
9387 0 : default:
9388 0 : llvm_unreachable("Unknown attribute spelling!");
9389 : return "(No spelling)";
9390 0 : case 0:
9391 : return "_Nonnull";
9392 : }
9393 : }
9394 :
9395 0 : TypeNullUnspecifiedAttr *TypeNullUnspecifiedAttr::clone(ASTContext &C) const {
9396 : auto *A = new (C) TypeNullUnspecifiedAttr(getLocation(), C, getSpellingListIndex());
9397 0 : A->Inherited = Inherited;
9398 0 : A->IsPackExpansion = IsPackExpansion;
9399 0 : A->Implicit = Implicit;
9400 0 : return A;
9401 : }
9402 :
9403 0 : void TypeNullUnspecifiedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9404 0 : switch (SpellingListIndex) {
9405 0 : default:
9406 0 : llvm_unreachable("Unknown attribute spelling!");
9407 : break;
9408 0 : case 0 : {
9409 0 : OS << " _Null_unspecified";
9410 : break;
9411 : }
9412 : }
9413 0 : }
9414 :
9415 0 : const char *TypeNullUnspecifiedAttr::getSpelling() const {
9416 0 : switch (SpellingListIndex) {
9417 0 : default:
9418 0 : llvm_unreachable("Unknown attribute spelling!");
9419 : return "(No spelling)";
9420 0 : case 0:
9421 : return "_Null_unspecified";
9422 : }
9423 : }
9424 :
9425 0 : TypeNullableAttr *TypeNullableAttr::clone(ASTContext &C) const {
9426 : auto *A = new (C) TypeNullableAttr(getLocation(), C, getSpellingListIndex());
9427 0 : A->Inherited = Inherited;
9428 0 : A->IsPackExpansion = IsPackExpansion;
9429 0 : A->Implicit = Implicit;
9430 0 : return A;
9431 : }
9432 :
9433 0 : void TypeNullableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9434 0 : switch (SpellingListIndex) {
9435 0 : default:
9436 0 : llvm_unreachable("Unknown attribute spelling!");
9437 : break;
9438 0 : case 0 : {
9439 0 : OS << " _Nullable";
9440 : break;
9441 : }
9442 : }
9443 0 : }
9444 :
9445 0 : const char *TypeNullableAttr::getSpelling() const {
9446 0 : switch (SpellingListIndex) {
9447 0 : default:
9448 0 : llvm_unreachable("Unknown attribute spelling!");
9449 : return "(No spelling)";
9450 0 : case 0:
9451 : return "_Nullable";
9452 : }
9453 : }
9454 :
9455 0 : TypeTagForDatatypeAttr *TypeTagForDatatypeAttr::clone(ASTContext &C) const {
9456 0 : auto *A = new (C) TypeTagForDatatypeAttr(getLocation(), C, argumentKind, matchingCType, layoutCompatible, mustBeNull, getSpellingListIndex());
9457 0 : A->Inherited = Inherited;
9458 0 : A->IsPackExpansion = IsPackExpansion;
9459 0 : A->Implicit = Implicit;
9460 0 : return A;
9461 : }
9462 :
9463 0 : void TypeTagForDatatypeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9464 0 : switch (SpellingListIndex) {
9465 0 : default:
9466 0 : llvm_unreachable("Unknown attribute spelling!");
9467 : break;
9468 0 : case 0 : {
9469 0 : OS << " __attribute__((type_tag_for_datatype(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")))";
9470 0 : break;
9471 : }
9472 0 : case 1 : {
9473 0 : OS << " [[clang::type_tag_for_datatype(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")]]";
9474 0 : break;
9475 : }
9476 0 : case 2 : {
9477 0 : OS << " [[clang::type_tag_for_datatype(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")]]";
9478 0 : break;
9479 : }
9480 : }
9481 0 : }
9482 :
9483 0 : const char *TypeTagForDatatypeAttr::getSpelling() const {
9484 0 : switch (SpellingListIndex) {
9485 0 : default:
9486 0 : llvm_unreachable("Unknown attribute spelling!");
9487 : return "(No spelling)";
9488 : case 0:
9489 : return "type_tag_for_datatype";
9490 : case 1:
9491 : return "type_tag_for_datatype";
9492 : case 2:
9493 : return "type_tag_for_datatype";
9494 : }
9495 : }
9496 :
9497 141 : TypeVisibilityAttr *TypeVisibilityAttr::clone(ASTContext &C) const {
9498 141 : auto *A = new (C) TypeVisibilityAttr(getLocation(), C, visibility, getSpellingListIndex());
9499 141 : A->Inherited = Inherited;
9500 141 : A->IsPackExpansion = IsPackExpansion;
9501 141 : A->Implicit = Implicit;
9502 141 : return A;
9503 : }
9504 :
9505 0 : void TypeVisibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9506 0 : switch (SpellingListIndex) {
9507 0 : default:
9508 0 : llvm_unreachable("Unknown attribute spelling!");
9509 : break;
9510 0 : case 0 : {
9511 0 : OS << " __attribute__((type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")))";
9512 0 : break;
9513 : }
9514 0 : case 1 : {
9515 0 : OS << " [[clang::type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
9516 0 : break;
9517 : }
9518 0 : case 2 : {
9519 0 : OS << " [[clang::type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
9520 0 : break;
9521 : }
9522 : }
9523 0 : }
9524 :
9525 0 : const char *TypeVisibilityAttr::getSpelling() const {
9526 0 : switch (SpellingListIndex) {
9527 0 : default:
9528 0 : llvm_unreachable("Unknown attribute spelling!");
9529 : return "(No spelling)";
9530 : case 0:
9531 : return "type_visibility";
9532 : case 1:
9533 : return "type_visibility";
9534 : case 2:
9535 : return "type_visibility";
9536 : }
9537 : }
9538 :
9539 0 : UPtrAttr *UPtrAttr::clone(ASTContext &C) const {
9540 : auto *A = new (C) UPtrAttr(getLocation(), C, getSpellingListIndex());
9541 0 : A->Inherited = Inherited;
9542 0 : A->IsPackExpansion = IsPackExpansion;
9543 0 : A->Implicit = Implicit;
9544 0 : return A;
9545 : }
9546 :
9547 0 : void UPtrAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9548 0 : switch (SpellingListIndex) {
9549 0 : default:
9550 0 : llvm_unreachable("Unknown attribute spelling!");
9551 : break;
9552 0 : case 0 : {
9553 0 : OS << " __uptr";
9554 : break;
9555 : }
9556 : }
9557 0 : }
9558 :
9559 0 : const char *UPtrAttr::getSpelling() const {
9560 0 : switch (SpellingListIndex) {
9561 0 : default:
9562 0 : llvm_unreachable("Unknown attribute spelling!");
9563 : return "(No spelling)";
9564 0 : case 0:
9565 : return "__uptr";
9566 : }
9567 : }
9568 :
9569 58 : UnavailableAttr *UnavailableAttr::clone(ASTContext &C) const {
9570 116 : auto *A = new (C) UnavailableAttr(getLocation(), C, getMessage(), implicitReason, getSpellingListIndex());
9571 58 : A->Inherited = Inherited;
9572 58 : A->IsPackExpansion = IsPackExpansion;
9573 58 : A->Implicit = Implicit;
9574 58 : return A;
9575 : }
9576 :
9577 1 : void UnavailableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9578 1 : switch (SpellingListIndex) {
9579 0 : default:
9580 0 : llvm_unreachable("Unknown attribute spelling!");
9581 : break;
9582 1 : case 0 : {
9583 1 : OS << " __attribute__((unavailable(\"" << getMessage() << "\")))";
9584 1 : break;
9585 : }
9586 0 : case 1 : {
9587 0 : OS << " [[clang::unavailable(\"" << getMessage() << "\")]]";
9588 0 : break;
9589 : }
9590 0 : case 2 : {
9591 0 : OS << " [[clang::unavailable(\"" << getMessage() << "\")]]";
9592 0 : break;
9593 : }
9594 : }
9595 1 : }
9596 :
9597 0 : const char *UnavailableAttr::getSpelling() const {
9598 0 : switch (SpellingListIndex) {
9599 0 : default:
9600 0 : llvm_unreachable("Unknown attribute spelling!");
9601 : return "(No spelling)";
9602 : case 0:
9603 : return "unavailable";
9604 : case 1:
9605 : return "unavailable";
9606 : case 2:
9607 : return "unavailable";
9608 : }
9609 : }
9610 :
9611 782 : UnusedAttr *UnusedAttr::clone(ASTContext &C) const {
9612 : auto *A = new (C) UnusedAttr(getLocation(), C, getSpellingListIndex());
9613 782 : A->Inherited = Inherited;
9614 782 : A->IsPackExpansion = IsPackExpansion;
9615 782 : A->Implicit = Implicit;
9616 782 : return A;
9617 : }
9618 :
9619 0 : void UnusedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9620 0 : switch (SpellingListIndex) {
9621 0 : default:
9622 0 : llvm_unreachable("Unknown attribute spelling!");
9623 : break;
9624 0 : case 0 : {
9625 0 : OS << " [[maybe_unused]]";
9626 0 : break;
9627 : }
9628 0 : case 1 : {
9629 0 : OS << " __attribute__((unused))";
9630 0 : break;
9631 : }
9632 0 : case 2 : {
9633 0 : OS << " [[gnu::unused]]";
9634 0 : break;
9635 : }
9636 0 : case 3 : {
9637 0 : OS << " [[maybe_unused]]";
9638 0 : break;
9639 : }
9640 : }
9641 0 : }
9642 :
9643 5 : const char *UnusedAttr::getSpelling() const {
9644 5 : switch (SpellingListIndex) {
9645 0 : default:
9646 0 : llvm_unreachable("Unknown attribute spelling!");
9647 : return "(No spelling)";
9648 : case 0:
9649 : return "maybe_unused";
9650 5 : case 1:
9651 5 : return "unused";
9652 0 : case 2:
9653 0 : return "unused";
9654 : case 3:
9655 : return "maybe_unused";
9656 : }
9657 : }
9658 :
9659 30 : UsedAttr *UsedAttr::clone(ASTContext &C) const {
9660 : auto *A = new (C) UsedAttr(getLocation(), C, getSpellingListIndex());
9661 30 : A->Inherited = Inherited;
9662 30 : A->IsPackExpansion = IsPackExpansion;
9663 30 : A->Implicit = Implicit;
9664 30 : return A;
9665 : }
9666 :
9667 0 : void UsedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9668 0 : switch (SpellingListIndex) {
9669 0 : default:
9670 0 : llvm_unreachable("Unknown attribute spelling!");
9671 : break;
9672 0 : case 0 : {
9673 0 : OS << " __attribute__((used))";
9674 0 : break;
9675 : }
9676 0 : case 1 : {
9677 0 : OS << " [[gnu::used]]";
9678 0 : break;
9679 : }
9680 : }
9681 0 : }
9682 :
9683 4 : const char *UsedAttr::getSpelling() const {
9684 4 : switch (SpellingListIndex) {
9685 0 : default:
9686 0 : llvm_unreachable("Unknown attribute spelling!");
9687 : return "(No spelling)";
9688 : case 0:
9689 : return "used";
9690 : case 1:
9691 : return "used";
9692 : }
9693 : }
9694 :
9695 0 : UuidAttr *UuidAttr::clone(ASTContext &C) const {
9696 0 : auto *A = new (C) UuidAttr(getLocation(), C, getGuid(), getSpellingListIndex());
9697 0 : A->Inherited = Inherited;
9698 0 : A->IsPackExpansion = IsPackExpansion;
9699 0 : A->Implicit = Implicit;
9700 0 : return A;
9701 : }
9702 :
9703 0 : void UuidAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9704 0 : switch (SpellingListIndex) {
9705 0 : default:
9706 0 : llvm_unreachable("Unknown attribute spelling!");
9707 : break;
9708 0 : case 0 : {
9709 0 : OS << " __declspec(uuid(\"" << getGuid() << "\"))";
9710 0 : break;
9711 : }
9712 0 : case 1 : {
9713 0 : OS << "[uuid(\"" << getGuid() << "\")]";
9714 0 : break;
9715 : }
9716 : }
9717 0 : }
9718 :
9719 0 : const char *UuidAttr::getSpelling() const {
9720 0 : switch (SpellingListIndex) {
9721 0 : default:
9722 0 : llvm_unreachable("Unknown attribute spelling!");
9723 : return "(No spelling)";
9724 : case 0:
9725 : return "uuid";
9726 : case 1:
9727 : return "uuid";
9728 : }
9729 : }
9730 :
9731 0 : VecReturnAttr *VecReturnAttr::clone(ASTContext &C) const {
9732 : auto *A = new (C) VecReturnAttr(getLocation(), C, getSpellingListIndex());
9733 0 : A->Inherited = Inherited;
9734 0 : A->IsPackExpansion = IsPackExpansion;
9735 0 : A->Implicit = Implicit;
9736 0 : return A;
9737 : }
9738 :
9739 0 : void VecReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9740 0 : switch (SpellingListIndex) {
9741 0 : default:
9742 0 : llvm_unreachable("Unknown attribute spelling!");
9743 : break;
9744 0 : case 0 : {
9745 0 : OS << " __attribute__((vecreturn))";
9746 0 : break;
9747 : }
9748 0 : case 1 : {
9749 0 : OS << " [[clang::vecreturn]]";
9750 0 : break;
9751 : }
9752 : }
9753 0 : }
9754 :
9755 1 : const char *VecReturnAttr::getSpelling() const {
9756 1 : switch (SpellingListIndex) {
9757 0 : default:
9758 0 : llvm_unreachable("Unknown attribute spelling!");
9759 : return "(No spelling)";
9760 : case 0:
9761 : return "vecreturn";
9762 : case 1:
9763 : return "vecreturn";
9764 : }
9765 : }
9766 :
9767 0 : VecTypeHintAttr *VecTypeHintAttr::clone(ASTContext &C) const {
9768 0 : auto *A = new (C) VecTypeHintAttr(getLocation(), C, typeHint, getSpellingListIndex());
9769 0 : A->Inherited = Inherited;
9770 0 : A->IsPackExpansion = IsPackExpansion;
9771 0 : A->Implicit = Implicit;
9772 0 : return A;
9773 : }
9774 :
9775 0 : void VecTypeHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9776 0 : switch (SpellingListIndex) {
9777 0 : default:
9778 0 : llvm_unreachable("Unknown attribute spelling!");
9779 : break;
9780 0 : case 0 : {
9781 0 : OS << " __attribute__((vec_type_hint(" << getTypeHint().getAsString() << ")))";
9782 : break;
9783 : }
9784 : }
9785 0 : }
9786 :
9787 2 : const char *VecTypeHintAttr::getSpelling() const {
9788 2 : switch (SpellingListIndex) {
9789 0 : default:
9790 0 : llvm_unreachable("Unknown attribute spelling!");
9791 : return "(No spelling)";
9792 2 : case 0:
9793 : return "vec_type_hint";
9794 : }
9795 : }
9796 :
9797 0 : VectorCallAttr *VectorCallAttr::clone(ASTContext &C) const {
9798 : auto *A = new (C) VectorCallAttr(getLocation(), C, getSpellingListIndex());
9799 0 : A->Inherited = Inherited;
9800 0 : A->IsPackExpansion = IsPackExpansion;
9801 0 : A->Implicit = Implicit;
9802 0 : return A;
9803 : }
9804 :
9805 0 : void VectorCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9806 0 : switch (SpellingListIndex) {
9807 0 : default:
9808 0 : llvm_unreachable("Unknown attribute spelling!");
9809 : break;
9810 0 : case 0 : {
9811 0 : OS << " __attribute__((vectorcall))";
9812 0 : break;
9813 : }
9814 0 : case 1 : {
9815 0 : OS << " [[clang::vectorcall]]";
9816 0 : break;
9817 : }
9818 0 : case 2 : {
9819 0 : OS << " [[clang::vectorcall]]";
9820 0 : break;
9821 : }
9822 0 : case 3 : {
9823 0 : OS << " __vectorcall";
9824 0 : break;
9825 : }
9826 0 : case 4 : {
9827 0 : OS << " _vectorcall";
9828 0 : break;
9829 : }
9830 : }
9831 0 : }
9832 :
9833 0 : const char *VectorCallAttr::getSpelling() const {
9834 0 : switch (SpellingListIndex) {
9835 0 : default:
9836 0 : llvm_unreachable("Unknown attribute spelling!");
9837 : return "(No spelling)";
9838 : case 0:
9839 : return "vectorcall";
9840 : case 1:
9841 : return "vectorcall";
9842 : case 2:
9843 : return "vectorcall";
9844 0 : case 3:
9845 0 : return "__vectorcall";
9846 0 : case 4:
9847 0 : return "_vectorcall";
9848 : }
9849 : }
9850 :
9851 12 : VisibilityAttr *VisibilityAttr::clone(ASTContext &C) const {
9852 12 : auto *A = new (C) VisibilityAttr(getLocation(), C, visibility, getSpellingListIndex());
9853 12 : A->Inherited = Inherited;
9854 12 : A->IsPackExpansion = IsPackExpansion;
9855 12 : A->Implicit = Implicit;
9856 12 : return A;
9857 : }
9858 :
9859 3 : void VisibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9860 3 : switch (SpellingListIndex) {
9861 0 : default:
9862 0 : llvm_unreachable("Unknown attribute spelling!");
9863 : break;
9864 2 : case 0 : {
9865 3 : OS << " __attribute__((visibility(\"" << VisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")))";
9866 2 : break;
9867 : }
9868 1 : case 1 : {
9869 2 : OS << " [[gnu::visibility(\"" << VisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
9870 1 : break;
9871 : }
9872 : }
9873 3 : }
9874 :
9875 0 : const char *VisibilityAttr::getSpelling() const {
9876 0 : switch (SpellingListIndex) {
9877 0 : default:
9878 0 : llvm_unreachable("Unknown attribute spelling!");
9879 : return "(No spelling)";
9880 : case 0:
9881 : return "visibility";
9882 : case 1:
9883 : return "visibility";
9884 : }
9885 : }
9886 :
9887 0 : WarnUnusedAttr *WarnUnusedAttr::clone(ASTContext &C) const {
9888 : auto *A = new (C) WarnUnusedAttr(getLocation(), C, getSpellingListIndex());
9889 0 : A->Inherited = Inherited;
9890 0 : A->IsPackExpansion = IsPackExpansion;
9891 0 : A->Implicit = Implicit;
9892 0 : return A;
9893 : }
9894 :
9895 0 : void WarnUnusedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9896 0 : switch (SpellingListIndex) {
9897 0 : default:
9898 0 : llvm_unreachable("Unknown attribute spelling!");
9899 : break;
9900 0 : case 0 : {
9901 0 : OS << " __attribute__((warn_unused))";
9902 0 : break;
9903 : }
9904 0 : case 1 : {
9905 0 : OS << " [[gnu::warn_unused]]";
9906 0 : break;
9907 : }
9908 : }
9909 0 : }
9910 :
9911 0 : const char *WarnUnusedAttr::getSpelling() const {
9912 0 : switch (SpellingListIndex) {
9913 0 : default:
9914 0 : llvm_unreachable("Unknown attribute spelling!");
9915 : return "(No spelling)";
9916 : case 0:
9917 : return "warn_unused";
9918 : case 1:
9919 : return "warn_unused";
9920 : }
9921 : }
9922 :
9923 92422 : WarnUnusedResultAttr *WarnUnusedResultAttr::clone(ASTContext &C) const {
9924 : auto *A = new (C) WarnUnusedResultAttr(getLocation(), C, getSpellingListIndex());
9925 92422 : A->Inherited = Inherited;
9926 92422 : A->IsPackExpansion = IsPackExpansion;
9927 92422 : A->Implicit = Implicit;
9928 92422 : return A;
9929 : }
9930 :
9931 3 : void WarnUnusedResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9932 3 : switch (SpellingListIndex) {
9933 0 : default:
9934 0 : llvm_unreachable("Unknown attribute spelling!");
9935 : break;
9936 0 : case 0 : {
9937 0 : OS << " [[nodiscard]]";
9938 0 : break;
9939 : }
9940 0 : case 1 : {
9941 0 : OS << " [[nodiscard]]";
9942 0 : break;
9943 : }
9944 1 : case 2 : {
9945 1 : OS << " [[clang::warn_unused_result]]";
9946 1 : break;
9947 : }
9948 1 : case 3 : {
9949 1 : OS << " __attribute__((warn_unused_result))";
9950 1 : break;
9951 : }
9952 1 : case 4 : {
9953 1 : OS << " [[gnu::warn_unused_result]]";
9954 1 : break;
9955 : }
9956 : }
9957 3 : }
9958 :
9959 101 : const char *WarnUnusedResultAttr::getSpelling() const {
9960 101 : switch (SpellingListIndex) {
9961 0 : default:
9962 0 : llvm_unreachable("Unknown attribute spelling!");
9963 : return "(No spelling)";
9964 : case 0:
9965 : return "nodiscard";
9966 : case 1:
9967 : return "nodiscard";
9968 16 : case 2:
9969 16 : return "warn_unused_result";
9970 18 : case 3:
9971 18 : return "warn_unused_result";
9972 0 : case 4:
9973 0 : return "warn_unused_result";
9974 : }
9975 : }
9976 :
9977 42 : WeakAttr *WeakAttr::clone(ASTContext &C) const {
9978 : auto *A = new (C) WeakAttr(getLocation(), C, getSpellingListIndex());
9979 42 : A->Inherited = Inherited;
9980 42 : A->IsPackExpansion = IsPackExpansion;
9981 42 : A->Implicit = Implicit;
9982 42 : return A;
9983 : }
9984 :
9985 0 : void WeakAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
9986 0 : switch (SpellingListIndex) {
9987 0 : default:
9988 0 : llvm_unreachable("Unknown attribute spelling!");
9989 : break;
9990 0 : case 0 : {
9991 0 : OS << " __attribute__((weak))";
9992 0 : break;
9993 : }
9994 0 : case 1 : {
9995 0 : OS << " [[gnu::weak]]";
9996 0 : break;
9997 : }
9998 : }
9999 0 : }
10000 :
10001 0 : const char *WeakAttr::getSpelling() const {
10002 0 : switch (SpellingListIndex) {
10003 0 : default:
10004 0 : llvm_unreachable("Unknown attribute spelling!");
10005 : return "(No spelling)";
10006 : case 0:
10007 : return "weak";
10008 : case 1:
10009 : return "weak";
10010 : }
10011 : }
10012 :
10013 8 : WeakImportAttr *WeakImportAttr::clone(ASTContext &C) const {
10014 : auto *A = new (C) WeakImportAttr(getLocation(), C, getSpellingListIndex());
10015 8 : A->Inherited = Inherited;
10016 8 : A->IsPackExpansion = IsPackExpansion;
10017 8 : A->Implicit = Implicit;
10018 8 : return A;
10019 : }
10020 :
10021 0 : void WeakImportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
10022 0 : switch (SpellingListIndex) {
10023 0 : default:
10024 0 : llvm_unreachable("Unknown attribute spelling!");
10025 : break;
10026 0 : case 0 : {
10027 0 : OS << " __attribute__((weak_import))";
10028 0 : break;
10029 : }
10030 0 : case 1 : {
10031 0 : OS << " [[clang::weak_import]]";
10032 0 : break;
10033 : }
10034 0 : case 2 : {
10035 0 : OS << " [[clang::weak_import]]";
10036 0 : break;
10037 : }
10038 : }
10039 0 : }
10040 :
10041 0 : const char *WeakImportAttr::getSpelling() const {
10042 0 : switch (SpellingListIndex) {
10043 0 : default:
10044 0 : llvm_unreachable("Unknown attribute spelling!");
10045 : return "(No spelling)";
10046 : case 0:
10047 : return "weak_import";
10048 : case 1:
10049 : return "weak_import";
10050 : case 2:
10051 : return "weak_import";
10052 : }
10053 : }
10054 :
10055 0 : WeakRefAttr *WeakRefAttr::clone(ASTContext &C) const {
10056 0 : auto *A = new (C) WeakRefAttr(getLocation(), C, getAliasee(), getSpellingListIndex());
10057 0 : A->Inherited = Inherited;
10058 0 : A->IsPackExpansion = IsPackExpansion;
10059 0 : A->Implicit = Implicit;
10060 0 : return A;
10061 : }
10062 :
10063 0 : void WeakRefAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
10064 0 : switch (SpellingListIndex) {
10065 0 : default:
10066 0 : llvm_unreachable("Unknown attribute spelling!");
10067 : break;
10068 0 : case 0 : {
10069 0 : OS << " __attribute__((weakref(\"" << getAliasee() << "\")))";
10070 0 : break;
10071 : }
10072 0 : case 1 : {
10073 0 : OS << " [[gnu::weakref(\"" << getAliasee() << "\")]]";
10074 0 : break;
10075 : }
10076 : }
10077 0 : }
10078 :
10079 0 : const char *WeakRefAttr::getSpelling() const {
10080 0 : switch (SpellingListIndex) {
10081 0 : default:
10082 0 : llvm_unreachable("Unknown attribute spelling!");
10083 : return "(No spelling)";
10084 : case 0:
10085 : return "weakref";
10086 : case 1:
10087 : return "weakref";
10088 : }
10089 : }
10090 :
10091 0 : WorkGroupSizeHintAttr *WorkGroupSizeHintAttr::clone(ASTContext &C) const {
10092 0 : auto *A = new (C) WorkGroupSizeHintAttr(getLocation(), C, xDim, yDim, zDim, getSpellingListIndex());
10093 0 : A->Inherited = Inherited;
10094 0 : A->IsPackExpansion = IsPackExpansion;
10095 0 : A->Implicit = Implicit;
10096 0 : return A;
10097 : }
10098 :
10099 0 : void WorkGroupSizeHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
10100 0 : switch (SpellingListIndex) {
10101 0 : default:
10102 0 : llvm_unreachable("Unknown attribute spelling!");
10103 : break;
10104 0 : case 0 : {
10105 0 : OS << " __attribute__((work_group_size_hint(" << getXDim() << ", " << getYDim() << ", " << getZDim() << ")))";
10106 : break;
10107 : }
10108 : }
10109 0 : }
10110 :
10111 2 : const char *WorkGroupSizeHintAttr::getSpelling() const {
10112 2 : switch (SpellingListIndex) {
10113 0 : default:
10114 0 : llvm_unreachable("Unknown attribute spelling!");
10115 : return "(No spelling)";
10116 2 : case 0:
10117 : return "work_group_size_hint";
10118 : }
10119 : }
10120 :
10121 1 : X86ForceAlignArgPointerAttr *X86ForceAlignArgPointerAttr::clone(ASTContext &C) const {
10122 : auto *A = new (C) X86ForceAlignArgPointerAttr(getLocation(), C, getSpellingListIndex());
10123 1 : A->Inherited = Inherited;
10124 1 : A->IsPackExpansion = IsPackExpansion;
10125 1 : A->Implicit = Implicit;
10126 1 : return A;
10127 : }
10128 :
10129 0 : void X86ForceAlignArgPointerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
10130 0 : switch (SpellingListIndex) {
10131 0 : default:
10132 0 : llvm_unreachable("Unknown attribute spelling!");
10133 : break;
10134 0 : case 0 : {
10135 0 : OS << " __attribute__((force_align_arg_pointer))";
10136 0 : break;
10137 : }
10138 0 : case 1 : {
10139 0 : OS << " [[gnu::force_align_arg_pointer]]";
10140 0 : break;
10141 : }
10142 : }
10143 0 : }
10144 :
10145 0 : const char *X86ForceAlignArgPointerAttr::getSpelling() const {
10146 0 : switch (SpellingListIndex) {
10147 0 : default:
10148 0 : llvm_unreachable("Unknown attribute spelling!");
10149 : return "(No spelling)";
10150 : case 0:
10151 : return "force_align_arg_pointer";
10152 : case 1:
10153 : return "force_align_arg_pointer";
10154 : }
10155 : }
10156 :
10157 0 : XRayInstrumentAttr *XRayInstrumentAttr::clone(ASTContext &C) const {
10158 : auto *A = new (C) XRayInstrumentAttr(getLocation(), C, getSpellingListIndex());
10159 0 : A->Inherited = Inherited;
10160 0 : A->IsPackExpansion = IsPackExpansion;
10161 0 : A->Implicit = Implicit;
10162 0 : return A;
10163 : }
10164 :
10165 0 : void XRayInstrumentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
10166 0 : switch (SpellingListIndex) {
10167 0 : default:
10168 0 : llvm_unreachable("Unknown attribute spelling!");
10169 : break;
10170 0 : case 0 : {
10171 0 : OS << " __attribute__((xray_always_instrument))";
10172 0 : break;
10173 : }
10174 0 : case 1 : {
10175 0 : OS << " [[clang::xray_always_instrument]]";
10176 0 : break;
10177 : }
10178 0 : case 2 : {
10179 0 : OS << " [[clang::xray_always_instrument]]";
10180 0 : break;
10181 : }
10182 0 : case 3 : {
10183 0 : OS << " __attribute__((xray_never_instrument))";
10184 0 : break;
10185 : }
10186 0 : case 4 : {
10187 0 : OS << " [[clang::xray_never_instrument]]";
10188 0 : break;
10189 : }
10190 0 : case 5 : {
10191 0 : OS << " [[clang::xray_never_instrument]]";
10192 0 : break;
10193 : }
10194 : }
10195 0 : }
10196 :
10197 0 : const char *XRayInstrumentAttr::getSpelling() const {
10198 0 : switch (SpellingListIndex) {
10199 0 : default:
10200 0 : llvm_unreachable("Unknown attribute spelling!");
10201 : return "(No spelling)";
10202 : case 0:
10203 : return "xray_always_instrument";
10204 : case 1:
10205 : return "xray_always_instrument";
10206 : case 2:
10207 : return "xray_always_instrument";
10208 0 : case 3:
10209 0 : return "xray_never_instrument";
10210 0 : case 4:
10211 0 : return "xray_never_instrument";
10212 0 : case 5:
10213 0 : return "xray_never_instrument";
10214 : }
10215 : }
10216 :
10217 0 : XRayLogArgsAttr *XRayLogArgsAttr::clone(ASTContext &C) const {
10218 0 : auto *A = new (C) XRayLogArgsAttr(getLocation(), C, argumentCount, getSpellingListIndex());
10219 0 : A->Inherited = Inherited;
10220 0 : A->IsPackExpansion = IsPackExpansion;
10221 0 : A->Implicit = Implicit;
10222 0 : return A;
10223 : }
10224 :
10225 4 : void XRayLogArgsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
10226 4 : switch (SpellingListIndex) {
10227 0 : default:
10228 0 : llvm_unreachable("Unknown attribute spelling!");
10229 : break;
10230 4 : case 0 : {
10231 4 : OS << " __attribute__((xray_log_args(" << getArgumentCount() << ")))";
10232 4 : break;
10233 : }
10234 0 : case 1 : {
10235 0 : OS << " [[clang::xray_log_args(" << getArgumentCount() << ")]]";
10236 0 : break;
10237 : }
10238 0 : case 2 : {
10239 0 : OS << " [[clang::xray_log_args(" << getArgumentCount() << ")]]";
10240 0 : break;
10241 : }
10242 : }
10243 4 : }
10244 :
10245 0 : const char *XRayLogArgsAttr::getSpelling() const {
10246 0 : switch (SpellingListIndex) {
10247 0 : default:
10248 0 : llvm_unreachable("Unknown attribute spelling!");
10249 : return "(No spelling)";
10250 : case 0:
10251 : return "xray_log_args";
10252 : case 1:
10253 : return "xray_log_args";
10254 : case 2:
10255 : return "xray_log_args";
10256 : }
10257 : }
10258 :
10259 1453 : const char *Attr::getSpelling() const {
10260 1453 : switch (getKind()) {
10261 : case attr::AMDGPUFlatWorkGroupSize:
10262 1 : return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->getSpelling();
10263 : case attr::AMDGPUNumSGPR:
10264 1 : return cast<AMDGPUNumSGPRAttr>(this)->getSpelling();
10265 : case attr::AMDGPUNumVGPR:
10266 1 : return cast<AMDGPUNumVGPRAttr>(this)->getSpelling();
10267 : case attr::AMDGPUWavesPerEU:
10268 2 : return cast<AMDGPUWavesPerEUAttr>(this)->getSpelling();
10269 : case attr::ARMInterrupt:
10270 0 : return cast<ARMInterruptAttr>(this)->getSpelling();
10271 : case attr::AVRInterrupt:
10272 0 : return cast<AVRInterruptAttr>(this)->getSpelling();
10273 : case attr::AVRSignal:
10274 0 : return cast<AVRSignalAttr>(this)->getSpelling();
10275 : case attr::AbiTag:
10276 0 : return cast<AbiTagAttr>(this)->getSpelling();
10277 : case attr::AcquireCapability:
10278 0 : return cast<AcquireCapabilityAttr>(this)->getSpelling();
10279 : case attr::AcquiredAfter:
10280 0 : return cast<AcquiredAfterAttr>(this)->getSpelling();
10281 : case attr::AcquiredBefore:
10282 0 : return cast<AcquiredBeforeAttr>(this)->getSpelling();
10283 : case attr::AddressSpace:
10284 0 : return cast<AddressSpaceAttr>(this)->getSpelling();
10285 : case attr::Alias:
10286 0 : return cast<AliasAttr>(this)->getSpelling();
10287 : case attr::AlignMac68k:
10288 0 : return cast<AlignMac68kAttr>(this)->getSpelling();
10289 : case attr::AlignValue:
10290 1 : return cast<AlignValueAttr>(this)->getSpelling();
10291 : case attr::Aligned:
10292 47 : return cast<AlignedAttr>(this)->getSpelling();
10293 : case attr::AllocAlign:
10294 10 : return cast<AllocAlignAttr>(this)->getSpelling();
10295 : case attr::AllocSize:
10296 0 : return cast<AllocSizeAttr>(this)->getSpelling();
10297 : case attr::AlwaysDestroy:
10298 2 : return cast<AlwaysDestroyAttr>(this)->getSpelling();
10299 : case attr::AlwaysInline:
10300 8 : return cast<AlwaysInlineAttr>(this)->getSpelling();
10301 : case attr::AnalyzerNoReturn:
10302 0 : return cast<AnalyzerNoReturnAttr>(this)->getSpelling();
10303 : case attr::Annotate:
10304 0 : return cast<AnnotateAttr>(this)->getSpelling();
10305 : case attr::AnyX86Interrupt:
10306 0 : return cast<AnyX86InterruptAttr>(this)->getSpelling();
10307 : case attr::AnyX86NoCallerSavedRegisters:
10308 2 : return cast<AnyX86NoCallerSavedRegistersAttr>(this)->getSpelling();
10309 : case attr::AnyX86NoCfCheck:
10310 0 : return cast<AnyX86NoCfCheckAttr>(this)->getSpelling();
10311 : case attr::ArcWeakrefUnavailable:
10312 0 : return cast<ArcWeakrefUnavailableAttr>(this)->getSpelling();
10313 : case attr::ArgumentWithTypeTag:
10314 3 : return cast<ArgumentWithTypeTagAttr>(this)->getSpelling();
10315 : case attr::Artificial:
10316 0 : return cast<ArtificialAttr>(this)->getSpelling();
10317 : case attr::AsmLabel:
10318 0 : return cast<AsmLabelAttr>(this)->getSpelling();
10319 : case attr::AssertCapability:
10320 0 : return cast<AssertCapabilityAttr>(this)->getSpelling();
10321 : case attr::AssertExclusiveLock:
10322 0 : return cast<AssertExclusiveLockAttr>(this)->getSpelling();
10323 : case attr::AssertSharedLock:
10324 0 : return cast<AssertSharedLockAttr>(this)->getSpelling();
10325 : case attr::AssumeAligned:
10326 3 : return cast<AssumeAlignedAttr>(this)->getSpelling();
10327 : case attr::Availability:
10328 0 : return cast<AvailabilityAttr>(this)->getSpelling();
10329 : case attr::Blocks:
10330 0 : return cast<BlocksAttr>(this)->getSpelling();
10331 : case attr::C11NoReturn:
10332 0 : return cast<C11NoReturnAttr>(this)->getSpelling();
10333 : case attr::CDecl:
10334 0 : return cast<CDeclAttr>(this)->getSpelling();
10335 : case attr::CFAuditedTransfer:
10336 0 : return cast<CFAuditedTransferAttr>(this)->getSpelling();
10337 : case attr::CFConsumed:
10338 0 : return cast<CFConsumedAttr>(this)->getSpelling();
10339 : case attr::CFReturnsNotRetained:
10340 0 : return cast<CFReturnsNotRetainedAttr>(this)->getSpelling();
10341 : case attr::CFReturnsRetained:
10342 0 : return cast<CFReturnsRetainedAttr>(this)->getSpelling();
10343 : case attr::CFUnknownTransfer:
10344 0 : return cast<CFUnknownTransferAttr>(this)->getSpelling();
10345 : case attr::CPUDispatch:
10346 0 : return cast<CPUDispatchAttr>(this)->getSpelling();
10347 : case attr::CPUSpecific:
10348 0 : return cast<CPUSpecificAttr>(this)->getSpelling();
10349 : case attr::CUDAConstant:
10350 4 : return cast<CUDAConstantAttr>(this)->getSpelling();
10351 : case attr::CUDADevice:
10352 2 : return cast<CUDADeviceAttr>(this)->getSpelling();
10353 : case attr::CUDAGlobal:
10354 4 : return cast<CUDAGlobalAttr>(this)->getSpelling();
10355 : case attr::CUDAHost:
10356 2 : return cast<CUDAHostAttr>(this)->getSpelling();
10357 : case attr::CUDAInvalidTarget:
10358 0 : return cast<CUDAInvalidTargetAttr>(this)->getSpelling();
10359 : case attr::CUDALaunchBounds:
10360 7 : return cast<CUDALaunchBoundsAttr>(this)->getSpelling();
10361 : case attr::CUDAShared:
10362 2 : return cast<CUDASharedAttr>(this)->getSpelling();
10363 : case attr::CXX11NoReturn:
10364 0 : return cast<CXX11NoReturnAttr>(this)->getSpelling();
10365 : case attr::CallableWhen:
10366 0 : return cast<CallableWhenAttr>(this)->getSpelling();
10367 : case attr::Capability:
10368 1 : return cast<CapabilityAttr>(this)->getSpelling();
10369 : case attr::CapturedRecord:
10370 0 : return cast<CapturedRecordAttr>(this)->getSpelling();
10371 : case attr::CarriesDependency:
10372 0 : return cast<CarriesDependencyAttr>(this)->getSpelling();
10373 : case attr::Cleanup:
10374 0 : return cast<CleanupAttr>(this)->getSpelling();
10375 : case attr::CodeSeg:
10376 0 : return cast<CodeSegAttr>(this)->getSpelling();
10377 : case attr::Cold:
10378 1 : return cast<ColdAttr>(this)->getSpelling();
10379 : case attr::Common:
10380 5 : return cast<CommonAttr>(this)->getSpelling();
10381 : case attr::Const:
10382 0 : return cast<ConstAttr>(this)->getSpelling();
10383 : case attr::Constructor:
10384 0 : return cast<ConstructorAttr>(this)->getSpelling();
10385 : case attr::Consumable:
10386 0 : return cast<ConsumableAttr>(this)->getSpelling();
10387 : case attr::ConsumableAutoCast:
10388 0 : return cast<ConsumableAutoCastAttr>(this)->getSpelling();
10389 : case attr::ConsumableSetOnRead:
10390 0 : return cast<ConsumableSetOnReadAttr>(this)->getSpelling();
10391 : case attr::Convergent:
10392 0 : return cast<ConvergentAttr>(this)->getSpelling();
10393 : case attr::DLLExport:
10394 365 : return cast<DLLExportAttr>(this)->getSpelling();
10395 : case attr::DLLImport:
10396 830 : return cast<DLLImportAttr>(this)->getSpelling();
10397 : case attr::Deprecated:
10398 0 : return cast<DeprecatedAttr>(this)->getSpelling();
10399 : case attr::Destructor:
10400 0 : return cast<DestructorAttr>(this)->getSpelling();
10401 : case attr::DiagnoseIf:
10402 0 : return cast<DiagnoseIfAttr>(this)->getSpelling();
10403 : case attr::DisableTailCalls:
10404 1 : return cast<DisableTailCallsAttr>(this)->getSpelling();
10405 : case attr::EmptyBases:
10406 0 : return cast<EmptyBasesAttr>(this)->getSpelling();
10407 : case attr::EnableIf:
10408 0 : return cast<EnableIfAttr>(this)->getSpelling();
10409 : case attr::EnumExtensibility:
10410 0 : return cast<EnumExtensibilityAttr>(this)->getSpelling();
10411 : case attr::ExcludeFromExplicitInstantiation:
10412 0 : return cast<ExcludeFromExplicitInstantiationAttr>(this)->getSpelling();
10413 : case attr::ExclusiveTrylockFunction:
10414 0 : return cast<ExclusiveTrylockFunctionAttr>(this)->getSpelling();
10415 : case attr::ExternalSourceSymbol:
10416 0 : return cast<ExternalSourceSymbolAttr>(this)->getSpelling();
10417 : case attr::FallThrough:
10418 1 : return cast<FallThroughAttr>(this)->getSpelling();
10419 : case attr::FastCall:
10420 0 : return cast<FastCallAttr>(this)->getSpelling();
10421 : case attr::Final:
10422 0 : return cast<FinalAttr>(this)->getSpelling();
10423 : case attr::FlagEnum:
10424 0 : return cast<FlagEnumAttr>(this)->getSpelling();
10425 : case attr::Flatten:
10426 0 : return cast<FlattenAttr>(this)->getSpelling();
10427 : case attr::Format:
10428 0 : return cast<FormatAttr>(this)->getSpelling();
10429 : case attr::FormatArg:
10430 0 : return cast<FormatArgAttr>(this)->getSpelling();
10431 : case attr::GNUInline:
10432 0 : return cast<GNUInlineAttr>(this)->getSpelling();
10433 : case attr::GuardedBy:
10434 0 : return cast<GuardedByAttr>(this)->getSpelling();
10435 : case attr::GuardedVar:
10436 0 : return cast<GuardedVarAttr>(this)->getSpelling();
10437 : case attr::Hot:
10438 1 : return cast<HotAttr>(this)->getSpelling();
10439 : case attr::IBAction:
10440 0 : return cast<IBActionAttr>(this)->getSpelling();
10441 : case attr::IBOutlet:
10442 0 : return cast<IBOutletAttr>(this)->getSpelling();
10443 : case attr::IBOutletCollection:
10444 0 : return cast<IBOutletCollectionAttr>(this)->getSpelling();
10445 : case attr::IFunc:
10446 0 : return cast<IFuncAttr>(this)->getSpelling();
10447 : case attr::InitPriority:
10448 0 : return cast<InitPriorityAttr>(this)->getSpelling();
10449 : case attr::InitSeg:
10450 0 : return cast<InitSegAttr>(this)->getSpelling();
10451 : case attr::IntelOclBicc:
10452 0 : return cast<IntelOclBiccAttr>(this)->getSpelling();
10453 : case attr::InternalLinkage:
10454 3 : return cast<InternalLinkageAttr>(this)->getSpelling();
10455 : case attr::LTOVisibilityPublic:
10456 0 : return cast<LTOVisibilityPublicAttr>(this)->getSpelling();
10457 : case attr::LayoutVersion:
10458 0 : return cast<LayoutVersionAttr>(this)->getSpelling();
10459 : case attr::LifetimeBound:
10460 0 : return cast<LifetimeBoundAttr>(this)->getSpelling();
10461 : case attr::LockReturned:
10462 0 : return cast<LockReturnedAttr>(this)->getSpelling();
10463 : case attr::LocksExcluded:
10464 0 : return cast<LocksExcludedAttr>(this)->getSpelling();
10465 : case attr::LoopHint:
10466 1 : return cast<LoopHintAttr>(this)->getSpelling();
10467 : case attr::MSABI:
10468 0 : return cast<MSABIAttr>(this)->getSpelling();
10469 : case attr::MSInheritance:
10470 0 : return cast<MSInheritanceAttr>(this)->getSpelling();
10471 : case attr::MSNoVTable:
10472 0 : return cast<MSNoVTableAttr>(this)->getSpelling();
10473 : case attr::MSP430Interrupt:
10474 0 : return cast<MSP430InterruptAttr>(this)->getSpelling();
10475 : case attr::MSStruct:
10476 0 : return cast<MSStructAttr>(this)->getSpelling();
10477 : case attr::MSVtorDisp:
10478 0 : return cast<MSVtorDispAttr>(this)->getSpelling();
10479 : case attr::MaxFieldAlignment:
10480 0 : return cast<MaxFieldAlignmentAttr>(this)->getSpelling();
10481 : case attr::MayAlias:
10482 0 : return cast<MayAliasAttr>(this)->getSpelling();
10483 : case attr::MicroMips:
10484 1 : return cast<MicroMipsAttr>(this)->getSpelling();
10485 : case attr::MinSize:
10486 3 : return cast<MinSizeAttr>(this)->getSpelling();
10487 : case attr::MinVectorWidth:
10488 0 : return cast<MinVectorWidthAttr>(this)->getSpelling();
10489 : case attr::Mips16:
10490 4 : return cast<Mips16Attr>(this)->getSpelling();
10491 : case attr::MipsInterrupt:
10492 2 : return cast<MipsInterruptAttr>(this)->getSpelling();
10493 : case attr::MipsLongCall:
10494 2 : return cast<MipsLongCallAttr>(this)->getSpelling();
10495 : case attr::MipsShortCall:
10496 2 : return cast<MipsShortCallAttr>(this)->getSpelling();
10497 : case attr::Mode:
10498 0 : return cast<ModeAttr>(this)->getSpelling();
10499 : case attr::NSConsumed:
10500 0 : return cast<NSConsumedAttr>(this)->getSpelling();
10501 : case attr::NSConsumesSelf:
10502 0 : return cast<NSConsumesSelfAttr>(this)->getSpelling();
10503 : case attr::NSReturnsAutoreleased:
10504 0 : return cast<NSReturnsAutoreleasedAttr>(this)->getSpelling();
10505 : case attr::NSReturnsNotRetained:
10506 0 : return cast<NSReturnsNotRetainedAttr>(this)->getSpelling();
10507 : case attr::NSReturnsRetained:
10508 0 : return cast<NSReturnsRetainedAttr>(this)->getSpelling();
10509 : case attr::Naked:
10510 1 : return cast<NakedAttr>(this)->getSpelling();
10511 : case attr::NoAlias:
10512 0 : return cast<NoAliasAttr>(this)->getSpelling();
10513 : case attr::NoCommon:
10514 0 : return cast<NoCommonAttr>(this)->getSpelling();
10515 : case attr::NoDebug:
10516 0 : return cast<NoDebugAttr>(this)->getSpelling();
10517 : case attr::NoDestroy:
10518 2 : return cast<NoDestroyAttr>(this)->getSpelling();
10519 : case attr::NoDuplicate:
10520 0 : return cast<NoDuplicateAttr>(this)->getSpelling();
10521 : case attr::NoEscape:
10522 0 : return cast<NoEscapeAttr>(this)->getSpelling();
10523 : case attr::NoInline:
10524 0 : return cast<NoInlineAttr>(this)->getSpelling();
10525 : case attr::NoInstrumentFunction:
10526 0 : return cast<NoInstrumentFunctionAttr>(this)->getSpelling();
10527 : case attr::NoMicroMips:
10528 0 : return cast<NoMicroMipsAttr>(this)->getSpelling();
10529 : case attr::NoMips16:
10530 0 : return cast<NoMips16Attr>(this)->getSpelling();
10531 : case attr::NoReturn:
10532 0 : return cast<NoReturnAttr>(this)->getSpelling();
10533 : case attr::NoSanitize:
10534 0 : return cast<NoSanitizeAttr>(this)->getSpelling();
10535 : case attr::NoSplitStack:
10536 0 : return cast<NoSplitStackAttr>(this)->getSpelling();
10537 : case attr::NoStackProtector:
10538 0 : return cast<NoStackProtectorAttr>(this)->getSpelling();
10539 : case attr::NoThreadSafetyAnalysis:
10540 0 : return cast<NoThreadSafetyAnalysisAttr>(this)->getSpelling();
10541 : case attr::NoThrow:
10542 0 : return cast<NoThrowAttr>(this)->getSpelling();
10543 : case attr::NonNull:
10544 0 : return cast<NonNullAttr>(this)->getSpelling();
10545 : case attr::NotTailCalled:
10546 3 : return cast<NotTailCalledAttr>(this)->getSpelling();
10547 : case attr::OMPCaptureKind:
10548 0 : return cast<OMPCaptureKindAttr>(this)->getSpelling();
10549 : case attr::OMPCaptureNoInit:
10550 0 : return cast<OMPCaptureNoInitAttr>(this)->getSpelling();
10551 : case attr::OMPDeclareSimdDecl:
10552 0 : return cast<OMPDeclareSimdDeclAttr>(this)->getSpelling();
10553 : case attr::OMPDeclareTargetDecl:
10554 0 : return cast<OMPDeclareTargetDeclAttr>(this)->getSpelling();
10555 : case attr::OMPReferencedVar:
10556 0 : return cast<OMPReferencedVarAttr>(this)->getSpelling();
10557 : case attr::OMPThreadPrivateDecl:
10558 0 : return cast<OMPThreadPrivateDeclAttr>(this)->getSpelling();
10559 : case attr::ObjCBoxable:
10560 0 : return cast<ObjCBoxableAttr>(this)->getSpelling();
10561 : case attr::ObjCBridge:
10562 0 : return cast<ObjCBridgeAttr>(this)->getSpelling();
10563 : case attr::ObjCBridgeMutable:
10564 0 : return cast<ObjCBridgeMutableAttr>(this)->getSpelling();
10565 : case attr::ObjCBridgeRelated:
10566 0 : return cast<ObjCBridgeRelatedAttr>(this)->getSpelling();
10567 : case attr::ObjCDesignatedInitializer:
10568 0 : return cast<ObjCDesignatedInitializerAttr>(this)->getSpelling();
10569 : case attr::ObjCException:
10570 0 : return cast<ObjCExceptionAttr>(this)->getSpelling();
10571 : case attr::ObjCExplicitProtocolImpl:
10572 0 : return cast<ObjCExplicitProtocolImplAttr>(this)->getSpelling();
10573 : case attr::ObjCGC:
10574 0 : return cast<ObjCGCAttr>(this)->getSpelling();
10575 : case attr::ObjCIndependentClass:
10576 0 : return cast<ObjCIndependentClassAttr>(this)->getSpelling();
10577 : case attr::ObjCInertUnsafeUnretained:
10578 0 : return cast<ObjCInertUnsafeUnretainedAttr>(this)->getSpelling();
10579 : case attr::ObjCKindOf:
10580 0 : return cast<ObjCKindOfAttr>(this)->getSpelling();
10581 : case attr::ObjCMethodFamily:
10582 0 : return cast<ObjCMethodFamilyAttr>(this)->getSpelling();
10583 : case attr::ObjCNSObject:
10584 0 : return cast<ObjCNSObjectAttr>(this)->getSpelling();
10585 : case attr::ObjCOwnership:
10586 0 : return cast<ObjCOwnershipAttr>(this)->getSpelling();
10587 : case attr::ObjCPreciseLifetime:
10588 0 : return cast<ObjCPreciseLifetimeAttr>(this)->getSpelling();
10589 : case attr::ObjCRequiresPropertyDefs:
10590 0 : return cast<ObjCRequiresPropertyDefsAttr>(this)->getSpelling();
10591 : case attr::ObjCRequiresSuper:
10592 0 : return cast<ObjCRequiresSuperAttr>(this)->getSpelling();
10593 : case attr::ObjCReturnsInnerPointer:
10594 0 : return cast<ObjCReturnsInnerPointerAttr>(this)->getSpelling();
10595 : case attr::ObjCRootClass:
10596 0 : return cast<ObjCRootClassAttr>(this)->getSpelling();
10597 : case attr::ObjCRuntimeName:
10598 0 : return cast<ObjCRuntimeNameAttr>(this)->getSpelling();
10599 : case attr::ObjCRuntimeVisible:
10600 0 : return cast<ObjCRuntimeVisibleAttr>(this)->getSpelling();
10601 : case attr::ObjCSubclassingRestricted:
10602 0 : return cast<ObjCSubclassingRestrictedAttr>(this)->getSpelling();
10603 : case attr::OpenCLAccess:
10604 2 : return cast<OpenCLAccessAttr>(this)->getSpelling();
10605 : case attr::OpenCLConstantAddressSpace:
10606 0 : return cast<OpenCLConstantAddressSpaceAttr>(this)->getSpelling();
10607 : case attr::OpenCLGenericAddressSpace:
10608 0 : return cast<OpenCLGenericAddressSpaceAttr>(this)->getSpelling();
10609 : case attr::OpenCLGlobalAddressSpace:
10610 0 : return cast<OpenCLGlobalAddressSpaceAttr>(this)->getSpelling();
10611 : case attr::OpenCLIntelReqdSubGroupSize:
10612 2 : return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->getSpelling();
10613 : case attr::OpenCLKernel:
10614 0 : return cast<OpenCLKernelAttr>(this)->getSpelling();
10615 : case attr::OpenCLLocalAddressSpace:
10616 0 : return cast<OpenCLLocalAddressSpaceAttr>(this)->getSpelling();
10617 : case attr::OpenCLPrivateAddressSpace:
10618 0 : return cast<OpenCLPrivateAddressSpaceAttr>(this)->getSpelling();
10619 : case attr::OpenCLUnrollHint:
10620 0 : return cast<OpenCLUnrollHintAttr>(this)->getSpelling();
10621 : case attr::OptimizeNone:
10622 0 : return cast<OptimizeNoneAttr>(this)->getSpelling();
10623 : case attr::Overloadable:
10624 0 : return cast<OverloadableAttr>(this)->getSpelling();
10625 : case attr::Override:
10626 0 : return cast<OverrideAttr>(this)->getSpelling();
10627 : case attr::Ownership:
10628 1 : return cast<OwnershipAttr>(this)->getSpelling();
10629 : case attr::Packed:
10630 0 : return cast<PackedAttr>(this)->getSpelling();
10631 : case attr::ParamTypestate:
10632 0 : return cast<ParamTypestateAttr>(this)->getSpelling();
10633 : case attr::Pascal:
10634 0 : return cast<PascalAttr>(this)->getSpelling();
10635 : case attr::PassObjectSize:
10636 0 : return cast<PassObjectSizeAttr>(this)->getSpelling();
10637 : case attr::Pcs:
10638 0 : return cast<PcsAttr>(this)->getSpelling();
10639 : case attr::PragmaClangBSSSection:
10640 0 : return cast<PragmaClangBSSSectionAttr>(this)->getSpelling();
10641 : case attr::PragmaClangDataSection:
10642 0 : return cast<PragmaClangDataSectionAttr>(this)->getSpelling();
10643 : case attr::PragmaClangRodataSection:
10644 0 : return cast<PragmaClangRodataSectionAttr>(this)->getSpelling();
10645 : case attr::PragmaClangTextSection:
10646 0 : return cast<PragmaClangTextSectionAttr>(this)->getSpelling();
10647 : case attr::PreserveAll:
10648 0 : return cast<PreserveAllAttr>(this)->getSpelling();
10649 : case attr::PreserveMost:
10650 0 : return cast<PreserveMostAttr>(this)->getSpelling();
10651 : case attr::PtGuardedBy:
10652 0 : return cast<PtGuardedByAttr>(this)->getSpelling();
10653 : case attr::PtGuardedVar:
10654 0 : return cast<PtGuardedVarAttr>(this)->getSpelling();
10655 : case attr::Ptr32:
10656 0 : return cast<Ptr32Attr>(this)->getSpelling();
10657 : case attr::Ptr64:
10658 0 : return cast<Ptr64Attr>(this)->getSpelling();
10659 : case attr::Pure:
10660 0 : return cast<PureAttr>(this)->getSpelling();
10661 : case attr::RISCVInterrupt:
10662 0 : return cast<RISCVInterruptAttr>(this)->getSpelling();
10663 : case attr::RegCall:
10664 0 : return cast<RegCallAttr>(this)->getSpelling();
10665 : case attr::Reinitializes:
10666 0 : return cast<ReinitializesAttr>(this)->getSpelling();
10667 : case attr::ReleaseCapability:
10668 0 : return cast<ReleaseCapabilityAttr>(this)->getSpelling();
10669 : case attr::RenderScriptKernel:
10670 0 : return cast<RenderScriptKernelAttr>(this)->getSpelling();
10671 : case attr::ReqdWorkGroupSize:
10672 2 : return cast<ReqdWorkGroupSizeAttr>(this)->getSpelling();
10673 : case attr::RequireConstantInit:
10674 0 : return cast<RequireConstantInitAttr>(this)->getSpelling();
10675 : case attr::RequiresCapability:
10676 0 : return cast<RequiresCapabilityAttr>(this)->getSpelling();
10677 : case attr::Restrict:
10678 0 : return cast<RestrictAttr>(this)->getSpelling();
10679 : case attr::ReturnTypestate:
10680 0 : return cast<ReturnTypestateAttr>(this)->getSpelling();
10681 : case attr::ReturnsNonNull:
10682 0 : return cast<ReturnsNonNullAttr>(this)->getSpelling();
10683 : case attr::ReturnsTwice:
10684 0 : return cast<ReturnsTwiceAttr>(this)->getSpelling();
10685 : case attr::SPtr:
10686 0 : return cast<SPtrAttr>(this)->getSpelling();
10687 : case attr::ScopedLockable:
10688 0 : return cast<ScopedLockableAttr>(this)->getSpelling();
10689 : case attr::Section:
10690 0 : return cast<SectionAttr>(this)->getSpelling();
10691 : case attr::SelectAny:
10692 0 : return cast<SelectAnyAttr>(this)->getSpelling();
10693 : case attr::Sentinel:
10694 0 : return cast<SentinelAttr>(this)->getSpelling();
10695 : case attr::SetTypestate:
10696 0 : return cast<SetTypestateAttr>(this)->getSpelling();
10697 : case attr::SharedTrylockFunction:
10698 0 : return cast<SharedTrylockFunctionAttr>(this)->getSpelling();
10699 : case attr::StdCall:
10700 0 : return cast<StdCallAttr>(this)->getSpelling();
10701 : case attr::Suppress:
10702 0 : return cast<SuppressAttr>(this)->getSpelling();
10703 : case attr::SwiftCall:
10704 0 : return cast<SwiftCallAttr>(this)->getSpelling();
10705 : case attr::SwiftContext:
10706 0 : return cast<SwiftContextAttr>(this)->getSpelling();
10707 : case attr::SwiftErrorResult:
10708 0 : return cast<SwiftErrorResultAttr>(this)->getSpelling();
10709 : case attr::SwiftIndirectResult:
10710 0 : return cast<SwiftIndirectResultAttr>(this)->getSpelling();
10711 : case attr::SysVABI:
10712 0 : return cast<SysVABIAttr>(this)->getSpelling();
10713 : case attr::TLSModel:
10714 0 : return cast<TLSModelAttr>(this)->getSpelling();
10715 : case attr::Target:
10716 0 : return cast<TargetAttr>(this)->getSpelling();
10717 : case attr::TestTypestate:
10718 0 : return cast<TestTypestateAttr>(this)->getSpelling();
10719 : case attr::ThisCall:
10720 0 : return cast<ThisCallAttr>(this)->getSpelling();
10721 : case attr::Thread:
10722 0 : return cast<ThreadAttr>(this)->getSpelling();
10723 : case attr::TransparentUnion:
10724 0 : return cast<TransparentUnionAttr>(this)->getSpelling();
10725 : case attr::TrivialABI:
10726 0 : return cast<TrivialABIAttr>(this)->getSpelling();
10727 : case attr::TryAcquireCapability:
10728 0 : return cast<TryAcquireCapabilityAttr>(this)->getSpelling();
10729 : case attr::TypeNonNull:
10730 0 : return cast<TypeNonNullAttr>(this)->getSpelling();
10731 : case attr::TypeNullUnspecified:
10732 0 : return cast<TypeNullUnspecifiedAttr>(this)->getSpelling();
10733 : case attr::TypeNullable:
10734 0 : return cast<TypeNullableAttr>(this)->getSpelling();
10735 : case attr::TypeTagForDatatype:
10736 0 : return cast<TypeTagForDatatypeAttr>(this)->getSpelling();
10737 : case attr::TypeVisibility:
10738 0 : return cast<TypeVisibilityAttr>(this)->getSpelling();
10739 : case attr::UPtr:
10740 0 : return cast<UPtrAttr>(this)->getSpelling();
10741 : case attr::Unavailable:
10742 0 : return cast<UnavailableAttr>(this)->getSpelling();
10743 : case attr::Unused:
10744 5 : return cast<UnusedAttr>(this)->getSpelling();
10745 : case attr::Used:
10746 4 : return cast<UsedAttr>(this)->getSpelling();
10747 : case attr::Uuid:
10748 0 : return cast<UuidAttr>(this)->getSpelling();
10749 : case attr::VecReturn:
10750 1 : return cast<VecReturnAttr>(this)->getSpelling();
10751 : case attr::VecTypeHint:
10752 2 : return cast<VecTypeHintAttr>(this)->getSpelling();
10753 : case attr::VectorCall:
10754 0 : return cast<VectorCallAttr>(this)->getSpelling();
10755 : case attr::Visibility:
10756 0 : return cast<VisibilityAttr>(this)->getSpelling();
10757 : case attr::WarnUnused:
10758 0 : return cast<WarnUnusedAttr>(this)->getSpelling();
10759 : case attr::WarnUnusedResult:
10760 101 : return cast<WarnUnusedResultAttr>(this)->getSpelling();
10761 : case attr::Weak:
10762 0 : return cast<WeakAttr>(this)->getSpelling();
10763 : case attr::WeakImport:
10764 0 : return cast<WeakImportAttr>(this)->getSpelling();
10765 : case attr::WeakRef:
10766 0 : return cast<WeakRefAttr>(this)->getSpelling();
10767 : case attr::WorkGroupSizeHint:
10768 2 : return cast<WorkGroupSizeHintAttr>(this)->getSpelling();
10769 : case attr::X86ForceAlignArgPointer:
10770 0 : return cast<X86ForceAlignArgPointerAttr>(this)->getSpelling();
10771 : case attr::XRayInstrument:
10772 0 : return cast<XRayInstrumentAttr>(this)->getSpelling();
10773 : case attr::XRayLogArgs:
10774 0 : return cast<XRayLogArgsAttr>(this)->getSpelling();
10775 : }
10776 0 : llvm_unreachable("Unexpected attribute kind!");
10777 : }
10778 :
10779 37368 : Attr *Attr::clone(ASTContext &C) const {
10780 37368 : switch (getKind()) {
10781 : case attr::AMDGPUFlatWorkGroupSize:
10782 0 : return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->clone(C);
10783 : case attr::AMDGPUNumSGPR:
10784 0 : return cast<AMDGPUNumSGPRAttr>(this)->clone(C);
10785 : case attr::AMDGPUNumVGPR:
10786 0 : return cast<AMDGPUNumVGPRAttr>(this)->clone(C);
10787 : case attr::AMDGPUWavesPerEU:
10788 0 : return cast<AMDGPUWavesPerEUAttr>(this)->clone(C);
10789 : case attr::ARMInterrupt:
10790 0 : return cast<ARMInterruptAttr>(this)->clone(C);
10791 : case attr::AVRInterrupt:
10792 0 : return cast<AVRInterruptAttr>(this)->clone(C);
10793 : case attr::AVRSignal:
10794 0 : return cast<AVRSignalAttr>(this)->clone(C);
10795 : case attr::AbiTag:
10796 0 : return cast<AbiTagAttr>(this)->clone(C);
10797 : case attr::AcquireCapability:
10798 50 : return cast<AcquireCapabilityAttr>(this)->clone(C);
10799 : case attr::AcquiredAfter:
10800 0 : return cast<AcquiredAfterAttr>(this)->clone(C);
10801 : case attr::AcquiredBefore:
10802 0 : return cast<AcquiredBeforeAttr>(this)->clone(C);
10803 : case attr::AddressSpace:
10804 0 : return cast<AddressSpaceAttr>(this)->clone(C);
10805 : case attr::Alias:
10806 0 : return cast<AliasAttr>(this)->clone(C);
10807 : case attr::AlignMac68k:
10808 0 : return cast<AlignMac68kAttr>(this)->clone(C);
10809 : case attr::AlignValue:
10810 0 : return cast<AlignValueAttr>(this)->clone(C);
10811 : case attr::Aligned:
10812 4 : return cast<AlignedAttr>(this)->clone(C);
10813 : case attr::AllocAlign:
10814 0 : return cast<AllocAlignAttr>(this)->clone(C);
10815 : case attr::AllocSize:
10816 0 : return cast<AllocSizeAttr>(this)->clone(C);
10817 : case attr::AlwaysDestroy:
10818 0 : return cast<AlwaysDestroyAttr>(this)->clone(C);
10819 : case attr::AlwaysInline:
10820 1 : return cast<AlwaysInlineAttr>(this)->clone(C);
10821 : case attr::AnalyzerNoReturn:
10822 0 : return cast<AnalyzerNoReturnAttr>(this)->clone(C);
10823 : case attr::Annotate:
10824 43 : return cast<AnnotateAttr>(this)->clone(C);
10825 : case attr::AnyX86Interrupt:
10826 0 : return cast<AnyX86InterruptAttr>(this)->clone(C);
10827 : case attr::AnyX86NoCallerSavedRegisters:
10828 0 : return cast<AnyX86NoCallerSavedRegistersAttr>(this)->clone(C);
10829 : case attr::AnyX86NoCfCheck:
10830 0 : return cast<AnyX86NoCfCheckAttr>(this)->clone(C);
10831 : case attr::ArcWeakrefUnavailable:
10832 0 : return cast<ArcWeakrefUnavailableAttr>(this)->clone(C);
10833 : case attr::ArgumentWithTypeTag:
10834 0 : return cast<ArgumentWithTypeTagAttr>(this)->clone(C);
10835 : case attr::Artificial:
10836 0 : return cast<ArtificialAttr>(this)->clone(C);
10837 : case attr::AsmLabel:
10838 13 : return cast<AsmLabelAttr>(this)->clone(C);
10839 : case attr::AssertCapability:
10840 12 : return cast<AssertCapabilityAttr>(this)->clone(C);
10841 : case attr::AssertExclusiveLock:
10842 6 : return cast<AssertExclusiveLockAttr>(this)->clone(C);
10843 : case attr::AssertSharedLock:
10844 6 : return cast<AssertSharedLockAttr>(this)->clone(C);
10845 : case attr::AssumeAligned:
10846 4 : return cast<AssumeAlignedAttr>(this)->clone(C);
10847 : case attr::Availability:
10848 110 : return cast<AvailabilityAttr>(this)->clone(C);
10849 : case attr::Blocks:
10850 0 : return cast<BlocksAttr>(this)->clone(C);
10851 : case attr::C11NoReturn:
10852 7 : return cast<C11NoReturnAttr>(this)->clone(C);
10853 : case attr::CDecl:
10854 0 : return cast<CDeclAttr>(this)->clone(C);
10855 : case attr::CFAuditedTransfer:
10856 0 : return cast<CFAuditedTransferAttr>(this)->clone(C);
10857 : case attr::CFConsumed:
10858 5 : return cast<CFConsumedAttr>(this)->clone(C);
10859 : case attr::CFReturnsNotRetained:
10860 5 : return cast<CFReturnsNotRetainedAttr>(this)->clone(C);
10861 : case attr::CFReturnsRetained:
10862 15 : return cast<CFReturnsRetainedAttr>(this)->clone(C);
10863 : case attr::CFUnknownTransfer:
10864 0 : return cast<CFUnknownTransferAttr>(this)->clone(C);
10865 : case attr::CPUDispatch:
10866 0 : return cast<CPUDispatchAttr>(this)->clone(C);
10867 : case attr::CPUSpecific:
10868 0 : return cast<CPUSpecificAttr>(this)->clone(C);
10869 : case attr::CUDAConstant:
10870 0 : return cast<CUDAConstantAttr>(this)->clone(C);
10871 : case attr::CUDADevice:
10872 0 : return cast<CUDADeviceAttr>(this)->clone(C);
10873 : case attr::CUDAGlobal:
10874 0 : return cast<CUDAGlobalAttr>(this)->clone(C);
10875 : case attr::CUDAHost:
10876 0 : return cast<CUDAHostAttr>(this)->clone(C);
10877 : case attr::CUDAInvalidTarget:
10878 0 : return cast<CUDAInvalidTargetAttr>(this)->clone(C);
10879 : case attr::CUDALaunchBounds:
10880 0 : return cast<CUDALaunchBoundsAttr>(this)->clone(C);
10881 : case attr::CUDAShared:
10882 0 : return cast<CUDASharedAttr>(this)->clone(C);
10883 : case attr::CXX11NoReturn:
10884 13527 : return cast<CXX11NoReturnAttr>(this)->clone(C);
10885 : case attr::CallableWhen:
10886 0 : return cast<CallableWhenAttr>(this)->clone(C);
10887 : case attr::Capability:
10888 0 : return cast<CapabilityAttr>(this)->clone(C);
10889 : case attr::CapturedRecord:
10890 0 : return cast<CapturedRecordAttr>(this)->clone(C);
10891 : case attr::CarriesDependency:
10892 5 : return cast<CarriesDependencyAttr>(this)->clone(C);
10893 : case attr::Cleanup:
10894 0 : return cast<CleanupAttr>(this)->clone(C);
10895 : case attr::CodeSeg:
10896 0 : return cast<CodeSegAttr>(this)->clone(C);
10897 : case attr::Cold:
10898 1 : return cast<ColdAttr>(this)->clone(C);
10899 : case attr::Common:
10900 0 : return cast<CommonAttr>(this)->clone(C);
10901 : case attr::Const:
10902 1004 : return cast<ConstAttr>(this)->clone(C);
10903 : case attr::Constructor:
10904 19 : return cast<ConstructorAttr>(this)->clone(C);
10905 : case attr::Consumable:
10906 0 : return cast<ConsumableAttr>(this)->clone(C);
10907 : case attr::ConsumableAutoCast:
10908 0 : return cast<ConsumableAutoCastAttr>(this)->clone(C);
10909 : case attr::ConsumableSetOnRead:
10910 0 : return cast<ConsumableSetOnReadAttr>(this)->clone(C);
10911 : case attr::Convergent:
10912 0 : return cast<ConvergentAttr>(this)->clone(C);
10913 : case attr::DLLExport:
10914 1966 : return cast<DLLExportAttr>(this)->clone(C);
10915 : case attr::DLLImport:
10916 1909 : return cast<DLLImportAttr>(this)->clone(C);
10917 : case attr::Deprecated:
10918 160 : return cast<DeprecatedAttr>(this)->clone(C);
10919 : case attr::Destructor:
10920 11 : return cast<DestructorAttr>(this)->clone(C);
10921 : case attr::DiagnoseIf:
10922 4 : return cast<DiagnoseIfAttr>(this)->clone(C);
10923 : case attr::DisableTailCalls:
10924 0 : return cast<DisableTailCallsAttr>(this)->clone(C);
10925 : case attr::EmptyBases:
10926 0 : return cast<EmptyBasesAttr>(this)->clone(C);
10927 : case attr::EnableIf:
10928 0 : return cast<EnableIfAttr>(this)->clone(C);
10929 : case attr::EnumExtensibility:
10930 2 : return cast<EnumExtensibilityAttr>(this)->clone(C);
10931 : case attr::ExcludeFromExplicitInstantiation:
10932 16 : return cast<ExcludeFromExplicitInstantiationAttr>(this)->clone(C);
10933 : case attr::ExclusiveTrylockFunction:
10934 9 : return cast<ExclusiveTrylockFunctionAttr>(this)->clone(C);
10935 : case attr::ExternalSourceSymbol:
10936 0 : return cast<ExternalSourceSymbolAttr>(this)->clone(C);
10937 : case attr::FallThrough:
10938 0 : return cast<FallThroughAttr>(this)->clone(C);
10939 : case attr::FastCall:
10940 0 : return cast<FastCallAttr>(this)->clone(C);
10941 : case attr::Final:
10942 12 : return cast<FinalAttr>(this)->clone(C);
10943 : case attr::FlagEnum:
10944 2 : return cast<FlagEnumAttr>(this)->clone(C);
10945 : case attr::Flatten:
10946 0 : return cast<FlattenAttr>(this)->clone(C);
10947 : case attr::Format:
10948 0 : return cast<FormatAttr>(this)->clone(C);
10949 : case attr::FormatArg:
10950 0 : return cast<FormatArgAttr>(this)->clone(C);
10951 : case attr::GNUInline:
10952 3 : return cast<GNUInlineAttr>(this)->clone(C);
10953 : case attr::GuardedBy:
10954 0 : return cast<GuardedByAttr>(this)->clone(C);
10955 : case attr::GuardedVar:
10956 0 : return cast<GuardedVarAttr>(this)->clone(C);
10957 : case attr::Hot:
10958 0 : return cast<HotAttr>(this)->clone(C);
10959 : case attr::IBAction:
10960 0 : return cast<IBActionAttr>(this)->clone(C);
10961 : case attr::IBOutlet:
10962 0 : return cast<IBOutletAttr>(this)->clone(C);
10963 : case attr::IBOutletCollection:
10964 0 : return cast<IBOutletCollectionAttr>(this)->clone(C);
10965 : case attr::IFunc:
10966 0 : return cast<IFuncAttr>(this)->clone(C);
10967 : case attr::InitPriority:
10968 0 : return cast<InitPriorityAttr>(this)->clone(C);
10969 : case attr::InitSeg:
10970 0 : return cast<InitSegAttr>(this)->clone(C);
10971 : case attr::IntelOclBicc:
10972 0 : return cast<IntelOclBiccAttr>(this)->clone(C);
10973 : case attr::InternalLinkage:
10974 0 : return cast<InternalLinkageAttr>(this)->clone(C);
10975 : case attr::LTOVisibilityPublic:
10976 0 : return cast<LTOVisibilityPublicAttr>(this)->clone(C);
10977 : case attr::LayoutVersion:
10978 0 : return cast<LayoutVersionAttr>(this)->clone(C);
10979 : case attr::LifetimeBound:
10980 0 : return cast<LifetimeBoundAttr>(this)->clone(C);
10981 : case attr::LockReturned:
10982 3 : return cast<LockReturnedAttr>(this)->clone(C);
10983 : case attr::LocksExcluded:
10984 19 : return cast<LocksExcludedAttr>(this)->clone(C);
10985 : case attr::LoopHint:
10986 2 : return cast<LoopHintAttr>(this)->clone(C);
10987 : case attr::MSABI:
10988 0 : return cast<MSABIAttr>(this)->clone(C);
10989 : case attr::MSInheritance:
10990 0 : return cast<MSInheritanceAttr>(this)->clone(C);
10991 : case attr::MSNoVTable:
10992 0 : return cast<MSNoVTableAttr>(this)->clone(C);
10993 : case attr::MSP430Interrupt:
10994 0 : return cast<MSP430InterruptAttr>(this)->clone(C);
10995 : case attr::MSStruct:
10996 0 : return cast<MSStructAttr>(this)->clone(C);
10997 : case attr::MSVtorDisp:
10998 0 : return cast<MSVtorDispAttr>(this)->clone(C);
10999 : case attr::MaxFieldAlignment:
11000 0 : return cast<MaxFieldAlignmentAttr>(this)->clone(C);
11001 : case attr::MayAlias:
11002 14 : return cast<MayAliasAttr>(this)->clone(C);
11003 : case attr::MicroMips:
11004 0 : return cast<MicroMipsAttr>(this)->clone(C);
11005 : case attr::MinSize:
11006 0 : return cast<MinSizeAttr>(this)->clone(C);
11007 : case attr::MinVectorWidth:
11008 0 : return cast<MinVectorWidthAttr>(this)->clone(C);
11009 : case attr::Mips16:
11010 1 : return cast<Mips16Attr>(this)->clone(C);
11011 : case attr::MipsInterrupt:
11012 0 : return cast<MipsInterruptAttr>(this)->clone(C);
11013 : case attr::MipsLongCall:
11014 0 : return cast<MipsLongCallAttr>(this)->clone(C);
11015 : case attr::MipsShortCall:
11016 0 : return cast<MipsShortCallAttr>(this)->clone(C);
11017 : case attr::Mode:
11018 0 : return cast<ModeAttr>(this)->clone(C);
11019 : case attr::NSConsumed:
11020 6 : return cast<NSConsumedAttr>(this)->clone(C);
11021 : case attr::NSConsumesSelf:
11022 137 : return cast<NSConsumesSelfAttr>(this)->clone(C);
11023 : case attr::NSReturnsAutoreleased:
11024 0 : return cast<NSReturnsAutoreleasedAttr>(this)->clone(C);
11025 : case attr::NSReturnsNotRetained:
11026 8 : return cast<NSReturnsNotRetainedAttr>(this)->clone(C);
11027 : case attr::NSReturnsRetained:
11028 174 : return cast<NSReturnsRetainedAttr>(this)->clone(C);
11029 : case attr::Naked:
11030 1 : return cast<NakedAttr>(this)->clone(C);
11031 : case attr::NoAlias:
11032 0 : return cast<NoAliasAttr>(this)->clone(C);
11033 : case attr::NoCommon:
11034 0 : return cast<NoCommonAttr>(this)->clone(C);
11035 : case attr::NoDebug:
11036 4 : return cast<NoDebugAttr>(this)->clone(C);
11037 : case attr::NoDestroy:
11038 0 : return cast<NoDestroyAttr>(this)->clone(C);
11039 : case attr::NoDuplicate:
11040 0 : return cast<NoDuplicateAttr>(this)->clone(C);
11041 : case attr::NoEscape:
11042 0 : return cast<NoEscapeAttr>(this)->clone(C);
11043 : case attr::NoInline:
11044 27 : return cast<NoInlineAttr>(this)->clone(C);
11045 : case attr::NoInstrumentFunction:
11046 3 : return cast<NoInstrumentFunctionAttr>(this)->clone(C);
11047 : case attr::NoMicroMips:
11048 0 : return cast<NoMicroMipsAttr>(this)->clone(C);
11049 : case attr::NoMips16:
11050 2 : return cast<NoMips16Attr>(this)->clone(C);
11051 : case attr::NoReturn:
11052 0 : return cast<NoReturnAttr>(this)->clone(C);
11053 : case attr::NoSanitize:
11054 9822 : return cast<NoSanitizeAttr>(this)->clone(C);
11055 : case attr::NoSplitStack:
11056 0 : return cast<NoSplitStackAttr>(this)->clone(C);
11057 : case attr::NoStackProtector:
11058 0 : return cast<NoStackProtectorAttr>(this)->clone(C);
11059 : case attr::NoThreadSafetyAnalysis:
11060 7 : return cast<NoThreadSafetyAnalysisAttr>(this)->clone(C);
11061 : case attr::NoThrow:
11062 2571 : return cast<NoThrowAttr>(this)->clone(C);
11063 : case attr::NonNull:
11064 2523 : return cast<NonNullAttr>(this)->clone(C);
11065 : case attr::NotTailCalled:
11066 0 : return cast<NotTailCalledAttr>(this)->clone(C);
11067 : case attr::OMPCaptureKind:
11068 0 : return cast<OMPCaptureKindAttr>(this)->clone(C);
11069 : case attr::OMPCaptureNoInit:
11070 0 : return cast<OMPCaptureNoInitAttr>(this)->clone(C);
11071 : case attr::OMPDeclareSimdDecl:
11072 0 : return cast<OMPDeclareSimdDeclAttr>(this)->clone(C);
11073 : case attr::OMPDeclareTargetDecl:
11074 14 : return cast<OMPDeclareTargetDeclAttr>(this)->clone(C);
11075 : case attr::OMPReferencedVar:
11076 0 : return cast<OMPReferencedVarAttr>(this)->clone(C);
11077 : case attr::OMPThreadPrivateDecl:
11078 40 : return cast<OMPThreadPrivateDeclAttr>(this)->clone(C);
11079 : case attr::ObjCBoxable:
11080 0 : return cast<ObjCBoxableAttr>(this)->clone(C);
11081 : case attr::ObjCBridge:
11082 4 : return cast<ObjCBridgeAttr>(this)->clone(C);
11083 : case attr::ObjCBridgeMutable:
11084 1 : return cast<ObjCBridgeMutableAttr>(this)->clone(C);
11085 : case attr::ObjCBridgeRelated:
11086 0 : return cast<ObjCBridgeRelatedAttr>(this)->clone(C);
11087 : case attr::ObjCDesignatedInitializer:
11088 0 : return cast<ObjCDesignatedInitializerAttr>(this)->clone(C);
11089 : case attr::ObjCException:
11090 0 : return cast<ObjCExceptionAttr>(this)->clone(C);
11091 : case attr::ObjCExplicitProtocolImpl:
11092 0 : return cast<ObjCExplicitProtocolImplAttr>(this)->clone(C);
11093 : case attr::ObjCGC:
11094 0 : return cast<ObjCGCAttr>(this)->clone(C);
11095 : case attr::ObjCIndependentClass:
11096 0 : return cast<ObjCIndependentClassAttr>(this)->clone(C);
11097 : case attr::ObjCInertUnsafeUnretained:
11098 0 : return cast<ObjCInertUnsafeUnretainedAttr>(this)->clone(C);
11099 : case attr::ObjCKindOf:
11100 0 : return cast<ObjCKindOfAttr>(this)->clone(C);
11101 : case attr::ObjCMethodFamily:
11102 9 : return cast<ObjCMethodFamilyAttr>(this)->clone(C);
11103 : case attr::ObjCNSObject:
11104 0 : return cast<ObjCNSObjectAttr>(this)->clone(C);
11105 : case attr::ObjCOwnership:
11106 0 : return cast<ObjCOwnershipAttr>(this)->clone(C);
11107 : case attr::ObjCPreciseLifetime:
11108 0 : return cast<ObjCPreciseLifetimeAttr>(this)->clone(C);
11109 : case attr::ObjCRequiresPropertyDefs:
11110 0 : return cast<ObjCRequiresPropertyDefsAttr>(this)->clone(C);
11111 : case attr::ObjCRequiresSuper:
11112 12 : return cast<ObjCRequiresSuperAttr>(this)->clone(C);
11113 : case attr::ObjCReturnsInnerPointer:
11114 0 : return cast<ObjCReturnsInnerPointerAttr>(this)->clone(C);
11115 : case attr::ObjCRootClass:
11116 0 : return cast<ObjCRootClassAttr>(this)->clone(C);
11117 : case attr::ObjCRuntimeName:
11118 0 : return cast<ObjCRuntimeNameAttr>(this)->clone(C);
11119 : case attr::ObjCRuntimeVisible:
11120 0 : return cast<ObjCRuntimeVisibleAttr>(this)->clone(C);
11121 : case attr::ObjCSubclassingRestricted:
11122 0 : return cast<ObjCSubclassingRestrictedAttr>(this)->clone(C);
11123 : case attr::OpenCLAccess:
11124 0 : return cast<OpenCLAccessAttr>(this)->clone(C);
11125 : case attr::OpenCLConstantAddressSpace:
11126 0 : return cast<OpenCLConstantAddressSpaceAttr>(this)->clone(C);
11127 : case attr::OpenCLGenericAddressSpace:
11128 0 : return cast<OpenCLGenericAddressSpaceAttr>(this)->clone(C);
11129 : case attr::OpenCLGlobalAddressSpace:
11130 0 : return cast<OpenCLGlobalAddressSpaceAttr>(this)->clone(C);
11131 : case attr::OpenCLIntelReqdSubGroupSize:
11132 0 : return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->clone(C);
11133 : case attr::OpenCLKernel:
11134 0 : return cast<OpenCLKernelAttr>(this)->clone(C);
11135 : case attr::OpenCLLocalAddressSpace:
11136 0 : return cast<OpenCLLocalAddressSpaceAttr>(this)->clone(C);
11137 : case attr::OpenCLPrivateAddressSpace:
11138 0 : return cast<OpenCLPrivateAddressSpaceAttr>(this)->clone(C);
11139 : case attr::OpenCLUnrollHint:
11140 0 : return cast<OpenCLUnrollHintAttr>(this)->clone(C);
11141 : case attr::OptimizeNone:
11142 0 : return cast<OptimizeNoneAttr>(this)->clone(C);
11143 : case attr::Overloadable:
11144 0 : return cast<OverloadableAttr>(this)->clone(C);
11145 : case attr::Override:
11146 7 : return cast<OverrideAttr>(this)->clone(C);
11147 : case attr::Ownership:
11148 0 : return cast<OwnershipAttr>(this)->clone(C);
11149 : case attr::Packed:
11150 9 : return cast<PackedAttr>(this)->clone(C);
11151 : case attr::ParamTypestate:
11152 0 : return cast<ParamTypestateAttr>(this)->clone(C);
11153 : case attr::Pascal:
11154 0 : return cast<PascalAttr>(this)->clone(C);
11155 : case attr::PassObjectSize:
11156 20 : return cast<PassObjectSizeAttr>(this)->clone(C);
11157 : case attr::Pcs:
11158 0 : return cast<PcsAttr>(this)->clone(C);
11159 : case attr::PragmaClangBSSSection:
11160 5 : return cast<PragmaClangBSSSectionAttr>(this)->clone(C);
11161 : case attr::PragmaClangDataSection:
11162 0 : return cast<PragmaClangDataSectionAttr>(this)->clone(C);
11163 : case attr::PragmaClangRodataSection:
11164 2 : return cast<PragmaClangRodataSectionAttr>(this)->clone(C);
11165 : case attr::PragmaClangTextSection:
11166 0 : return cast<PragmaClangTextSectionAttr>(this)->clone(C);
11167 : case attr::PreserveAll:
11168 0 : return cast<PreserveAllAttr>(this)->clone(C);
11169 : case attr::PreserveMost:
11170 0 : return cast<PreserveMostAttr>(this)->clone(C);
11171 : case attr::PtGuardedBy:
11172 0 : return cast<PtGuardedByAttr>(this)->clone(C);
11173 : case attr::PtGuardedVar:
11174 0 : return cast<PtGuardedVarAttr>(this)->clone(C);
11175 : case attr::Ptr32:
11176 0 : return cast<Ptr32Attr>(this)->clone(C);
11177 : case attr::Ptr64:
11178 0 : return cast<Ptr64Attr>(this)->clone(C);
11179 : case attr::Pure:
11180 1033 : return cast<PureAttr>(this)->clone(C);
11181 : case attr::RISCVInterrupt:
11182 0 : return cast<RISCVInterruptAttr>(this)->clone(C);
11183 : case attr::RegCall:
11184 0 : return cast<RegCallAttr>(this)->clone(C);
11185 : case attr::Reinitializes:
11186 0 : return cast<ReinitializesAttr>(this)->clone(C);
11187 : case attr::ReleaseCapability:
11188 35 : return cast<ReleaseCapabilityAttr>(this)->clone(C);
11189 : case attr::RenderScriptKernel:
11190 0 : return cast<RenderScriptKernelAttr>(this)->clone(C);
11191 : case attr::ReqdWorkGroupSize:
11192 0 : return cast<ReqdWorkGroupSizeAttr>(this)->clone(C);
11193 : case attr::RequireConstantInit:
11194 22 : return cast<RequireConstantInitAttr>(this)->clone(C);
11195 : case attr::RequiresCapability:
11196 134 : return cast<RequiresCapabilityAttr>(this)->clone(C);
11197 : case attr::Restrict:
11198 14 : return cast<RestrictAttr>(this)->clone(C);
11199 : case attr::ReturnTypestate:
11200 2 : return cast<ReturnTypestateAttr>(this)->clone(C);
11201 : case attr::ReturnsNonNull:
11202 1 : return cast<ReturnsNonNullAttr>(this)->clone(C);
11203 : case attr::ReturnsTwice:
11204 114 : return cast<ReturnsTwiceAttr>(this)->clone(C);
11205 : case attr::SPtr:
11206 0 : return cast<SPtrAttr>(this)->clone(C);
11207 : case attr::ScopedLockable:
11208 0 : return cast<ScopedLockableAttr>(this)->clone(C);
11209 : case attr::Section:
11210 0 : return cast<SectionAttr>(this)->clone(C);
11211 : case attr::SelectAny:
11212 3 : return cast<SelectAnyAttr>(this)->clone(C);
11213 : case attr::Sentinel:
11214 0 : return cast<SentinelAttr>(this)->clone(C);
11215 : case attr::SetTypestate:
11216 0 : return cast<SetTypestateAttr>(this)->clone(C);
11217 : case attr::SharedTrylockFunction:
11218 7 : return cast<SharedTrylockFunctionAttr>(this)->clone(C);
11219 : case attr::StdCall:
11220 0 : return cast<StdCallAttr>(this)->clone(C);
11221 : case attr::Suppress:
11222 0 : return cast<SuppressAttr>(this)->clone(C);
11223 : case attr::SwiftCall:
11224 0 : return cast<SwiftCallAttr>(this)->clone(C);
11225 : case attr::SwiftContext:
11226 0 : return cast<SwiftContextAttr>(this)->clone(C);
11227 : case attr::SwiftErrorResult:
11228 0 : return cast<SwiftErrorResultAttr>(this)->clone(C);
11229 : case attr::SwiftIndirectResult:
11230 0 : return cast<SwiftIndirectResultAttr>(this)->clone(C);
11231 : case attr::SysVABI:
11232 0 : return cast<SysVABIAttr>(this)->clone(C);
11233 : case attr::TLSModel:
11234 3 : return cast<TLSModelAttr>(this)->clone(C);
11235 : case attr::Target:
11236 3 : return cast<TargetAttr>(this)->clone(C);
11237 : case attr::TestTypestate:
11238 0 : return cast<TestTypestateAttr>(this)->clone(C);
11239 : case attr::ThisCall:
11240 0 : return cast<ThisCallAttr>(this)->clone(C);
11241 : case attr::Thread:
11242 0 : return cast<ThreadAttr>(this)->clone(C);
11243 : case attr::TransparentUnion:
11244 0 : return cast<TransparentUnionAttr>(this)->clone(C);
11245 : case attr::TrivialABI:
11246 0 : return cast<TrivialABIAttr>(this)->clone(C);
11247 : case attr::TryAcquireCapability:
11248 10 : return cast<TryAcquireCapabilityAttr>(this)->clone(C);
11249 : case attr::TypeNonNull:
11250 0 : return cast<TypeNonNullAttr>(this)->clone(C);
11251 : case attr::TypeNullUnspecified:
11252 0 : return cast<TypeNullUnspecifiedAttr>(this)->clone(C);
11253 : case attr::TypeNullable:
11254 0 : return cast<TypeNullableAttr>(this)->clone(C);
11255 : case attr::TypeTagForDatatype:
11256 0 : return cast<TypeTagForDatatypeAttr>(this)->clone(C);
11257 : case attr::TypeVisibility:
11258 141 : return cast<TypeVisibilityAttr>(this)->clone(C);
11259 : case attr::UPtr:
11260 0 : return cast<UPtrAttr>(this)->clone(C);
11261 : case attr::Unavailable:
11262 55 : return cast<UnavailableAttr>(this)->clone(C);
11263 : case attr::Unused:
11264 354 : return cast<UnusedAttr>(this)->clone(C);
11265 : case attr::Used:
11266 0 : return cast<UsedAttr>(this)->clone(C);
11267 : case attr::Uuid:
11268 0 : return cast<UuidAttr>(this)->clone(C);
11269 : case attr::VecReturn:
11270 0 : return cast<VecReturnAttr>(this)->clone(C);
11271 : case attr::VecTypeHint:
11272 0 : return cast<VecTypeHintAttr>(this)->clone(C);
11273 : case attr::VectorCall:
11274 0 : return cast<VectorCallAttr>(this)->clone(C);
11275 : case attr::Visibility:
11276 12 : return cast<VisibilityAttr>(this)->clone(C);
11277 : case attr::WarnUnused:
11278 0 : return cast<WarnUnusedAttr>(this)->clone(C);
11279 : case attr::WarnUnusedResult:
11280 1002 : return cast<WarnUnusedResultAttr>(this)->clone(C);
11281 : case attr::Weak:
11282 36 : return cast<WeakAttr>(this)->clone(C);
11283 : case attr::WeakImport:
11284 8 : return cast<WeakImportAttr>(this)->clone(C);
11285 : case attr::WeakRef:
11286 0 : return cast<WeakRefAttr>(this)->clone(C);
11287 : case attr::WorkGroupSizeHint:
11288 0 : return cast<WorkGroupSizeHintAttr>(this)->clone(C);
11289 : case attr::X86ForceAlignArgPointer:
11290 1 : return cast<X86ForceAlignArgPointerAttr>(this)->clone(C);
11291 : case attr::XRayInstrument:
11292 0 : return cast<XRayInstrumentAttr>(this)->clone(C);
11293 : case attr::XRayLogArgs:
11294 0 : return cast<XRayLogArgsAttr>(this)->clone(C);
11295 : }
11296 0 : llvm_unreachable("Unexpected attribute kind!");
11297 : }
11298 :
11299 502 : void Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
11300 502 : switch (getKind()) {
11301 : case attr::AMDGPUFlatWorkGroupSize:
11302 0 : return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->printPretty(OS, Policy);
11303 : case attr::AMDGPUNumSGPR:
11304 0 : return cast<AMDGPUNumSGPRAttr>(this)->printPretty(OS, Policy);
11305 : case attr::AMDGPUNumVGPR:
11306 0 : return cast<AMDGPUNumVGPRAttr>(this)->printPretty(OS, Policy);
11307 : case attr::AMDGPUWavesPerEU:
11308 0 : return cast<AMDGPUWavesPerEUAttr>(this)->printPretty(OS, Policy);
11309 : case attr::ARMInterrupt:
11310 0 : return cast<ARMInterruptAttr>(this)->printPretty(OS, Policy);
11311 : case attr::AVRInterrupt:
11312 0 : return cast<AVRInterruptAttr>(this)->printPretty(OS, Policy);
11313 : case attr::AVRSignal:
11314 0 : return cast<AVRSignalAttr>(this)->printPretty(OS, Policy);
11315 : case attr::AbiTag:
11316 0 : return cast<AbiTagAttr>(this)->printPretty(OS, Policy);
11317 : case attr::AcquireCapability:
11318 0 : return cast<AcquireCapabilityAttr>(this)->printPretty(OS, Policy);
11319 : case attr::AcquiredAfter:
11320 0 : return cast<AcquiredAfterAttr>(this)->printPretty(OS, Policy);
11321 : case attr::AcquiredBefore:
11322 0 : return cast<AcquiredBeforeAttr>(this)->printPretty(OS, Policy);
11323 : case attr::AddressSpace:
11324 0 : return cast<AddressSpaceAttr>(this)->printPretty(OS, Policy);
11325 : case attr::Alias:
11326 0 : return cast<AliasAttr>(this)->printPretty(OS, Policy);
11327 : case attr::AlignMac68k:
11328 0 : return cast<AlignMac68kAttr>(this)->printPretty(OS, Policy);
11329 : case attr::AlignValue:
11330 0 : return cast<AlignValueAttr>(this)->printPretty(OS, Policy);
11331 : case attr::Aligned:
11332 62 : return cast<AlignedAttr>(this)->printPretty(OS, Policy);
11333 : case attr::AllocAlign:
11334 4 : return cast<AllocAlignAttr>(this)->printPretty(OS, Policy);
11335 : case attr::AllocSize:
11336 8 : return cast<AllocSizeAttr>(this)->printPretty(OS, Policy);
11337 : case attr::AlwaysDestroy:
11338 0 : return cast<AlwaysDestroyAttr>(this)->printPretty(OS, Policy);
11339 : case attr::AlwaysInline:
11340 0 : return cast<AlwaysInlineAttr>(this)->printPretty(OS, Policy);
11341 : case attr::AnalyzerNoReturn:
11342 0 : return cast<AnalyzerNoReturnAttr>(this)->printPretty(OS, Policy);
11343 : case attr::Annotate:
11344 0 : return cast<AnnotateAttr>(this)->printPretty(OS, Policy);
11345 : case attr::AnyX86Interrupt:
11346 0 : return cast<AnyX86InterruptAttr>(this)->printPretty(OS, Policy);
11347 : case attr::AnyX86NoCallerSavedRegisters:
11348 0 : return cast<AnyX86NoCallerSavedRegistersAttr>(this)->printPretty(OS, Policy);
11349 : case attr::AnyX86NoCfCheck:
11350 0 : return cast<AnyX86NoCfCheckAttr>(this)->printPretty(OS, Policy);
11351 : case attr::ArcWeakrefUnavailable:
11352 0 : return cast<ArcWeakrefUnavailableAttr>(this)->printPretty(OS, Policy);
11353 : case attr::ArgumentWithTypeTag:
11354 8 : return cast<ArgumentWithTypeTagAttr>(this)->printPretty(OS, Policy);
11355 : case attr::Artificial:
11356 0 : return cast<ArtificialAttr>(this)->printPretty(OS, Policy);
11357 : case attr::AsmLabel:
11358 0 : return cast<AsmLabelAttr>(this)->printPretty(OS, Policy);
11359 : case attr::AssertCapability:
11360 0 : return cast<AssertCapabilityAttr>(this)->printPretty(OS, Policy);
11361 : case attr::AssertExclusiveLock:
11362 0 : return cast<AssertExclusiveLockAttr>(this)->printPretty(OS, Policy);
11363 : case attr::AssertSharedLock:
11364 0 : return cast<AssertSharedLockAttr>(this)->printPretty(OS, Policy);
11365 : case attr::AssumeAligned:
11366 0 : return cast<AssumeAlignedAttr>(this)->printPretty(OS, Policy);
11367 : case attr::Availability:
11368 6 : return cast<AvailabilityAttr>(this)->printPretty(OS, Policy);
11369 : case attr::Blocks:
11370 2 : return cast<BlocksAttr>(this)->printPretty(OS, Policy);
11371 : case attr::C11NoReturn:
11372 0 : return cast<C11NoReturnAttr>(this)->printPretty(OS, Policy);
11373 : case attr::CDecl:
11374 0 : return cast<CDeclAttr>(this)->printPretty(OS, Policy);
11375 : case attr::CFAuditedTransfer:
11376 0 : return cast<CFAuditedTransferAttr>(this)->printPretty(OS, Policy);
11377 : case attr::CFConsumed:
11378 0 : return cast<CFConsumedAttr>(this)->printPretty(OS, Policy);
11379 : case attr::CFReturnsNotRetained:
11380 0 : return cast<CFReturnsNotRetainedAttr>(this)->printPretty(OS, Policy);
11381 : case attr::CFReturnsRetained:
11382 0 : return cast<CFReturnsRetainedAttr>(this)->printPretty(OS, Policy);
11383 : case attr::CFUnknownTransfer:
11384 0 : return cast<CFUnknownTransferAttr>(this)->printPretty(OS, Policy);
11385 : case attr::CPUDispatch:
11386 0 : return cast<CPUDispatchAttr>(this)->printPretty(OS, Policy);
11387 : case attr::CPUSpecific:
11388 0 : return cast<CPUSpecificAttr>(this)->printPretty(OS, Policy);
11389 : case attr::CUDAConstant:
11390 0 : return cast<CUDAConstantAttr>(this)->printPretty(OS, Policy);
11391 : case attr::CUDADevice:
11392 0 : return cast<CUDADeviceAttr>(this)->printPretty(OS, Policy);
11393 : case attr::CUDAGlobal:
11394 0 : return cast<CUDAGlobalAttr>(this)->printPretty(OS, Policy);
11395 : case attr::CUDAHost:
11396 0 : return cast<CUDAHostAttr>(this)->printPretty(OS, Policy);
11397 : case attr::CUDAInvalidTarget:
11398 0 : return cast<CUDAInvalidTargetAttr>(this)->printPretty(OS, Policy);
11399 : case attr::CUDALaunchBounds:
11400 0 : return cast<CUDALaunchBoundsAttr>(this)->printPretty(OS, Policy);
11401 : case attr::CUDAShared:
11402 0 : return cast<CUDASharedAttr>(this)->printPretty(OS, Policy);
11403 : case attr::CXX11NoReturn:
11404 1 : return cast<CXX11NoReturnAttr>(this)->printPretty(OS, Policy);
11405 : case attr::CallableWhen:
11406 1 : return cast<CallableWhenAttr>(this)->printPretty(OS, Policy);
11407 : case attr::Capability:
11408 0 : return cast<CapabilityAttr>(this)->printPretty(OS, Policy);
11409 : case attr::CapturedRecord:
11410 0 : return cast<CapturedRecordAttr>(this)->printPretty(OS, Policy);
11411 : case attr::CarriesDependency:
11412 0 : return cast<CarriesDependencyAttr>(this)->printPretty(OS, Policy);
11413 : case attr::Cleanup:
11414 0 : return cast<CleanupAttr>(this)->printPretty(OS, Policy);
11415 : case attr::CodeSeg:
11416 0 : return cast<CodeSegAttr>(this)->printPretty(OS, Policy);
11417 : case attr::Cold:
11418 12 : return cast<ColdAttr>(this)->printPretty(OS, Policy);
11419 : case attr::Common:
11420 0 : return cast<CommonAttr>(this)->printPretty(OS, Policy);
11421 : case attr::Const:
11422 6 : return cast<ConstAttr>(this)->printPretty(OS, Policy);
11423 : case attr::Constructor:
11424 0 : return cast<ConstructorAttr>(this)->printPretty(OS, Policy);
11425 : case attr::Consumable:
11426 1 : return cast<ConsumableAttr>(this)->printPretty(OS, Policy);
11427 : case attr::ConsumableAutoCast:
11428 0 : return cast<ConsumableAutoCastAttr>(this)->printPretty(OS, Policy);
11429 : case attr::ConsumableSetOnRead:
11430 0 : return cast<ConsumableSetOnReadAttr>(this)->printPretty(OS, Policy);
11431 : case attr::Convergent:
11432 0 : return cast<ConvergentAttr>(this)->printPretty(OS, Policy);
11433 : case attr::DLLExport:
11434 0 : return cast<DLLExportAttr>(this)->printPretty(OS, Policy);
11435 : case attr::DLLImport:
11436 0 : return cast<DLLImportAttr>(this)->printPretty(OS, Policy);
11437 : case attr::Deprecated:
11438 55 : return cast<DeprecatedAttr>(this)->printPretty(OS, Policy);
11439 : case attr::Destructor:
11440 0 : return cast<DestructorAttr>(this)->printPretty(OS, Policy);
11441 : case attr::DiagnoseIf:
11442 0 : return cast<DiagnoseIfAttr>(this)->printPretty(OS, Policy);
11443 : case attr::DisableTailCalls:
11444 0 : return cast<DisableTailCallsAttr>(this)->printPretty(OS, Policy);
11445 : case attr::EmptyBases:
11446 0 : return cast<EmptyBasesAttr>(this)->printPretty(OS, Policy);
11447 : case attr::EnableIf:
11448 0 : return cast<EnableIfAttr>(this)->printPretty(OS, Policy);
11449 : case attr::EnumExtensibility:
11450 0 : return cast<EnumExtensibilityAttr>(this)->printPretty(OS, Policy);
11451 : case attr::ExcludeFromExplicitInstantiation:
11452 0 : return cast<ExcludeFromExplicitInstantiationAttr>(this)->printPretty(OS, Policy);
11453 : case attr::ExclusiveTrylockFunction:
11454 0 : return cast<ExclusiveTrylockFunctionAttr>(this)->printPretty(OS, Policy);
11455 : case attr::ExternalSourceSymbol:
11456 0 : return cast<ExternalSourceSymbolAttr>(this)->printPretty(OS, Policy);
11457 : case attr::FallThrough:
11458 3 : return cast<FallThroughAttr>(this)->printPretty(OS, Policy);
11459 : case attr::FastCall:
11460 0 : return cast<FastCallAttr>(this)->printPretty(OS, Policy);
11461 : case attr::Final:
11462 0 : return cast<FinalAttr>(this)->printPretty(OS, Policy);
11463 : case attr::FlagEnum:
11464 0 : return cast<FlagEnumAttr>(this)->printPretty(OS, Policy);
11465 : case attr::Flatten:
11466 0 : return cast<FlattenAttr>(this)->printPretty(OS, Policy);
11467 : case attr::Format:
11468 5 : return cast<FormatAttr>(this)->printPretty(OS, Policy);
11469 : case attr::FormatArg:
11470 4 : return cast<FormatArgAttr>(this)->printPretty(OS, Policy);
11471 : case attr::GNUInline:
11472 2 : return cast<GNUInlineAttr>(this)->printPretty(OS, Policy);
11473 : case attr::GuardedBy:
11474 0 : return cast<GuardedByAttr>(this)->printPretty(OS, Policy);
11475 : case attr::GuardedVar:
11476 0 : return cast<GuardedVarAttr>(this)->printPretty(OS, Policy);
11477 : case attr::Hot:
11478 0 : return cast<HotAttr>(this)->printPretty(OS, Policy);
11479 : case attr::IBAction:
11480 0 : return cast<IBActionAttr>(this)->printPretty(OS, Policy);
11481 : case attr::IBOutlet:
11482 0 : return cast<IBOutletAttr>(this)->printPretty(OS, Policy);
11483 : case attr::IBOutletCollection:
11484 0 : return cast<IBOutletCollectionAttr>(this)->printPretty(OS, Policy);
11485 : case attr::IFunc:
11486 0 : return cast<IFuncAttr>(this)->printPretty(OS, Policy);
11487 : case attr::InitPriority:
11488 0 : return cast<InitPriorityAttr>(this)->printPretty(OS, Policy);
11489 : case attr::InitSeg:
11490 1 : return cast<InitSegAttr>(this)->printPretty(OS, Policy);
11491 : case attr::IntelOclBicc:
11492 0 : return cast<IntelOclBiccAttr>(this)->printPretty(OS, Policy);
11493 : case attr::InternalLinkage:
11494 0 : return cast<InternalLinkageAttr>(this)->printPretty(OS, Policy);
11495 : case attr::LTOVisibilityPublic:
11496 0 : return cast<LTOVisibilityPublicAttr>(this)->printPretty(OS, Policy);
11497 : case attr::LayoutVersion:
11498 0 : return cast<LayoutVersionAttr>(this)->printPretty(OS, Policy);
11499 : case attr::LifetimeBound:
11500 0 : return cast<LifetimeBoundAttr>(this)->printPretty(OS, Policy);
11501 : case attr::LockReturned:
11502 0 : return cast<LockReturnedAttr>(this)->printPretty(OS, Policy);
11503 : case attr::LocksExcluded:
11504 0 : return cast<LocksExcludedAttr>(this)->printPretty(OS, Policy);
11505 : case attr::LoopHint:
11506 42 : return cast<LoopHintAttr>(this)->printPretty(OS, Policy);
11507 : case attr::MSABI:
11508 0 : return cast<MSABIAttr>(this)->printPretty(OS, Policy);
11509 : case attr::MSInheritance:
11510 3 : return cast<MSInheritanceAttr>(this)->printPretty(OS, Policy);
11511 : case attr::MSNoVTable:
11512 0 : return cast<MSNoVTableAttr>(this)->printPretty(OS, Policy);
11513 : case attr::MSP430Interrupt:
11514 0 : return cast<MSP430InterruptAttr>(this)->printPretty(OS, Policy);
11515 : case attr::MSStruct:
11516 0 : return cast<MSStructAttr>(this)->printPretty(OS, Policy);
11517 : case attr::MSVtorDisp:
11518 0 : return cast<MSVtorDispAttr>(this)->printPretty(OS, Policy);
11519 : case attr::MaxFieldAlignment:
11520 0 : return cast<MaxFieldAlignmentAttr>(this)->printPretty(OS, Policy);
11521 : case attr::MayAlias:
11522 16 : return cast<MayAliasAttr>(this)->printPretty(OS, Policy);
11523 : case attr::MicroMips:
11524 0 : return cast<MicroMipsAttr>(this)->printPretty(OS, Policy);
11525 : case attr::MinSize:
11526 0 : return cast<MinSizeAttr>(this)->printPretty(OS, Policy);
11527 : case attr::MinVectorWidth:
11528 0 : return cast<MinVectorWidthAttr>(this)->printPretty(OS, Policy);
11529 : case attr::Mips16:
11530 0 : return cast<Mips16Attr>(this)->printPretty(OS, Policy);
11531 : case attr::MipsInterrupt:
11532 0 : return cast<MipsInterruptAttr>(this)->printPretty(OS, Policy);
11533 : case attr::MipsLongCall:
11534 0 : return cast<MipsLongCallAttr>(this)->printPretty(OS, Policy);
11535 : case attr::MipsShortCall:
11536 0 : return cast<MipsShortCallAttr>(this)->printPretty(OS, Policy);
11537 : case attr::Mode:
11538 3 : return cast<ModeAttr>(this)->printPretty(OS, Policy);
11539 : case attr::NSConsumed:
11540 0 : return cast<NSConsumedAttr>(this)->printPretty(OS, Policy);
11541 : case attr::NSConsumesSelf:
11542 0 : return cast<NSConsumesSelfAttr>(this)->printPretty(OS, Policy);
11543 : case attr::NSReturnsAutoreleased:
11544 0 : return cast<NSReturnsAutoreleasedAttr>(this)->printPretty(OS, Policy);
11545 : case attr::NSReturnsNotRetained:
11546 0 : return cast<NSReturnsNotRetainedAttr>(this)->printPretty(OS, Policy);
11547 : case attr::NSReturnsRetained:
11548 0 : return cast<NSReturnsRetainedAttr>(this)->printPretty(OS, Policy);
11549 : case attr::Naked:
11550 0 : return cast<NakedAttr>(this)->printPretty(OS, Policy);
11551 : case attr::NoAlias:
11552 0 : return cast<NoAliasAttr>(this)->printPretty(OS, Policy);
11553 : case attr::NoCommon:
11554 0 : return cast<NoCommonAttr>(this)->printPretty(OS, Policy);
11555 : case attr::NoDebug:
11556 0 : return cast<NoDebugAttr>(this)->printPretty(OS, Policy);
11557 : case attr::NoDestroy:
11558 0 : return cast<NoDestroyAttr>(this)->printPretty(OS, Policy);
11559 : case attr::NoDuplicate:
11560 0 : return cast<NoDuplicateAttr>(this)->printPretty(OS, Policy);
11561 : case attr::NoEscape:
11562 0 : return cast<NoEscapeAttr>(this)->printPretty(OS, Policy);
11563 : case attr::NoInline:
11564 1 : return cast<NoInlineAttr>(this)->printPretty(OS, Policy);
11565 : case attr::NoInstrumentFunction:
11566 0 : return cast<NoInstrumentFunctionAttr>(this)->printPretty(OS, Policy);
11567 : case attr::NoMicroMips:
11568 0 : return cast<NoMicroMipsAttr>(this)->printPretty(OS, Policy);
11569 : case attr::NoMips16:
11570 0 : return cast<NoMips16Attr>(this)->printPretty(OS, Policy);
11571 : case attr::NoReturn:
11572 0 : return cast<NoReturnAttr>(this)->printPretty(OS, Policy);
11573 : case attr::NoSanitize:
11574 5 : return cast<NoSanitizeAttr>(this)->printPretty(OS, Policy);
11575 : case attr::NoSplitStack:
11576 0 : return cast<NoSplitStackAttr>(this)->printPretty(OS, Policy);
11577 : case attr::NoStackProtector:
11578 0 : return cast<NoStackProtectorAttr>(this)->printPretty(OS, Policy);
11579 : case attr::NoThreadSafetyAnalysis:
11580 0 : return cast<NoThreadSafetyAnalysisAttr>(this)->printPretty(OS, Policy);
11581 : case attr::NoThrow:
11582 0 : return cast<NoThrowAttr>(this)->printPretty(OS, Policy);
11583 : case attr::NonNull:
11584 4 : return cast<NonNullAttr>(this)->printPretty(OS, Policy);
11585 : case attr::NotTailCalled:
11586 0 : return cast<NotTailCalledAttr>(this)->printPretty(OS, Policy);
11587 : case attr::OMPCaptureKind:
11588 0 : return cast<OMPCaptureKindAttr>(this)->printPretty(OS, Policy);
11589 : case attr::OMPCaptureNoInit:
11590 0 : return cast<OMPCaptureNoInitAttr>(this)->printPretty(OS, Policy);
11591 : case attr::OMPDeclareSimdDecl:
11592 92 : return cast<OMPDeclareSimdDeclAttr>(this)->printPretty(OS, Policy);
11593 : case attr::OMPDeclareTargetDecl:
11594 124 : return cast<OMPDeclareTargetDeclAttr>(this)->printPretty(OS, Policy);
11595 : case attr::OMPReferencedVar:
11596 0 : return cast<OMPReferencedVarAttr>(this)->printPretty(OS, Policy);
11597 : case attr::OMPThreadPrivateDecl:
11598 0 : return cast<OMPThreadPrivateDeclAttr>(this)->printPretty(OS, Policy);
11599 : case attr::ObjCBoxable:
11600 0 : return cast<ObjCBoxableAttr>(this)->printPretty(OS, Policy);
11601 : case attr::ObjCBridge:
11602 0 : return cast<ObjCBridgeAttr>(this)->printPretty(OS, Policy);
11603 : case attr::ObjCBridgeMutable:
11604 0 : return cast<ObjCBridgeMutableAttr>(this)->printPretty(OS, Policy);
11605 : case attr::ObjCBridgeRelated:
11606 1 : return cast<ObjCBridgeRelatedAttr>(this)->printPretty(OS, Policy);
11607 : case attr::ObjCDesignatedInitializer:
11608 0 : return cast<ObjCDesignatedInitializerAttr>(this)->printPretty(OS, Policy);
11609 : case attr::ObjCException:
11610 0 : return cast<ObjCExceptionAttr>(this)->printPretty(OS, Policy);
11611 : case attr::ObjCExplicitProtocolImpl:
11612 0 : return cast<ObjCExplicitProtocolImplAttr>(this)->printPretty(OS, Policy);
11613 : case attr::ObjCGC:
11614 0 : return cast<ObjCGCAttr>(this)->printPretty(OS, Policy);
11615 : case attr::ObjCIndependentClass:
11616 0 : return cast<ObjCIndependentClassAttr>(this)->printPretty(OS, Policy);
11617 : case attr::ObjCInertUnsafeUnretained:
11618 0 : return cast<ObjCInertUnsafeUnretainedAttr>(this)->printPretty(OS, Policy);
11619 : case attr::ObjCKindOf:
11620 0 : return cast<ObjCKindOfAttr>(this)->printPretty(OS, Policy);
11621 : case attr::ObjCMethodFamily:
11622 0 : return cast<ObjCMethodFamilyAttr>(this)->printPretty(OS, Policy);
11623 : case attr::ObjCNSObject:
11624 0 : return cast<ObjCNSObjectAttr>(this)->printPretty(OS, Policy);
11625 : case attr::ObjCOwnership:
11626 0 : return cast<ObjCOwnershipAttr>(this)->printPretty(OS, Policy);
11627 : case attr::ObjCPreciseLifetime:
11628 0 : return cast<ObjCPreciseLifetimeAttr>(this)->printPretty(OS, Policy);
11629 : case attr::ObjCRequiresPropertyDefs:
11630 0 : return cast<ObjCRequiresPropertyDefsAttr>(this)->printPretty(OS, Policy);
11631 : case attr::ObjCRequiresSuper:
11632 0 : return cast<ObjCRequiresSuperAttr>(this)->printPretty(OS, Policy);
11633 : case attr::ObjCReturnsInnerPointer:
11634 0 : return cast<ObjCReturnsInnerPointerAttr>(this)->printPretty(OS, Policy);
11635 : case attr::ObjCRootClass:
11636 0 : return cast<ObjCRootClassAttr>(this)->printPretty(OS, Policy);
11637 : case attr::ObjCRuntimeName:
11638 0 : return cast<ObjCRuntimeNameAttr>(this)->printPretty(OS, Policy);
11639 : case attr::ObjCRuntimeVisible:
11640 0 : return cast<ObjCRuntimeVisibleAttr>(this)->printPretty(OS, Policy);
11641 : case attr::ObjCSubclassingRestricted:
11642 0 : return cast<ObjCSubclassingRestrictedAttr>(this)->printPretty(OS, Policy);
11643 : case attr::OpenCLAccess:
11644 0 : return cast<OpenCLAccessAttr>(this)->printPretty(OS, Policy);
11645 : case attr::OpenCLConstantAddressSpace:
11646 0 : return cast<OpenCLConstantAddressSpaceAttr>(this)->printPretty(OS, Policy);
11647 : case attr::OpenCLGenericAddressSpace:
11648 0 : return cast<OpenCLGenericAddressSpaceAttr>(this)->printPretty(OS, Policy);
11649 : case attr::OpenCLGlobalAddressSpace:
11650 0 : return cast<OpenCLGlobalAddressSpaceAttr>(this)->printPretty(OS, Policy);
11651 : case attr::OpenCLIntelReqdSubGroupSize:
11652 0 : return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->printPretty(OS, Policy);
11653 : case attr::OpenCLKernel:
11654 0 : return cast<OpenCLKernelAttr>(this)->printPretty(OS, Policy);
11655 : case attr::OpenCLLocalAddressSpace:
11656 0 : return cast<OpenCLLocalAddressSpaceAttr>(this)->printPretty(OS, Policy);
11657 : case attr::OpenCLPrivateAddressSpace:
11658 0 : return cast<OpenCLPrivateAddressSpaceAttr>(this)->printPretty(OS, Policy);
11659 : case attr::OpenCLUnrollHint:
11660 0 : return cast<OpenCLUnrollHintAttr>(this)->printPretty(OS, Policy);
11661 : case attr::OptimizeNone:
11662 0 : return cast<OptimizeNoneAttr>(this)->printPretty(OS, Policy);
11663 : case attr::Overloadable:
11664 0 : return cast<OverloadableAttr>(this)->printPretty(OS, Policy);
11665 : case attr::Override:
11666 0 : return cast<OverrideAttr>(this)->printPretty(OS, Policy);
11667 : case attr::Ownership:
11668 12 : return cast<OwnershipAttr>(this)->printPretty(OS, Policy);
11669 : case attr::Packed:
11670 0 : return cast<PackedAttr>(this)->printPretty(OS, Policy);
11671 : case attr::ParamTypestate:
11672 0 : return cast<ParamTypestateAttr>(this)->printPretty(OS, Policy);
11673 : case attr::Pascal:
11674 0 : return cast<PascalAttr>(this)->printPretty(OS, Policy);
11675 : case attr::PassObjectSize:
11676 0 : return cast<PassObjectSizeAttr>(this)->printPretty(OS, Policy);
11677 : case attr::Pcs:
11678 0 : return cast<PcsAttr>(this)->printPretty(OS, Policy);
11679 : case attr::PragmaClangBSSSection:
11680 0 : return cast<PragmaClangBSSSectionAttr>(this)->printPretty(OS, Policy);
11681 : case attr::PragmaClangDataSection:
11682 0 : return cast<PragmaClangDataSectionAttr>(this)->printPretty(OS, Policy);
11683 : case attr::PragmaClangRodataSection:
11684 0 : return cast<PragmaClangRodataSectionAttr>(this)->printPretty(OS, Policy);
11685 : case attr::PragmaClangTextSection:
11686 0 : return cast<PragmaClangTextSectionAttr>(this)->printPretty(OS, Policy);
11687 : case attr::PreserveAll:
11688 0 : return cast<PreserveAllAttr>(this)->printPretty(OS, Policy);
11689 : case attr::PreserveMost:
11690 0 : return cast<PreserveMostAttr>(this)->printPretty(OS, Policy);
11691 : case attr::PtGuardedBy:
11692 0 : return cast<PtGuardedByAttr>(this)->printPretty(OS, Policy);
11693 : case attr::PtGuardedVar:
11694 0 : return cast<PtGuardedVarAttr>(this)->printPretty(OS, Policy);
11695 : case attr::Ptr32:
11696 0 : return cast<Ptr32Attr>(this)->printPretty(OS, Policy);
11697 : case attr::Ptr64:
11698 0 : return cast<Ptr64Attr>(this)->printPretty(OS, Policy);
11699 : case attr::Pure:
11700 5 : return cast<PureAttr>(this)->printPretty(OS, Policy);
11701 : case attr::RISCVInterrupt:
11702 0 : return cast<RISCVInterruptAttr>(this)->printPretty(OS, Policy);
11703 : case attr::RegCall:
11704 0 : return cast<RegCallAttr>(this)->printPretty(OS, Policy);
11705 : case attr::Reinitializes:
11706 0 : return cast<ReinitializesAttr>(this)->printPretty(OS, Policy);
11707 : case attr::ReleaseCapability:
11708 0 : return cast<ReleaseCapabilityAttr>(this)->printPretty(OS, Policy);
11709 : case attr::RenderScriptKernel:
11710 0 : return cast<RenderScriptKernelAttr>(this)->printPretty(OS, Policy);
11711 : case attr::ReqdWorkGroupSize:
11712 0 : return cast<ReqdWorkGroupSizeAttr>(this)->printPretty(OS, Policy);
11713 : case attr::RequireConstantInit:
11714 0 : return cast<RequireConstantInitAttr>(this)->printPretty(OS, Policy);
11715 : case attr::RequiresCapability:
11716 0 : return cast<RequiresCapabilityAttr>(this)->printPretty(OS, Policy);
11717 : case attr::Restrict:
11718 1 : return cast<RestrictAttr>(this)->printPretty(OS, Policy);
11719 : case attr::ReturnTypestate:
11720 0 : return cast<ReturnTypestateAttr>(this)->printPretty(OS, Policy);
11721 : case attr::ReturnsNonNull:
11722 0 : return cast<ReturnsNonNullAttr>(this)->printPretty(OS, Policy);
11723 : case attr::ReturnsTwice:
11724 0 : return cast<ReturnsTwiceAttr>(this)->printPretty(OS, Policy);
11725 : case attr::SPtr:
11726 0 : return cast<SPtrAttr>(this)->printPretty(OS, Policy);
11727 : case attr::ScopedLockable:
11728 0 : return cast<ScopedLockableAttr>(this)->printPretty(OS, Policy);
11729 : case attr::Section:
11730 0 : return cast<SectionAttr>(this)->printPretty(OS, Policy);
11731 : case attr::SelectAny:
11732 0 : return cast<SelectAnyAttr>(this)->printPretty(OS, Policy);
11733 : case attr::Sentinel:
11734 0 : return cast<SentinelAttr>(this)->printPretty(OS, Policy);
11735 : case attr::SetTypestate:
11736 0 : return cast<SetTypestateAttr>(this)->printPretty(OS, Policy);
11737 : case attr::SharedTrylockFunction:
11738 0 : return cast<SharedTrylockFunctionAttr>(this)->printPretty(OS, Policy);
11739 : case attr::StdCall:
11740 0 : return cast<StdCallAttr>(this)->printPretty(OS, Policy);
11741 : case attr::Suppress:
11742 0 : return cast<SuppressAttr>(this)->printPretty(OS, Policy);
11743 : case attr::SwiftCall:
11744 0 : return cast<SwiftCallAttr>(this)->printPretty(OS, Policy);
11745 : case attr::SwiftContext:
11746 0 : return cast<SwiftContextAttr>(this)->printPretty(OS, Policy);
11747 : case attr::SwiftErrorResult:
11748 0 : return cast<SwiftErrorResultAttr>(this)->printPretty(OS, Policy);
11749 : case attr::SwiftIndirectResult:
11750 0 : return cast<SwiftIndirectResultAttr>(this)->printPretty(OS, Policy);
11751 : case attr::SysVABI:
11752 0 : return cast<SysVABIAttr>(this)->printPretty(OS, Policy);
11753 : case attr::TLSModel:
11754 0 : return cast<TLSModelAttr>(this)->printPretty(OS, Policy);
11755 : case attr::Target:
11756 0 : return cast<TargetAttr>(this)->printPretty(OS, Policy);
11757 : case attr::TestTypestate:
11758 0 : return cast<TestTypestateAttr>(this)->printPretty(OS, Policy);
11759 : case attr::ThisCall:
11760 0 : return cast<ThisCallAttr>(this)->printPretty(OS, Policy);
11761 : case attr::Thread:
11762 1 : return cast<ThreadAttr>(this)->printPretty(OS, Policy);
11763 : case attr::TransparentUnion:
11764 0 : return cast<TransparentUnionAttr>(this)->printPretty(OS, Policy);
11765 : case attr::TrivialABI:
11766 0 : return cast<TrivialABIAttr>(this)->printPretty(OS, Policy);
11767 : case attr::TryAcquireCapability:
11768 0 : return cast<TryAcquireCapabilityAttr>(this)->printPretty(OS, Policy);
11769 : case attr::TypeNonNull:
11770 0 : return cast<TypeNonNullAttr>(this)->printPretty(OS, Policy);
11771 : case attr::TypeNullUnspecified:
11772 0 : return cast<TypeNullUnspecifiedAttr>(this)->printPretty(OS, Policy);
11773 : case attr::TypeNullable:
11774 0 : return cast<TypeNullableAttr>(this)->printPretty(OS, Policy);
11775 : case attr::TypeTagForDatatype:
11776 0 : return cast<TypeTagForDatatypeAttr>(this)->printPretty(OS, Policy);
11777 : case attr::TypeVisibility:
11778 0 : return cast<TypeVisibilityAttr>(this)->printPretty(OS, Policy);
11779 : case attr::UPtr:
11780 0 : return cast<UPtrAttr>(this)->printPretty(OS, Policy);
11781 : case attr::Unavailable:
11782 1 : return cast<UnavailableAttr>(this)->printPretty(OS, Policy);
11783 : case attr::Unused:
11784 0 : return cast<UnusedAttr>(this)->printPretty(OS, Policy);
11785 : case attr::Used:
11786 0 : return cast<UsedAttr>(this)->printPretty(OS, Policy);
11787 : case attr::Uuid:
11788 0 : return cast<UuidAttr>(this)->printPretty(OS, Policy);
11789 : case attr::VecReturn:
11790 0 : return cast<VecReturnAttr>(this)->printPretty(OS, Policy);
11791 : case attr::VecTypeHint:
11792 0 : return cast<VecTypeHintAttr>(this)->printPretty(OS, Policy);
11793 : case attr::VectorCall:
11794 0 : return cast<VectorCallAttr>(this)->printPretty(OS, Policy);
11795 : case attr::Visibility:
11796 3 : return cast<VisibilityAttr>(this)->printPretty(OS, Policy);
11797 : case attr::WarnUnused:
11798 0 : return cast<WarnUnusedAttr>(this)->printPretty(OS, Policy);
11799 : case attr::WarnUnusedResult:
11800 3 : return cast<WarnUnusedResultAttr>(this)->printPretty(OS, Policy);
11801 : case attr::Weak:
11802 0 : return cast<WeakAttr>(this)->printPretty(OS, Policy);
11803 : case attr::WeakImport:
11804 0 : return cast<WeakImportAttr>(this)->printPretty(OS, Policy);
11805 : case attr::WeakRef:
11806 0 : return cast<WeakRefAttr>(this)->printPretty(OS, Policy);
11807 : case attr::WorkGroupSizeHint:
11808 0 : return cast<WorkGroupSizeHintAttr>(this)->printPretty(OS, Policy);
11809 : case attr::X86ForceAlignArgPointer:
11810 0 : return cast<X86ForceAlignArgPointerAttr>(this)->printPretty(OS, Policy);
11811 : case attr::XRayInstrument:
11812 0 : return cast<XRayInstrumentAttr>(this)->printPretty(OS, Policy);
11813 : case attr::XRayLogArgs:
11814 4 : return cast<XRayLogArgsAttr>(this)->printPretty(OS, Policy);
11815 : }
11816 0 : llvm_unreachable("Unexpected attribute kind!");
11817 : }
11818 :
|
