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/StringExtras.h" 11 #include "llvm/Support/ARMBuildAttributes.h" 12 #include "llvm/Support/Errc.h" 13 #include "llvm/Support/ScopedPrinter.h" 14 #include <optional> 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 ATTRIBUTE_HANDLER(also_compatible_with), 68 }; 69 70 #undef ATTRIBUTE_HANDLER 71 72 Error ARMAttributeParser::stringAttribute(AttrType tag) { 73 StringRef tagName = 74 ELFAttrs::attrTypeAsString(tag, tagToStringMap, /*hasTagPrefix=*/false); 75 StringRef desc = de.getCStrRef(cursor); 76 77 if (sw) { 78 DictScope scope(*sw, "Attribute"); 79 sw->printNumber("Tag", tag); 80 if (!tagName.empty()) 81 sw->printString("TagName", tagName); 82 sw->printString("Value", desc); 83 } 84 return Error::success(); 85 } 86 87 static const char *const CPU_arch_strings[] = {"Pre-v4", 88 "ARM v4", 89 "ARM v4T", 90 "ARM v5T", 91 "ARM v5TE", 92 "ARM v5TEJ", 93 "ARM v6", 94 "ARM v6KZ", 95 "ARM v6T2", 96 "ARM v6K", 97 "ARM v7", 98 "ARM v6-M", 99 "ARM v6S-M", 100 "ARM v7E-M", 101 "ARM v8-A", 102 "ARM v8-R", 103 "ARM v8-M Baseline", 104 "ARM v8-M Mainline", 105 nullptr, 106 nullptr, 107 nullptr, 108 "ARM v8.1-M Mainline", 109 "ARM v9-A"}; 110 111 Error ARMAttributeParser::CPU_arch(AttrType tag) { 112 return parseStringAttribute("CPU_arch", tag, ArrayRef(CPU_arch_strings)); 113 } 114 115 Error ARMAttributeParser::CPU_arch_profile(AttrType tag) { 116 uint64_t value = de.getULEB128(cursor); 117 118 StringRef profile; 119 switch (value) { 120 default: profile = "Unknown"; break; 121 case 'A': profile = "Application"; break; 122 case 'R': profile = "Real-time"; break; 123 case 'M': profile = "Microcontroller"; break; 124 case 'S': profile = "Classic"; break; 125 case 0: profile = "None"; break; 126 } 127 128 printAttribute(tag, value, profile); 129 return Error::success(); 130 } 131 132 Error ARMAttributeParser::ARM_ISA_use(AttrType tag) { 133 static const char *const strings[] = {"Not Permitted", "Permitted"}; 134 return parseStringAttribute("ARM_ISA_use", tag, ArrayRef(strings)); 135 } 136 137 Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) { 138 static const char *const strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", 139 "Permitted"}; 140 return parseStringAttribute("THUMB_ISA_use", tag, ArrayRef(strings)); 141 } 142 143 Error ARMAttributeParser::FP_arch(AttrType tag) { 144 static const char *const strings[] = { 145 "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", 146 "VFPv4", "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"}; 147 return parseStringAttribute("FP_arch", tag, ArrayRef(strings)); 148 } 149 150 Error ARMAttributeParser::WMMX_arch(AttrType tag) { 151 static const char *const strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"}; 152 return parseStringAttribute("WMMX_arch", tag, ArrayRef(strings)); 153 } 154 155 Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) { 156 static const char *const strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA", 157 "ARMv8-a NEON", "ARMv8.1-a NEON"}; 158 return parseStringAttribute("Advanced_SIMD_arch", tag, ArrayRef(strings)); 159 } 160 161 Error ARMAttributeParser::MVE_arch(AttrType tag) { 162 static const char *const strings[] = {"Not Permitted", "MVE integer", 163 "MVE integer and float"}; 164 return parseStringAttribute("MVE_arch", tag, ArrayRef(strings)); 165 } 166 167 Error ARMAttributeParser::PCS_config(AttrType tag) { 168 static const char *const strings[] = {"None", 169 "Bare Platform", 170 "Linux Application", 171 "Linux DSO", 172 "Palm OS 2004", 173 "Reserved (Palm OS)", 174 "Symbian OS 2004", 175 "Reserved (Symbian OS)"}; 176 return parseStringAttribute("PCS_config", tag, ArrayRef(strings)); 177 } 178 179 Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) { 180 static const char *const strings[] = {"v6", "Static Base", "TLS", "Unused"}; 181 return parseStringAttribute("ABI_PCS_R9_use", tag, ArrayRef(strings)); 182 } 183 184 Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) { 185 static const char *const strings[] = {"Absolute", "PC-relative", 186 "SB-relative", "Not Permitted"}; 187 return parseStringAttribute("ABI_PCS_RW_data", tag, ArrayRef(strings)); 188 } 189 190 Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) { 191 static const char *const strings[] = {"Absolute", "PC-relative", 192 "Not Permitted"}; 193 return parseStringAttribute("ABI_PCS_RO_data", tag, ArrayRef(strings)); 194 } 195 196 Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) { 197 static const char *const strings[] = {"Not Permitted", "Direct", 198 "GOT-Indirect"}; 199 return parseStringAttribute("ABI_PCS_GOT_use", tag, ArrayRef(strings)); 200 } 201 202 Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) { 203 static const char *const strings[] = {"Not Permitted", "Unknown", "2-byte", 204 "Unknown", "4-byte"}; 205 return parseStringAttribute("ABI_PCS_wchar_t", tag, ArrayRef(strings)); 206 } 207 208 Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) { 209 static const char *const strings[] = {"IEEE-754", "Runtime"}; 210 return parseStringAttribute("ABI_FP_rounding", tag, ArrayRef(strings)); 211 } 212 213 Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) { 214 static const char *const strings[] = {"Unsupported", "IEEE-754", "Sign Only"}; 215 return parseStringAttribute("ABI_FP_denormal", tag, ArrayRef(strings)); 216 } 217 218 Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) { 219 static const char *const strings[] = {"Not Permitted", "IEEE-754"}; 220 return parseStringAttribute("ABI_FP_exceptions", tag, ArrayRef(strings)); 221 } 222 Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) { 223 static const char *const strings[] = {"Not Permitted", "IEEE-754"}; 224 return parseStringAttribute("ABI_FP_user_exceptions", tag, ArrayRef(strings)); 225 } 226 227 Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) { 228 static const char *const strings[] = {"Not Permitted", "Finite Only", "RTABI", 229 "IEEE-754"}; 230 return parseStringAttribute("ABI_FP_number_model", tag, ArrayRef(strings)); 231 } 232 233 Error ARMAttributeParser::ABI_align_needed(AttrType tag) { 234 static const char *const strings[] = {"Not Permitted", "8-byte alignment", 235 "4-byte alignment", "Reserved"}; 236 237 uint64_t value = de.getULEB128(cursor); 238 239 std::string description; 240 if (value < std::size(strings)) 241 description = strings[value]; 242 else if (value <= 12) 243 description = "8-byte alignment, " + utostr(1ULL << value) + 244 "-byte extended alignment"; 245 else 246 description = "Invalid"; 247 248 printAttribute(tag, value, description); 249 return Error::success(); 250 } 251 252 Error ARMAttributeParser::ABI_align_preserved(AttrType tag) { 253 static const char *strings[] = {"Not Required", "8-byte data alignment", 254 "8-byte data and code alignment", "Reserved"}; 255 256 uint64_t value = de.getULEB128(cursor); 257 258 std::string description; 259 if (value < std::size(strings)) 260 description = std::string(strings[value]); 261 else if (value <= 12) 262 description = std::string("8-byte stack alignment, ") + 263 utostr(1ULL << value) + std::string("-byte data alignment"); 264 else 265 description = "Invalid"; 266 267 printAttribute(tag, value, description); 268 return Error::success(); 269 } 270 271 Error ARMAttributeParser::ABI_enum_size(AttrType tag) { 272 static const char *const strings[] = {"Not Permitted", "Packed", "Int32", 273 "External Int32"}; 274 return parseStringAttribute("ABI_enum_size", tag, ArrayRef(strings)); 275 } 276 277 Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) { 278 static const char *const strings[] = {"Tag_FP_arch", "Single-Precision", 279 "Reserved", "Tag_FP_arch (deprecated)"}; 280 return parseStringAttribute("ABI_HardFP_use", tag, ArrayRef(strings)); 281 } 282 283 Error ARMAttributeParser::ABI_VFP_args(AttrType tag) { 284 static const char *const strings[] = {"AAPCS", "AAPCS VFP", "Custom", 285 "Not Permitted"}; 286 return parseStringAttribute("ABI_VFP_args", tag, ArrayRef(strings)); 287 } 288 289 Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) { 290 static const char *const strings[] = {"AAPCS", "iWMMX", "Custom"}; 291 return parseStringAttribute("ABI_WMMX_args", tag, ArrayRef(strings)); 292 } 293 294 Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) { 295 static const char *const strings[] = { 296 "None", "Speed", "Aggressive Speed", 297 "Size", "Aggressive Size", "Debugging", 298 "Best Debugging"}; 299 return parseStringAttribute("ABI_optimization_goals", tag, ArrayRef(strings)); 300 } 301 302 Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) { 303 static const char *const strings[] = { 304 "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", 305 "Accuracy", "Best Accuracy"}; 306 return parseStringAttribute("ABI_FP_optimization_goals", tag, 307 ArrayRef(strings)); 308 } 309 310 Error ARMAttributeParser::compatibility(AttrType tag) { 311 uint64_t integer = de.getULEB128(cursor); 312 StringRef string = de.getCStrRef(cursor); 313 314 if (sw) { 315 DictScope scope(*sw, "Attribute"); 316 sw->printNumber("Tag", tag); 317 sw->startLine() << "Value: " << integer << ", " << string << '\n'; 318 sw->printString("TagName", 319 ELFAttrs::attrTypeAsString(tag, tagToStringMap, 320 /*hasTagPrefix=*/false)); 321 switch (integer) { 322 case 0: 323 sw->printString("Description", StringRef("No Specific Requirements")); 324 break; 325 case 1: 326 sw->printString("Description", StringRef("AEABI Conformant")); 327 break; 328 default: 329 sw->printString("Description", StringRef("AEABI Non-Conformant")); 330 break; 331 } 332 } 333 return Error::success(); 334 } 335 336 Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) { 337 static const char *const strings[] = {"Not Permitted", "v6-style"}; 338 return parseStringAttribute("CPU_unaligned_access", tag, ArrayRef(strings)); 339 } 340 341 Error ARMAttributeParser::FP_HP_extension(AttrType tag) { 342 static const char *const strings[] = {"If Available", "Permitted"}; 343 return parseStringAttribute("FP_HP_extension", tag, ArrayRef(strings)); 344 } 345 346 Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) { 347 static const char *const strings[] = {"Not Permitted", "IEEE-754", "VFPv3"}; 348 return parseStringAttribute("ABI_FP_16bit_format", tag, ArrayRef(strings)); 349 } 350 351 Error ARMAttributeParser::MPextension_use(AttrType tag) { 352 static const char *const strings[] = {"Not Permitted", "Permitted"}; 353 return parseStringAttribute("MPextension_use", tag, ArrayRef(strings)); 354 } 355 356 Error ARMAttributeParser::DIV_use(AttrType tag) { 357 static const char *const strings[] = {"If Available", "Not Permitted", 358 "Permitted"}; 359 return parseStringAttribute("DIV_use", tag, ArrayRef(strings)); 360 } 361 362 Error ARMAttributeParser::DSP_extension(AttrType tag) { 363 static const char *const strings[] = {"Not Permitted", "Permitted"}; 364 return parseStringAttribute("DSP_extension", tag, ArrayRef(strings)); 365 } 366 367 Error ARMAttributeParser::T2EE_use(AttrType tag) { 368 static const char *const strings[] = {"Not Permitted", "Permitted"}; 369 return parseStringAttribute("T2EE_use", tag, ArrayRef(strings)); 370 } 371 372 Error ARMAttributeParser::Virtualization_use(AttrType tag) { 373 static const char *const strings[] = { 374 "Not Permitted", "TrustZone", "Virtualization Extensions", 375 "TrustZone + Virtualization Extensions"}; 376 return parseStringAttribute("Virtualization_use", tag, ArrayRef(strings)); 377 } 378 379 Error ARMAttributeParser::PAC_extension(ARMBuildAttrs::AttrType tag) { 380 static const char *const strings[] = {"Not Permitted", 381 "Permitted in NOP space", "Permitted"}; 382 return parseStringAttribute("PAC_extension", tag, ArrayRef(strings)); 383 } 384 385 Error ARMAttributeParser::BTI_extension(ARMBuildAttrs::AttrType tag) { 386 static const char *const strings[] = {"Not Permitted", 387 "Permitted in NOP space", "Permitted"}; 388 return parseStringAttribute("BTI_extension", tag, ArrayRef(strings)); 389 } 390 391 Error ARMAttributeParser::PACRET_use(ARMBuildAttrs::AttrType tag) { 392 static const char *const strings[] = {"Not Used", "Used"}; 393 return parseStringAttribute("PACRET_use", tag, ArrayRef(strings)); 394 } 395 396 Error ARMAttributeParser::BTI_use(ARMBuildAttrs::AttrType tag) { 397 static const char *const strings[] = {"Not Used", "Used"}; 398 return parseStringAttribute("BTI_use", tag, ArrayRef(strings)); 399 } 400 401 Error ARMAttributeParser::nodefaults(AttrType tag) { 402 uint64_t value = de.getULEB128(cursor); 403 printAttribute(tag, value, "Unspecified Tags UNDEFINED"); 404 return Error::success(); 405 } 406 407 Error ARMAttributeParser::also_compatible_with(AttrType tag) { 408 // Parse value as a C string first in order to print it in escaped form later. 409 // Then, parse it again to catch errors or to pretty print if Tag_CPU_arch. 410 std::optional<Error> returnValue; 411 412 SmallString<8> Description; 413 raw_svector_ostream DescStream(Description); 414 415 uint64_t InitialOffset = cursor.tell(); 416 StringRef RawStringValue = de.getCStrRef(cursor); 417 uint64_t FinalOffset = cursor.tell(); 418 cursor.seek(InitialOffset); 419 uint64_t InnerTag = de.getULEB128(cursor); 420 421 bool ValidInnerTag = 422 any_of(tagToStringMap, [InnerTag](const TagNameItem &Item) { 423 return Item.attr == InnerTag; 424 }); 425 426 if (!ValidInnerTag) { 427 returnValue = 428 createStringError(errc::argument_out_of_domain, 429 Twine(InnerTag) + " is not a valid tag number"); 430 } else { 431 switch (InnerTag) { 432 case ARMBuildAttrs::CPU_arch: { 433 uint64_t InnerValue = de.getULEB128(cursor); 434 auto strings = ArrayRef(CPU_arch_strings); 435 if (InnerValue >= strings.size()) { 436 returnValue = createStringError( 437 errc::argument_out_of_domain, 438 Twine(InnerValue) + " is not a valid " + 439 ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) + 440 " value"); 441 } else { 442 DescStream << ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) 443 << " = " << InnerValue; 444 if (strings[InnerValue]) 445 DescStream << " (" << strings[InnerValue] << ')'; 446 } 447 break; 448 } 449 case ARMBuildAttrs::also_compatible_with: 450 returnValue = createStringError( 451 errc::invalid_argument, 452 ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) + 453 " cannot be recursively defined"); 454 break; 455 case ARMBuildAttrs::CPU_raw_name: 456 case ARMBuildAttrs::CPU_name: 457 case ARMBuildAttrs::compatibility: 458 case ARMBuildAttrs::conformance: { 459 StringRef InnerValue = de.getCStrRef(cursor); 460 DescStream << ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) 461 << " = " << InnerValue; 462 break; 463 } 464 default: { 465 uint64_t InnerValue = de.getULEB128(cursor); 466 DescStream << ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) 467 << " = " << InnerValue; 468 } 469 } 470 } 471 472 setAttributeString(tag, RawStringValue); 473 if (sw) { 474 DictScope scope(*sw, "Attribute"); 475 sw->printNumber("Tag", tag); 476 sw->printString("TagName", 477 ELFAttrs::attrTypeAsString(tag, tagToStringMap, false)); 478 sw->printStringEscaped("Value", RawStringValue); 479 if (!Description.empty()) { 480 sw->printString("Description", Description); 481 } 482 } 483 484 cursor.seek(FinalOffset); 485 486 return returnValue ? std::move(*returnValue) : Error::success(); 487 } 488 489 Error ARMAttributeParser::handler(uint64_t tag, bool &handled) { 490 handled = false; 491 for (const auto &AH : displayRoutines) { 492 if (uint64_t(AH.attribute) == tag) { 493 if (Error e = (this->*AH.routine)(static_cast<AttrType>(tag))) 494 return e; 495 handled = true; 496 break; 497 } 498 } 499 500 return Error::success(); 501 } 502