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