[readobj][AArch64] Support Parsing AArch64 Build Attributes

Added support for parsing AArch64 build attributes in llvm-readobj.

Author: sivan-shani

llvm/include/llvm/Object/ELFObjectFile.h

@@ -410,6 +410,9 @@ template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
     case ELF::EM_ARM:
       Type = ELF::SHT_ARM_ATTRIBUTES;
       break;
+    case ELF::EM_AARCH64:
+      Type = ELF::SHT_AARCH64_ATTRIBUTES;
+      break;
     case ELF::EM_RISCV:
       Type = ELF::SHT_RISCV_ATTRIBUTES;
       break;

llvm/include/llvm/Support/AArch64AttributeParser.h

@@ -0,0 +1,32 @@
+//=== - AArch64AttributeParser.h-AArch64 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
+//
+//===--------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_AARCH64ATTRIBUTEPARSER_H
+#define LLVM_SUPPORT_AARCH64ATTRIBUTEPARSER_H
+
+#include "ELFAttributeParser.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+
+class ScopedPrinter;
+
+class AArch64AttributeParser : public ELFAttributeParser {
+  Error handler(uint64_t Tag, bool &Handled) override {
+    return Error::success();
+  }
+
+public:
+  Error parse(ArrayRef<uint8_t> Section, llvm::endianness Endian) override;
+
+  AArch64AttributeParser(ScopedPrinter *Sw) : ELFAttributeParser(Sw) {}
+  AArch64AttributeParser() {}
+};
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_AARCH64ATTRIBUTEPARSER_H

llvm/include/llvm/Support/AArch64BuildAttributes.h

@@ -22,7 +22,7 @@
 
 namespace llvm {
 
-namespace AArch64BuildAttrs {
+namespace AArch64BuildAttributes {
 
 /// AArch64 build attributes vendors IDs (a.k.a subsection name)
 enum VendorID : unsigned {
@@ -69,7 +69,7 @@ enum FeatureAndBitsFlag : unsigned {
   Feature_PAC_Flag = 1 << 1,
   Feature_GCS_Flag = 1 << 2
 };
-} // namespace AArch64BuildAttrs
+} // namespace AArch64BuildAttributes
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_AARCH64BUILDATTRIBUTES_H

llvm/include/llvm/Support/ELFAttributeParser.h

@@ -56,8 +56,10 @@ class ELFAttributeParser {
 
   ELFAttributeParser(TagNameMap tagNameMap, StringRef vendor)
       : vendor(vendor), sw(nullptr), tagToStringMap(tagNameMap) {}
+  ELFAttributeParser(ScopedPrinter *sw) : sw(sw) {}
+  ELFAttributeParser() : sw(nullptr) {}
 
-  Error parse(ArrayRef<uint8_t> section, llvm::endianness endian);
+  virtual Error parse(ArrayRef<uint8_t> section, llvm::endianness endian);
 
   std::optional<unsigned> getAttributeValue(unsigned tag) const {
     auto I = attributes.find(tag);

llvm/lib/Support/AArch64AttributeParser.cpp

@@ -0,0 +1,152 @@
+//===-AArch64AttributeParser.cpp-AArch64 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/AArch64AttributeParser.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/AArch64BuildAttributes.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+
+using namespace llvm;
+
+Error AArch64AttributeParser::parse(ArrayRef<uint8_t> Section,
+                                    llvm::endianness Endian) {
+
+  unsigned SectionNumber = 0;
+  de = DataExtractor(Section, Endian == llvm::endianness::little, 0);
+
+  // Early returns have specific errors. Consume the Error in cursor.
+  struct ClearCursorError {
+    DataExtractor::Cursor &Cursor;
+    ~ClearCursorError() { consumeError(Cursor.takeError()); }
+  } Clear{cursor};
+
+  /*
+    AArch64 build attributes layout:
+    <format-version: ‘A’> --> There is only one version, 'A' (0x41)
+    [ <uint32: subsection-length> <NTBS: vendor-name> <bytes: vendor-data> ]
+      --> subsection-length: the offset from the start of this subsection to the
+    start of the next one.
+      --> vendor-name: NUL-terminated byte string.
+      --> vendor-data expands to:
+        [ <uint8: optional> <uint8: parameter type> <attribute>*]
+          --> optional: 0- required, 1- optional
+          --> type: 0- ULEB128, 1- NTBS
+          --> attribute: <tag, value>* pair. Tag is ULEB128, value is <parameter
+    type> type.
+  */
+
+  // Get format-version
+  uint8_t FormatVersion = de.getU8(cursor);
+  if (ELFAttrs::Format_Version != FormatVersion)
+    return createStringError(errc::invalid_argument,
+                             "unrecognized format-version: 0x" +
+                                 utohexstr(FormatVersion));
+
+  while (!de.eof(cursor)) {
+    uint32_t BASubsectionLength = de.getU32(cursor);
+    // Minimal valid BA subsection header size is at least 8: length(4) name(at
+    // least a single char + null) optionality(1) and type(1)
+    if (BASubsectionLength < 8)
+      return createStringError(
+          errc::invalid_argument,
+          "invalid AArch64 build attribute subsection size at offset: " +
+              utohexstr(cursor.tell() - 4));
+
+    StringRef VendorName = de.getCStrRef(cursor);
+    // The layout of a private subsection (--> vendor name does not starts with
+    // 'aeabi') is unknown, skip)
+    if (!VendorName.starts_with("aeabi")) {
+      sw->startLine()
+          << "** Skipping private AArch64 build attributes subsection: "
+          << VendorName << "\n";
+      // Offset in Section
+      uint64_t OffsetInSection = cursor.tell();
+      // Size: 4 bytes, Vendor Name: VendorName.size() + 1 (null termination)
+      uint32_t BytesForLengthName = 4 + (VendorName.size() + 1);
+      cursor.seek(OffsetInSection + BASubsectionLength - BytesForLengthName);
+      continue;
+    }
+    // All public subsections names must be known
+    if (VendorName.starts_with("aeabi")) {
+      if (!("aeabi_feature_and_bits" == VendorName ||
+            "aeabi_pauthabi" == VendorName)) {
+        return createStringError(
+            errc::invalid_argument,
+            "unknown public AArch64 build attribute subsection name at "
+            "offset: " +
+                utohexstr(cursor.tell() - (VendorName.size() + 1)));
+      }
+    }
+
+    uint8_t IsOptional = de.getU8(cursor);
+    StringRef IsOptionalStr = IsOptional ? "optional" : "required";
+    uint8_t Type = de.getU8(cursor);
+    StringRef TypeStr = Type ? "ntbs" : "uleb128";
+
+    if (sw) {
+      sw->startLine() << "Section " << ++SectionNumber << " {\n";
+      sw->indent();
+      sw->printNumber("SectionLength", BASubsectionLength);
+      sw->startLine() << "VendorName" << ": " << VendorName
+                      << " Optionality: " << IsOptionalStr
+                      << " Type: " << TypeStr << "\n";
+      sw->startLine() << "Attributes {\n";
+      sw->indent();
+    }
+
+    // Offset in Section
+    uint64_t OffsetInSection = cursor.tell();
+    // Size: 4 bytes, Vendor Name: VendorName.size() + 1 (null termination),
+    // optionality: 1, size: 1
+    uint32_t BytesAllButAttributes = 4 + (VendorName.size() + 1) + 1 + 1;
+    while (cursor.tell() <
+           (OffsetInSection + BASubsectionLength - BytesAllButAttributes)) {
+
+      uint64_t Tag = de.getULEB128(cursor);
+      std::string Str = utostr(Tag);
+      StringRef TagStr(Str);
+      if ("aeabi_feature_and_bits" == VendorName) {
+        StringRef TagAsString =
+            AArch64BuildAttributes::getFeatureAndBitsTagsStr(Tag);
+        if ("" != TagAsString)
+          TagStr = TagAsString;
+      }
+      if ("aeabi_pauthabi" == VendorName) {
+        StringRef TagAsString = AArch64BuildAttributes::getPauthABITagsStr(Tag);
+        if ("" != TagAsString)
+          TagStr = TagAsString;
+      }
+
+      if (Type) { // type==1 --> ntbs
+        StringRef Value = de.getCStrRef(cursor);
+        if (sw)
+          sw->printString(TagStr, Value);
+      } else { // type==0 --> uleb128
+        uint64_t Value = de.getULEB128(cursor);
+        if (sw)
+          sw->printNumber(TagStr, Value);
+      }
+    }
+    if (sw) {
+      // Close 'Attributes'
+      sw->unindent();
+      sw->startLine() << "}\n";
+      // Close 'Section'
+      sw->unindent();
+      sw->startLine() << "}\n";
+    }
+  }
+
+  return cursor.takeError();
+}

llvm/lib/Support/AArch64BuildAttributes.cpp

@@ -10,9 +10,9 @@
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace llvm;
-using namespace llvm::AArch64BuildAttrs;
+using namespace llvm::AArch64BuildAttributes;
 
-StringRef AArch64BuildAttrs::getVendorName(unsigned Vendor) {
+StringRef AArch64BuildAttributes::getVendorName(unsigned Vendor) {
   switch (Vendor) {
   case AEABI_FEATURE_AND_BITS:
     return "aeabi_feature_and_bits";
@@ -25,14 +25,14 @@ StringRef AArch64BuildAttrs::getVendorName(unsigned Vendor) {
     return "";
   }
 }
-VendorID AArch64BuildAttrs::getVendorID(StringRef Vendor) {
+VendorID AArch64BuildAttributes::getVendorID(StringRef Vendor) {
   return StringSwitch<VendorID>(Vendor)
       .Case("aeabi_feature_and_bits", AEABI_FEATURE_AND_BITS)
       .Case("aeabi_pauthabi", AEABI_PAUTHABI)
       .Default(VENDOR_UNKNOWN);
 }
 
-StringRef AArch64BuildAttrs::getOptionalStr(unsigned Optional) {
+StringRef AArch64BuildAttributes::getOptionalStr(unsigned Optional) {
   switch (Optional) {
   case REQUIRED:
     return "required";
@@ -43,18 +43,18 @@ StringRef AArch64BuildAttrs::getOptionalStr(unsigned Optional) {
     return "";
   }
 }
-SubsectionOptional AArch64BuildAttrs::getOptionalID(StringRef Optional) {
+SubsectionOptional AArch64BuildAttributes::getOptionalID(StringRef Optional) {
   return StringSwitch<SubsectionOptional>(Optional)
       .Case("required", REQUIRED)
       .Case("optional", OPTIONAL)
       .Default(OPTIONAL_NOT_FOUND);
 }
-StringRef AArch64BuildAttrs::getSubsectionOptionalUnknownError() {
+StringRef AArch64BuildAttributes::getSubsectionOptionalUnknownError() {
   return "unknown AArch64 build attributes optionality, expected "
          "required|optional";
 }
 
-StringRef AArch64BuildAttrs::getTypeStr(unsigned Type) {
+StringRef AArch64BuildAttributes::getTypeStr(unsigned Type) {
   switch (Type) {
   case ULEB128:
     return "uleb128";
@@ -65,17 +65,17 @@ StringRef AArch64BuildAttrs::getTypeStr(unsigned Type) {
     return "";
   }
 }
-SubsectionType AArch64BuildAttrs::getTypeID(StringRef Type) {
+SubsectionType AArch64BuildAttributes::getTypeID(StringRef Type) {
   return StringSwitch<SubsectionType>(Type)
       .Cases("uleb128", "ULEB128", ULEB128)
       .Cases("ntbs", "NTBS", NTBS)
       .Default(TYPE_NOT_FOUND);
 }
-StringRef AArch64BuildAttrs::getSubsectionTypeUnknownError() {
+StringRef AArch64BuildAttributes::getSubsectionTypeUnknownError() {
   return "unknown AArch64 build attributes type, expected uleb128|ntbs";
 }
 
-StringRef AArch64BuildAttrs::getPauthABITagsStr(unsigned PauthABITag) {
+StringRef AArch64BuildAttributes::getPauthABITagsStr(unsigned PauthABITag) {
   switch (PauthABITag) {
   case TAG_PAUTH_PLATFORM:
     return "Tag_PAuth_Platform";
@@ -87,15 +87,15 @@ StringRef AArch64BuildAttrs::getPauthABITagsStr(unsigned PauthABITag) {
   }
 }
 
-PauthABITags AArch64BuildAttrs::getPauthABITagsID(StringRef PauthABITag) {
+PauthABITags AArch64BuildAttributes::getPauthABITagsID(StringRef PauthABITag) {
   return StringSwitch<PauthABITags>(PauthABITag)
       .Case("Tag_PAuth_Platform", TAG_PAUTH_PLATFORM)
       .Case("Tag_PAuth_Schema", TAG_PAUTH_SCHEMA)
       .Default(PAUTHABI_TAG_NOT_FOUND);
 }
 
 StringRef
-AArch64BuildAttrs::getFeatureAndBitsTagsStr(unsigned FeatureAndBitsTag) {
+AArch64BuildAttributes::getFeatureAndBitsTagsStr(unsigned FeatureAndBitsTag) {
   switch (FeatureAndBitsTag) {
   case TAG_FEATURE_BTI:
     return "Tag_Feature_BTI";
@@ -110,7 +110,7 @@ AArch64BuildAttrs::getFeatureAndBitsTagsStr(unsigned FeatureAndBitsTag) {
 }
 
 FeatureAndBitsTags
-AArch64BuildAttrs::getFeatureAndBitsTagsID(StringRef FeatureAndBitsTag) {
+AArch64BuildAttributes::getFeatureAndBitsTagsID(StringRef FeatureAndBitsTag) {
   return StringSwitch<FeatureAndBitsTags>(FeatureAndBitsTag)
       .Case("Tag_Feature_BTI", TAG_FEATURE_BTI)
       .Case("Tag_Feature_PAC", TAG_FEATURE_PAC)

llvm/lib/Support/CMakeLists.txt

@@ -146,6 +146,7 @@ add_llvm_component_library(LLVMSupport
   ARMBuildAttributes.cpp
   AArch64BuildAttributes.cpp
   ARMAttributeParser.cpp
+  AArch64AttributeParser.cpp
   ARMWinEH.cpp
   Allocator.cpp
   AutoConvert.cpp

llvm/lib/Support/ELFAttributeParser.cpp

@@ -128,9 +128,8 @@ Error ELFAttributeParser::parseSubsection(uint32_t length) {
   }
 
   // Handle a subsection with an unrecognized vendor-name by skipping
-  // over it to the next subsection. ADDENDA32 in the Arm ABI defines
-  // that vendor attribute sections must not affect compatibility, so
-  // this should always be safe.
+  // over it to the next subsection. vendor attribute sections must not
+  // affect compatibility, so this should always be safe.
   if (vendorName.lower() != vendor) {
     cursor.seek(end);
     return Error::success();