[Arm] Fix parsing and emission of Tag_also_compatible_with eabi attribute

[pratlucas]

Summary

According to the ABI for the Arm Architecture, the value for the
Tag_also_compatible_with eabi attribute is represented by an NTBS entry.
This string value, in turn, is composed of a pair of tag+value encoded
in one of two formats:

• ULEB128: tag, ULEB128: value, 0.
• ULEB128: tag, NBTS: data.

(See section 3.3.7.3 on the Addenda to, and Errata in, the ABI for the Arm Architecture.)

Currently the Arm assembly parser and streamer ignore the encoding of
the attribute's NTBS value, which can result in incorrect attributes
being emitted in both assembly and object file outputs.

This patch fixes these issues by properly handing the value's encoding.
An update to llvm-readobj to properly handle the attribute's value will be
covered by a separate patch.

Patch by Victor Campos and Lucas Prates.

[pratlucas]

Minor update to include order.

[vhscampos]

A couple of typos in the commit message:

"streamerignore"
"enconding" (twice)

[pratlucas]

Updated commit message to fix typos.

[vhscampos]

LGTM. Please wait one week or so for any other comment.

llvm/include/llvm/Support/ARMBuildAttributes.h

enum {
   BTINotUsed = 0,
   BTIUsed = 1,
 
   // Tag_PACRET_use, (=76), uleb128
   PACRETNotUsed = 0,
   PACRETUsed = 1
 };
 
+std::string encodeAttrTagValuePair(StringRef OriginalString);
+
 } // namespace ARMBuildAttrs
 } // namespace llvm
 
 #endif

llvm/lib/Support/ARMBuildAttrs.cpp

 //===-- ARMBuildAttrs.cpp - ARM Build Attributes --------------------------===//
 //
 // 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/ARMBuildAttributes.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/LEB128.h"
+#include <iomanip>
+#include <sstream>
 
 using namespace llvm;
 
 static const TagNameItem tagData[] = {
     {ARMBuildAttrs::File, "Tag_File"},
     {ARMBuildAttrs::Section, "Tag_Section"},
     {ARMBuildAttrs::Symbol, "Tag_Symbol"},
     {ARMBuildAttrs::CPU_raw_name, "Tag_CPU_raw_name"},
static const TagNameItem tagData[] = {
     {ARMBuildAttrs::ABI_align_needed, "Tag_ABI_align8_needed"},
     {ARMBuildAttrs::ABI_align_preserved, "Tag_ABI_align8_preserved"},
 };
 
 constexpr TagNameMap ARMAttributeTags{tagData};
 const TagNameMap &llvm::ARMBuildAttrs::getARMAttributeTags() {
   return ARMAttributeTags;
 }
+
+static std::string getEncodedULEB128AsText(const uint8_t *Value,
+                                           unsigned Size) {
+  std::stringstream SS;
+  for (unsigned i = 0; i < Size; ++i) {
+    SS << "\\" << std::setfill('0') << std::setw(3) << std::oct
+       << int(Value[i]);
+  }
+  return SS.str();
+}
+
+std::string
+llvm::ARMBuildAttrs::encodeAttrTagValuePair(StringRef OriginalString) {
+  auto BytesBegin = reinterpret_cast<const uint8_t *>(OriginalString.data());
+  auto BytesEnd = BytesBegin + OriginalString.size();
+
+  unsigned N = 0;
+  const char *Error = nullptr;
+  unsigned Tag = decodeULEB128(BytesBegin, &N, BytesEnd, &Error);
+  if (Error)
+    report_fatal_error("Could not decode Tag value: " + Twine(Error));
+
+  std::string EncodedPair = getEncodedULEB128AsText(BytesBegin, N);
+  switch (Tag) {
+  case ARMBuildAttrs::CPU_raw_name:
+  case ARMBuildAttrs::CPU_name:
+  case ARMBuildAttrs::compatibility:
+  case ARMBuildAttrs::conformance:
+    EncodedPair += OriginalString.substr(N);
+    break;
+  default:
+    EncodedPair +=
+        getEncodedULEB128AsText(BytesBegin + N, OriginalString.size() - N);
+  }
+  return EncodedPair;
+}

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

if (IsIntegerValue) {
     IntegerValue = CE->getValue();
   }
 
   if (Tag == ARMBuildAttrs::compatibility) {
     if (Parser.parseToken(AsmToken::Comma, "comma expected"))
       return true;
   }
 
+  std::string EscapedValue;
   if (IsStringValue) {
     if (Parser.getTok().isNot(AsmToken::String))
       return Error(Parser.getTok().getLoc(), "bad string constant");
 
+    if (Tag == ARMBuildAttrs::also_compatible_with) {
+      if (Parser.parseEscapedString(EscapedValue))
+        return Error(Parser.getTok().getLoc(), "bad escaped string constant");
+
+      StringValue = EscapedValue;
+    } else {
       StringValue = Parser.getTok().getStringContents();
       Parser.Lex();
     }
+  }
 
   if (Parser.parseEOL())
     return true;
 
   if (IsIntegerValue && IsStringValue) {
     assert(Tag == ARMBuildAttrs::compatibility);
     getTargetStreamer().emitIntTextAttribute(Tag, IntegerValue, StringValue);
   } else if (IsIntegerValue)

llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

 
 void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
                                              StringRef String) {
   switch (Attribute) {
   case ARMBuildAttrs::CPU_name:
     OS << "\t.cpu\t" << String.lower();
     break;
   default:
-    OS << "\t.eabi_attribute\t" << Attribute << ", \"" << String << "\"";
+    OS << "\t.eabi_attribute\t" << Attribute << ", \"";
+    if (Attribute == ARMBuildAttrs::also_compatible_with)
+      OS << ARMBuildAttrs::encodeAttrTagValuePair(String);
+    else
+      OS << String;
+    OS << "\"";
     if (IsVerboseAsm) {
       StringRef Name = ELFAttrs::attrTypeAsString(
           Attribute, ARMBuildAttrs::getARMAttributeTags());
       if (!Name.empty())
         OS << "\t@ " << Name;
     }
     break;
   }

llvm/test/CodeGen/ARM/build-attributes-encoding.s

 .eabi_attribute 46, 1
 
 // Tag_PAC_extension (=50)
 .eabi_attribute 50, 0
 
 // Tag_BTI_extension (=52)
 .eabi_attribute 52, 0
 
+// Tag_also_compatible_with (=65)
+.eabi_attribute 65, "\006\017"
+
 // Tag_BTI_use (=74)
 .eabi_attribute 74, 0
 
 // Tag_PACRET_use (=76)
 .eabi_attribute 76, 0
 
 // Tag_Virtualization_use (=68)
 .eabi_attribute 68, 3
 
 // Check that values > 128 are encoded properly
 .eabi_attribute 110, 160
 
 // Check that tags > 128 are encoded properly
 .eabi_attribute 129, "1"
 .eabi_attribute 250, 1
 
 // CHECK:       Section {
 // CHECK:         Name: .ARM.attributes (7)
 // CHECK-NEXT:    Type: SHT_ARM_ATTRIBUTES (0x70000003)
 // CHECK-NEXT:    Flags [ (0x0)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x0
 // CHECK-NEXT:    Offset: 0x34
-// CHECK-NEXT:    Size: 81
+// CHECK-NEXT:    Size: 85
 // CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 1
 // CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 41500000 00616561 62690001 46000000  |AP...aeabi..F...|
+// CHECK-NEXT:      0000: 41540000 00616561 62690001 4A000000  |AT...aeabi..J...|
 // CHECK-NEXT:      0010: 05636F72 7465782D 61380006 0A074108  |.cortex-a8....A.|
 // CHECK-NEXT:      0020: 0109020A 030C0214 01150117 01180119  |................|
 // CHECK-NEXT:      0030: 011B001C 0124012A 012C022E 01320034  |.....$.*.,...2.4|
-// CHECK-NEXT:      0040: 0044034A 004C006E A0018101 3100FA01  |.D.J.L.n....1...|
-// CHECK-NEXT:      0050: 01                                   |.|
+// CHECK-NEXT:      0040: 0041060F 0044034A 004C006E A0018101  |.A...D.J.L.n....|
+// CHECK-NEXT:      0050: 3100FA01 01                          |1....|
 // CHECK-NEXT:    )

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

 @ CHECK-OBJ-NEXT:   TagName: BTI_extension
 @ 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, "gnu"
-@ CHECK: .eabi_attribute 65, "gnu"
+  .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: gnu
+@ CHECK-OBJ-NEXT:   Value:
   .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