1#ifdef GET_ASITagsList_DECL
2const ASITag *lookupASITagByEncoding(uint8_t Encoding);
3const ASITag *lookupASITagByAltName(StringRef AltName);
4const ASITag *lookupASITagByName(StringRef Name);
5StringRef getASITagStr(StringTable::Offset);
6#endif
7
8#ifdef GET_ASITagsList_IMPL
9constexpr ASITag ASITagsList[] = {
10 { 1 /* "ASI_N" */, 7 /* "ASI_NUCLEUS" */, 0x4 }, // 0
11 { 19 /* "ASI_N_L" */, 27 /* "ASI_NUCLEUS_LITTLE" */, 0xC }, // 1
12 { 46 /* "ASI_AIUP" */, 55 /* "ASI_AS_IF_USER_PRIMARY" */, 0x10 }, // 2
13 { 78 /* "ASI_AIUS" */, 87 /* "ASI_AS_IF_USER_SECONDARY" */, 0x11 }, // 3
14 { 112 /* "ASI_AIUP_L" */, 123 /* "ASI_AS_IF_USER_PRIMARY_LITTLE" */, 0x18 }, // 4
15 { 153 /* "ASI_AIUS_L" */, 164 /* "ASI_AS_IF_USER_SECONDARY_LITTLE" */, 0x19 }, // 5
16 { 196 /* "ASI_P" */, 202 /* "ASI_PRIMARY" */, 0x80 }, // 6
17 { 214 /* "ASI_S" */, 220 /* "ASI_SECONDARY" */, 0x81 }, // 7
18 { 234 /* "ASI_PNF" */, 242 /* "ASI_PRIMARY_NOFAULT" */, 0x82 }, // 8
19 { 262 /* "ASI_SNF" */, 270 /* "ASI_SECONDARY_NOFAULT" */, 0x83 }, // 9
20 { 292 /* "ASI_P_L" */, 300 /* "ASI_PRIMARY_LITTLE" */, 0x88 }, // 10
21 { 319 /* "ASI_S_L" */, 327 /* "ASI_SECONDARY_LITTLE" */, 0x89 }, // 11
22 { 348 /* "ASI_PNF_L" */, 358 /* "ASI_PRIMARY_NOFAULT_LITTLE" */, 0x8A }, // 12
23 { 385 /* "ASI_SNF_L" */, 395 /* "ASI_SECONDARY_NOFAULT_LITTLE" */, 0x8B }, // 13
24 };
25
26#ifdef __GNUC__
27#pragma GCC diagnostic push
28#pragma GCC diagnostic ignored "-Woverlength-strings"
29#endif
30static constexpr char ASITagsListStringsStorage[] =
31 "\0"
32 "ASI_N\0"
33 "ASI_NUCLEUS\0"
34 "ASI_N_L\0"
35 "ASI_NUCLEUS_LITTLE\0"
36 "ASI_AIUP\0"
37 "ASI_AS_IF_USER_PRIMARY\0"
38 "ASI_AIUS\0"
39 "ASI_AS_IF_USER_SECONDARY\0"
40 "ASI_AIUP_L\0"
41 "ASI_AS_IF_USER_PRIMARY_LITTLE\0"
42 "ASI_AIUS_L\0"
43 "ASI_AS_IF_USER_SECONDARY_LITTLE\0"
44 "ASI_P\0"
45 "ASI_PRIMARY\0"
46 "ASI_S\0"
47 "ASI_SECONDARY\0"
48 "ASI_PNF\0"
49 "ASI_PRIMARY_NOFAULT\0"
50 "ASI_SNF\0"
51 "ASI_SECONDARY_NOFAULT\0"
52 "ASI_P_L\0"
53 "ASI_PRIMARY_LITTLE\0"
54 "ASI_S_L\0"
55 "ASI_SECONDARY_LITTLE\0"
56 "ASI_PNF_L\0"
57 "ASI_PRIMARY_NOFAULT_LITTLE\0"
58 "ASI_SNF_L\0"
59 "ASI_SECONDARY_NOFAULT_LITTLE\0"
60 ;
61#ifdef __GNUC__
62#pragma GCC diagnostic pop
63#endif
64
65static constexpr llvm::StringTable
66ASITagsListStrings = ASITagsListStringsStorage;
67
68StringRef getASITagStr(StringTable::Offset Offset) {
69 return ASITagsListStrings[Offset];
70}
71
72const ASITag *lookupASITagByEncoding(uint8_t Encoding) {
73 struct KeyType {
74 uint8_t Encoding;
75 };
76 KeyType Key = {Encoding};
77 struct Comp {
78 bool operator()(const ASITag &LHS, const KeyType &RHS) const {
79 if (LHS.Encoding < RHS.Encoding)
80 return true;
81 if (LHS.Encoding > RHS.Encoding)
82 return false;
83 return false;
84 }
85 };
86 auto Table = ArrayRef(ASITagsList);
87 auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, Comp());
88 if (Idx == Table.end() ||
89 Key.Encoding != Idx->Encoding)
90 return nullptr;
91
92 return &*Idx;
93}
94
95const ASITag *lookupASITagByAltName(StringRef AltName) {
96 struct IndexType {
97 unsigned AltName;
98 unsigned _index;
99 };
100 static const struct IndexType Index[] = {
101 { 55 /* "ASI_AS_IF_USER_PRIMARY" */, 2 },
102 { 123 /* "ASI_AS_IF_USER_PRIMARY_LITTLE" */, 4 },
103 { 87 /* "ASI_AS_IF_USER_SECONDARY" */, 3 },
104 { 164 /* "ASI_AS_IF_USER_SECONDARY_LITTLE" */, 5 },
105 { 7 /* "ASI_NUCLEUS" */, 0 },
106 { 27 /* "ASI_NUCLEUS_LITTLE" */, 1 },
107 { 202 /* "ASI_PRIMARY" */, 6 },
108 { 300 /* "ASI_PRIMARY_LITTLE" */, 10 },
109 { 242 /* "ASI_PRIMARY_NOFAULT" */, 8 },
110 { 358 /* "ASI_PRIMARY_NOFAULT_LITTLE" */, 12 },
111 { 220 /* "ASI_SECONDARY" */, 7 },
112 { 327 /* "ASI_SECONDARY_LITTLE" */, 11 },
113 { 270 /* "ASI_SECONDARY_NOFAULT" */, 9 },
114 { 395 /* "ASI_SECONDARY_NOFAULT_LITTLE" */, 13 },
115 };
116
117 struct KeyType {
118 std::string AltName;
119 };
120 KeyType Key = {AltName.upper()};
121 struct Comp {
122 bool operator()(const IndexType &LHS, const KeyType &RHS) const {
123 StringRef LHSStr = ASITagsListStrings[LHS.AltName];
124 StringRef RHSStr = RHS.AltName;
125 int CmpAltName = LHSStr.compare(RHSStr);
126 if (CmpAltName < 0) return true;
127 if (CmpAltName > 0) return false;
128 return false;
129 }
130 };
131 auto Table = ArrayRef(Index);
132 auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, Comp());
133 if (Idx == Table.end() ||
134 Key.AltName != ASITagsListStrings[Idx->AltName])
135 return nullptr;
136
137 return &ASITagsList[Idx->_index];
138}
139
140const ASITag *lookupASITagByName(StringRef Name) {
141 struct IndexType {
142 unsigned Name;
143 unsigned _index;
144 };
145 static const struct IndexType Index[] = {
146 { 46 /* "ASI_AIUP" */, 2 },
147 { 112 /* "ASI_AIUP_L" */, 4 },
148 { 78 /* "ASI_AIUS" */, 3 },
149 { 153 /* "ASI_AIUS_L" */, 5 },
150 { 1 /* "ASI_N" */, 0 },
151 { 19 /* "ASI_N_L" */, 1 },
152 { 196 /* "ASI_P" */, 6 },
153 { 234 /* "ASI_PNF" */, 8 },
154 { 348 /* "ASI_PNF_L" */, 12 },
155 { 292 /* "ASI_P_L" */, 10 },
156 { 214 /* "ASI_S" */, 7 },
157 { 262 /* "ASI_SNF" */, 9 },
158 { 385 /* "ASI_SNF_L" */, 13 },
159 { 319 /* "ASI_S_L" */, 11 },
160 };
161
162 struct KeyType {
163 std::string Name;
164 };
165 KeyType Key = {Name.upper()};
166 struct Comp {
167 bool operator()(const IndexType &LHS, const KeyType &RHS) const {
168 StringRef LHSStr = ASITagsListStrings[LHS.Name];
169 StringRef RHSStr = RHS.Name;
170 int CmpName = LHSStr.compare(RHSStr);
171 if (CmpName < 0) return true;
172 if (CmpName > 0) return false;
173 return false;
174 }
175 };
176 auto Table = ArrayRef(Index);
177 auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, Comp());
178 if (Idx == Table.end() ||
179 Key.Name != ASITagsListStrings[Idx->Name])
180 return nullptr;
181
182 return &ASITagsList[Idx->_index];
183}
184#endif
185
186#ifdef GET_PrefetchTagsList_DECL
187const PrefetchTag *lookupPrefetchTagByEncoding(uint8_t Encoding);
188const PrefetchTag *lookupPrefetchTagByName(StringRef Name);
189StringRef getPrefetchTagStr(StringTable::Offset);
190#endif
191
192#ifdef GET_PrefetchTagsList_IMPL
193constexpr PrefetchTag PrefetchTagsList[] = {
194 { 1 /* "n_reads" */, 0x0 }, // 0
195 { 9 /* "one_read" */, 0x1 }, // 1
196 { 18 /* "n_writes" */, 0x2 }, // 2
197 { 27 /* "one_write" */, 0x3 }, // 3
198 { 37 /* "page" */, 0x4 }, // 4
199 { 42 /* "unified" */, 0x11 }, // 5
200 { 50 /* "n_reads_strong" */, 0x14 }, // 6
201 { 65 /* "one_read_strong" */, 0x15 }, // 7
202 { 81 /* "n_writes_strong" */, 0x16 }, // 8
203 { 97 /* "one_write_strong" */, 0x17 }, // 9
204 };
205
206#ifdef __GNUC__
207#pragma GCC diagnostic push
208#pragma GCC diagnostic ignored "-Woverlength-strings"
209#endif
210static constexpr char PrefetchTagsListStringsStorage[] =
211 "\0"
212 "n_reads\0"
213 "one_read\0"
214 "n_writes\0"
215 "one_write\0"
216 "page\0"
217 "unified\0"
218 "n_reads_strong\0"
219 "one_read_strong\0"
220 "n_writes_strong\0"
221 "one_write_strong\0"
222 "N_READS\0"
223 "N_READS_STRONG\0"
224 "N_WRITES\0"
225 "N_WRITES_STRONG\0"
226 "ONE_READ\0"
227 "ONE_READ_STRONG\0"
228 "ONE_WRITE\0"
229 "ONE_WRITE_STRONG\0"
230 "PAGE\0"
231 "UNIFIED\0"
232 ;
233#ifdef __GNUC__
234#pragma GCC diagnostic pop
235#endif
236
237static constexpr llvm::StringTable
238PrefetchTagsListStrings = PrefetchTagsListStringsStorage;
239
240StringRef getPrefetchTagStr(StringTable::Offset Offset) {
241 return PrefetchTagsListStrings[Offset];
242}
243
244const PrefetchTag *lookupPrefetchTagByEncoding(uint8_t Encoding) {
245 struct KeyType {
246 uint8_t Encoding;
247 };
248 KeyType Key = {Encoding};
249 struct Comp {
250 bool operator()(const PrefetchTag &LHS, const KeyType &RHS) const {
251 if (LHS.Encoding < RHS.Encoding)
252 return true;
253 if (LHS.Encoding > RHS.Encoding)
254 return false;
255 return false;
256 }
257 };
258 auto Table = ArrayRef(PrefetchTagsList);
259 auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, Comp());
260 if (Idx == Table.end() ||
261 Key.Encoding != Idx->Encoding)
262 return nullptr;
263
264 return &*Idx;
265}
266
267const PrefetchTag *lookupPrefetchTagByName(StringRef Name) {
268 struct IndexType {
269 unsigned Name;
270 unsigned _index;
271 };
272 static const struct IndexType Index[] = {
273 { 114 /* "N_READS" */, 0 },
274 { 122 /* "N_READS_STRONG" */, 6 },
275 { 137 /* "N_WRITES" */, 2 },
276 { 146 /* "N_WRITES_STRONG" */, 8 },
277 { 162 /* "ONE_READ" */, 1 },
278 { 171 /* "ONE_READ_STRONG" */, 7 },
279 { 187 /* "ONE_WRITE" */, 3 },
280 { 197 /* "ONE_WRITE_STRONG" */, 9 },
281 { 214 /* "PAGE" */, 4 },
282 { 219 /* "UNIFIED" */, 5 },
283 };
284
285 struct KeyType {
286 std::string Name;
287 };
288 KeyType Key = {Name.upper()};
289 struct Comp {
290 bool operator()(const IndexType &LHS, const KeyType &RHS) const {
291 StringRef LHSStr = PrefetchTagsListStrings[LHS.Name];
292 StringRef RHSStr = RHS.Name;
293 int CmpName = LHSStr.compare(RHSStr);
294 if (CmpName < 0) return true;
295 if (CmpName > 0) return false;
296 return false;
297 }
298 };
299 auto Table = ArrayRef(Index);
300 auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, Comp());
301 if (Idx == Table.end() ||
302 Key.Name != PrefetchTagsListStrings[Idx->Name])
303 return nullptr;
304
305 return &PrefetchTagsList[Idx->_index];
306}
307#endif
308
309#undef GET_ASITagsList_DECL
310#undef GET_ASITagsList_IMPL
311#undef GET_PrefetchTagsList_DECL
312#undef GET_PrefetchTagsList_IMPL
313