[llvm-readelf] - Allow dumping of the .dynamic section even if there is no PT_DYNAMIC header.

[grimar]

Summary

It is now possible after D61937 was landed and was discussed
in it's review comments. It is not consistent with GNU, which
does not output .dynamic section content in this case for
no visible reason.

Should it be only done for LLVM style output, i.e. for llvm-readobj,
but not for GNU (llvm-readelf)?

[jhenderson]

This is an odd situation anyway (unless you know of a concrete example), so I don't think any users are likely to hit it either way. I don't think we need to follow GNU's behaviour here as a result. We should just do what makes the most sense (and GNU's behaviour doesn't make much sense to me). It would be worth getting somebody else's opinion on this too.

tools/llvm-readobj/ELFDumper.cpp

1363–1364 ↗

(On Diff #200439)

might want -> will
the dynamic section found -> the found dynamic section

I don't think you need the last sentence.

[grimar]

• Updated comments.

[jhenderson]

LGTM, but you may want to wait for others to comment too.

[grimar]

In D62179#1511693, @jhenderson wrote:

LGTM, but you may want to wait for others to comment too.

Yep, I'll hold it for a while.

[rupprecht]

In D62179#1510386, @jhenderson wrote:

This is an odd situation anyway (unless you know of a concrete example), so I don't think any users are likely to hit it either way. I don't think we need to follow GNU's behaviour here as a result. We should just do what makes the most sense (and GNU's behaviour doesn't make much sense to me). It would be worth getting somebody else's opinion on this too.

Same here... this patch seems fine, someone would need a use case for:

• Having dynamic sections
• Not having PT_HEADERs
• Needing llvm-readelf to be quiet about it

Which seems unlikely, but maybe wait a day or two.

[grimar]

I had to revert this one.
It broke the following tests in a different projects:
(My apologies that I did not notice that before posting on review)

lld :: ELF/linkerscript/empty-tls.test
lld :: ELF/linkerscript/pt-interp.test
LLVM :: Object/invalid.test
LLVM :: tools/yaml2obj/dynamic-section-raw-content.yaml

The error is the same, it is: "Virtual address is not in any segment"
and is coming from `here: https://github.com/llvm-mirror/llvm/blob/master/lib/Object/ELF.cpp#L559

which is called from a place where dynamic tags are parsed:
https://github.com/llvm-mirror/llvm/blob/master/tools/llvm-readobj/ELFDumper.cpp#L1497

I looked on the empty-tls.test and the problem is that it contains only TLS prorgam header,
and the following call fails:

case ELF::DT_SYMTAB:
   DynSymRegion.Addr = toMappedAddr(Dyn.getPtr());
..

I.e. since there is no segment, covering the address of dynamic symbol table,
it fails to get its data properly.

We probably can make this error not critical, i.e. skip the dynamic entries that
requires other segnemts, but I am not sure it really worth the efford and
additional code complication.

I am abandodning this patch.

[rupprecht]

In D62179#1515750, @grimar wrote:

I had to revert this one.
It broke the following tests in a different projects:
(My apologies that I did not notice that before posting on review)

lld :: ELF/linkerscript/empty-tls.test
lld :: ELF/linkerscript/pt-interp.test
LLVM :: Object/invalid.test
LLVM :: tools/yaml2obj/dynamic-section-raw-content.yaml

The error is the same, it is: "Virtual address is not in any segment"
and is coming from `here: https://github.com/llvm-mirror/llvm/blob/master/lib/Object/ELF.cpp#L559

which is called from a place where dynamic tags are parsed:
https://github.com/llvm-mirror/llvm/blob/master/tools/llvm-readobj/ELFDumper.cpp#L1497
...
We probably can make this error not critical, i.e. skip the dynamic entries that
requires other segnemts, but I am not sure it really worth the efford and
additional code complication.

I am abandodning this patch.

I've seen this same error internally when switching from GNU readelf to llvm-readelf and reading core files with it, and I'm interested in fixing that. GNU readelf does what you mention -- prints a warning and moves on. I think that's useful; we should be able to use tools to read partial information from a corrupt/incomplete file.

[grimar]

In D62179#1516667, @rupprecht wrote:

In D62179#1515750, @grimar wrote:

I had to revert this one.
It broke the following tests in a different projects:
(My apologies that I did not notice that before posting on review)

lld :: ELF/linkerscript/empty-tls.test
lld :: ELF/linkerscript/pt-interp.test
LLVM :: Object/invalid.test
LLVM :: tools/yaml2obj/dynamic-section-raw-content.yaml

The error is the same, it is: "Virtual address is not in any segment"
and is coming from `here: https://github.com/llvm-mirror/llvm/blob/master/lib/Object/ELF.cpp#L559

which is called from a place where dynamic tags are parsed:
https://github.com/llvm-mirror/llvm/blob/master/tools/llvm-readobj/ELFDumper.cpp#L1497
...
We probably can make this error not critical, i.e. skip the dynamic entries that
requires other segnemts, but I am not sure it really worth the efford and
additional code complication.

I am abandodning this patch.

I've seen this same error internally when switching from GNU readelf to llvm-readelf and reading core files with it, and I'm interested in fixing that. GNU readelf does what you mention -- prints a warning and moves on. I think that's useful; we should be able to use tools to read partial information from a corrupt/incomplete file.

OK. I'll resurrect this one and take a look.

[grimar]

• Updated implementation and test cases in according to latest discussion comments.

(now llvm-readelf bypass the "Virtual address is not in any segment" error and will try to continue parsing the object).

[rupprecht]

Thanks for following up with this! Just one optional suggestion:

tools/llvm-readobj/ELFDumper.cpp

1486 ↗

(On Diff #201530)

Instead of constants like "DT_HASH" for all these changes, can you pass in Dyn.d_tag instead and use getTypeString() within toMappedAddr to print the string? (Passing Obj->getHeader()->e_machine by lambda capture). That will keep all these calls identical.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

1486 ↗

(On Diff #201530)

Oh, cool, I did not know we have something like getTypeString() here (or perhaps forgot about that) , thanks!

[jankratochvil]

There is a regression - after this patch - at least after its later commit:

commit 8ac7b2d07bd6042afe0e8618ca8682d7663f4be8
Author: George Rimar <[e-mail]>
Date:   Wed May 29 10:31:46 2019 +0000
    [llvm-readelf] - Allow dumping of the .dynamic section even if there is no PT_DYNAMIC header.
    Differential revision: https://reviews.llvm.org/D62179
    llvm-svn: 361943

llvm-readobj cannot print .dynsym of executable without Program Headers. GNU readelf can print it fine. We have found it with @kwk because of some unrelated bug in obj2yaml/`yaml2obj' dropping Program Headers.
On 64-bit Linux one can create a test binary with:

cp -p /bin/bash /tmp/bashtest;dd if=/dev/zero of=/tmp/bashtest bs=1 count=2 seek=$[0x38] conv=notrunc

llvm-readobj -dyn-symbols formerly printed for example:

Symbol {
  Name: tilde_expand_word (11424)
  Value: 0xDBE60

while now it prints only:

warning: Unable to parse DT_GNU_HASH: Virtual address is not in any segment
warning: Unable to parse DT_STRTAB: Virtual address is not in any segment
warning: Unable to parse DT_SYMTAB: Virtual address is not in any segment
warning: Unable to parse DT_JMPREL: Virtual address is not in any segment
warning: Unable to parse DT_RELA: Virtual address is not in any segment
File: /tmp/bashtest
Format: ELF64-x86-64
Arch: x86_64
AddressSize: 64bit 
LoadName:
DynamicSymbols [
]

[grimar]

In D62179#1652778, @jankratochvil wrote:

There is a regression - after this patch - at least after its later commit

I'll investigate.

[grimar]

In D62179#1652778, @jankratochvil wrote:

There is a regression - after this patch - at least after its later commit:

commit 8ac7b2d07bd6042afe0e8618ca8682d7663f4be8
Author: George Rimar <[e-mail]>
Date:   Wed May 29 10:31:46 2019 +0000
    [llvm-readelf] - Allow dumping of the .dynamic section even if there is no PT_DYNAMIC header.
    Differential revision: https://reviews.llvm.org/D62179
    llvm-svn: 361943

llvm-readobj cannot print .dynsym of executable without Program Headers. GNU readelf can print it fine. We have found it with @kwk because of some unrelated bug in obj2yaml/`yaml2obj' dropping Program Headers.
On 64-bit Linux one can create a test binary with:

cp -p /bin/bash /tmp/bashtest;dd if=/dev/zero of=/tmp/bashtest bs=1 count=2 seek=$[0x38] conv=notrunc

llvm-readobj -dyn-symbols formerly printed for example:

Symbol {
  Name: tilde_expand_word (11424)
  Value: 0xDBE60

while now it prints only:

warning: Unable to parse DT_GNU_HASH: Virtual address is not in any segment
warning: Unable to parse DT_STRTAB: Virtual address is not in any segment
warning: Unable to parse DT_SYMTAB: Virtual address is not in any segment
warning: Unable to parse DT_JMPREL: Virtual address is not in any segment
warning: Unable to parse DT_RELA: Virtual address is not in any segment
File: /tmp/bashtest
Format: ELF64-x86-64
Arch: x86_64
AddressSize: 64bit 
LoadName:
DynamicSymbols [
]

I posted a patch to fix this: https://reviews.llvm.org/D67078. Thanks for reporting!

llvm/trunk/test/Object/corrupt.test

 STRTAB: Invalid dynamic string table reference
 
 RUN: not llvm-readobj -l \
 RUN:   %p/Inputs/corrupt-invalid-phentsize.elf.x86-64 2>&1 | \
 RUN:   FileCheck --check-prefix=PHENTSIZE %s
 
 PHENTSIZE: invalid e_phentsize
 
-RUN: not llvm-readobj --dynamic-table \
+RUN: llvm-readobj --dynamic-table \
 RUN:   %p/Inputs/corrupt-invalid-virtual-addr.elf.x86-64 2>&1 | \
 RUN:   FileCheck --check-prefix=VIRTADDR %s
 
-VIRTADDR: Virtual address is not in any segment
+VIRTADDR: warning: Unable to parse DT_STRTAB: Virtual address is not in any segment
 
 
 RUN: not llvm-readobj --dyn-relocations \
 RUN:   %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 | \
 RUN:   FileCheck --check-prefix=RELOC %s
 
 RELOC:  Invalid entity size
 

llvm/trunk/test/Object/invalid.test

 SECTION-NEXT:    Link:
 SECTION-NEXT:    Info:
 SECTION-NEXT:    AddressAlignment:
 SECTION-NEXT:    EntrySize: 32
 
 RUN: not llvm-readobj --symbols %p/Inputs/invalid-sh_entsize.elf 2>&1 | FileCheck --check-prefix=INVALID-SYM-SIZE %s
 INVALID-SYM-SIZE: invalid sh_entsize
 
-RUN: not llvm-readobj --dyn-symbols %p/Inputs/invalid-sh_entsize.elf 2>&1 | FileCheck --check-prefix=INVALID-DYNSYM-SIZE %s
-INVALID-DYNSYM-SIZE: Invalid entity size
-
 RUN: not llvm-readobj --symbols %p/Inputs/invalid-section-index.elf 2>&1 | FileCheck --check-prefix=INVALID-SECTION-INDEX %s
 INVALID-SECTION-INDEX: invalid section index
 
 RUN: not llvm-readobj -S %p/Inputs/invalid-section-size.elf 2>&1 | FileCheck --check-prefix=INVALID-SECTION-SIZE %s
 INVALID-SECTION-SIZE: invalid section header entry size (e_shentsize) in ELF header
 
 
 RUN: not llvm-readobj --symbols %p/Inputs/invalid-symbol-table-size.elf 2>&1 | FileCheck --check-prefix=INVALID-SYMTAB-SIZE %s

llvm/trunk/test/tools/llvm-readobj/elf-dynamic-malformed.test

- Type: PT_DYNAMIC
     Sections:
       - Section: .dynamic
 
 # Test handling of DT_STRTAB pointing outside the file's address space.
 # RUN: yaml2obj %s --docnum=4 -o %t.bad-strtab
 # RUN: not llvm-readobj --dynamic-table %t.bad-strtab 2>&1 | FileCheck %s --check-prefix BAD-STRTAB
 # RUN: not llvm-readelf --dynamic-table %t.bad-strtab 2>&1 | FileCheck %s --check-prefix BAD-STRTAB
 
-# BAD-STRTAB: LLVM ERROR: Virtual address is not in any segment
+# BAD-STRTAB: warning: Unable to parse DT_STRTAB: Virtual address is not in any segment
+# BAD-STRTAB: error: Invalid dynamic string table reference
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
Sections:
       - Section: .dynamic
   - Type: PT_DYNAMIC
     VAddr: 0x1000
     Sections:
       - Section: .dynamic
 
 # Test handling of other d_ptr tags pointing outside the file's address space.
 # RUN: yaml2obj %s --docnum=5 -o %t.bad-rela
-# RUN: not llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck %s --check-prefix BAD-RELA
-# RUN: not llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck %s --check-prefix BAD-RELA
+# RUN: llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck %s --check-prefixes=CHECK,BAD-RELA
+# RUN: llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck %s --check-prefixes=CHECK,BAD-RELA-GNU
 
-# BAD-RELA: LLVM ERROR: Virtual address is not in any segment
+# CHECK: warning: Unable to parse DT_RELA: Virtual address is not in any segment
+# BAD-RELA:      DynamicSection [ (2 entries)
+# BAD-RELA-NEXT:   Tag                Type Name/Value
+# BAD-RELA-NEXT:   0x0000000000000007 RELA 0x1000000
+# BAD-RELA-NEXT:   0x0000000000000000 NULL 0x0
+# BAD-RELA-NEXT: ]
+# BAD-RELA-GNU:      Dynamic section at offset 0x1f0 contains 2 entries:
+# BAD-RELA-GNU-NEXT: Tag                Type   Name/Value
+# BAD-RELA-GNU-NEXT: 0x0000000000000007 (RELA) 0x1000000
+# BAD-RELA-GNU-NEXT: 0x0000000000000000 (NULL) 0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

llvm/trunk/test/tools/llvm-readobj/elf-dynamic-no-pt-dynamic.test

-# Show that no dumping occurs if there is no PT_DYNAMIC header.
+## Show that dumping occurs even if there is no PT_DYNAMIC header.
+## This is inconsistent with the GNU behavior, but seems to be more reasonable.
 # RUN: yaml2obj %s -o %t.no-phdr
 # RUN: llvm-readobj --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=LLVM
-# RUN: llvm-readelf --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=GNU --allow-empty
+# RUN: llvm-readelf --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=GNU
 
 # LLVM:      File: {{.*}}.no-phdr
 # LLVM-NEXT: Format: ELF64-x86-64
 # LLVM-NEXT: Arch: x86_64
 # LLVM-NEXT: AddressSize: 64bit
 # LLVM-NEXT: LoadName:{{ *}}
-# LLVM-NOT:  {{.}}
+# LLVM-NEXT: DynamicSection [ (1 entries)
+# LLVM-NEXT:   Tag                Type Name/Value
+# LLVM-NEXT:   0x0000000000000000 NULL 0x0
+# LLVM-NEXT: ]
 
-# GNU-NOT: {{.}}
+# GNU:      Dynamic section at offset 0x1b8 contains 1 entries:
+# GNU-NEXT: Tag                Type   Name/Value
+# GNU-NEXT: 0x0000000000000000 (NULL) 0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

llvm/trunk/test/tools/yaml2obj/dynamic-section-raw-content.yaml

 # Show that yaml2obj can handle a dynamic section with raw content instead of
 # entries. Also show that it rejects raw content when entries are also provided.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj -x .dynamic --sections %t1 | FileCheck %s --check-prefix=RAW
 
 # RAW:      Name: .dynamic
 # RAW-NEXT: Type: SHT_DYNAMIC
 # RAW-NEXT: Flags [
 # RAW-NEXT: ]
 # RAW-NEXT: Address:
 # RAW-NEXT: Offset:
-# RAW-NEXT: Size: 5
+# RAW-NEXT: Size: 16
 
 # RAW:      Hex dump of section '.dynamic':
-# RAW-NEXT: 0x00000000 01234567 89 {{.*}}
+# RAW-NEXT: 0x00000000 01234567 89012345 67890000 00000000 {{.*}}
 
 # RUN: not yaml2obj --docnum=2 %s -o %t2 2>&1 | FileCheck %s --check-prefix=ERR
 # ERR: Cannot specify both raw content and explicit entries for dynamic section '.dynamic'.
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
-    Content: "0123456789"
+    Content: "01234567890123456789000000000000"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Content: "0123456789"
     Entries:
       - Tag:   DT_STRSZ
         Value: 0

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

static const char *getElfMipsOptionsOdkType(unsigned Odk) {
   LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE);
   default:
     return "Unknown";
   }
 }
 
 template <typename ELFT>
 void ELFDumper<ELFT>::loadDynamicTable(const ELFFile<ELFT> *Obj) {
+  // Try to locate the PT_DYNAMIC header.
   const Elf_Phdr *DynamicPhdr = nullptr;
   for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
     if (Phdr.p_type != ELF::PT_DYNAMIC)
       continue;
     DynamicPhdr = &Phdr;
     break;
   }
 
-  // We do not want to dump dynamic section if we have no PT_DYNAMIC header.
-  // This matches GNU's behavior.
-  if (!DynamicPhdr)
-    return;
-
   // Try to locate the .dynamic section in the sections header table.
   const Elf_Shdr *DynamicSec = nullptr;
   for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
     if (Sec.sh_type != ELF::SHT_DYNAMIC)
       continue;
     DynamicSec = &Sec;
     break;
   }
 
   // Information in the section header has priority over the information
   // in a PT_DYNAMIC header.
   // Ignore sh_entsize and use the expected value for entry size explicitly.
   // This allows us to dump the dynamic sections with a broken sh_entsize
   // field.
-  if (DynamicSec)
+  if (DynamicSec) {
     DynamicTable = checkDRI({ObjF->getELFFile()->base() + DynamicSec->sh_offset,
                              DynamicSec->sh_size, sizeof(Elf_Dyn)});
+    parseDynamicTable();
+  }
+
+  // If we have a PT_DYNAMIC header, we will either check the found dynamic
+  // section or take the dynamic table data directly from the header.
+  if (!DynamicPhdr)
+    return;
 
   if (DynamicPhdr->p_offset + DynamicPhdr->p_filesz >
       ObjF->getMemoryBufferRef().getBufferSize())
     reportError(
         "PT_DYNAMIC segment offset + size exceeds the size of the file");
 
   if (!DynamicSec) {
     DynamicTable = createDRIFrom(DynamicPhdr, sizeof(Elf_Dyn));
     parseDynamicTable();
     return;
   }
 
   StringRef Name = unwrapOrError(Obj->getSectionName(DynamicSec));
-
   if (DynamicSec->sh_addr + DynamicSec->sh_size >
           DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz ||
       DynamicSec->sh_addr < DynamicPhdr->p_vaddr)
     reportWarning("The SHT_DYNAMIC section '" + Name +
                   "' is not contained within the "
                   "PT_DYNAMIC segment");
 
   if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr)
     reportWarning("The SHT_DYNAMIC section '" + Name +
                   "' is not at the start of "
                   "PT_DYNAMIC segment");
-
-  parseDynamicTable();
 }
 
 template <typename ELFT>
 ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> *ObjF,
     ScopedPrinter &Writer)
     : ObjDumper(Writer), ObjF(ObjF) {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
 
ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> *ObjF,
   loadDynamicTable(Obj);
 
   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_HEXAGON:
+    switch (Type) {
+#define HEXAGON_DYNAMIC_TAG(name, value)                                       \
+  case DT_##name:                                                              \
+    return #name;
+#include "llvm/BinaryFormat/DynamicTags.def"
+#undef HEXAGON_DYNAMIC_TAG
+    }
+    break;
+
+  case EM_MIPS:
+    switch (Type) {
+#define MIPS_DYNAMIC_TAG(name, value)                                          \
+  case DT_##name:                                                              \
+    return #name;
+#include "llvm/BinaryFormat/DynamicTags.def"
+#undef MIPS_DYNAMIC_TAG
+    }
+    break;
+
+  case EM_PPC64:
+    switch (Type) {
+#define PPC64_DYNAMIC_TAG(name, value)                                         \
+  case DT_##name:                                                              \
+    return #name;
+#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 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 MIPS_DYNAMIC_TAG
+#undef HEXAGON_DYNAMIC_TAG
+#undef PPC64_DYNAMIC_TAG
+#undef DYNAMIC_TAG_MARKER
+  default:
+    return "unknown";
+  }
+}
+
 template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() {
-  auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
+  auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * {
     auto MappedAddrOrError = ObjF->getELFFile()->toMappedAddr(VAddr);
-    if (!MappedAddrOrError)
-      report_fatal_error(MappedAddrOrError.takeError());
+    if (!MappedAddrOrError) {
+      reportWarning("Unable to parse DT_" +
+                    Twine(getTypeString(
+                        ObjF->getELFFile()->getHeader()->e_machine, Tag)) +
+                    ": " + llvm::toString(MappedAddrOrError.takeError()));
+      return nullptr;
+    }
     return MappedAddrOrError.get();
   };
 
   uint64_t SONameOffset = 0;
   const char *StringTableBegin = nullptr;
   uint64_t StringTableSize = 0;
   for (const Elf_Dyn &Dyn : dynamic_table()) {
     switch (Dyn.d_tag) {
     case ELF::DT_HASH:
-      HashTable =
-          reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
+      HashTable = reinterpret_cast<const Elf_Hash *>(
+          toMappedAddr(Dyn.getTag(), Dyn.getPtr()));
       break;
     case ELF::DT_GNU_HASH:
-      GnuHashTable =
-          reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr()));
+      GnuHashTable = reinterpret_cast<const Elf_GnuHash *>(
+          toMappedAddr(Dyn.getTag(), Dyn.getPtr()));
       break;
     case ELF::DT_STRTAB:
-      StringTableBegin =
-          reinterpret_cast<const char *>(toMappedAddr(Dyn.getPtr()));
+      StringTableBegin = reinterpret_cast<const char *>(
+          toMappedAddr(Dyn.getTag(), Dyn.getPtr()));
       break;
     case ELF::DT_STRSZ:
       StringTableSize = Dyn.getVal();
       break;
     case ELF::DT_SYMTAB:
-      DynSymRegion.Addr = toMappedAddr(Dyn.getPtr());
+      DynSymRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr());
       DynSymRegion.EntSize = sizeof(Elf_Sym);
       break;
     case ELF::DT_RELA:
-      DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
+      DynRelaRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr());
       break;
     case ELF::DT_RELASZ:
       DynRelaRegion.Size = Dyn.getVal();
       break;
     case ELF::DT_RELAENT:
       DynRelaRegion.EntSize = Dyn.getVal();
       break;
     case ELF::DT_SONAME:
       SONameOffset = Dyn.getVal();
       break;
     case ELF::DT_REL:
-      DynRelRegion.Addr = toMappedAddr(Dyn.getPtr());
+      DynRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr());
       break;
     case ELF::DT_RELSZ:
       DynRelRegion.Size = Dyn.getVal();
       break;
     case ELF::DT_RELENT:
       DynRelRegion.EntSize = Dyn.getVal();
       break;
     case ELF::DT_RELR:
     case ELF::DT_ANDROID_RELR:
-      DynRelrRegion.Addr = toMappedAddr(Dyn.getPtr());
+      DynRelrRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr());
       break;
     case ELF::DT_RELRSZ:
     case ELF::DT_ANDROID_RELRSZ:
       DynRelrRegion.Size = Dyn.getVal();
       break;
     case ELF::DT_RELRENT:
     case ELF::DT_ANDROID_RELRENT:
       DynRelrRegion.EntSize = Dyn.getVal();
       break;
     case ELF::DT_PLTREL:
       if (Dyn.getVal() == DT_REL)
         DynPLTRelRegion.EntSize = sizeof(Elf_Rel);
       else if (Dyn.getVal() == DT_RELA)
         DynPLTRelRegion.EntSize = sizeof(Elf_Rela);
       else
         reportError(Twine("unknown DT_PLTREL value of ") +
                     Twine((uint64_t)Dyn.getVal()));
       break;
     case ELF::DT_JMPREL:
-      DynPLTRelRegion.Addr = toMappedAddr(Dyn.getPtr());
+      DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr());
       break;
     case ELF::DT_PLTRELSZ:
       DynPLTRelRegion.Size = Dyn.getVal();
       break;
     }
   }
   if (StringTableBegin)
     DynamicStringTable = StringRef(StringTableBegin, StringTableSize);

 template <class ELFT> void ELFDumper<ELFT>::printNotes() {
   ELFDumperStyle->printNotes(ObjF->getELFFile());
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printELFLinkerOptions() {
   ELFDumperStyle->printELFLinkerOptions(ObjF->getELFFile());
 }
 
-static const char *getTypeString(unsigned Arch, uint64_t Type) {
-#define DYNAMIC_TAG(n, v)
-  switch (Arch) {
-  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
-    }
-    break;
-
-  case EM_MIPS:
-    switch (Type) {
-#define MIPS_DYNAMIC_TAG(name, value)                                          \
-    case DT_##name:                                                            \
-      return #name;
-#include "llvm/BinaryFormat/DynamicTags.def"
-#undef MIPS_DYNAMIC_TAG
-    }
-    break;
-
-  case EM_PPC64:
-    switch(Type) {
-#define PPC64_DYNAMIC_TAG(name, value)                                         \
-    case DT_##name:                                                            \
-      return #name;
-#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 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 MIPS_DYNAMIC_TAG
-#undef HEXAGON_DYNAMIC_TAG
-#undef PPC64_DYNAMIC_TAG
-#undef DYNAMIC_TAG_MARKER
-  default:
-    return "unknown";
-  }
-}
-
 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum)                                 \
   { #enum, prefix##_##enum }
 
 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
   LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
   LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
   LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
   LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),