Implemented sane default for llvm-objdump's relocation Value format

[dcederman]

Summary

"Unknown" for platforms that were not manually added into the switch
did not make sense at all. Now it prints Target + addend for all
elf-machines that were not explicitly mentioned.

Addresses PR21059 and PR25124.

[fedor.sergeev]

Initially this problem was mentioned to me by James during https://reviews.llvm.org/D35567 review.
I found at least 2 PRs that mention objdump and Unknown.
Perhaps there are more, as this deficiency is rather obvious in code.

[jyknight]

tools/llvm-objdump/llvm-objdump.cpp

693 ↗

(On Diff #110186)

And after the other changes, I think this can go back to an int64_t.

739 ↗

(On Diff #110186)

This "-P" suffix here doesn't seem particularly useful, I'd suggest just removing it.

The reloc name is printed, I don't think the fact that PC is subtracted needs to be printed as part of the output here as well. (Perhaps the intent was to print the "full formula", but if so, this list is woefully incomplete, and I don't think that's particularly worthwhile to spend time implementing).

745 ↗

(On Diff #110186)

I believe this list of case statements which override addend = None is bogus and should go away. Most of these have SHT_REL relocations, which put the addend in the instruction -- and thus don't get printed anyways (see also TODO note above -- although I'd note that GNU objdump also doesn't print SHT_REL addends either). And when they _do_ actually have addends, I see no reason why we would not want them printed.

Other than that, looks good.

[dcederman]

Hello,

I got referred to this revision by @jyknight after I created a patch to add Sparc to the list in getRelocationValueString. Changing the default does seem like a better approach, so I will update this revision following the comment. I hope that is ok.

llvm/trunk/test/DebugInfo/X86/DW_AT_location-reference.ll

 ; CHECK-NEXT:   DW_AT_type
 
 ; Check that we have no relocations in Darwin's output.
 ; DARWIN-NOT: X86_64_RELOC{{.*}} __debug_loc
 
 ; Check we have a relocation for the debug_loc entry in Linux output.
 ; LINUX: RELOCATION RECORDS FOR [.rela.debug_info]
 ; LINUX-NOT: RELOCATION RECORDS
-; LINUX: R_X86_64{{.*}} .debug_loc+0
+; LINUX: R_X86_64{{.*}} .debug_loc
 
 ; ModuleID = 'simple.c'
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n32"
 
 @a = external global i32
 
 define void @f() nounwind !dbg !0 {
 entry:

llvm/trunk/test/MC/Sparc/sparc-tls-relocations.s

 foo:
 ! Here we use two different sequences to get the address of a static TLS variable 'Head'
 ! (note - there is no intent to have valid assembler function here,
 !  we just check how TLS relocations are emitted)
 !
 ! First sequence uses LE_HIX22/LE_LOX10
 
 ! OBJDUMP: {{[0-9,a-f]+}}:  31 00 00 00  sethi 0, %i0
-! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LE_HIX22 Unknown
+! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LE_HIX22 Head
 ! ASM: sethi %tle_hix22(Head), %i0 ! encoding: [0x31,0x00,0x00,0x00]
 ! ASM:                                 !   fixup A - offset: 0, value: %tle_hix22(Head), kind: fixup_sparc_tls_le_hix22
         sethi %tle_hix22(Head), %i0
 
 ! OBJDUMP: {{[0-9,a-f]+}}:  b0 1e 20 00  xor %i0, 0, %i0
-! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LE_LOX10 Unknown
+! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LE_LOX10 Head
 ! ASM: xor %i0, %tle_lox10(Head), %i0 ! encoding: [0xb0,0x1e,0x20,0x00]
 ! ASM:                                    !   fixup A - offset: 0, value: %tle_lox10(Head), kind: fixup_sparc_tls_le_lox10
         xor %i0, %tle_lox10(Head), %i0
 
 
 ! Second sequence is for PIC, so it is more complicated.
 ! It uses LDO_HIX22/LDO_LOX10/LDO_ADD/LDM_HI22/LDM_LO10/LDM_ADD/LDM_CALL
 
 ! OBJDUMP: {{[0-9,a-f]+}}:  33 00 00 00  sethi 0, %i1
-! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDO_HIX22 Unknown
+! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDO_HIX22 Head
 ! ASM: sethi %tldo_hix22(Head), %i1 ! encoding: [0x33,0b00AAAAAA,A,A]
 ! ASM:                                  !   fixup A - offset: 0, value: %tldo_hix22(Head), kind: fixup_sparc_tls_ldo_hix22
         sethi %tldo_hix22(Head), %i1
 
 ! OBJDUMP: {{[0-9,a-f]+}}:  35 00 00 00  sethi 0, %i2
-! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDM_HI22 Unknown
+! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDM_HI22 Head
 ! ASM: sethi %tldm_hi22(Head), %i2 ! encoding: [0x35,0b00AAAAAA,A,A]
 ! ASM:                                 !   fixup A - offset: 0, value: %tldm_hi22(Head), kind: fixup_sparc_tls_ldm_hi22
         sethi %tldm_hi22(Head), %i2
 
 ! OBJDUMP: {{[0-9,a-f]+}}:  b4 06 a0 00  add %i2, 0, %i2
-! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDM_LO10 Unknown
+! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDM_LO10 Head
 ! ASM: add %i2, %tldm_lo10(Head), %i2 ! encoding: [0xb4,0x06,0b101000AA,A]
 ! ASM:                                    !   fixup A - offset: 0, value: %tldm_lo10(Head), kind: fixup_sparc_tls_ldm_lo10
         add %i2, %tldm_lo10(Head), %i2
 
   ! ???error from llvm-mc on the next asm line???
   ! add %i0, %i2, %o0, %tldm_add(Head)
 
 ! OBJDUMP: {{[0-9,a-f]+}}:  b0 1e 60 00  xor %i1, 0, %i0
-! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDO_LOX10 Unknown
+! OBJDUMP: {{[0-9,a-f]+}}:     R_SPARC_TLS_LDO_LOX10 Head
 ! ASM: xor %i1, %tldo_lox10(Head), %i0 ! encoding: [0xb0,0x1e,0b011000AA,A]
 ! ASM:                                     !   fixup A - offset: 0, value: %tldo_lox10(Head), kind: fixup_sparc_tls_ldo_lox10
         xor %i1, %tldo_lox10(Head), %i0
 
         ! ???error from llvm-mc on the next asm line???
         ! call __tls_get_addr, %tldm_call(Head)
         ! nop
         ! ???error from llvm-mc on the next asm line???
         ! add %o0, %i0, %i0, %tldo_add(Head)
 
         .type  Head,@object
         .section      .tbss,#alloc,#write,#tls
 Head:
         .word  0
         .size  Head, 4

llvm/trunk/test/MC/X86/abs8.s

 // RUN: llvm-mc -filetype=obj %s -o - -triple i686-pc-linux | llvm-objdump -d -r - | FileCheck --check-prefix=32 %s
 // RUN: llvm-mc -filetype=obj %s -o - -triple x86_64-pc-linux | llvm-objdump -d -r - | FileCheck --check-prefix=64 %s
 
 // 32: 0: 83 ff 00  cmpl $0, %edi
 // 32:   00000002:  R_386_8 foo
 // 64: 0: 83 ff 00  cmpl $0, %edi
-// 64:  0000000000000002:  R_X86_64_8 foo+0
+// 64:  0000000000000002:  R_X86_64_8 foo
 cmp $foo@ABS8, %edi

llvm/trunk/test/Object/X86/objdump-disassembly-inline-relocations.test

 ELF-i386:       23:     c3                                              ret
 
 ELF-x86-64: file format ELF64-x86-64
 ELF-x86-64: Disassembly of section .text:
 ELF-x86-64: main:
 ELF-x86-64:        0:   48 83 ec 08                                     subq    $8, %rsp
 ELF-x86-64:        4:   c7 44 24 04 00 00 00 00                         movl    $0, 4(%rsp)
 ELF-x86-64:        c:   bf 00 00 00 00                                  movl    $0, %edi
-ELF-x86-64:                            d: R_X86_64_32S  .rodata.str1.1+0
+ELF-x86-64:                            d: R_X86_64_32S  .rodata.str1.1
 ELF-x86-64:       11:   e8 00 00 00 00                                  callq   0
-ELF-x86-64:                           12: R_X86_64_PC32 puts-4-P
+ELF-x86-64:                           12: R_X86_64_PC32 puts-4
 ELF-x86-64:       16:   30 c0                                           xorb    %al, %al
 ELF-x86-64:       18:   e8 00 00 00 00                                  callq   0
-ELF-x86-64:                           19: R_X86_64_PC32 SomeOtherFunction-4-P
+ELF-x86-64:                           19: R_X86_64_PC32 SomeOtherFunction-4
 ELF-x86-64:       1d:   8b 44 24 04                                     movl    4(%rsp), %eax
 ELF-x86-64:       21:   48 83 c4 08                                     addq    $8, %rsp
 ELF-x86-64:       25:   c3                                              ret

llvm/trunk/test/Object/objdump-relocations.test

 ELF-MIPSEL: R_MIPS_HI16 _gp_disp
 ELF-MIPSEL: R_MIPS_LO16 _gp_disp
 ELF-MIPSEL: R_MIPS_GOT16 $.str
 ELF-MIPSEL: R_MIPS_LO16 $.str
 ELF-MIPSEL: R_MIPS_CALL16 puts
 ELF-MIPSEL: R_MIPS_CALL16 SomeOtherFunction
 
 WASM:      CODE
-WASM-NEXT: R_WEBASSEMBLY_MEMORY_ADDR_SLEB .L.str+0
-WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB puts+0
-WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB SomeOtherFunction+0
+WASM-NEXT: R_WEBASSEMBLY_MEMORY_ADDR_SLEB .L.str
+WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB puts
+WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB SomeOtherFunction
 
 ELF-complex-x86-64: .text
 ELF-complex-x86-64-NEXT: R_X86_64_8 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_16 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32S .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_64 .data-4
-ELF-complex-x86-64-NEXT: R_X86_64_PC32 .data-4-P
-ELF-complex-x86-64-NEXT: R_X86_64_32 .data+0
+ELF-complex-x86-64-NEXT: R_X86_64_PC32 .data-4
+ELF-complex-x86-64-NEXT: R_X86_64_32 .data
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data+4

llvm/trunk/test/Object/objdump-shndx.test

 RUN: llvm-objdump -r %p/Inputs/shndx.elf | FileCheck %s
 
 Test that llvm-objdump can handle shndx. The relocation points to a section
 symbol that has st_shndx == SHN_XINDEX. To print the section name llvm-objdump
 has to use the shndx section.
 
 CHECK:      RELOCATION RECORDS FOR [.rela.text]:
-CHECK-NEXT: 0000000000000000 R_X86_64_32 bar+0
+CHECK-NEXT: 0000000000000000 R_X86_64_32 bar

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

assert(SymTab->sh_type == ELF::SHT_SYMTAB ||
          SymTab->sh_type == ELF::SHT_DYNSYM);
   auto StrTabSec = EF.getSection(SymTab->sh_link);
   if (!StrTabSec)
     return errorToErrorCode(StrTabSec.takeError());
   auto StrTabOrErr = EF.getStringTable(*StrTabSec);
   if (!StrTabOrErr)
     return errorToErrorCode(StrTabOrErr.takeError());
   StringRef StrTab = *StrTabOrErr;
-  uint8_t type = RelRef.getType();
-  StringRef res;
   int64_t addend = 0;
   switch (Sec->sh_type) {
   default:
     return object_error::parse_failed;
   case ELF::SHT_REL: {
     // TODO: Read implicit addend from section data.
     break;
   }
if (!SecName)
       return errorToErrorCode(SecName.takeError());
     Target = *SecName;
   } else {
     Expected<StringRef> SymName = symb->getName(StrTab);
     if (!SymName)
       return errorToErrorCode(SymName.takeError());
     Target = *SymName;
   }
-  switch (EF.getHeader()->e_machine) {
-  case ELF::EM_X86_64:
-    switch (type) {
-    case ELF::R_X86_64_PC8:
-    case ELF::R_X86_64_PC16:
-    case ELF::R_X86_64_PC32: {
-      std::string fmtbuf;
-      raw_string_ostream fmt(fmtbuf);
-      fmt << Target << (addend < 0 ? "" : "+") << addend << "-P";
-      fmt.flush();
-      Result.append(fmtbuf.begin(), fmtbuf.end());
-    } break;
-    case ELF::R_X86_64_8:
-    case ELF::R_X86_64_16:
-    case ELF::R_X86_64_32:
-    case ELF::R_X86_64_32S:
-    case ELF::R_X86_64_64: {
-      std::string fmtbuf;
-      raw_string_ostream fmt(fmtbuf);
-      fmt << Target << (addend < 0 ? "" : "+") << addend;
-      fmt.flush();
-      Result.append(fmtbuf.begin(), fmtbuf.end());
-    } break;
-    default:
-      res = "Unknown";
-    }
-    break;
-  case ELF::EM_LANAI:
-  case ELF::EM_AVR:
-  case ELF::EM_AARCH64: {
-    std::string fmtbuf;
-    raw_string_ostream fmt(fmtbuf);
-    fmt << Target;
-    if (addend != 0)
-      fmt << (addend < 0 ? "" : "+") << addend;
-    fmt.flush();
-    Result.append(fmtbuf.begin(), fmtbuf.end());
-    break;
-  }
-  case ELF::EM_386:
-  case ELF::EM_IAMCU:
-  case ELF::EM_ARM:
-  case ELF::EM_HEXAGON:
-  case ELF::EM_MIPS:
-  case ELF::EM_BPF:
-  case ELF::EM_RISCV:
-    res = Target;
-    break;
-  case ELF::EM_WEBASSEMBLY:
-    switch (type) {
-    case ELF::R_WEBASSEMBLY_DATA: {
-      std::string fmtbuf;
-      raw_string_ostream fmt(fmtbuf);
-      fmt << Target << (addend < 0 ? "" : "+") << addend;
-      fmt.flush();
-      Result.append(fmtbuf.begin(), fmtbuf.end());
-      break;
-    }
-    case ELF::R_WEBASSEMBLY_FUNCTION:
-      res = Target;
-      break;
-    default:
-      res = "Unknown";
-    }
-    break;
-  default:
-    res = "Unknown";
-  }
-  if (Result.empty())
-    Result.append(res.begin(), res.end());
+
+  // Default scheme is to print Target, as well as "+ <addend>" for nonzero
+  // addend. Should be acceptable for all normal purposes.
   return std::error_code();
 }
 
 static std::error_code getRelocationValueString(const ELFObjectFileBase *Obj,
                                                 const RelocationRef &Rel,
                                                 SmallVectorImpl<char> &Result) {
   if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
     return getRelocationValueString(ELF32LE, Rel, Result);