Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Attribute dumper *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 363 : switch (A->getKind()) {
10 0 : case attr::AMDGPUFlatWorkGroupSize: {
11 : const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A);
12 0 : OS << " " << SA->getMin();
13 0 : OS << " " << SA->getMax();
14 : break;
15 : }
16 0 : case attr::AMDGPUNumSGPR: {
17 : const auto *SA = cast<AMDGPUNumSGPRAttr>(A);
18 0 : OS << " " << SA->getNumSGPR();
19 : break;
20 : }
21 0 : case attr::AMDGPUNumVGPR: {
22 : const auto *SA = cast<AMDGPUNumVGPRAttr>(A);
23 0 : OS << " " << SA->getNumVGPR();
24 : break;
25 : }
26 0 : case attr::AMDGPUWavesPerEU: {
27 : const auto *SA = cast<AMDGPUWavesPerEUAttr>(A);
28 0 : OS << " " << SA->getMin();
29 0 : OS << " " << SA->getMax();
30 : break;
31 : }
32 1 : case attr::ARMInterrupt: {
33 : const auto *SA = cast<ARMInterruptAttr>(A);
34 1 : switch(SA->getInterrupt()) {
35 0 : case ARMInterruptAttr::IRQ:
36 0 : OS << " IRQ";
37 0 : break;
38 0 : case ARMInterruptAttr::FIQ:
39 0 : OS << " FIQ";
40 0 : break;
41 0 : case ARMInterruptAttr::SWI:
42 0 : OS << " SWI";
43 0 : break;
44 0 : case ARMInterruptAttr::ABORT:
45 0 : OS << " ABORT";
46 0 : break;
47 0 : case ARMInterruptAttr::UNDEF:
48 0 : OS << " UNDEF";
49 0 : break;
50 1 : case ARMInterruptAttr::Generic:
51 1 : OS << " Generic";
52 1 : break;
53 : }
54 : break;
55 : }
56 : case attr::AVRInterrupt: {
57 : break;
58 : }
59 : case attr::AVRSignal: {
60 : break;
61 : }
62 19 : case attr::AbiTag: {
63 : const auto *SA = cast<AbiTagAttr>(A);
64 57 : for (const auto &Val : SA->tags())
65 19 : OS << " " << Val;
66 : break;
67 : }
68 0 : case attr::AcquireCapability: {
69 0 : OS << " " << A->getSpelling();
70 : const auto *SA = cast<AcquireCapabilityAttr>(A);
71 0 : for (AcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
72 0 : dumpStmt(*I);
73 : break;
74 : }
75 1 : case attr::AcquiredAfter: {
76 : const auto *SA = cast<AcquiredAfterAttr>(A);
77 6 : for (AcquiredAfterAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
78 2 : dumpStmt(*I);
79 : break;
80 : }
81 0 : case attr::AcquiredBefore: {
82 : const auto *SA = cast<AcquiredBeforeAttr>(A);
83 0 : for (AcquiredBeforeAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
84 0 : dumpStmt(*I);
85 : break;
86 : }
87 1 : case attr::Alias: {
88 : const auto *SA = cast<AliasAttr>(A);
89 2 : OS << " \"" << SA->getAliasee() << "\"";
90 1 : break;
91 : }
92 : case attr::AlignMac68k: {
93 : break;
94 : }
95 0 : case attr::AlignValue: {
96 : const auto *SA = cast<AlignValueAttr>(A);
97 0 : dumpStmt(SA->getAlignment());
98 : break;
99 : }
100 16 : case attr::Aligned: {
101 32 : OS << " " << A->getSpelling();
102 : const auto *SA = cast<AlignedAttr>(A);
103 16 : if (SA->isAlignmentExpr())
104 16 : dumpStmt(SA->getAlignmentExpr());
105 : else
106 0 : dumpType(SA->getAlignmentType()->getType());
107 : break;
108 : }
109 0 : case attr::AllocAlign: {
110 : const auto *SA = cast<AllocAlignAttr>(A);
111 0 : OS << " " << SA->getParamIndex().getSourceIndex();
112 0 : break;
113 : }
114 0 : case attr::AllocSize: {
115 : const auto *SA = cast<AllocSizeAttr>(A);
116 0 : OS << " " << SA->getElemSizeParam().getSourceIndex();
117 0 : if (SA->getNumElemsParam().isValid())
118 0 : OS << " " << SA->getNumElemsParam().getSourceIndex();
119 : break;
120 : }
121 0 : case attr::AlwaysInline: {
122 0 : OS << " " << A->getSpelling();
123 0 : break;
124 : }
125 : case attr::AnalyzerNoReturn: {
126 : break;
127 : }
128 105 : case attr::Annotate: {
129 : const auto *SA = cast<AnnotateAttr>(A);
130 210 : OS << " \"" << SA->getAnnotation() << "\"";
131 105 : break;
132 : }
133 : case attr::AnyX86Interrupt: {
134 : break;
135 : }
136 : case attr::AnyX86NoCallerSavedRegisters: {
137 : break;
138 : }
139 : case attr::AnyX86NoCfCheck: {
140 : break;
141 : }
142 : case attr::ArcWeakrefUnavailable: {
143 : break;
144 : }
145 3 : case attr::ArgumentWithTypeTag: {
146 6 : OS << " " << A->getSpelling();
147 : const auto *SA = cast<ArgumentWithTypeTagAttr>(A);
148 3 : if (SA->getArgumentKind())
149 6 : OS << " " << SA->getArgumentKind()->getName();
150 6 : OS << " " << SA->getArgumentIdx().getSourceIndex();
151 6 : OS << " " << SA->getTypeTagIdx().getSourceIndex();
152 6 : if (SA->getIsPointer()) OS << " IsPointer";
153 : break;
154 : }
155 : case attr::Artificial: {
156 : break;
157 : }
158 0 : case attr::AsmLabel: {
159 : const auto *SA = cast<AsmLabelAttr>(A);
160 0 : OS << " \"" << SA->getLabel() << "\"";
161 0 : break;
162 : }
163 0 : case attr::AssertCapability: {
164 0 : OS << " " << A->getSpelling();
165 : const auto *SA = cast<AssertCapabilityAttr>(A);
166 0 : for (AssertCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
167 0 : dumpStmt(*I);
168 : break;
169 : }
170 0 : case attr::AssertExclusiveLock: {
171 : const auto *SA = cast<AssertExclusiveLockAttr>(A);
172 0 : for (AssertExclusiveLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
173 0 : dumpStmt(*I);
174 : break;
175 : }
176 0 : case attr::AssertSharedLock: {
177 : const auto *SA = cast<AssertSharedLockAttr>(A);
178 0 : for (AssertSharedLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
179 0 : dumpStmt(*I);
180 : break;
181 : }
182 0 : case attr::AssumeAligned: {
183 : const auto *SA = cast<AssumeAlignedAttr>(A);
184 0 : dumpStmt(SA->getAlignment());
185 0 : dumpStmt(SA->getOffset());
186 : break;
187 : }
188 0 : case attr::Availability: {
189 : const auto *SA = cast<AvailabilityAttr>(A);
190 0 : if (SA->getPlatform())
191 0 : OS << " " << SA->getPlatform()->getName();
192 0 : OS << " " << SA->getIntroduced();
193 0 : OS << " " << SA->getDeprecated();
194 0 : OS << " " << SA->getObsoleted();
195 0 : if (SA->getUnavailable()) OS << " Unavailable";
196 0 : OS << " \"" << SA->getMessage() << "\"";
197 0 : if (SA->getStrict()) OS << " Strict";
198 0 : OS << " \"" << SA->getReplacement() << "\"";
199 0 : break;
200 : }
201 0 : case attr::Blocks: {
202 : const auto *SA = cast<BlocksAttr>(A);
203 0 : switch(SA->getType()) {
204 0 : case BlocksAttr::ByRef:
205 0 : OS << " ByRef";
206 0 : break;
207 : }
208 : break;
209 : }
210 : case attr::C11NoReturn: {
211 : break;
212 : }
213 : case attr::CDecl: {
214 : break;
215 : }
216 : case attr::CFAuditedTransfer: {
217 : break;
218 : }
219 : case attr::CFConsumed: {
220 : break;
221 : }
222 : case attr::CFReturnsNotRetained: {
223 : break;
224 : }
225 : case attr::CFReturnsRetained: {
226 : break;
227 : }
228 : case attr::CFUnknownTransfer: {
229 : break;
230 : }
231 : case attr::CUDAConstant: {
232 : break;
233 : }
234 : case attr::CUDADevice: {
235 : break;
236 : }
237 : case attr::CUDAGlobal: {
238 : break;
239 : }
240 : case attr::CUDAHost: {
241 : break;
242 : }
243 : case attr::CUDAInvalidTarget: {
244 : break;
245 : }
246 0 : case attr::CUDALaunchBounds: {
247 : const auto *SA = cast<CUDALaunchBoundsAttr>(A);
248 0 : dumpStmt(SA->getMaxThreads());
249 0 : dumpStmt(SA->getMinBlocks());
250 : break;
251 : }
252 : case attr::CUDAShared: {
253 : break;
254 : }
255 : case attr::CXX11NoReturn: {
256 : break;
257 : }
258 0 : case attr::CallableWhen: {
259 : const auto *SA = cast<CallableWhenAttr>(A);
260 0 : for (CallableWhenAttr::callableStates_iterator I = SA->callableStates_begin(), E = SA->callableStates_end(); I != E; ++I) {
261 0 : switch(*I) {
262 0 : case CallableWhenAttr::Unknown:
263 0 : OS << " Unknown";
264 0 : break;
265 0 : case CallableWhenAttr::Consumed:
266 0 : OS << " Consumed";
267 0 : break;
268 0 : case CallableWhenAttr::Unconsumed:
269 0 : OS << " Unconsumed";
270 0 : break;
271 : }
272 : }
273 : break;
274 : }
275 1 : case attr::Capability: {
276 2 : OS << " " << A->getSpelling();
277 : const auto *SA = cast<CapabilityAttr>(A);
278 2 : OS << " \"" << SA->getName() << "\"";
279 1 : break;
280 : }
281 : case attr::CapturedRecord: {
282 : break;
283 : }
284 : case attr::CarriesDependency: {
285 : break;
286 : }
287 1 : case attr::Cleanup: {
288 : const auto *SA = cast<CleanupAttr>(A);
289 1 : OS << " ";
290 1 : dumpBareDeclRef(SA->getFunctionDecl());
291 1 : break;
292 : }
293 : case attr::Cold: {
294 : break;
295 : }
296 : case attr::Common: {
297 : break;
298 : }
299 : case attr::Const: {
300 : break;
301 : }
302 1 : case attr::Constructor: {
303 : const auto *SA = cast<ConstructorAttr>(A);
304 1 : OS << " " << SA->getPriority();
305 : break;
306 : }
307 0 : case attr::Consumable: {
308 : const auto *SA = cast<ConsumableAttr>(A);
309 0 : switch(SA->getDefaultState()) {
310 0 : case ConsumableAttr::Unknown:
311 0 : OS << " Unknown";
312 0 : break;
313 0 : case ConsumableAttr::Consumed:
314 0 : OS << " Consumed";
315 0 : break;
316 0 : case ConsumableAttr::Unconsumed:
317 0 : OS << " Unconsumed";
318 0 : break;
319 : }
320 : break;
321 : }
322 : case attr::ConsumableAutoCast: {
323 : break;
324 : }
325 : case attr::ConsumableSetOnRead: {
326 : break;
327 : }
328 : case attr::Convergent: {
329 : break;
330 : }
331 : case attr::DLLExport: {
332 : break;
333 : }
334 : case attr::DLLImport: {
335 : break;
336 : }
337 14 : case attr::Deprecated: {
338 : const auto *SA = cast<DeprecatedAttr>(A);
339 28 : OS << " \"" << SA->getMessage() << "\"";
340 28 : OS << " \"" << SA->getReplacement() << "\"";
341 14 : break;
342 : }
343 0 : case attr::Destructor: {
344 : const auto *SA = cast<DestructorAttr>(A);
345 0 : OS << " " << SA->getPriority();
346 : break;
347 : }
348 0 : case attr::DiagnoseIf: {
349 : const auto *SA = cast<DiagnoseIfAttr>(A);
350 0 : OS << " \"" << SA->getMessage() << "\"";
351 0 : switch(SA->getDiagnosticType()) {
352 0 : case DiagnoseIfAttr::DT_Error:
353 0 : OS << " DT_Error";
354 0 : break;
355 0 : case DiagnoseIfAttr::DT_Warning:
356 0 : OS << " DT_Warning";
357 0 : break;
358 : }
359 0 : if (SA->getArgDependent()) OS << " ArgDependent";
360 0 : OS << " ";
361 0 : dumpBareDeclRef(SA->getParent());
362 0 : dumpStmt(SA->getCond());
363 : break;
364 : }
365 : case attr::DisableTailCalls: {
366 : break;
367 : }
368 : case attr::EmptyBases: {
369 : break;
370 : }
371 0 : case attr::EnableIf: {
372 : const auto *SA = cast<EnableIfAttr>(A);
373 0 : OS << " \"" << SA->getMessage() << "\"";
374 0 : dumpStmt(SA->getCond());
375 : break;
376 : }
377 0 : case attr::EnumExtensibility: {
378 : const auto *SA = cast<EnumExtensibilityAttr>(A);
379 0 : switch(SA->getExtensibility()) {
380 0 : case EnumExtensibilityAttr::Closed:
381 0 : OS << " Closed";
382 0 : break;
383 0 : case EnumExtensibilityAttr::Open:
384 0 : OS << " Open";
385 0 : break;
386 : }
387 : break;
388 : }
389 0 : case attr::ExclusiveTrylockFunction: {
390 : const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A);
391 0 : dumpStmt(SA->getSuccessValue());
392 0 : for (ExclusiveTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
393 0 : dumpStmt(*I);
394 : break;
395 : }
396 8 : case attr::ExternalSourceSymbol: {
397 : const auto *SA = cast<ExternalSourceSymbolAttr>(A);
398 16 : OS << " \"" << SA->getLanguage() << "\"";
399 16 : OS << " \"" << SA->getDefinedIn() << "\"";
400 12 : if (SA->getGeneratedDeclaration()) OS << " GeneratedDeclaration";
401 : break;
402 : }
403 : case attr::FallThrough: {
404 : break;
405 : }
406 : case attr::FastCall: {
407 : break;
408 : }
409 0 : case attr::Final: {
410 0 : OS << " " << A->getSpelling();
411 0 : break;
412 : }
413 : case attr::FlagEnum: {
414 : break;
415 : }
416 : case attr::Flatten: {
417 : break;
418 : }
419 2 : case attr::Format: {
420 : const auto *SA = cast<FormatAttr>(A);
421 2 : if (SA->getType())
422 4 : OS << " " << SA->getType()->getName();
423 2 : OS << " " << SA->getFormatIdx();
424 2 : OS << " " << SA->getFirstArg();
425 : break;
426 : }
427 0 : case attr::FormatArg: {
428 : const auto *SA = cast<FormatArgAttr>(A);
429 0 : OS << " " << SA->getFormatIdx().getSourceIndex();
430 0 : break;
431 : }
432 : case attr::GNUInline: {
433 : break;
434 : }
435 2 : case attr::GuardedBy: {
436 : const auto *SA = cast<GuardedByAttr>(A);
437 2 : dumpStmt(SA->getArg());
438 : break;
439 : }
440 : case attr::GuardedVar: {
441 : break;
442 : }
443 : case attr::Hot: {
444 : break;
445 : }
446 : case attr::IBAction: {
447 : break;
448 : }
449 : case attr::IBOutlet: {
450 : break;
451 : }
452 0 : case attr::IBOutletCollection: {
453 : const auto *SA = cast<IBOutletCollectionAttr>(A);
454 0 : OS << " " << SA->getInterface().getAsString();
455 0 : break;
456 : }
457 0 : case attr::IFunc: {
458 : const auto *SA = cast<IFuncAttr>(A);
459 0 : OS << " \"" << SA->getResolver() << "\"";
460 0 : break;
461 : }
462 0 : case attr::InitPriority: {
463 : const auto *SA = cast<InitPriorityAttr>(A);
464 0 : OS << " " << SA->getPriority();
465 : break;
466 : }
467 0 : case attr::InitSeg: {
468 : const auto *SA = cast<InitSegAttr>(A);
469 0 : OS << " \"" << SA->getSection() << "\"";
470 0 : break;
471 : }
472 : case attr::IntelOclBicc: {
473 : break;
474 : }
475 : case attr::InternalLinkage: {
476 : break;
477 : }
478 : case attr::LTOVisibilityPublic: {
479 : break;
480 : }
481 0 : case attr::LayoutVersion: {
482 : const auto *SA = cast<LayoutVersionAttr>(A);
483 0 : OS << " " << SA->getVersion();
484 : break;
485 : }
486 0 : case attr::LockReturned: {
487 : const auto *SA = cast<LockReturnedAttr>(A);
488 0 : dumpStmt(SA->getArg());
489 : break;
490 : }
491 0 : case attr::LocksExcluded: {
492 : const auto *SA = cast<LocksExcludedAttr>(A);
493 0 : for (LocksExcludedAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
494 0 : dumpStmt(*I);
495 : break;
496 : }
497 1 : case attr::LoopHint: {
498 2 : OS << " " << A->getSpelling();
499 : const auto *SA = cast<LoopHintAttr>(A);
500 1 : switch(SA->getOption()) {
501 0 : case LoopHintAttr::Vectorize:
502 0 : OS << " Vectorize";
503 0 : break;
504 0 : case LoopHintAttr::VectorizeWidth:
505 0 : OS << " VectorizeWidth";
506 0 : break;
507 0 : case LoopHintAttr::Interleave:
508 0 : OS << " Interleave";
509 0 : break;
510 0 : case LoopHintAttr::InterleaveCount:
511 0 : OS << " InterleaveCount";
512 0 : break;
513 1 : case LoopHintAttr::Unroll:
514 1 : OS << " Unroll";
515 1 : break;
516 0 : case LoopHintAttr::UnrollCount:
517 0 : OS << " UnrollCount";
518 0 : break;
519 0 : case LoopHintAttr::Distribute:
520 0 : OS << " Distribute";
521 0 : break;
522 : }
523 1 : switch(SA->getState()) {
524 1 : case LoopHintAttr::Enable:
525 1 : OS << " Enable";
526 1 : break;
527 0 : case LoopHintAttr::Disable:
528 0 : OS << " Disable";
529 0 : break;
530 0 : case LoopHintAttr::Numeric:
531 0 : OS << " Numeric";
532 0 : break;
533 0 : case LoopHintAttr::AssumeSafety:
534 0 : OS << " AssumeSafety";
535 0 : break;
536 0 : case LoopHintAttr::Full:
537 0 : OS << " Full";
538 0 : break;
539 : }
540 1 : dumpStmt(SA->getValue());
541 : break;
542 : }
543 : case attr::MSABI: {
544 : break;
545 : }
546 0 : case attr::MSInheritance: {
547 0 : OS << " " << A->getSpelling();
548 : const auto *SA = cast<MSInheritanceAttr>(A);
549 0 : if (SA->getBestCase()) OS << " BestCase";
550 : break;
551 : }
552 : case attr::MSNoVTable: {
553 : break;
554 : }
555 1 : case attr::MSP430Interrupt: {
556 : const auto *SA = cast<MSP430InterruptAttr>(A);
557 1 : OS << " " << SA->getNumber();
558 : break;
559 : }
560 : case attr::MSStruct: {
561 : break;
562 : }
563 0 : case attr::MSVtorDisp: {
564 : const auto *SA = cast<MSVtorDispAttr>(A);
565 0 : OS << " " << SA->getVdm();
566 : break;
567 : }
568 27 : case attr::MaxFieldAlignment: {
569 : const auto *SA = cast<MaxFieldAlignmentAttr>(A);
570 27 : OS << " " << SA->getAlignment();
571 : break;
572 : }
573 : case attr::MayAlias: {
574 : break;
575 : }
576 : case attr::MicroMips: {
577 : break;
578 : }
579 : case attr::MinSize: {
580 : break;
581 : }
582 0 : case attr::MinVectorWidth: {
583 : const auto *SA = cast<MinVectorWidthAttr>(A);
584 0 : OS << " " << SA->getVectorWidth();
585 : break;
586 : }
587 : case attr::Mips16: {
588 : break;
589 : }
590 0 : case attr::MipsInterrupt: {
591 : const auto *SA = cast<MipsInterruptAttr>(A);
592 0 : switch(SA->getInterrupt()) {
593 0 : case MipsInterruptAttr::sw0:
594 0 : OS << " sw0";
595 0 : break;
596 0 : case MipsInterruptAttr::sw1:
597 0 : OS << " sw1";
598 0 : break;
599 0 : case MipsInterruptAttr::hw0:
600 0 : OS << " hw0";
601 0 : break;
602 0 : case MipsInterruptAttr::hw1:
603 0 : OS << " hw1";
604 0 : break;
605 0 : case MipsInterruptAttr::hw2:
606 0 : OS << " hw2";
607 0 : break;
608 0 : case MipsInterruptAttr::hw3:
609 0 : OS << " hw3";
610 0 : break;
611 0 : case MipsInterruptAttr::hw4:
612 0 : OS << " hw4";
613 0 : break;
614 0 : case MipsInterruptAttr::hw5:
615 0 : OS << " hw5";
616 0 : break;
617 0 : case MipsInterruptAttr::eic:
618 0 : OS << " eic";
619 0 : break;
620 : }
621 : break;
622 : }
623 0 : case attr::MipsLongCall: {
624 0 : OS << " " << A->getSpelling();
625 0 : break;
626 : }
627 0 : case attr::MipsShortCall: {
628 0 : OS << " " << A->getSpelling();
629 0 : break;
630 : }
631 0 : case attr::Mode: {
632 : const auto *SA = cast<ModeAttr>(A);
633 0 : if (SA->getMode())
634 0 : OS << " " << SA->getMode()->getName();
635 : break;
636 : }
637 : case attr::NSConsumed: {
638 : break;
639 : }
640 : case attr::NSConsumesSelf: {
641 : break;
642 : }
643 : case attr::NSReturnsAutoreleased: {
644 : break;
645 : }
646 : case attr::NSReturnsNotRetained: {
647 : break;
648 : }
649 : case attr::NSReturnsRetained: {
650 : break;
651 : }
652 : case attr::Naked: {
653 : break;
654 : }
655 : case attr::NoAlias: {
656 : break;
657 : }
658 : case attr::NoCommon: {
659 : break;
660 : }
661 : case attr::NoDebug: {
662 : break;
663 : }
664 : case attr::NoDuplicate: {
665 : break;
666 : }
667 : case attr::NoEscape: {
668 : break;
669 : }
670 : case attr::NoInline: {
671 : break;
672 : }
673 : case attr::NoInstrumentFunction: {
674 : break;
675 : }
676 : case attr::NoMicroMips: {
677 : break;
678 : }
679 : case attr::NoMips16: {
680 : break;
681 : }
682 : case attr::NoReturn: {
683 : break;
684 : }
685 5 : case attr::NoSanitize: {
686 : const auto *SA = cast<NoSanitizeAttr>(A);
687 19 : for (const auto &Val : SA->sanitizers())
688 7 : OS << " " << Val;
689 : break;
690 : }
691 : case attr::NoSplitStack: {
692 : break;
693 : }
694 : case attr::NoStackProtector: {
695 : break;
696 : }
697 : case attr::NoThreadSafetyAnalysis: {
698 : break;
699 : }
700 : case attr::NoThrow: {
701 : break;
702 : }
703 0 : case attr::NonNull: {
704 : const auto *SA = cast<NonNullAttr>(A);
705 0 : for (const auto &Val : SA->args())
706 0 : OS << " " << Val.getSourceIndex();
707 : break;
708 : }
709 : case attr::NotTailCalled: {
710 : break;
711 : }
712 0 : case attr::OMPCaptureKind: {
713 : const auto *SA = cast<OMPCaptureKindAttr>(A);
714 0 : OS << " " << SA->getCaptureKind();
715 : break;
716 : }
717 : case attr::OMPCaptureNoInit: {
718 : break;
719 : }
720 4 : case attr::OMPDeclareSimdDecl: {
721 : const auto *SA = cast<OMPDeclareSimdDeclAttr>(A);
722 4 : switch(SA->getBranchState()) {
723 2 : case OMPDeclareSimdDeclAttr::BS_Undefined:
724 2 : OS << " BS_Undefined";
725 2 : break;
726 2 : case OMPDeclareSimdDeclAttr::BS_Inbranch:
727 2 : OS << " BS_Inbranch";
728 2 : break;
729 0 : case OMPDeclareSimdDeclAttr::BS_Notinbranch:
730 0 : OS << " BS_Notinbranch";
731 0 : break;
732 : }
733 4 : for (const auto &Val : SA->modifiers())
734 0 : OS << " " << Val;
735 4 : dumpStmt(SA->getSimdlen());
736 8 : for (OMPDeclareSimdDeclAttr::uniforms_iterator I = SA->uniforms_begin(), E = SA->uniforms_end(); I != E; ++I)
737 0 : dumpStmt(*I);
738 8 : for (OMPDeclareSimdDeclAttr::aligneds_iterator I = SA->aligneds_begin(), E = SA->aligneds_end(); I != E; ++I)
739 0 : dumpStmt(*I);
740 8 : for (OMPDeclareSimdDeclAttr::alignments_iterator I = SA->alignments_begin(), E = SA->alignments_end(); I != E; ++I)
741 0 : dumpStmt(*I);
742 8 : for (OMPDeclareSimdDeclAttr::linears_iterator I = SA->linears_begin(), E = SA->linears_end(); I != E; ++I)
743 0 : dumpStmt(*I);
744 8 : for (OMPDeclareSimdDeclAttr::steps_iterator I = SA->steps_begin(), E = SA->steps_end(); I != E; ++I)
745 0 : dumpStmt(*I);
746 : break;
747 : }
748 2 : case attr::OMPDeclareTargetDecl: {
749 : const auto *SA = cast<OMPDeclareTargetDeclAttr>(A);
750 2 : switch(SA->getMapType()) {
751 2 : case OMPDeclareTargetDeclAttr::MT_To:
752 2 : OS << " MT_To";
753 2 : break;
754 0 : case OMPDeclareTargetDeclAttr::MT_Link:
755 0 : OS << " MT_Link";
756 0 : break;
757 : }
758 : break;
759 : }
760 0 : case attr::OMPReferencedVar: {
761 : const auto *SA = cast<OMPReferencedVarAttr>(A);
762 0 : dumpStmt(SA->getRef());
763 : break;
764 : }
765 : case attr::OMPThreadPrivateDecl: {
766 : break;
767 : }
768 : case attr::ObjCBoxable: {
769 : break;
770 : }
771 0 : case attr::ObjCBridge: {
772 : const auto *SA = cast<ObjCBridgeAttr>(A);
773 0 : if (SA->getBridgedType())
774 0 : OS << " " << SA->getBridgedType()->getName();
775 : break;
776 : }
777 0 : case attr::ObjCBridgeMutable: {
778 : const auto *SA = cast<ObjCBridgeMutableAttr>(A);
779 0 : if (SA->getBridgedType())
780 0 : OS << " " << SA->getBridgedType()->getName();
781 : break;
782 : }
783 1 : case attr::ObjCBridgeRelated: {
784 : const auto *SA = cast<ObjCBridgeRelatedAttr>(A);
785 1 : if (SA->getRelatedClass())
786 2 : OS << " " << SA->getRelatedClass()->getName();
787 1 : if (SA->getClassMethod())
788 0 : OS << " " << SA->getClassMethod()->getName();
789 1 : if (SA->getInstanceMethod())
790 0 : OS << " " << SA->getInstanceMethod()->getName();
791 : break;
792 : }
793 : case attr::ObjCDesignatedInitializer: {
794 : break;
795 : }
796 : case attr::ObjCException: {
797 : break;
798 : }
799 : case attr::ObjCExplicitProtocolImpl: {
800 : break;
801 : }
802 : case attr::ObjCIndependentClass: {
803 : break;
804 : }
805 0 : case attr::ObjCMethodFamily: {
806 : const auto *SA = cast<ObjCMethodFamilyAttr>(A);
807 0 : switch(SA->getFamily()) {
808 0 : case ObjCMethodFamilyAttr::OMF_None:
809 0 : OS << " OMF_None";
810 0 : break;
811 0 : case ObjCMethodFamilyAttr::OMF_alloc:
812 0 : OS << " OMF_alloc";
813 0 : break;
814 0 : case ObjCMethodFamilyAttr::OMF_copy:
815 0 : OS << " OMF_copy";
816 0 : break;
817 0 : case ObjCMethodFamilyAttr::OMF_init:
818 0 : OS << " OMF_init";
819 0 : break;
820 0 : case ObjCMethodFamilyAttr::OMF_mutableCopy:
821 0 : OS << " OMF_mutableCopy";
822 0 : break;
823 0 : case ObjCMethodFamilyAttr::OMF_new:
824 0 : OS << " OMF_new";
825 0 : break;
826 : }
827 : break;
828 : }
829 : case attr::ObjCNSObject: {
830 : break;
831 : }
832 : case attr::ObjCPreciseLifetime: {
833 : break;
834 : }
835 : case attr::ObjCRequiresPropertyDefs: {
836 : break;
837 : }
838 : case attr::ObjCRequiresSuper: {
839 : break;
840 : }
841 : case attr::ObjCReturnsInnerPointer: {
842 : break;
843 : }
844 : case attr::ObjCRootClass: {
845 : break;
846 : }
847 1 : case attr::ObjCRuntimeName: {
848 : const auto *SA = cast<ObjCRuntimeNameAttr>(A);
849 2 : OS << " \"" << SA->getMetadataName() << "\"";
850 1 : break;
851 : }
852 : case attr::ObjCRuntimeVisible: {
853 : break;
854 : }
855 : case attr::ObjCSubclassingRestricted: {
856 : break;
857 : }
858 2 : case attr::OpenCLAccess: {
859 4 : OS << " " << A->getSpelling();
860 2 : break;
861 : }
862 0 : case attr::OpenCLIntelReqdSubGroupSize: {
863 : const auto *SA = cast<OpenCLIntelReqdSubGroupSizeAttr>(A);
864 0 : OS << " " << SA->getSubGroupSize();
865 : break;
866 : }
867 : case attr::OpenCLKernel: {
868 : break;
869 : }
870 0 : case attr::OpenCLUnrollHint: {
871 : const auto *SA = cast<OpenCLUnrollHintAttr>(A);
872 0 : OS << " " << SA->getUnrollHint();
873 : break;
874 : }
875 : case attr::OptimizeNone: {
876 : break;
877 : }
878 : case attr::Overloadable: {
879 : break;
880 : }
881 : case attr::Override: {
882 : break;
883 : }
884 0 : case attr::Ownership: {
885 0 : OS << " " << A->getSpelling();
886 : const auto *SA = cast<OwnershipAttr>(A);
887 0 : if (SA->getModule())
888 0 : OS << " " << SA->getModule()->getName();
889 0 : for (const auto &Val : SA->args())
890 0 : OS << " " << Val.getSourceIndex();
891 : break;
892 : }
893 : case attr::Packed: {
894 : break;
895 : }
896 0 : case attr::ParamTypestate: {
897 : const auto *SA = cast<ParamTypestateAttr>(A);
898 0 : switch(SA->getParamState()) {
899 0 : case ParamTypestateAttr::Unknown:
900 0 : OS << " Unknown";
901 0 : break;
902 0 : case ParamTypestateAttr::Consumed:
903 0 : OS << " Consumed";
904 0 : break;
905 0 : case ParamTypestateAttr::Unconsumed:
906 0 : OS << " Unconsumed";
907 0 : break;
908 : }
909 : break;
910 : }
911 : case attr::Pascal: {
912 : break;
913 : }
914 0 : case attr::PassObjectSize: {
915 : const auto *SA = cast<PassObjectSizeAttr>(A);
916 0 : OS << " " << SA->getType();
917 : break;
918 : }
919 0 : case attr::Pcs: {
920 : const auto *SA = cast<PcsAttr>(A);
921 0 : switch(SA->getPCS()) {
922 0 : case PcsAttr::AAPCS:
923 0 : OS << " AAPCS";
924 0 : break;
925 0 : case PcsAttr::AAPCS_VFP:
926 0 : OS << " AAPCS_VFP";
927 0 : break;
928 : }
929 : break;
930 : }
931 0 : case attr::PragmaClangBSSSection: {
932 : const auto *SA = cast<PragmaClangBSSSectionAttr>(A);
933 0 : OS << " \"" << SA->getName() << "\"";
934 0 : break;
935 : }
936 0 : case attr::PragmaClangDataSection: {
937 : const auto *SA = cast<PragmaClangDataSectionAttr>(A);
938 0 : OS << " \"" << SA->getName() << "\"";
939 0 : break;
940 : }
941 0 : case attr::PragmaClangRodataSection: {
942 : const auto *SA = cast<PragmaClangRodataSectionAttr>(A);
943 0 : OS << " \"" << SA->getName() << "\"";
944 0 : break;
945 : }
946 0 : case attr::PragmaClangTextSection: {
947 : const auto *SA = cast<PragmaClangTextSectionAttr>(A);
948 0 : OS << " \"" << SA->getName() << "\"";
949 0 : break;
950 : }
951 : case attr::PreserveAll: {
952 : break;
953 : }
954 : case attr::PreserveMost: {
955 : break;
956 : }
957 0 : case attr::PtGuardedBy: {
958 : const auto *SA = cast<PtGuardedByAttr>(A);
959 0 : dumpStmt(SA->getArg());
960 : break;
961 : }
962 : case attr::PtGuardedVar: {
963 : break;
964 : }
965 : case attr::Pure: {
966 : break;
967 : }
968 : case attr::RegCall: {
969 : break;
970 : }
971 0 : case attr::ReleaseCapability: {
972 0 : OS << " " << A->getSpelling();
973 : const auto *SA = cast<ReleaseCapabilityAttr>(A);
974 0 : for (ReleaseCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
975 0 : dumpStmt(*I);
976 : break;
977 : }
978 : case attr::RenderScriptKernel: {
979 : break;
980 : }
981 0 : case attr::ReqdWorkGroupSize: {
982 : const auto *SA = cast<ReqdWorkGroupSizeAttr>(A);
983 0 : OS << " " << SA->getXDim();
984 0 : OS << " " << SA->getYDim();
985 0 : OS << " " << SA->getZDim();
986 : break;
987 : }
988 : case attr::RequireConstantInit: {
989 : break;
990 : }
991 0 : case attr::RequiresCapability: {
992 0 : OS << " " << A->getSpelling();
993 : const auto *SA = cast<RequiresCapabilityAttr>(A);
994 0 : for (RequiresCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
995 0 : dumpStmt(*I);
996 : break;
997 : }
998 0 : case attr::Restrict: {
999 0 : OS << " " << A->getSpelling();
1000 0 : break;
1001 : }
1002 0 : case attr::ReturnTypestate: {
1003 : const auto *SA = cast<ReturnTypestateAttr>(A);
1004 0 : switch(SA->getState()) {
1005 0 : case ReturnTypestateAttr::Unknown:
1006 0 : OS << " Unknown";
1007 0 : break;
1008 0 : case ReturnTypestateAttr::Consumed:
1009 0 : OS << " Consumed";
1010 0 : break;
1011 0 : case ReturnTypestateAttr::Unconsumed:
1012 0 : OS << " Unconsumed";
1013 0 : break;
1014 : }
1015 : break;
1016 : }
1017 : case attr::ReturnsNonNull: {
1018 : break;
1019 : }
1020 : case attr::ReturnsTwice: {
1021 : break;
1022 : }
1023 : case attr::ScopedLockable: {
1024 : break;
1025 : }
1026 0 : case attr::Section: {
1027 0 : OS << " " << A->getSpelling();
1028 : const auto *SA = cast<SectionAttr>(A);
1029 0 : OS << " \"" << SA->getName() << "\"";
1030 0 : break;
1031 : }
1032 : case attr::SelectAny: {
1033 : break;
1034 : }
1035 0 : case attr::Sentinel: {
1036 : const auto *SA = cast<SentinelAttr>(A);
1037 0 : OS << " " << SA->getSentinel();
1038 0 : OS << " " << SA->getNullPos();
1039 : break;
1040 : }
1041 0 : case attr::SetTypestate: {
1042 : const auto *SA = cast<SetTypestateAttr>(A);
1043 0 : switch(SA->getNewState()) {
1044 0 : case SetTypestateAttr::Unknown:
1045 0 : OS << " Unknown";
1046 0 : break;
1047 0 : case SetTypestateAttr::Consumed:
1048 0 : OS << " Consumed";
1049 0 : break;
1050 0 : case SetTypestateAttr::Unconsumed:
1051 0 : OS << " Unconsumed";
1052 0 : break;
1053 : }
1054 : break;
1055 : }
1056 0 : case attr::SharedTrylockFunction: {
1057 : const auto *SA = cast<SharedTrylockFunctionAttr>(A);
1058 0 : dumpStmt(SA->getSuccessValue());
1059 0 : for (SharedTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
1060 0 : dumpStmt(*I);
1061 : break;
1062 : }
1063 : case attr::StdCall: {
1064 : break;
1065 : }
1066 3 : case attr::Suppress: {
1067 : const auto *SA = cast<SuppressAttr>(A);
1068 9 : for (const auto &Val : SA->diagnosticIdentifiers())
1069 3 : OS << " " << Val;
1070 : break;
1071 : }
1072 : case attr::SwiftCall: {
1073 : break;
1074 : }
1075 : case attr::SwiftContext: {
1076 : break;
1077 : }
1078 : case attr::SwiftErrorResult: {
1079 : break;
1080 : }
1081 : case attr::SwiftIndirectResult: {
1082 : break;
1083 : }
1084 : case attr::SysVABI: {
1085 : break;
1086 : }
1087 0 : case attr::TLSModel: {
1088 : const auto *SA = cast<TLSModelAttr>(A);
1089 0 : OS << " \"" << SA->getModel() << "\"";
1090 0 : break;
1091 : }
1092 0 : case attr::Target: {
1093 : const auto *SA = cast<TargetAttr>(A);
1094 0 : OS << " \"" << SA->getFeaturesStr() << "\"";
1095 0 : break;
1096 : }
1097 0 : case attr::TestTypestate: {
1098 : const auto *SA = cast<TestTypestateAttr>(A);
1099 0 : switch(SA->getTestState()) {
1100 0 : case TestTypestateAttr::Consumed:
1101 0 : OS << " Consumed";
1102 0 : break;
1103 0 : case TestTypestateAttr::Unconsumed:
1104 0 : OS << " Unconsumed";
1105 0 : break;
1106 : }
1107 : break;
1108 : }
1109 : case attr::ThisCall: {
1110 : break;
1111 : }
1112 : case attr::Thread: {
1113 : break;
1114 : }
1115 : case attr::TransparentUnion: {
1116 : break;
1117 : }
1118 : case attr::TrivialABI: {
1119 : break;
1120 : }
1121 0 : case attr::TryAcquireCapability: {
1122 0 : OS << " " << A->getSpelling();
1123 : const auto *SA = cast<TryAcquireCapabilityAttr>(A);
1124 0 : dumpStmt(SA->getSuccessValue());
1125 0 : for (TryAcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
1126 0 : dumpStmt(*I);
1127 : break;
1128 : }
1129 1 : case attr::TypeTagForDatatype: {
1130 : const auto *SA = cast<TypeTagForDatatypeAttr>(A);
1131 1 : if (SA->getArgumentKind())
1132 2 : OS << " " << SA->getArgumentKind()->getName();
1133 3 : OS << " " << SA->getMatchingCType().getAsString();
1134 1 : if (SA->getLayoutCompatible()) OS << " LayoutCompatible";
1135 1 : if (SA->getMustBeNull()) OS << " MustBeNull";
1136 : break;
1137 : }
1138 0 : case attr::TypeVisibility: {
1139 : const auto *SA = cast<TypeVisibilityAttr>(A);
1140 0 : switch(SA->getVisibility()) {
1141 0 : case TypeVisibilityAttr::Default:
1142 0 : OS << " Default";
1143 0 : break;
1144 0 : case TypeVisibilityAttr::Hidden:
1145 0 : OS << " Hidden";
1146 0 : break;
1147 0 : case TypeVisibilityAttr::Protected:
1148 0 : OS << " Protected";
1149 0 : break;
1150 : }
1151 : break;
1152 : }
1153 0 : case attr::Unavailable: {
1154 : const auto *SA = cast<UnavailableAttr>(A);
1155 0 : OS << " \"" << SA->getMessage() << "\"";
1156 0 : switch(SA->getImplicitReason()) {
1157 0 : case UnavailableAttr::IR_None:
1158 0 : OS << " IR_None";
1159 0 : break;
1160 0 : case UnavailableAttr::IR_ARCForbiddenType:
1161 0 : OS << " IR_ARCForbiddenType";
1162 0 : break;
1163 0 : case UnavailableAttr::IR_ForbiddenWeak:
1164 0 : OS << " IR_ForbiddenWeak";
1165 0 : break;
1166 0 : case UnavailableAttr::IR_ARCForbiddenConversion:
1167 0 : OS << " IR_ARCForbiddenConversion";
1168 0 : break;
1169 0 : case UnavailableAttr::IR_ARCInitReturnsUnrelated:
1170 0 : OS << " IR_ARCInitReturnsUnrelated";
1171 0 : break;
1172 0 : case UnavailableAttr::IR_ARCFieldWithOwnership:
1173 0 : OS << " IR_ARCFieldWithOwnership";
1174 0 : break;
1175 : }
1176 : break;
1177 : }
1178 4 : case attr::Unused: {
1179 8 : OS << " " << A->getSpelling();
1180 4 : break;
1181 : }
1182 : case attr::Used: {
1183 : break;
1184 : }
1185 0 : case attr::Uuid: {
1186 : const auto *SA = cast<UuidAttr>(A);
1187 0 : OS << " \"" << SA->getGuid() << "\"";
1188 0 : break;
1189 : }
1190 : case attr::VecReturn: {
1191 : break;
1192 : }
1193 0 : case attr::VecTypeHint: {
1194 : const auto *SA = cast<VecTypeHintAttr>(A);
1195 0 : OS << " " << SA->getTypeHint().getAsString();
1196 0 : break;
1197 : }
1198 : case attr::VectorCall: {
1199 : break;
1200 : }
1201 37 : case attr::Visibility: {
1202 : const auto *SA = cast<VisibilityAttr>(A);
1203 37 : switch(SA->getVisibility()) {
1204 37 : case VisibilityAttr::Default:
1205 37 : OS << " Default";
1206 37 : break;
1207 0 : case VisibilityAttr::Hidden:
1208 0 : OS << " Hidden";
1209 0 : break;
1210 0 : case VisibilityAttr::Protected:
1211 0 : OS << " Protected";
1212 0 : break;
1213 : }
1214 : break;
1215 : }
1216 : case attr::WarnUnused: {
1217 : break;
1218 : }
1219 1 : case attr::WarnUnusedResult: {
1220 2 : OS << " " << A->getSpelling();
1221 1 : break;
1222 : }
1223 : case attr::Weak: {
1224 : break;
1225 : }
1226 : case attr::WeakImport: {
1227 : break;
1228 : }
1229 0 : case attr::WeakRef: {
1230 : const auto *SA = cast<WeakRefAttr>(A);
1231 0 : OS << " \"" << SA->getAliasee() << "\"";
1232 0 : break;
1233 : }
1234 0 : case attr::WorkGroupSizeHint: {
1235 : const auto *SA = cast<WorkGroupSizeHintAttr>(A);
1236 0 : OS << " " << SA->getXDim();
1237 0 : OS << " " << SA->getYDim();
1238 0 : OS << " " << SA->getZDim();
1239 : break;
1240 : }
1241 : case attr::X86ForceAlignArgPointer: {
1242 : break;
1243 : }
1244 0 : case attr::XRayInstrument: {
1245 0 : OS << " " << A->getSpelling();
1246 0 : break;
1247 : }
1248 0 : case attr::XRayLogArgs: {
1249 : const auto *SA = cast<XRayLogArgsAttr>(A);
1250 0 : OS << " " << SA->getArgumentCount();
1251 : break;
1252 : }
1253 : }
|
