1 //===- ARMAttributeParser.cpp - ARM Attribute Information Printer ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/Support/ARMAttributeParser.h"
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/Support/Errc.h"
13 #include "llvm/Support/LEB128.h"
14 #include "llvm/Support/ScopedPrinter.h"
15
16 using namespace llvm;
17 using namespace llvm::ARMBuildAttrs;
18
19 #define ATTRIBUTE_HANDLER(attr) \
20 { ARMBuildAttrs::attr, &ARMAttributeParser::attr }
21
22 const ARMAttributeParser::DisplayHandler ARMAttributeParser::displayRoutines[] =
23 {
24 {ARMBuildAttrs::CPU_raw_name, &ARMAttributeParser::stringAttribute},
25 {ARMBuildAttrs::CPU_name, &ARMAttributeParser::stringAttribute},
26 ATTRIBUTE_HANDLER(CPU_arch),
27 ATTRIBUTE_HANDLER(CPU_arch_profile),
28 ATTRIBUTE_HANDLER(ARM_ISA_use),
29 ATTRIBUTE_HANDLER(THUMB_ISA_use),
30 ATTRIBUTE_HANDLER(FP_arch),
31 ATTRIBUTE_HANDLER(WMMX_arch),
32 ATTRIBUTE_HANDLER(Advanced_SIMD_arch),
33 ATTRIBUTE_HANDLER(MVE_arch),
34 ATTRIBUTE_HANDLER(PCS_config),
35 ATTRIBUTE_HANDLER(ABI_PCS_R9_use),
36 ATTRIBUTE_HANDLER(ABI_PCS_RW_data),
37 ATTRIBUTE_HANDLER(ABI_PCS_RO_data),
38 ATTRIBUTE_HANDLER(ABI_PCS_GOT_use),
39 ATTRIBUTE_HANDLER(ABI_PCS_wchar_t),
40 ATTRIBUTE_HANDLER(ABI_FP_rounding),
41 ATTRIBUTE_HANDLER(ABI_FP_denormal),
42 ATTRIBUTE_HANDLER(ABI_FP_exceptions),
43 ATTRIBUTE_HANDLER(ABI_FP_user_exceptions),
44 ATTRIBUTE_HANDLER(ABI_FP_number_model),
45 ATTRIBUTE_HANDLER(ABI_align_needed),
46 ATTRIBUTE_HANDLER(ABI_align_preserved),
47 ATTRIBUTE_HANDLER(ABI_enum_size),
48 ATTRIBUTE_HANDLER(ABI_HardFP_use),
49 ATTRIBUTE_HANDLER(ABI_VFP_args),
50 ATTRIBUTE_HANDLER(ABI_WMMX_args),
51 ATTRIBUTE_HANDLER(ABI_optimization_goals),
52 ATTRIBUTE_HANDLER(ABI_FP_optimization_goals),
53 ATTRIBUTE_HANDLER(compatibility),
54 ATTRIBUTE_HANDLER(CPU_unaligned_access),
55 ATTRIBUTE_HANDLER(FP_HP_extension),
56 ATTRIBUTE_HANDLER(ABI_FP_16bit_format),
57 ATTRIBUTE_HANDLER(MPextension_use),
58 ATTRIBUTE_HANDLER(DIV_use),
59 ATTRIBUTE_HANDLER(DSP_extension),
60 ATTRIBUTE_HANDLER(T2EE_use),
61 ATTRIBUTE_HANDLER(Virtualization_use),
62 ATTRIBUTE_HANDLER(nodefaults),
63 };
64
65 #undef ATTRIBUTE_HANDLER
66
stringAttribute(AttrType tag)67 Error ARMAttributeParser::stringAttribute(AttrType tag) {
68 StringRef tagName =
69 ELFAttrs::attrTypeAsString(tag, tagToStringMap, /*TagPrefix=*/false);
70 StringRef desc = de.getCStrRef(cursor);
71
72 if (sw) {
73 DictScope scope(*sw, "Attribute");
74 sw->printNumber("Tag", tag);
75 if (!tagName.empty())
76 sw->printString("TagName", tagName);
77 sw->printString("Value", desc);
78 }
79 return Error::success();
80 }
81
CPU_arch(AttrType tag)82 Error ARMAttributeParser::CPU_arch(AttrType tag) {
83 static const char *strings[] = {
84 "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
85 "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
86 "ARM v7E-M", "ARM v8", nullptr,
87 "ARM v8-M Baseline", "ARM v8-M Mainline", nullptr, nullptr, nullptr,
88 "ARM v8.1-M Mainline"
89 };
90 return parseStringAttribute("CPU_arch", tag, makeArrayRef(strings));
91 }
92
CPU_arch_profile(AttrType tag)93 Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
94 uint64_t value = de.getULEB128(cursor);
95
96 StringRef profile;
97 switch (value) {
98 default: profile = "Unknown"; break;
99 case 'A': profile = "Application"; break;
100 case 'R': profile = "Real-time"; break;
101 case 'M': profile = "Microcontroller"; break;
102 case 'S': profile = "Classic"; break;
103 case 0: profile = "None"; break;
104 }
105
106 printAttribute(tag, value, profile);
107 return Error::success();
108 }
109
ARM_ISA_use(AttrType tag)110 Error ARMAttributeParser::ARM_ISA_use(AttrType tag) {
111 static const char *strings[] = {"Not Permitted", "Permitted"};
112 return parseStringAttribute("ARM_ISA_use", tag, makeArrayRef(strings));
113 }
114
THUMB_ISA_use(AttrType tag)115 Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) {
116 static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", "Permitted"};
117 return parseStringAttribute("THUMB_ISA_use", tag, makeArrayRef(strings));
118 }
119
FP_arch(AttrType tag)120 Error ARMAttributeParser::FP_arch(AttrType tag) {
121 static const char *strings[] = {
122 "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16",
123 "VFPv4", "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"};
124 return parseStringAttribute("FP_arch", tag, makeArrayRef(strings));
125 }
126
WMMX_arch(AttrType tag)127 Error ARMAttributeParser::WMMX_arch(AttrType tag) {
128 static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
129 return parseStringAttribute("WMMX_arch", tag, makeArrayRef(strings));
130 }
131
Advanced_SIMD_arch(AttrType tag)132 Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) {
133 static const char *strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA",
134 "ARMv8-a NEON", "ARMv8.1-a NEON"};
135 return parseStringAttribute("Advanced_SIMD_arch", tag, makeArrayRef(strings));
136 }
137
MVE_arch(AttrType tag)138 Error ARMAttributeParser::MVE_arch(AttrType tag) {
139 static const char *strings[] = {"Not Permitted", "MVE integer",
140 "MVE integer and float"};
141 return parseStringAttribute("MVE_arch", tag, makeArrayRef(strings));
142 }
143
PCS_config(AttrType tag)144 Error ARMAttributeParser::PCS_config(AttrType tag) {
145 static const char *strings[] = {
146 "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
147 "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"};
148 return parseStringAttribute("PCS_config", tag, makeArrayRef(strings));
149 }
150
ABI_PCS_R9_use(AttrType tag)151 Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) {
152 static const char *strings[] = {"v6", "Static Base", "TLS", "Unused"};
153 return parseStringAttribute("ABI_PCS_R9_use", tag, makeArrayRef(strings));
154 }
155
ABI_PCS_RW_data(AttrType tag)156 Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) {
157 static const char *strings[] = {"Absolute", "PC-relative", "SB-relative",
158 "Not Permitted"};
159 return parseStringAttribute("ABI_PCS_RW_data", tag, makeArrayRef(strings));
160 }
161
ABI_PCS_RO_data(AttrType tag)162 Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) {
163 static const char *strings[] = {"Absolute", "PC-relative", "Not Permitted"};
164 return parseStringAttribute("ABI_PCS_RO_data", tag, makeArrayRef(strings));
165 }
166
ABI_PCS_GOT_use(AttrType tag)167 Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) {
168 static const char *strings[] = {"Not Permitted", "Direct", "GOT-Indirect"};
169 return parseStringAttribute("ABI_PCS_GOT_use", tag, makeArrayRef(strings));
170 }
171
ABI_PCS_wchar_t(AttrType tag)172 Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) {
173 static const char *strings[] = {"Not Permitted", "Unknown", "2-byte",
174 "Unknown", "4-byte"};
175 return parseStringAttribute("ABI_PCS_wchar_t", tag, makeArrayRef(strings));
176 }
177
ABI_FP_rounding(AttrType tag)178 Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) {
179 static const char *strings[] = {"IEEE-754", "Runtime"};
180 return parseStringAttribute("ABI_FP_rounding", tag, makeArrayRef(strings));
181 }
182
ABI_FP_denormal(AttrType tag)183 Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) {
184 static const char *strings[] = {"Unsupported", "IEEE-754", "Sign Only"};
185 return parseStringAttribute("ABI_FP_denormal", tag, makeArrayRef(strings));
186 }
187
ABI_FP_exceptions(AttrType tag)188 Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) {
189 static const char *strings[] = {"Not Permitted", "IEEE-754"};
190 return parseStringAttribute("ABI_FP_exceptions", tag, makeArrayRef(strings));
191 }
ABI_FP_user_exceptions(AttrType tag)192 Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) {
193 static const char *strings[] = {"Not Permitted", "IEEE-754"};
194 return parseStringAttribute("ABI_FP_user_exceptions", tag,
195 makeArrayRef(strings));
196 }
197
ABI_FP_number_model(AttrType tag)198 Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) {
199 static const char *strings[] = {"Not Permitted", "Finite Only", "RTABI",
200 "IEEE-754"};
201 return parseStringAttribute("ABI_FP_number_model", tag,
202 makeArrayRef(strings));
203 }
204
ABI_align_needed(AttrType tag)205 Error ARMAttributeParser::ABI_align_needed(AttrType tag) {
206 static const char *strings[] = {"Not Permitted", "8-byte alignment",
207 "4-byte alignment", "Reserved"};
208
209 uint64_t value = de.getULEB128(cursor);
210
211 std::string description;
212 if (value < array_lengthof(strings))
213 description = strings[value];
214 else if (value <= 12)
215 description = "8-byte alignment, " + utostr(1ULL << value) +
216 "-byte extended alignment";
217 else
218 description = "Invalid";
219
220 printAttribute(tag, value, description);
221 return Error::success();
222 }
223
ABI_align_preserved(AttrType tag)224 Error ARMAttributeParser::ABI_align_preserved(AttrType tag) {
225 static const char *strings[] = {"Not Required", "8-byte data alignment",
226 "8-byte data and code alignment", "Reserved"};
227
228 uint64_t value = de.getULEB128(cursor);
229
230 std::string description;
231 if (value < array_lengthof(strings))
232 description = std::string(strings[value]);
233 else if (value <= 12)
234 description = std::string("8-byte stack alignment, ") +
235 utostr(1ULL << value) + std::string("-byte data alignment");
236 else
237 description = "Invalid";
238
239 printAttribute(tag, value, description);
240 return Error::success();
241 }
242
ABI_enum_size(AttrType tag)243 Error ARMAttributeParser::ABI_enum_size(AttrType tag) {
244 static const char *strings[] = {"Not Permitted", "Packed", "Int32",
245 "External Int32"};
246 return parseStringAttribute("ABI_enum_size", tag, makeArrayRef(strings));
247 }
248
ABI_HardFP_use(AttrType tag)249 Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) {
250 static const char *strings[] = {"Tag_FP_arch", "Single-Precision", "Reserved",
251 "Tag_FP_arch (deprecated)"};
252 return parseStringAttribute("ABI_HardFP_use", tag, makeArrayRef(strings));
253 }
254
ABI_VFP_args(AttrType tag)255 Error ARMAttributeParser::ABI_VFP_args(AttrType tag) {
256 static const char *strings[] = {"AAPCS", "AAPCS VFP", "Custom",
257 "Not Permitted"};
258 return parseStringAttribute("ABI_VFP_args", tag, makeArrayRef(strings));
259 }
260
ABI_WMMX_args(AttrType tag)261 Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) {
262 static const char *strings[] = {"AAPCS", "iWMMX", "Custom"};
263 return parseStringAttribute("ABI_WMMX_args", tag, makeArrayRef(strings));
264 }
265
ABI_optimization_goals(AttrType tag)266 Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) {
267 static const char *strings[] = {
268 "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
269 "Best Debugging"
270 };
271 return parseStringAttribute("ABI_optimization_goals", tag,
272 makeArrayRef(strings));
273 }
274
ABI_FP_optimization_goals(AttrType tag)275 Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) {
276 static const char *strings[] = {
277 "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size",
278 "Accuracy", "Best Accuracy"};
279 return parseStringAttribute("ABI_FP_optimization_goals", tag,
280 makeArrayRef(strings));
281 }
282
compatibility(AttrType tag)283 Error ARMAttributeParser::compatibility(AttrType tag) {
284 uint64_t integer = de.getULEB128(cursor);
285 StringRef string = de.getCStrRef(cursor);
286
287 if (sw) {
288 DictScope scope(*sw, "Attribute");
289 sw->printNumber("Tag", tag);
290 sw->startLine() << "Value: " << integer << ", " << string << '\n';
291 sw->printString("TagName",
292 ELFAttrs::attrTypeAsString(tag, tagToStringMap,
293 /*hasTagPrefix=*/false));
294 switch (integer) {
295 case 0:
296 sw->printString("Description", StringRef("No Specific Requirements"));
297 break;
298 case 1:
299 sw->printString("Description", StringRef("AEABI Conformant"));
300 break;
301 default:
302 sw->printString("Description", StringRef("AEABI Non-Conformant"));
303 break;
304 }
305 }
306 return Error::success();
307 }
308
CPU_unaligned_access(AttrType tag)309 Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) {
310 static const char *strings[] = {"Not Permitted", "v6-style"};
311 return parseStringAttribute("CPU_unaligned_access", tag,
312 makeArrayRef(strings));
313 }
314
FP_HP_extension(AttrType tag)315 Error ARMAttributeParser::FP_HP_extension(AttrType tag) {
316 static const char *strings[] = {"If Available", "Permitted"};
317 return parseStringAttribute("FP_HP_extension", tag, makeArrayRef(strings));
318 }
319
ABI_FP_16bit_format(AttrType tag)320 Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) {
321 static const char *strings[] = {"Not Permitted", "IEEE-754", "VFPv3"};
322 return parseStringAttribute("ABI_FP_16bit_format", tag,
323 makeArrayRef(strings));
324 }
325
MPextension_use(AttrType tag)326 Error ARMAttributeParser::MPextension_use(AttrType tag) {
327 static const char *strings[] = {"Not Permitted", "Permitted"};
328 return parseStringAttribute("MPextension_use", tag, makeArrayRef(strings));
329 }
330
DIV_use(AttrType tag)331 Error ARMAttributeParser::DIV_use(AttrType tag) {
332 static const char *strings[] = {"If Available", "Not Permitted", "Permitted"};
333 return parseStringAttribute("DIV_use", tag, makeArrayRef(strings));
334 }
335
DSP_extension(AttrType tag)336 Error ARMAttributeParser::DSP_extension(AttrType tag) {
337 static const char *strings[] = {"Not Permitted", "Permitted"};
338 return parseStringAttribute("DSP_extension", tag, makeArrayRef(strings));
339 }
340
T2EE_use(AttrType tag)341 Error ARMAttributeParser::T2EE_use(AttrType tag) {
342 static const char *strings[] = {"Not Permitted", "Permitted"};
343 return parseStringAttribute("T2EE_use", tag, makeArrayRef(strings));
344 }
345
Virtualization_use(AttrType tag)346 Error ARMAttributeParser::Virtualization_use(AttrType tag) {
347 static const char *strings[] = {"Not Permitted", "TrustZone",
348 "Virtualization Extensions",
349 "TrustZone + Virtualization Extensions"};
350 return parseStringAttribute("Virtualization_use", tag, makeArrayRef(strings));
351 }
352
nodefaults(AttrType tag)353 Error ARMAttributeParser::nodefaults(AttrType tag) {
354 uint64_t value = de.getULEB128(cursor);
355 printAttribute(tag, value, "Unspecified Tags UNDEFINED");
356 return Error::success();
357 }
358
handler(uint64_t tag,bool & handled)359 Error ARMAttributeParser::handler(uint64_t tag, bool &handled) {
360 handled = false;
361 for (unsigned AHI = 0, AHE = array_lengthof(displayRoutines); AHI != AHE;
362 ++AHI) {
363 if (uint64_t(displayRoutines[AHI].attribute) == tag) {
364 if (Error e =
365 (this->*displayRoutines[AHI].routine)(static_cast<AttrType>(tag)))
366 return e;
367 handled = true;
368 break;
369 }
370 }
371
372 return Error::success();
373 }
374