Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 1 | /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
| 2 | |* *| |
||
| 3 | |* Attribute text node traverser *| |
||
| 4 | |* *| |
||
| 5 | |* Automatically generated file, do not edit! *| |
||
| 6 | |* *| |
||
| 7 | \*===----------------------------------------------------------------------===*/ |
||
| 8 | |||
| 9 | void VisitAMDGPUFlatWorkGroupSizeAttr(const AMDGPUFlatWorkGroupSizeAttr *A) { |
||
| 10 | const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A); (void)SA; |
||
| 11 | Visit(SA->getMin()); |
||
| 12 | Visit(SA->getMax()); |
||
| 13 | } |
||
| 14 | void VisitAMDGPUWavesPerEUAttr(const AMDGPUWavesPerEUAttr *A) { |
||
| 15 | const auto *SA = cast<AMDGPUWavesPerEUAttr>(A); (void)SA; |
||
| 16 | Visit(SA->getMin()); |
||
| 17 | Visit(SA->getMax()); |
||
| 18 | } |
||
| 19 | void VisitAcquireCapabilityAttr(const AcquireCapabilityAttr *A) { |
||
| 20 | const auto *SA = cast<AcquireCapabilityAttr>(A); (void)SA; |
||
| 21 | for (AcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 22 | Visit(*I); |
||
| 23 | } |
||
| 24 | void VisitAcquiredAfterAttr(const AcquiredAfterAttr *A) { |
||
| 25 | const auto *SA = cast<AcquiredAfterAttr>(A); (void)SA; |
||
| 26 | for (AcquiredAfterAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 27 | Visit(*I); |
||
| 28 | } |
||
| 29 | void VisitAcquiredBeforeAttr(const AcquiredBeforeAttr *A) { |
||
| 30 | const auto *SA = cast<AcquiredBeforeAttr>(A); (void)SA; |
||
| 31 | for (AcquiredBeforeAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 32 | Visit(*I); |
||
| 33 | } |
||
| 34 | void VisitAlignValueAttr(const AlignValueAttr *A) { |
||
| 35 | const auto *SA = cast<AlignValueAttr>(A); (void)SA; |
||
| 36 | Visit(SA->getAlignment()); |
||
| 37 | } |
||
| 38 | void VisitAlignedAttr(const AlignedAttr *A) { |
||
| 39 | const auto *SA = cast<AlignedAttr>(A); (void)SA; |
||
| 40 | if (SA->isAlignmentExpr()) |
||
| 41 | Visit(SA->getAlignmentExpr()); |
||
| 42 | } |
||
| 43 | void VisitAnnotateAttr(const AnnotateAttr *A) { |
||
| 44 | const auto *SA = cast<AnnotateAttr>(A); (void)SA; |
||
| 45 | for (AnnotateAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 46 | Visit(*I); |
||
| 47 | for (AnnotateAttr::delayedArgs_iterator I = SA->delayedArgs_begin(), E = SA->delayedArgs_end(); I != E; ++I) |
||
| 48 | Visit(*I); |
||
| 49 | } |
||
| 50 | void VisitAnnotateTypeAttr(const AnnotateTypeAttr *A) { |
||
| 51 | const auto *SA = cast<AnnotateTypeAttr>(A); (void)SA; |
||
| 52 | for (AnnotateTypeAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 53 | Visit(*I); |
||
| 54 | for (AnnotateTypeAttr::delayedArgs_iterator I = SA->delayedArgs_begin(), E = SA->delayedArgs_end(); I != E; ++I) |
||
| 55 | Visit(*I); |
||
| 56 | } |
||
| 57 | void VisitAssertCapabilityAttr(const AssertCapabilityAttr *A) { |
||
| 58 | const auto *SA = cast<AssertCapabilityAttr>(A); (void)SA; |
||
| 59 | for (AssertCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 60 | Visit(*I); |
||
| 61 | } |
||
| 62 | void VisitAssertExclusiveLockAttr(const AssertExclusiveLockAttr *A) { |
||
| 63 | const auto *SA = cast<AssertExclusiveLockAttr>(A); (void)SA; |
||
| 64 | for (AssertExclusiveLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 65 | Visit(*I); |
||
| 66 | } |
||
| 67 | void VisitAssertSharedLockAttr(const AssertSharedLockAttr *A) { |
||
| 68 | const auto *SA = cast<AssertSharedLockAttr>(A); (void)SA; |
||
| 69 | for (AssertSharedLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 70 | Visit(*I); |
||
| 71 | } |
||
| 72 | void VisitAssumeAlignedAttr(const AssumeAlignedAttr *A) { |
||
| 73 | const auto *SA = cast<AssumeAlignedAttr>(A); (void)SA; |
||
| 74 | Visit(SA->getAlignment()); |
||
| 75 | Visit(SA->getOffset()); |
||
| 76 | } |
||
| 77 | void VisitCUDALaunchBoundsAttr(const CUDALaunchBoundsAttr *A) { |
||
| 78 | const auto *SA = cast<CUDALaunchBoundsAttr>(A); (void)SA; |
||
| 79 | Visit(SA->getMaxThreads()); |
||
| 80 | Visit(SA->getMinBlocks()); |
||
| 81 | } |
||
| 82 | void VisitDiagnoseIfAttr(const DiagnoseIfAttr *A) { |
||
| 83 | const auto *SA = cast<DiagnoseIfAttr>(A); (void)SA; |
||
| 84 | Visit(SA->getCond()); |
||
| 85 | } |
||
| 86 | void VisitEnableIfAttr(const EnableIfAttr *A) { |
||
| 87 | const auto *SA = cast<EnableIfAttr>(A); (void)SA; |
||
| 88 | Visit(SA->getCond()); |
||
| 89 | } |
||
| 90 | void VisitExclusiveTrylockFunctionAttr(const ExclusiveTrylockFunctionAttr *A) { |
||
| 91 | const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A); (void)SA; |
||
| 92 | Visit(SA->getSuccessValue()); |
||
| 93 | for (ExclusiveTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 94 | Visit(*I); |
||
| 95 | } |
||
| 96 | void VisitGuardedByAttr(const GuardedByAttr *A) { |
||
| 97 | const auto *SA = cast<GuardedByAttr>(A); (void)SA; |
||
| 98 | Visit(SA->getArg()); |
||
| 99 | } |
||
| 100 | void VisitLockReturnedAttr(const LockReturnedAttr *A) { |
||
| 101 | const auto *SA = cast<LockReturnedAttr>(A); (void)SA; |
||
| 102 | Visit(SA->getArg()); |
||
| 103 | } |
||
| 104 | void VisitLocksExcludedAttr(const LocksExcludedAttr *A) { |
||
| 105 | const auto *SA = cast<LocksExcludedAttr>(A); (void)SA; |
||
| 106 | for (LocksExcludedAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 107 | Visit(*I); |
||
| 108 | } |
||
| 109 | void VisitLoopHintAttr(const LoopHintAttr *A) { |
||
| 110 | const auto *SA = cast<LoopHintAttr>(A); (void)SA; |
||
| 111 | Visit(SA->getValue()); |
||
| 112 | } |
||
| 113 | void VisitOMPAllocateDeclAttr(const OMPAllocateDeclAttr *A) { |
||
| 114 | const auto *SA = cast<OMPAllocateDeclAttr>(A); (void)SA; |
||
| 115 | Visit(SA->getAllocator()); |
||
| 116 | Visit(SA->getAlignment()); |
||
| 117 | } |
||
| 118 | void VisitOMPDeclareSimdDeclAttr(const OMPDeclareSimdDeclAttr *A) { |
||
| 119 | const auto *SA = cast<OMPDeclareSimdDeclAttr>(A); (void)SA; |
||
| 120 | Visit(SA->getSimdlen()); |
||
| 121 | for (OMPDeclareSimdDeclAttr::uniforms_iterator I = SA->uniforms_begin(), E = SA->uniforms_end(); I != E; ++I) |
||
| 122 | Visit(*I); |
||
| 123 | for (OMPDeclareSimdDeclAttr::aligneds_iterator I = SA->aligneds_begin(), E = SA->aligneds_end(); I != E; ++I) |
||
| 124 | Visit(*I); |
||
| 125 | for (OMPDeclareSimdDeclAttr::alignments_iterator I = SA->alignments_begin(), E = SA->alignments_end(); I != E; ++I) |
||
| 126 | Visit(*I); |
||
| 127 | for (OMPDeclareSimdDeclAttr::linears_iterator I = SA->linears_begin(), E = SA->linears_end(); I != E; ++I) |
||
| 128 | Visit(*I); |
||
| 129 | for (OMPDeclareSimdDeclAttr::steps_iterator I = SA->steps_begin(), E = SA->steps_end(); I != E; ++I) |
||
| 130 | Visit(*I); |
||
| 131 | } |
||
| 132 | void VisitOMPDeclareTargetDeclAttr(const OMPDeclareTargetDeclAttr *A) { |
||
| 133 | const auto *SA = cast<OMPDeclareTargetDeclAttr>(A); (void)SA; |
||
| 134 | Visit(SA->getIndirectExpr()); |
||
| 135 | } |
||
| 136 | void VisitOMPDeclareVariantAttr(const OMPDeclareVariantAttr *A) { |
||
| 137 | const auto *SA = cast<OMPDeclareVariantAttr>(A); (void)SA; |
||
| 138 | Visit(SA->getVariantFuncRef()); |
||
| 139 | for (OMPDeclareVariantAttr::adjustArgsNothing_iterator I = SA->adjustArgsNothing_begin(), E = SA->adjustArgsNothing_end(); I != E; ++I) |
||
| 140 | Visit(*I); |
||
| 141 | for (OMPDeclareVariantAttr::adjustArgsNeedDevicePtr_iterator I = SA->adjustArgsNeedDevicePtr_begin(), E = SA->adjustArgsNeedDevicePtr_end(); I != E; ++I) |
||
| 142 | Visit(*I); |
||
| 143 | } |
||
| 144 | void VisitOMPReferencedVarAttr(const OMPReferencedVarAttr *A) { |
||
| 145 | const auto *SA = cast<OMPReferencedVarAttr>(A); (void)SA; |
||
| 146 | Visit(SA->getRef()); |
||
| 147 | } |
||
| 148 | void VisitPtGuardedByAttr(const PtGuardedByAttr *A) { |
||
| 149 | const auto *SA = cast<PtGuardedByAttr>(A); (void)SA; |
||
| 150 | Visit(SA->getArg()); |
||
| 151 | } |
||
| 152 | void VisitReleaseCapabilityAttr(const ReleaseCapabilityAttr *A) { |
||
| 153 | const auto *SA = cast<ReleaseCapabilityAttr>(A); (void)SA; |
||
| 154 | for (ReleaseCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 155 | Visit(*I); |
||
| 156 | } |
||
| 157 | void VisitRequiresCapabilityAttr(const RequiresCapabilityAttr *A) { |
||
| 158 | const auto *SA = cast<RequiresCapabilityAttr>(A); (void)SA; |
||
| 159 | for (RequiresCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 160 | Visit(*I); |
||
| 161 | } |
||
| 162 | void VisitSharedTrylockFunctionAttr(const SharedTrylockFunctionAttr *A) { |
||
| 163 | const auto *SA = cast<SharedTrylockFunctionAttr>(A); (void)SA; |
||
| 164 | Visit(SA->getSuccessValue()); |
||
| 165 | for (SharedTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 166 | Visit(*I); |
||
| 167 | } |
||
| 168 | void VisitTryAcquireCapabilityAttr(const TryAcquireCapabilityAttr *A) { |
||
| 169 | const auto *SA = cast<TryAcquireCapabilityAttr>(A); (void)SA; |
||
| 170 | Visit(SA->getSuccessValue()); |
||
| 171 | for (TryAcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I) |
||
| 172 | Visit(*I); |
||
| 173 | } |