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
16using namespace llvm;
17using namespace llvm::ARMBuildAttrs;
18
19#define ATTRIBUTE_HANDLER(attr)                                                \
20  { ARMBuildAttrs::attr, &ARMAttributeParser::attr }
21
22const 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
67Error 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
82Error 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
93Error 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
110Error 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
115Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) {
116  static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2"};
117  return parseStringAttribute("THUMB_ISA_use", tag, makeArrayRef(strings));
118}
119
120Error 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
127Error ARMAttributeParser::WMMX_arch(AttrType tag) {
128  static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
129  return parseStringAttribute("WMMX_arch", tag, makeArrayRef(strings));
130}
131
132Error 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
138Error 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
144Error 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
151Error 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
156Error 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
162Error 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
167Error 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
172Error 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
178Error 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
183Error 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
188Error 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}
192Error 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
198Error 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
205Error 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
224Error 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
243Error 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
249Error 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
255Error 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
261Error 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
266Error 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
275Error 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
283Error 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
309Error 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
315Error 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
320Error 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
326Error ARMAttributeParser::MPextension_use(AttrType tag) {
327  static const char *strings[] = {"Not Permitted", "Permitted"};
328  return parseStringAttribute("MPextension_use", tag, makeArrayRef(strings));
329}
330
331Error 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
336Error ARMAttributeParser::DSP_extension(AttrType tag) {
337  static const char *strings[] = {"Not Permitted", "Permitted"};
338  return parseStringAttribute("DSP_extension", tag, makeArrayRef(strings));
339}
340
341Error ARMAttributeParser::T2EE_use(AttrType tag) {
342  static const char *strings[] = {"Not Permitted", "Permitted"};
343  return parseStringAttribute("T2EE_use", tag, makeArrayRef(strings));
344}
345
346Error 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
353Error ARMAttributeParser::nodefaults(AttrType tag) {
354  uint64_t value = de.getULEB128(cursor);
355  printAttribute(tag, value, "Unspecified Tags UNDEFINED");
356  return Error::success();
357}
358
359Error 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