vendor/llvm-project/llvmorg-16-init-18548-gb0daacf58f41

1 files changed, 134 insertions, 56 deletions

diff --git a/llvm/lib/Support/ARMAttributeParser.cpp b/llvm/lib/Support/ARMAttributeParser.cpp
index 03c0c7aac423..3c89d160da41 100644
--- a/llvm/lib/Support/ARMAttributeParser.cpp
+++ b/llvm/lib/Support/ARMAttributeParser.cpp
@@ -7,9 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ARMAttributeParser.h"
-#include "llvm/ADT/STLArrayExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/ARMBuildAttributes.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include <optional>
 
 using namespace llvm;
 using namespace llvm::ARMBuildAttrs;
@@ -62,6 +64,7 @@ const ARMAttributeParser::DisplayHandler ARMAttributeParser::displayRoutines[] =
         ATTRIBUTE_HANDLER(PACRET_use),
         ATTRIBUTE_HANDLER(BTI_use),
         ATTRIBUTE_HANDLER(nodefaults),
+        ATTRIBUTE_HANDLER(also_compatible_with),
 };
 
 #undef ATTRIBUTE_HANDLER
@@ -81,15 +84,15 @@ Error ARMAttributeParser::stringAttribute(AttrType tag) {
   return Error::success();
 }
 
+static const char *CPU_arch_strings[] = {
+    "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ",
+    "ARM v6", "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M",
+    "ARM v6S-M", "ARM v7E-M", "ARM v8-A", "ARM v8-R", "ARM v8-M Baseline",
+    "ARM v8-M Mainline", nullptr, nullptr, nullptr, "ARM v8.1-M Mainline",
+    "ARM v9-A"};
+
 Error ARMAttributeParser::CPU_arch(AttrType tag) {
-  static const char *strings[] = {
-    "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
-    "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
-    "ARM v7E-M", "ARM v8-A", "ARM v8-R",
-    "ARM v8-M Baseline", "ARM v8-M Mainline", nullptr, nullptr, nullptr,
-    "ARM v8.1-M Mainline", "ARM v9-A"
-  };
-  return parseStringAttribute("CPU_arch", tag, makeArrayRef(strings));
+  return parseStringAttribute("CPU_arch", tag, ArrayRef(CPU_arch_strings));
 }
 
 Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
@@ -111,97 +114,95 @@ Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
 
 Error ARMAttributeParser::ARM_ISA_use(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Permitted"};
-  return parseStringAttribute("ARM_ISA_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("ARM_ISA_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", "Permitted"};
-  return parseStringAttribute("THUMB_ISA_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("THUMB_ISA_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::FP_arch(AttrType tag) {
   static const char *strings[] = {
       "Not Permitted", "VFPv1",     "VFPv2",      "VFPv3",         "VFPv3-D16",
       "VFPv4",         "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"};
-  return parseStringAttribute("FP_arch", tag, makeArrayRef(strings));
+  return parseStringAttribute("FP_arch", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::WMMX_arch(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
-  return parseStringAttribute("WMMX_arch", tag, makeArrayRef(strings));
+  return parseStringAttribute("WMMX_arch", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA",
                                   "ARMv8-a NEON", "ARMv8.1-a NEON"};
-  return parseStringAttribute("Advanced_SIMD_arch", tag, makeArrayRef(strings));
+  return parseStringAttribute("Advanced_SIMD_arch", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::MVE_arch(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "MVE integer",
                                   "MVE integer and float"};
-  return parseStringAttribute("MVE_arch", tag, makeArrayRef(strings));
+  return parseStringAttribute("MVE_arch", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::PCS_config(AttrType tag) {
   static const char *strings[] = {
     "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
     "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"};
-  return parseStringAttribute("PCS_config", tag, makeArrayRef(strings));
+  return parseStringAttribute("PCS_config", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) {
   static const char *strings[] = {"v6", "Static Base", "TLS", "Unused"};
-  return parseStringAttribute("ABI_PCS_R9_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_PCS_R9_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) {
   static const char *strings[] = {"Absolute", "PC-relative", "SB-relative",
                                   "Not Permitted"};
-  return parseStringAttribute("ABI_PCS_RW_data", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_PCS_RW_data", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) {
   static const char *strings[] = {"Absolute", "PC-relative", "Not Permitted"};
-  return parseStringAttribute("ABI_PCS_RO_data", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_PCS_RO_data", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Direct", "GOT-Indirect"};
-  return parseStringAttribute("ABI_PCS_GOT_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_PCS_GOT_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Unknown", "2-byte",
                                   "Unknown", "4-byte"};
-  return parseStringAttribute("ABI_PCS_wchar_t", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_PCS_wchar_t", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) {
   static const char *strings[] = {"IEEE-754", "Runtime"};
-  return parseStringAttribute("ABI_FP_rounding", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_FP_rounding", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) {
   static const char *strings[] = {"Unsupported", "IEEE-754", "Sign Only"};
-  return parseStringAttribute("ABI_FP_denormal", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_FP_denormal", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "IEEE-754"};
-  return parseStringAttribute("ABI_FP_exceptions", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_FP_exceptions", tag, ArrayRef(strings));
 }
 Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "IEEE-754"};
-  return parseStringAttribute("ABI_FP_user_exceptions", tag,
-                              makeArrayRef(strings));
+  return parseStringAttribute("ABI_FP_user_exceptions", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Finite Only", "RTABI",
                                   "IEEE-754"};
-  return parseStringAttribute("ABI_FP_number_model", tag,
-                              makeArrayRef(strings));
+  return parseStringAttribute("ABI_FP_number_model", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_align_needed(AttrType tag) {
@@ -211,7 +212,7 @@ Error ARMAttributeParser::ABI_align_needed(AttrType tag) {
   uint64_t value = de.getULEB128(cursor);
 
   std::string description;
-  if (value < array_lengthof(strings))
+  if (value < std::size(strings))
     description = strings[value];
   else if (value <= 12)
     description = "8-byte alignment, " + utostr(1ULL << value) +
@@ -230,7 +231,7 @@ Error ARMAttributeParser::ABI_align_preserved(AttrType tag) {
   uint64_t value = de.getULEB128(cursor);
 
   std::string description;
-  if (value < array_lengthof(strings))
+  if (value < std::size(strings))
     description = std::string(strings[value]);
   else if (value <= 12)
     description = std::string("8-byte stack alignment, ") +
@@ -245,24 +246,24 @@ Error ARMAttributeParser::ABI_align_preserved(AttrType tag) {
 Error ARMAttributeParser::ABI_enum_size(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Packed", "Int32",
                                   "External Int32"};
-  return parseStringAttribute("ABI_enum_size", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_enum_size", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) {
   static const char *strings[] = {"Tag_FP_arch", "Single-Precision", "Reserved",
                                   "Tag_FP_arch (deprecated)"};
-  return parseStringAttribute("ABI_HardFP_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_HardFP_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_VFP_args(AttrType tag) {
   static const char *strings[] = {"AAPCS", "AAPCS VFP", "Custom",
                                   "Not Permitted"};
-  return parseStringAttribute("ABI_VFP_args", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_VFP_args", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) {
   static const char *strings[] = {"AAPCS", "iWMMX", "Custom"};
-  return parseStringAttribute("ABI_WMMX_args", tag, makeArrayRef(strings));
+  return parseStringAttribute("ABI_WMMX_args", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) {
@@ -270,8 +271,7 @@ Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) {
     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
     "Best Debugging"
   };
-  return parseStringAttribute("ABI_optimization_goals", tag,
-                              makeArrayRef(strings));
+  return parseStringAttribute("ABI_optimization_goals", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) {
@@ -279,7 +279,7 @@ Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) {
       "None",     "Speed",        "Aggressive Speed", "Size", "Aggressive Size",
       "Accuracy", "Best Accuracy"};
   return parseStringAttribute("ABI_FP_optimization_goals", tag,
-                              makeArrayRef(strings));
+                              ArrayRef(strings));
 }
 
 Error ARMAttributeParser::compatibility(AttrType tag) {
@@ -310,68 +310,66 @@ Error ARMAttributeParser::compatibility(AttrType tag) {
 
 Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "v6-style"};
-  return parseStringAttribute("CPU_unaligned_access", tag,
-                              makeArrayRef(strings));
+  return parseStringAttribute("CPU_unaligned_access", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::FP_HP_extension(AttrType tag) {
   static const char *strings[] = {"If Available", "Permitted"};
-  return parseStringAttribute("FP_HP_extension", tag, makeArrayRef(strings));
+  return parseStringAttribute("FP_HP_extension", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "IEEE-754", "VFPv3"};
-  return parseStringAttribute("ABI_FP_16bit_format", tag,
-                              makeArrayRef(strings));
+  return parseStringAttribute("ABI_FP_16bit_format", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::MPextension_use(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Permitted"};
-  return parseStringAttribute("MPextension_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("MPextension_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::DIV_use(AttrType tag) {
   static const char *strings[] = {"If Available", "Not Permitted", "Permitted"};
-  return parseStringAttribute("DIV_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("DIV_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::DSP_extension(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Permitted"};
-  return parseStringAttribute("DSP_extension", tag, makeArrayRef(strings));
+  return parseStringAttribute("DSP_extension", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::T2EE_use(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Permitted"};
-  return parseStringAttribute("T2EE_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("T2EE_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::Virtualization_use(AttrType tag) {
   static const char *strings[] = {"Not Permitted", "TrustZone",
                                   "Virtualization Extensions",
                                   "TrustZone + Virtualization Extensions"};
-  return parseStringAttribute("Virtualization_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("Virtualization_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::PAC_extension(ARMBuildAttrs::AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Permitted in NOP space",
                                   "Permitted"};
-  return parseStringAttribute("PAC_extension", tag, makeArrayRef(strings));
+  return parseStringAttribute("PAC_extension", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::BTI_extension(ARMBuildAttrs::AttrType tag) {
   static const char *strings[] = {"Not Permitted", "Permitted in NOP space",
                                   "Permitted"};
-  return parseStringAttribute("BTI_extension", tag, makeArrayRef(strings));
+  return parseStringAttribute("BTI_extension", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::PACRET_use(ARMBuildAttrs::AttrType tag) {
   static const char *strings[] = {"Not Used", "Used"};
-  return parseStringAttribute("PACRET_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("PACRET_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::BTI_use(ARMBuildAttrs::AttrType tag) {
   static const char *strings[] = {"Not Used", "Used"};
-  return parseStringAttribute("BTI_use", tag, makeArrayRef(strings));
+  return parseStringAttribute("BTI_use", tag, ArrayRef(strings));
 }
 
 Error ARMAttributeParser::nodefaults(AttrType tag) {
@@ -380,13 +378,93 @@ Error ARMAttributeParser::nodefaults(AttrType tag) {
   return Error::success();
 }
 
+Error ARMAttributeParser::also_compatible_with(AttrType tag) {
+  // Parse value as a C string first in order to print it in escaped form later.
+  // Then, parse it again to catch errors or to pretty print if Tag_CPU_arch.
+  std::optional<Error> returnValue;
+
+  SmallString<8> Description;
+  raw_svector_ostream DescStream(Description);
+
+  uint64_t InitialOffset = cursor.tell();
+  StringRef RawStringValue = de.getCStrRef(cursor);
+  uint64_t FinalOffset = cursor.tell();
+  cursor.seek(InitialOffset);
+  uint64_t InnerTag = de.getULEB128(cursor);
+
+  bool ValidInnerTag =
+      any_of(tagToStringMap, [InnerTag](const TagNameItem &Item) {
+        return Item.attr == InnerTag;
+      });
+
+  if (!ValidInnerTag) {
+    returnValue =
+        createStringError(errc::argument_out_of_domain,
+                          Twine(InnerTag) + " is not a valid tag number");
+  } else {
+    switch (InnerTag) {
+    case ARMBuildAttrs::CPU_arch: {
+      uint64_t InnerValue = de.getULEB128(cursor);
+      auto strings = ArrayRef(CPU_arch_strings);
+      if (InnerValue >= strings.size()) {
+        returnValue = createStringError(
+            errc::argument_out_of_domain,
+            Twine(InnerValue) + " is not a valid " +
+                ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) +
+                " value");
+      } else {
+        DescStream << ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap)
+                   << " = " << InnerValue;
+        if (strings[InnerValue])
+          DescStream << " (" << strings[InnerValue] << ')';
+      }
+      break;
+    }
+    case ARMBuildAttrs::also_compatible_with:
+      returnValue = createStringError(
+          errc::invalid_argument,
+          ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap) +
+              " cannot be recursively defined");
+      break;
+    case ARMBuildAttrs::CPU_raw_name:
+    case ARMBuildAttrs::CPU_name:
+    case ARMBuildAttrs::compatibility:
+    case ARMBuildAttrs::conformance: {
+      StringRef InnerValue = de.getCStrRef(cursor);
+      DescStream << ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap)
+                 << " = " << InnerValue;
+      break;
+    }
+    default: {
+      uint64_t InnerValue = de.getULEB128(cursor);
+      DescStream << ELFAttrs::attrTypeAsString(InnerTag, tagToStringMap)
+                 << " = " << InnerValue;
+    }
+    }
+  }
+
+  setAttributeString(tag, RawStringValue);
+  if (sw) {
+    DictScope scope(*sw, "Attribute");
+    sw->printNumber("Tag", tag);
+    sw->printString("TagName",
+                    ELFAttrs::attrTypeAsString(tag, tagToStringMap, false));
+    sw->printStringEscaped("Value", RawStringValue);
+    if (!Description.empty()) {
+      sw->printString("Description", Description);
+    }
+  }
+
+  cursor.seek(FinalOffset);
+
+  return returnValue ? std::move(*returnValue) : Error::success();
+}
+
 Error ARMAttributeParser::handler(uint64_t tag, bool &handled) {
   handled = false;
-  for (unsigned AHI = 0, AHE = array_lengthof(displayRoutines); AHI != AHE;
-       ++AHI) {
-    if (uint64_t(displayRoutines[AHI].attribute) == tag) {
-      if (Error e =
-              (this->*displayRoutines[AHI].routine)(static_cast<AttrType>(tag)))
+  for (const auto &AH : displayRoutines) {
+    if (uint64_t(AH.attribute) == tag) {
+      if (Error e = (this->*AH.routine)(static_cast<AttrType>(tag)))
         return e;
       handled = true;
       break;