[llvm-readobj/elf] - AArch64: Handle AARCH64_VARIANT_PCS for GNUStyle

[zatrazz]

Summary

It mimics the GNU readelf where it prints a [VARIANT_PCS] for symbols
with st_other with STO_AARCH64_VARIANT_PCS.

llvm/include/llvm/BinaryFormat/DynamicTags.def

 DYNAMIC_TAG(VERDEFNUM, 0X6FFFFFFD)  // The number of entries in DT_VERDEF.
 DYNAMIC_TAG(VERNEED, 0X6FFFFFFE)    // The address of the version dependency
                                     // table.
 DYNAMIC_TAG(VERNEEDNUM, 0X6FFFFFFF) // The number of entries in DT_VERNEED.
 
 // AArch64 specific dynamic table entries
 AARCH64_DYNAMIC_TAG(AARCH64_BTI_PLT, 0x70000001)
 AARCH64_DYNAMIC_TAG(AARCH64_PAC_PLT, 0x70000003)
+AARCH64_DYNAMIC_TAG(AARCH64_VARIANT_PCS, 0x70000005)
 
 // Hexagon specific dynamic table entries
 HEXAGON_DYNAMIC_TAG(HEXAGON_SYMSZ, 0x70000000)
 HEXAGON_DYNAMIC_TAG(HEXAGON_VER, 0x70000001)
 HEXAGON_DYNAMIC_TAG(HEXAGON_PLT, 0x70000002)
 
 // Mips specific dynamic table entry tags.
 

llvm/test/tools/llvm-readobj/ELF/dynamic-tags-machine-specific.test

- Type:     PT_DYNAMIC
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 ## Case 5: Test that AARCH64 machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=5 %s -o %t.aarch64
 # RUN: llvm-readobj --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=LLVM-AARCH64
 # RUN: llvm-readelf --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=GNU-AARCH64
 
-# LLVM-AARCH64:     DynamicSection [ (3 entries)
+# LLVM-AARCH64:     DynamicSection [ (4 entries)
 # LLVM-AARCH64-NEXT:  Tag                Type            Name/Value
 # LLVM-AARCH64-NEXT:  0x0000000070000001 AARCH64_BTI_PLT 1
 # LLVM-AARCH64-NEXT:  0x0000000070000003 AARCH64_PAC_PLT 2
+# LLVM-AARCH64-NEXT:  0x0000000070000005 AARCH64_VARIANT_PCS 3
 # LLVM-AARCH64-NEXT:  0x0000000000000000 NULL            0x0
 # LLVM-AARCH64-NEXT:]
 
-# GNU-AARCH64:      Dynamic section at offset {{.*}} contains 3 entries:
+# GNU-AARCH64:      Dynamic section at offset {{.*}} contains 4 entries:
 # GNU-AARCH64-NEXT:  Tag                Type              Name/Value
 # GNU-AARCH64-NEXT:  0x0000000070000001 (AARCH64_BTI_PLT) 1
 # GNU-AARCH64-NEXT:  0x0000000070000003 (AARCH64_PAC_PLT) 2
+# GNU-AARCH64-NEXT:  0x0000000070000005 (AARCH64_VARIANT_PCS) 3
 # GNU-AARCH64-NEXT:  0x0000000000000000 (NULL)            0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_AARCH64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_AARCH64_BTI_PLT
         Value: 1
       - Tag:   DT_AARCH64_PAC_PLT
         Value: 2
+      - Tag:   DT_AARCH64_VARIANT_PCS
+        Value: 3
       - Tag:   DT_NULL
         Value: 0
 ProgramHeaders:
   - Type:     PT_LOAD
     FirstSec: .dynamic
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     FirstSec: .dynamic
     LastSec:  .dynamic

llvm/tools/llvm-readobj/ELFDumper.cpp

 //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
std::string ELFDumper<ELFT>::getDynamicEntry(uint64_t Type,
   };
 
   // Handle custom printing of architecture specific tags
   switch (Obj.getHeader().e_machine) {
   case EM_AARCH64:
     switch (Type) {
     case DT_AARCH64_BTI_PLT:
     case DT_AARCH64_PAC_PLT:
+    case DT_AARCH64_VARIANT_PCS:
       return std::to_string(Value);
     default:
       break;
     }
     break;
   case EM_HEXAGON:
     switch (Type) {
     case DT_HEXAGON_VER:
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
     Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
   else
     Fields[3].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
 
   Fields[4].Str =
       printEnum(Symbol.getBinding(), makeArrayRef(ElfSymbolBindings));
   Fields[5].Str =
       printEnum(Symbol.getVisibility(), makeArrayRef(ElfSymbolVisibilities));
-  if (Symbol.st_other & ~0x3)
+
+  if (Symbol.st_other & ~0x3) {
+    if (this->Obj.getHeader().e_machine == ELF::EM_AARCH64) {
+      uint8_t other = Symbol.st_other & ~0x3;
+      if (other & STO_AARCH64_VARIANT_PCS) {
+        other &= ~STO_AARCH64_VARIANT_PCS;
+        Fields[5].Str += " [VARIANT_PCS";
+        if (other != 0)
+          Fields[5].Str.append(" | " + to_hexString(other, false));
+        Fields[5].Str.append("]");
+      }
+    } else {
       Fields[5].Str +=
           " [<other: " + to_string(format_hex(Symbol.st_other, 2)) + ">]";
+    }
+  }
 
   Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0;
   Fields[6].Str = getSymbolSectionNdx(Symbol, SymIndex);
 
   Fields[7].Str =
       this->dumper().getFullSymbolName(Symbol, SymIndex, StrTable, IsDynamic);
   for (const Field &Entry : Fields)
     printField(Entry);