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