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