[AARCH64][ELF][llvm-readobj] Add support for BTI and PAC dynamic tags

[peter.smith]

Summary

ELF for the 64-bit Arm Architecture defines two processor-specific dynamic tags:

• DT_AARCH64_BTI_PLT 0x70000001, d_val
• DT_AARCH64_PAC_PLT 0x70000003, d_val

These presence of these tags indicate that PLT sequences have been protected using Branch Target Identification and Pointer Authentication respectively. The presence of both indicates that the PLT sequences have been protected with both Branch Target Identification and Pointer Authentication.

This patch adds the tags and tests for llvm-readobj and yaml2obj.

ELF for the 64-bit Arm Architecture containing definitions of the tags can be found at: https://developer.arm.com/docs/ihi0056/latest/elf-for-the-arm-64-bit-architecture-aarch64-abi-2019q1-documentation

[ostannard]

test/tools/llvm-readobj/aarch64-bti-pac-dynamic.test

1 ↗

(On Diff #201917)

Copy-pasted comment?

15 ↗

(On Diff #201917)

Why is the value for PAC printed as "0x0", but BTI is just "0"?

[grimar]

test/tools/llvm-readobj/aarch64-bti-pac-dynamic.test

1 ↗

(On Diff #201917)

It is becoming common to start comments from ## in LLVM tools.
(see dynamic-section-arch-tags.test below, for example).

3 ↗

(On Diff #201917)

Lets use yaml2obj instead of precompiled binary.

15 ↗

(On Diff #201917)

FWIW it is not an issue of this patch it seems.

23 ↗

(On Diff #201917)

You can probably omit dumping of other tags.

tools/llvm-readobj/ELFDumper.cpp

1466

Excessive empty line.

[peter.smith]

test/tools/llvm-readobj/aarch64-bti-pac-dynamic.test

1 ↗

(On Diff #201917)

Yes will fix, thanks for the spot.

15 ↗

(On Diff #201917)

That is interesting, in many places in llvm-readelf the architecture specific tags are separated from each other, but in the case of printDynamicEntry they are not. So the AArch64 tags overlap with MIPS_RLD_VERSION and MIPS_ICHECKSUM. In this particular case this doesn't really matter as the value of the tag isn't important, but it may do in the future. To fix this properly will need some similar logic to isolate the cases by processor. I'll have a think.

[peter.smith]

Thanks for the comments, I hope to have an update later today.

test/tools/llvm-readobj/aarch64-bti-pac-dynamic.test

1 ↗

(On Diff #201917)

Thanks, will do.

3 ↗

(On Diff #201917)

Ok, will do so.

23 ↗

(On Diff #201917)

Ok will do.

[LukeCheeseman]

test/tools/llvm-readobj/aarch64-bti-pac-dynamic.test

15 ↗

(On Diff #201917)

Sounds like a similar issue to https://reviews.llvm.org/D50136. The overlapping aarch64 and sparc tags meant that the dumped attribute always came out as sparc attribute. It was arguably more of an issue there as it would dump an unrelated attribute. I wasn't too happy with the solution but there wasn't/isn't any support for target specific dumping.

[peter.smith]

Updated diff to use yaml2obj. It turns out there was already a processor specific dynamic tags test so I've added to that instead of writing a new one. I've taken the opportunity to separate out the printing of values for [DT_LOPROC, DT_AUXILIARY) so that the types don't clash.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

1842

I'd suggest to make the code more explicit and isolated from the switch below:

switch (ObjF->getELFFile()->getHeader()->e_machine) {
case EM_AARCH64:
  switch (Type) {
  case DT_AARCH64_BTI_PLT:
  case DT_AARCH64_PAC_PLT:
    OS << Value;
    return;
  default:
    break;
  }
case EM_HEXAGON:
  switch (Type) {
  case DT_HEXAGON_VER:
    OS << Value;
    return;
  case DT_HEXAGON_SYMSZ:
  case DT_HEXAGON_PLT:
    OS << format(ConvChar, Value);
    return;
  default:
    break;
  }
case EM_MIPS:
  switch (Type) {
  case DT_MIPS_RLD_VERSION:
  case DT_MIPS_LOCAL_GOTNO:
  case DT_MIPS_SYMTABNO:
  case DT_MIPS_UNREFEXTNO:
    <place missing mips tags here>
    OS << Value;
    return;
  case DT_MIPS_FLAGS:
    <and here (and seems one more case is also needed)>
    printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
    return;
  default:
    break;
  }
default:
  break;
}

I.e. idea is that we try to handle target specific flags first and either return or fall back to the switch for
common tags below if flag was not handled.
No need to do checks like Type >= DT_LOPROC && Type < DT_AUXILIARY or have any printing logic in default: case I think.

[peter.smith]

Thanks for the suggestion, I'll update the patch on Monday.

[peter.smith]

I've updated printDynamicEntry as suggested. There are an awful lot of MIPS tags! I've kept them with the same value as before, although I'd think that the NO tags would probably best be output as decimal. I'll leave that decision to the MIPS maintainers.

[grimar]

LGTM

include/llvm/BinaryFormat/DynamicTags.def

 #ifndef DYNAMIC_TAG
 #error "DYNAMIC_TAG must be defined"
 #endif
 
 // Add separate macros for the architecture specific tags and the markers
 // such as DT_HIOS, etc. to allow using this file to in other contexts.
 // For example we can use it to generate a stringification switch statement.
 
+#ifndef AARCH64_DYNAMIC_TAG
+#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
+#define AARCH64_DYNAMIC_TAG_DEFINED
+#endif
+
 #ifndef HEXAGON_DYNAMIC_TAG
 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
 #define HEXAGON_DYNAMIC_TAG_DEFINED
 #endif
 
 #ifndef MIPS_DYNAMIC_TAG
 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
 #define MIPS_DYNAMIC_TAG_DEFINED

 DYNAMIC_TAG(VERSYM, 0x6FFFFFF0)     // The address of .gnu.version section.
 DYNAMIC_TAG(VERDEF, 0X6FFFFFFC)     // The address of the version definition
                                     // table.
 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)
+
 // 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.
 
 MIPS_DYNAMIC_TAG(MIPS_RLD_VERSION, 0x70000001)  // 32 bit version number for

 DYNAMIC_TAG(USED, 0x7FFFFFFE)      // Same as DT_NEEDED
 DYNAMIC_TAG(FILTER, 0x7FFFFFFF)    // Shared object to get values from
 
 
 #ifdef DYNAMIC_TAG_MARKER_DEFINED
 #undef DYNAMIC_TAG_MARKER
 #undef DYNAMIC_TAG_MARKER_DEFINED
 #endif
+#ifdef AARCH64_DYNAMIC_TAG_DEFINED
+#undef AARCH64_DYNAMIC_TAG
+#undef AARCH64_DYNAMIC_TAG_DEFINED
+#endif
 #ifdef MIPS_DYNAMIC_TAG_DEFINED
 #undef MIPS_DYNAMIC_TAG
 #undef MIPS_DYNAMIC_TAG_DEFINED
 #endif
 #ifdef HEXAGON_DYNAMIC_TAG_DEFINED
 #undef HEXAGON_DYNAMIC_TAG
 #undef HEXAGON_DYNAMIC_TAG_DEFINED
 #endif
 #ifdef PPC64_DYNAMIC_TAG_DEFINED
 #undef PPC64_DYNAMIC_TAG
 #undef PPC64_DYNAMIC_TAG_DEFINED
 #endif

lib/Object/ELF.cpp

 std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
                                                  uint64_t Type) const {
 #define DYNAMIC_STRINGIFY_ENUM(tag, value)                                     \
   case value:                                                                  \
     return #tag;
 
 #define DYNAMIC_TAG(n, v)
   switch (Arch) {
+  case ELF::EM_AARCH64:
+    switch (Type) {
+#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
+#include "llvm/BinaryFormat/DynamicTags.def"
+#undef AARCH64_DYNAMIC_TAG
+    }
+    break;
+
   case ELF::EM_HEXAGON:
     switch (Type) {
 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef HEXAGON_DYNAMIC_TAG
     }
     break;
 

 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef PPC64_DYNAMIC_TAG
     }
     break;
   }
 #undef DYNAMIC_TAG
   switch (Type) {
 // Now handle all dynamic tags except the architecture specific ones
+#define AARCH64_DYNAMIC_TAG(name, value)
 #define MIPS_DYNAMIC_TAG(name, value)
 #define HEXAGON_DYNAMIC_TAG(name, value)
 #define PPC64_DYNAMIC_TAG(name, value)
 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
 #define DYNAMIC_TAG_MARKER(name, value)
 #define DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef DYNAMIC_TAG
+#undef AARCH64_DYNAMIC_TAG
 #undef MIPS_DYNAMIC_TAG
 #undef HEXAGON_DYNAMIC_TAG
 #undef PPC64_DYNAMIC_TAG
 #undef DYNAMIC_TAG_MARKER
 #undef DYNAMIC_STRINGIFY_ENUM
   default:
     return "<unknown:>0x" + utohexstr(Type, true);
   }

lib/ObjectYAML/ELFYAML.cpp

 }
 
 void ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG>::enumeration(
     IO &IO, ELFYAML::ELF_DYNTAG &Value) {
   const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
   assert(Object && "The IO context is not initialized");
 
 // Disable architecture specific tags by default. We might enable them below.
+#define AARCH64_DYNAMIC_TAG(name, value)
 #define MIPS_DYNAMIC_TAG(name, value)
 #define HEXAGON_DYNAMIC_TAG(name, value)
 #define PPC64_DYNAMIC_TAG(name, value)
 // Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
 #define DYNAMIC_TAG_MARKER(name, value)
 
 #define STRINGIFY(X) (#X)
 #define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
   switch (Object->Header.Machine) {
+  case ELF::EM_AARCH64:
+#undef AARCH64_DYNAMIC_TAG
+#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
+#include "llvm/BinaryFormat/DynamicTags.def"
+#undef AARCH64_DYNAMIC_TAG
+#define AARCH64_DYNAMIC_TAG(name, value)
+    break;
   case ELF::EM_MIPS:
 #undef MIPS_DYNAMIC_TAG
 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef MIPS_DYNAMIC_TAG
 #define MIPS_DYNAMIC_TAG(name, value)
     break;
   case ELF::EM_HEXAGON:

 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef PPC64_DYNAMIC_TAG
 #define PPC64_DYNAMIC_TAG(name, value)
     break;
   default:
 #include "llvm/BinaryFormat/DynamicTags.def"
     break;
   }
-
+#undef AARCH64_DYNAMIC_TAG
 #undef MIPS_DYNAMIC_TAG
 #undef HEXAGON_DYNAMIC_TAG
 #undef PPC64_DYNAMIC_TAG
 #undef DYNAMIC_TAG_MARKER
 #undef STRINGIFY
 #undef DYNAMIC_TAG
 
   IO.enumFallback<Hex64>(Value);

test/tools/llvm-readobj/Inputs/elf-dynamic-tags-machine-specific.yaml

- Type: PT_LOAD
     VAddr: 0x1000
     Sections:
       - Section: .dynstr
       - Section: .dynamic
   - Type: PT_DYNAMIC
     VAddr: 0x1010
     Sections:
       - Section: .dynamic
+
+# Fourth document: AARCH64
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_AARCH64
+Sections:
+  - Name:    .dynstr
+    Type:    SHT_STRTAB
+    Address: 0x1000
+    Size:    0x10
+    Content: "004400550066007700"
+  - Name:    .dynamic
+    Type:    SHT_DYNAMIC
+    Address: 0x1010
+    Entries:
+      - Tag:   DT_HASH
+        Value: 0x1000
+      - Tag:   DT_AARCH64_BTI_PLT
+        Value: 0
+      - Tag:   DT_AARCH64_PAC_PLT
+        Value: 0
+      - Tag:   0x1234abcd
+        Value: 0x1
+      - Tag:   DT_NULL
+        Value: 0
+ProgramHeaders:
+  - Type: PT_LOAD
+    VAddr: 0x1000
+    Sections:
+      - Section: .dynstr
+      - Section: .dynamic
+  - Type: PT_DYNAMIC
+    VAddr: 0x1010
+    Sections:
+      - Section: .dynamic

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

 # LLVM-PPC-NEXT: ]
 
 # GNU-PPC:      Dynamic section at offset {{.*}} contains 4 entries:
 # GNU-PPC-NEXT:   Tag                Type                 Name/Value
 # GNU-PPC-NEXT:   0x0000000000000004 (HASH)               0x1000
 # GNU-PPC-NEXT:   0x0000000070000000 (PPC64_GLINK)        0x1000
 # GNU-PPC-NEXT:   0x000000001234abcd (unknown)            0x1
 # GNU-PPC-NEXT:   0x0000000000000000 (NULL)               0x0
+
+# Test that AARCH64 machine-specific tags can be dumped.
+# RUN: yaml2obj --docnum=4 %S/Inputs/elf-dynamic-tags-machine-specific.yaml -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 [ (5 entries)
+# LLVM-AARCH64-NEXT:  Tag                Type                 Name/Value
+# LLVM-AARCH64-NEXT:  0x0000000000000004 HASH                 0x1000
+# LLVM-AARCH64-NEXT:  0x0000000070000001 AARCH64_BTI_PLT      0
+# LLVM-AARCH64-NEXT:  0x0000000070000003 AARCH64_PAC_PLT      0
+# LLVM-AARCH64-NEXT:  0x000000001234ABCD unknown              0x1
+# LLVM-AARCH64-NEXT:  0x0000000000000000 NULL                 0x0
+# LLVM-AARCH64-NEXT:]
+
+# GNU-AARCH64:      Dynamic section at offset {{.*}} contains 5 entries:
+# GNU-AARCH64-NEXT:  Tag                Type                 Name/Value
+# GNU-AARCH64-NEXT:  0x0000000000000004 (HASH)               0x1000
+# GNU-AARCH64-NEXT:  0x0000000070000001 (AARCH64_BTI_PLT)    0
+# GNU-AARCH64-NEXT:  0x0000000070000003 (AARCH64_PAC_PLT)    0
+# GNU-AARCH64-NEXT:  0x000000001234abcd (unknown)            0x1
+# GNU-AARCH64-NEXT:  0x0000000000000000 (NULL)               0x0

test/tools/obj2yaml/dynamic-section-arch-tags.test

FileHeader:
   Machine:           EM_PPC64
 Sections:
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Entries:
       - Tag:             DT_PPC64_GLINK
         Value:           0x0000000000000001
 
+## Check we can handle AARCH64 specific tags.
+# RUN: yaml2obj -docnum=4 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=AARCH64
+
+# AARCH64:      - Tag:             DT_AARCH64_BTI_PLT
+# AARCH64-NEXT:   Value:           0x0000000000000000
+# AARCH64-NEXT: - Tag:             DT_AARCH64_PAC_PLT
+# AARCH64-NEXT:   Value:           0x0000000000000000
+
+--- !ELF
+FileHeader:
+  Class:             ELFCLASS64
+  Data:              ELFDATA2LSB
+  Type:              ET_REL
+  Machine:           EM_AARCH64
+Sections:
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Entries:
+      - Tag:             DT_AARCH64_BTI_PLT
+        Value:           0x0000000000000000
+      - Tag:             DT_AARCH64_PAC_PLT
+        Value:           0x0000000000000000
+
 ## Check we can't use a tag from a different architecture,
 ## even if it has the same numeric value as a valid tag.
 ## Here for EM_PPC64 we are trying to use DT_HEXAGON_SYMSZ
 ## instead of DT_PPC64_GLINK. They both have value of 0x70000000.
 
-# RUN: not yaml2obj -docnum=4 %s 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: not yaml2obj -docnum=5 %s 2>&1 | FileCheck %s --check-prefix=ERR
 # ERR:      error: invalid hex64 number
 # ERR-NEXT: - Tag: DT_HEXAGON_SYMSZ
 
 --- !ELF
 FileHeader:
   Class:             ELFCLASS64
   Data:              ELFDATA2LSB
   Type:              ET_REL
   Machine:           EM_PPC64
 Sections:
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Entries:
       - Tag:             DT_HEXAGON_SYMSZ
         Value:           0x0000000000000001

tools/llvm-readobj/ELFDumper.cpp

if (opts::Output == opts::GNU)
     ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer, this));
   else
     ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer, this));
 }
 
 static const char *getTypeString(unsigned Arch, uint64_t Type) {
 #define DYNAMIC_TAG(n, v)
   switch (Arch) {
+
+  case EM_AARCH64:
+    switch (Type) {
+#define AARCH64_DYNAMIC_TAG(name, value)                                       \
+    case DT_##name:                                                            \
+      return #name;
+#include "llvm/BinaryFormat/DynamicTags.def"
+#undef AARCH64_DYNAMIC_TAG
+    }
+    break;
+
   case EM_HEXAGON:
     switch (Type) {
 #define HEXAGON_DYNAMIC_TAG(name, value)                                       \
   case DT_##name:                                                              \
     return #name;
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef HEXAGON_DYNAMIC_TAG
     }

 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef PPC64_DYNAMIC_TAG
     }
     break;
   }
 #undef DYNAMIC_TAG
   switch (Type) {
 // Now handle all dynamic tags except the architecture specific ones
+#define AARCH64_DYNAMIC_TAG(name, value)
 #define MIPS_DYNAMIC_TAG(name, value)
 #define HEXAGON_DYNAMIC_TAG(name, value)
 #define PPC64_DYNAMIC_TAG(name, value)
 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
 #define DYNAMIC_TAG_MARKER(name, value)
 #define DYNAMIC_TAG(name, value)                                               \
   case DT_##name:                                                              \
     return #name;
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef DYNAMIC_TAG
+#undef AARCH64_DYNAMIC_TAG
 #undef MIPS_DYNAMIC_TAG
 #undef HEXAGON_DYNAMIC_TAG
 #undef PPC64_DYNAMIC_TAG
 #undef DYNAMIC_TAG_MARKER
   default:
     return "unknown";
   }
 }
static void printLibrary(raw_ostream &OS, const Twine &Tag, const Twine &Name) {
   OS << Tag << ": [" << Name << "]";
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printDynamicEntry(raw_ostream &OS, uint64_t Type,
                                         uint64_t Value) const {
   const char *ConvChar =
       (opts::Output == opts::GNU) ? "0x%" PRIx64 : "0x%" PRIX64;
+
+  // Handle custom printing of architecture specific tags apart
+  // from the machine independent SUN extensions from DT_AUXILIARY
+  if (Type >= DT_LOPROC && Type < DT_AUXILIARY) {
+    switch (ObjF->getELFFile()->getHeader()->e_machine) {
+    case EM_AARCH64:
+      switch (Type) {
+      case DT_AARCH64_BTI_PLT:
+      case DT_AARCH64_PAC_PLT:
+        OS << Value;
+        return;
+      default:
+        OS << format(ConvChar, Value);
+        return;
+      }
+    case EM_HEXAGON:
+      switch (Type) {
+      case DT_HEXAGON_VER:
+        OS << Value;
+        return;
+      default:
+        OS << format(ConvChar, Value);
+        return;
+      }
+    case EM_MIPS:
+      switch (Type) {
+      case DT_MIPS_RLD_VERSION:
+      case DT_MIPS_LOCAL_GOTNO:
+      case DT_MIPS_SYMTABNO:
+      case DT_MIPS_UNREFEXTNO:
+        OS << Value;
+        return;
+      case DT_MIPS_FLAGS:
+        printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
+        return;
+      default:
+        OS << format(ConvChar, Value);
+        return;
+      }
+    default:
+      OS << format(ConvChar, Value);
+      return;
+    }
+  }
+
   switch (Type) {
   case DT_PLTREL:
     if (Value == DT_REL) {
       OS << "REL";
       break;
     } else if (Value == DT_RELA) {
       OS << "RELA";
       break;
void ELFDumper<ELFT>::printDynamicEntry(raw_ostream &OS, uint64_t Type,
   case DT_FINI_ARRAY:
   case DT_PREINIT_ARRAY:
   case DT_DEBUG:
   case DT_VERDEF:
   case DT_VERNEED:
   case DT_VERSYM:
   case DT_GNU_HASH:
   case DT_NULL:
-  case DT_MIPS_BASE_ADDRESS:
-  case DT_MIPS_GOTSYM:
-  case DT_MIPS_RLD_MAP:
-  case DT_MIPS_RLD_MAP_REL:
-  case DT_MIPS_PLTGOT:
-  case DT_MIPS_OPTIONS:
     OS << format(ConvChar, Value);
     break;
   case DT_RELACOUNT:
   case DT_RELCOUNT:
   case DT_VERDEFNUM:
   case DT_VERNEEDNUM:
-  case DT_MIPS_RLD_VERSION:
-  case DT_MIPS_LOCAL_GOTNO:
-  case DT_MIPS_SYMTABNO:
-  case DT_MIPS_UNREFEXTNO:
     OS << Value;
     break;
   case DT_PLTRELSZ:
   case DT_RELASZ:
   case DT_RELAENT:
   case DT_STRSZ:
   case DT_SYMENT:
   case DT_RELSZ:
case DT_USED:
     break;
   case DT_FILTER:
     printLibrary(OS, "Filter library", getDynamicString(Value));
     break;
   case DT_RPATH:
   case DT_RUNPATH:
     OS << getDynamicString(Value);
     break;
-  case DT_MIPS_FLAGS:
-    printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
-    break;
   case DT_FLAGS:
     printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
     break;
   case DT_FLAGS_1:
     printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
     break;
   default:
     OS << format(ConvChar, Value);