[ARM] Parse Tag_also_compatible_with attribute

[vhscampos]

Summary

The ARM Attribute Parser used to parse the value of also_compatible_with
as it is, disregarding the way it is encoded.

This patch does a context aware parsing of the also_compatible_with
attribute. Additionally, some error handling is also done for incorrect
cases.

[pratlucas]

llvm/lib/Support/ARMAttributeParser.cpp

438

Should other tags be handled here too, in a more gereric way?
The ABI specifies that the inner values can be either an ULEB128 value or an NTBS string. It would be useful to have these presented in a decoded way in adition to the raw string.

[vhscampos]

More general handling of attributes inside also_compatible_with

[vhscampos]

Small improvement to printStringEscapedImpl

[pratlucas]

LGTM.

llvm/include/llvm/Support/ARMAttributeParser.h

class ARMAttributeParser : public ELFAttributeParser {
   Error DSP_extension(ARMBuildAttrs::AttrType tag);
   Error T2EE_use(ARMBuildAttrs::AttrType tag);
   Error Virtualization_use(ARMBuildAttrs::AttrType tag);
   Error PAC_extension(ARMBuildAttrs::AttrType tag);
   Error BTI_extension(ARMBuildAttrs::AttrType tag);
   Error PACRET_use(ARMBuildAttrs::AttrType tag);
   Error BTI_use(ARMBuildAttrs::AttrType tag);
   Error nodefaults(ARMBuildAttrs::AttrType tag);
+  Error also_compatible_with(ARMBuildAttrs::AttrType tag);
 
 public:
   ARMAttributeParser(ScopedPrinter *sw)
       : ELFAttributeParser(sw, ARMBuildAttrs::getARMAttributeTags(), "aeabi") {}
   ARMAttributeParser()
       : ELFAttributeParser(ARMBuildAttrs::getARMAttributeTags(), "aeabi") {}
 };
 }
 
 #endif

llvm/include/llvm/Support/ScopedPrinter.h

public:
   }
 
   virtual void printString(StringRef Value) { startLine() << Value << "\n"; }
 
   virtual void printString(StringRef Label, StringRef Value) {
     startLine() << Label << ": " << Value << "\n";
   }
 
+  void printStringEscaped(StringRef Label, StringRef Value) {
+    printStringEscapedImpl(Label, Value);
+  }
+
   void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) {
     printBinaryImpl(Label, Str, Value, false);
   }
 
   void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) {
     auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
                           Value.size());
     printBinaryImpl(Label, Str, V, false);
virtual void printSymbolOffsetImpl(StringRef Label, StringRef Symbol,
     startLine() << Label << ": " << Symbol << '+' << Value << '\n';
   }
 
   virtual void printNumberImpl(StringRef Label, StringRef Str,
                                StringRef Value) {
     startLine() << Label << ": " << Str << " (" << Value << ")\n";
   }
 
+  virtual void printStringEscapedImpl(StringRef Label, StringRef Value) {
+    startLine() << Label << ": ";
+    OS.write_escaped(Value);
+    OS << '\n';
+  }
+
   void scopedBegin(char Symbol) {
     startLine() << Symbol << '\n';
     indent();
   }
 
   void scopedBegin(StringRef Label, char Symbol) {
     startLine() << Label;
     if (!Label.empty())

llvm/lib/Support/ARMAttributeParser.cpp

 //===- ARMAttributeParser.cpp - ARM Attribute Information Printer ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 
 using namespace llvm;
 using namespace llvm::ARMBuildAttrs;
 
 #define ATTRIBUTE_HANDLER(attr)                                                \
   { ARMBuildAttrs::attr, &ARMAttributeParser::attr }
 
const ARMAttributeParser::DisplayHandler ARMAttributeParser::displayRoutines[] =
         ATTRIBUTE_HANDLER(DSP_extension),
         ATTRIBUTE_HANDLER(T2EE_use),
         ATTRIBUTE_HANDLER(Virtualization_use),
         ATTRIBUTE_HANDLER(PAC_extension),
         ATTRIBUTE_HANDLER(BTI_extension),
         ATTRIBUTE_HANDLER(PACRET_use),
         ATTRIBUTE_HANDLER(BTI_use),
         ATTRIBUTE_HANDLER(nodefaults),
+        ATTRIBUTE_HANDLER(also_compatible_with),
 };
 
 #undef ATTRIBUTE_HANDLER
 
 Error ARMAttributeParser::stringAttribute(AttrType tag) {
   StringRef tagName =
       ELFAttrs::attrTypeAsString(tag, tagToStringMap, /*hasTagPrefix=*/false);
   StringRef desc = de.getCStrRef(cursor);
 
   if (sw) {
     DictScope scope(*sw, "Attribute");
     sw->printNumber("Tag", tag);
     if (!tagName.empty())
       sw->printString("TagName", tagName);
     sw->printString("Value", desc);
   }
   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, makeArrayRef(CPU_arch_strings));
 }
 
 Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
   uint64_t value = de.getULEB128(cursor);
 
   StringRef profile;
   switch (value) {
   default: profile = "Unknown"; break;

 }
 
 Error ARMAttributeParser::nodefaults(AttrType tag) {
   uint64_t value = de.getULEB128(cursor);
   printAttribute(tag, value, "Unspecified Tags UNDEFINED");
   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.
+  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 = makeArrayRef(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;
+    }
+    }
+  }
+
+  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)))
         return e;
       handled = true;
       break;
     }
   }
 
   return Error::success();
 }

llvm/test/MC/ARM/directive-eabi_attribute-also_compatible_with-integer.s

+@ RUN: llvm-mc -triple arm -filetype obj -o - %s | \
+@ RUN: llvm-readobj -A - | \
+@ RUN: FileCheck %s
+
+.eabi_attribute Tag_also_compatible_with, "\015\001"
+@ CHECK: Attribute
+@ CHECK: Tag: 65
+@ CHECK: TagName: also_compatible_with
+@ CHECK: Value: \015\001
+@ CHECK: Description: Tag_PCS_config = 1

llvm/test/MC/ARM/directive-eabi_attribute-also_compatible_with-invalid_arch.s

+@ RUN: llvm-mc -triple arm -filetype obj -o - %s | \
+@ RUN: llvm-readobj -A - 2>&1 | \
+@ RUN: FileCheck %s --check-prefix=CHECK-WARNING
+
+.eabi_attribute Tag_also_compatible_with, "\006\143"
+@ CHECK-WARNING: 99 is not a valid Tag_CPU_arch value

llvm/test/MC/ARM/directive-eabi_attribute-also_compatible_with-invalid_tag.s

+@ RUN: llvm-mc -triple arm -filetype obj -o - %s | \
+@ RUN: llvm-readobj -A - 2>&1 | \
+@ RUN: FileCheck %s --check-prefix=CHECK-WARNING
+
+.eabi_attribute Tag_also_compatible_with, "\074\001"
+@ CHECK-WARNING: 60 is not a valid tag number

llvm/test/MC/ARM/directive-eabi_attribute-also_compatible_with-recursive.s

+@ RUN: llvm-mc -triple arm -filetype obj -o - %s | \
+@ RUN: llvm-readobj -A - 2>&1 | \
+@ RUN: FileCheck %s --check-prefix=CHECK-WARNING
+
+.eabi_attribute Tag_also_compatible_with, "\101\006\017"
+@ CHECK-WARNING: Tag_also_compatible_with cannot be recursively defined

llvm/test/MC/ARM/directive-eabi_attribute-also_compatible_with-string.s

+@ RUN: llvm-mc -triple arm -filetype obj -o - %s | \
+@ RUN: llvm-readobj -A - | \
+@ RUN: FileCheck %s
+
+.eabi_attribute Tag_also_compatible_with, "\005Cortex-A7"
+@ CHECK: Attribute
+@ CHECK: Tag: 65
+@ CHECK: TagName: also_compatible_with
+@ CHECK: Value: \005Cortex-A7
+@ CHECK: Description: Tag_CPU_name = Cortex-A7

llvm/test/MC/ARM/directive-eabi_attribute.s

 @ CHECK-OBJ-NEXT:   Description: Not Permitted
   .eabi_attribute Tag_nodefaults, 0
 @ CHECK: .eabi_attribute 64, 0
 @ CHECK-OBJ:        Tag: 64
 @ CHECK-OBJ-NEXT:   Value: 0
 @ CHECK-OBJ-NEXT:   TagName: nodefaults
 @ CHECK-OBJ-NEXT:   Description: Unspecified Tags UNDEFINED
   .eabi_attribute Tag_also_compatible_with, "\006\017"
-@ The value for Tag_also_compatible_with should be a pair of a tag (ULEB128) +
-@ a value (ULEB128 + null or NTBS). llvm-readobj doesn't now how to process
-@ this yet, so we use the encoded value explicitly here.
 @ CHECK: .eabi_attribute 65, "\006\017"
 @ CHECK-OBJ:        Tag: 65
 @ CHECK-OBJ-NEXT:   TagName: also_compatible_with
-@ CHECK-OBJ-NEXT:   Value:
+@ CHECK-OBJ-NEXT:   Value: \006\017
+@ CHECK-OBJ-NEXT:   Description: Tag_CPU_arch = 15 (ARM v8-R)
   .eabi_attribute Tag_T2EE_use, 0
 @ CHECK: .eabi_attribute 66, 0
 @ CHECK-OBJ:        Tag: 66
 @ CHECK-OBJ-NEXT:   Value: 0
 @ CHECK-OBJ-NEXT:   TagName: T2EE_use
 @ CHECK-OBJ-NEXT:   Description: Not Permitted
   .eabi_attribute Tag_Virtualization_use, 0
 @ CHECK: .eabi_attribute 68, 0