[llvm-readobj] Print <null> for relocation target with an empty name

[MaskRay]

Summary

For a relocation, we don't differentiate the two cases:

• the symbol index is 0
• the symbol index is non zero, the type is not STT_SECTION, and the name is empty. Clang generates such local symbols for RISC-V linker relaxation.

So we may print

    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
000000000000001c  0000000100000039 R_RISCV_32_PCREL       0000000000000000 0

// llvm-readobj
0x1C R_RISCV_32_PCREL - 0x0

while GNU readelf prints "<null>", which is clearer. Let's match the GNU behavior.
Related to https://reviews.llvm.org/D81842

000000000000001c  0000000100000039 R_RISCV_32_PCREL       0000000000000000 <null> + 0

// llvm-readobj
0x1C R_RISCV_32_PCREL <null> 0x0

[kito-cheng]

LGTM

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

6953–6954

If I'm not mistaken, we don't actually have a dedicated test case for this bit of the logic? (It's covered by other tests, but more by accident than design, I feel - there's no purpose-written llvm-readobj LLVM style test).

[MaskRay]

llvm/tools/llvm-readobj/ELFDumper.cpp

6953–6954

There is a dedicated test: reloc-zero-name-or-value.test from D81842

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

6953–6954

That only covers GNU style though, if I'm not mistaken (it uses llvm-readelf with no --elf-output-style option). We should have an LLVM style version, no? I.e. something equivalent to the reloc-zero-name-or-value.test that uses LLVM style that shows the behaviour change highlighted by "llvm/test/tools/yaml2obj/ELF/symbol-name.yaml".

[MaskRay]

Add dedicate llvm-readobj tests. When landing, the test will be pre-committed.

[jhenderson]

In D155353#4517430, @MaskRay wrote:

Add dedicate llvm-readobj tests. When landing, the test will be pre-committed.

Thanks. Presumably the pre-committed test won't use <null>, since that wasn't the old behaviour.

LGTM.

lld/test/ELF/mips-eh_frame-pic.s

 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux --position-independent %s -o %t-pic32.o
 # RUN: llvm-readobj -r %t-pic32.o | FileCheck %s --check-prefixes=RELOCS,PIC32-RELOCS
 # RUN: ld.lld -shared %t-pic32.o -o %t-pic32.so
 # RUN: llvm-dwarfdump --eh-frame %t-pic32.so | FileCheck %s --check-prefix=PIC-EH-FRAME
 
 # RELOCS:            .rel{{a?}}.eh_frame {
 # ABS32-RELOCS-NEXT:   0x1C R_MIPS_32 .text
 # ABS64-RELOCS-NEXT:   0x1C R_MIPS_64/R_MIPS_NONE/R_MIPS_NONE .text
-# PIC64-RELOCS-NEXT:   0x1C R_MIPS_PC32/R_MIPS_NONE/R_MIPS_NONE -
-# PIC32-RELOCS-NEXT:   0x1C R_MIPS_PC32 -
+# PIC64-RELOCS-NEXT:   0x1C R_MIPS_PC32/R_MIPS_NONE/R_MIPS_NONE <null>
+# PIC32-RELOCS-NEXT:   0x1C R_MIPS_PC32 <null>
 # RELOCS-NEXT:       }
 
 # ABS64-EH-FRAME: Augmentation data: 0C
 ##                                   ^^ fde pointer encoding: DW_EH_PE_sdata8
 # ABS32-EH-FRAME: Augmentation data: 0B
 ##                                   ^^ fde pointer encoding: DW_EH_PE_sdata4
 # PIC-EH-FRAME: Augmentation data: 1B
 ##                                 ^^ fde pointer encoding: DW_EH_PE_pcrel | DW_EH_PE_sdata4

llvm/test/CodeGen/RISCV/fixups-diff.ll

 define i32 @main() !dbg !7 {
 entry:
   %retval = alloca i32, align 4
   store i32 0, ptr %retval, align 4
   ret i32 0
 }
 
 ; CHECK:      Section {{.*}} .rela.debug_info {
-; CHECK:        0x22 R_RISCV_ADD32 - 0x0
-; CHECK-NEXT:   0x22 R_RISCV_SUB32 - 0x0
-; CHECK:        0x2B R_RISCV_ADD32 - 0x0
-; CHECK-NEXT:   0x2B R_RISCV_SUB32 - 0x0
+; CHECK:        0x22 R_RISCV_ADD32 <null> 0x0
+; CHECK-NEXT:   0x22 R_RISCV_SUB32 <null> 0x0
+; CHECK:        0x2B R_RISCV_ADD32 <null> 0x0
+; CHECK-NEXT:   0x2B R_RISCV_SUB32 <null> 0x0
 ; CHECK:      }
 
 ; CHECK:      Section {{.*}} .rela.eh_frame {
-; CHECK:        0x1C R_RISCV_32_PCREL - 0x0
-; CHECK:        0x20 R_RISCV_ADD32 - 0x0
-; CHECK-NEXT:   0x20 R_RISCV_SUB32 - 0x0
+; CHECK:        0x1C R_RISCV_32_PCREL <null> 0x0
+; CHECK:        0x20 R_RISCV_ADD32 <null> 0x0
+; CHECK-NEXT:   0x20 R_RISCV_SUB32 <null> 0x0
 ; CHECK:      }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 !1 = !DIFile(filename: "fixups-diff.ll", directory: "test/MC/RISCV")

llvm/test/DebugInfo/RISCV/dwarf-riscv-relocs.ll

 ; RUN: llc -filetype=obj -mtriple=riscv32 -mattr=+relax %s -o %t.o
 ; RUN: llvm-readobj -r %t.o | FileCheck -check-prefix=READOBJ-RELOCS %s
 ; RUN: llvm-objdump --source %t.o | FileCheck --check-prefix=OBJDUMP-SOURCE %s
 ; RUN: llvm-dwarfdump --debug-info --debug-line %t.o | \
 ; RUN:     FileCheck -check-prefix=DWARF-DUMP %s
 
 ; Check that we actually have relocations, otherwise this is kind of pointless.
 ; READOBJ-RELOCS:  Section ({{.*}}) .rela.debug_info {
-; READOBJ-RELOCS:    0x1B R_RISCV_ADD32 - 0x0
-; READOBJ-RELOCS-NEXT:    0x1B R_RISCV_SUB32 - 0x0
+; READOBJ-RELOCS:    0x1B R_RISCV_ADD32 <null> 0x0
+; READOBJ-RELOCS-NEXT:    0x1B R_RISCV_SUB32 <null> 0x0
 ; READOBJ-RELOCS:  Section ({{.*}}) .rela.debug_frame {
-; READOBJ-RELOCS:    0x20 R_RISCV_ADD32 - 0x0
-; READOBJ-RELOCS-NEXT:    0x20 R_RISCV_SUB32 - 0x0
+; READOBJ-RELOCS:    0x20 R_RISCV_ADD32 <null> 0x0
+; READOBJ-RELOCS-NEXT:    0x20 R_RISCV_SUB32 <null> 0x0
 ; READOBJ-RELOCS:  Section ({{.*}}) .rela.debug_line {
-; READOBJ-RELOCS:    0x5A R_RISCV_ADD16 - 0x0
-; READOBJ-RELOCS-NEXT:    0x5A R_RISCV_SUB16 - 0x0
+; READOBJ-RELOCS:    0x5A R_RISCV_ADD16 <null> 0x0
+; READOBJ-RELOCS-NEXT:    0x5A R_RISCV_SUB16 <null> 0x0
 
 ; Check that we can print the source, even with relocations.
 ; OBJDUMP-SOURCE: Disassembly of section .text:
 ; OBJDUMP-SOURCE-EMPTY:
 ; OBJDUMP-SOURCE-NEXT: 00000000 <main>:
 ; OBJDUMP-SOURCE: ; {
 ; OBJDUMP-SOURCE: ; return 0;
 

llvm/test/DebugInfo/RISCV/relax-debug-frame.ll

 ; RUN: llc -filetype=obj -mtriple=riscv32 -mattr=+relax %s -o %t.o
 ; RUN: llvm-readobj -r %t.o | FileCheck -check-prefix=RELAX %s
 ; RUN: llvm-dwarfdump --debug-frame %t.o 2>&1 \
 ; RUN:     | FileCheck -check-prefix=RELAX-DWARFDUMP %s
 ;
 ; RELAX:      Section ({{.*}}) .rela.eh_frame {
-; RELAX-NEXT:   0x1C R_RISCV_32_PCREL - 0x0
-; RELAX-NEXT:   0x20 R_RISCV_ADD32 - 0x0
-; RELAX-NEXT:   0x20 R_RISCV_SUB32 - 0x0
-; RELAX-NEXT:   0x30 R_RISCV_32_PCREL - 0x0
-; RELAX-NEXT:   0x34 R_RISCV_ADD32 - 0x0
-; RELAX-NEXT:   0x34 R_RISCV_SUB32 - 0x0
-; RELAX-NEXT:   0x44 R_RISCV_32_PCREL - 0x0
-; RELAX-NEXT:   0x48 R_RISCV_ADD32 - 0x0
-; RELAX-NEXT:   0x48 R_RISCV_SUB32 - 0x0
+; RELAX-NEXT:   0x1C R_RISCV_32_PCREL <null> 0x0
+; RELAX-NEXT:   0x20 R_RISCV_ADD32 <null> 0x0
+; RELAX-NEXT:   0x20 R_RISCV_SUB32 <null> 0x0
+; RELAX-NEXT:   0x30 R_RISCV_32_PCREL <null> 0x0
+; RELAX-NEXT:   0x34 R_RISCV_ADD32 <null> 0x0
+; RELAX-NEXT:   0x34 R_RISCV_SUB32 <null> 0x0
+; RELAX-NEXT:   0x44 R_RISCV_32_PCREL <null> 0x0
+; RELAX-NEXT:   0x48 R_RISCV_ADD32 <null> 0x0
+; RELAX-NEXT:   0x48 R_RISCV_SUB32 <null> 0x0
 ; RELAX-NEXT:  }
 
 ; RELAX-DWARFDUMP-NOT: error: failed to compute relocation
 ; RELAX-DWARFDUMP:      FDE
 ; RELAX-DWARFDUMP-NEXT: Format:
 ; RELAX-DWARFDUMP:      DW_CFA_advance_loc: 4
 ; RELAX-DWARFDUMP-NEXT: DW_CFA_def_cfa_offset: +16
 ; RELAX-DWARFDUMP-EMPTY:

llvm/test/MC/ELF/RISCV/gen-dwarf.s

 
 # CHECK:      0x00000000: range list header: length = 0x0000001d, format = DWARF32, version = 0x0005
 # CHECK-NEXT: ranges:
 # CHECK-NEXT: 0x0000000c: [DW_RLE_start_length]:  0x0000000000000000, 0x0000000000000034
 # CHECK-NEXT: 0x00000016: [DW_RLE_start_length]:  0x0000000000000000, 0x0000000000000004
 # CHECK-NEXT: 0x00000020: [DW_RLE_end_of_list ]
 
 # RELOC:      Section ([[#]]) .rela.eh_frame {
-# RELOC-NEXT:   0x1C R_RISCV_32_PCREL - 0x0
-# RELOC-NEXT:   0x20 R_RISCV_ADD32 - 0x0
-# RELOC-NEXT:   0x20 R_RISCV_SUB32 - 0x0
-# RELOC-NEXT:   0x25 R_RISCV_SET6 - 0x0
-# RELOC-NEXT:   0x25 R_RISCV_SUB6 - 0x0
-# RELOC-NEXT:   0x34 R_RISCV_32_PCREL - 0x0
-# RELOC-NEXT:   0x38 R_RISCV_ADD32 - 0x0
-# RELOC-NEXT:   0x38 R_RISCV_SUB32 - 0x0
+# RELOC-NEXT:   0x1C R_RISCV_32_PCREL <null> 0x0
+# RELOC-NEXT:   0x20 R_RISCV_ADD32 <null> 0x0
+# RELOC-NEXT:   0x20 R_RISCV_SUB32 <null> 0x0
+# RELOC-NEXT:   0x25 R_RISCV_SET6 <null> 0x0
+# RELOC-NEXT:   0x25 R_RISCV_SUB6 <null> 0x0
+# RELOC-NEXT:   0x34 R_RISCV_32_PCREL <null> 0x0
+# RELOC-NEXT:   0x38 R_RISCV_ADD32 <null> 0x0
+# RELOC-NEXT:   0x38 R_RISCV_SUB32 <null> 0x0
 # RELOC-NEXT: }
 
 ## TODO A section needs two relocations.
 # RELOC:      Section ([[#]]) .rela.debug_rnglists {
 # RELOC-NEXT:   0xD R_RISCV_64 .text.foo 0x0
 # RELOC-NEXT:   0x17 R_RISCV_64 .text.bar 0x0
 # RELOC-NEXT: }
 
 # RELOC:      Section ([[#]]) .rela.debug_line {
-# RELOC:        R_RISCV_ADD16 - 0x0
-# RELOC-NEXT:   R_RISCV_SUB16 - 0x0
-# RELOC-NEXT:   R_RISCV_ADD16 - 0x0
-# RELOC-NEXT:   R_RISCV_SUB16 - 0x0
-# RELOC-NEXT:   R_RISCV_ADD16 - 0x0
-# RELOC-NEXT:   R_RISCV_SUB16 - 0x0
+# RELOC:        R_RISCV_ADD16 <null> 0x0
+# RELOC-NEXT:   R_RISCV_SUB16 <null> 0x0
+# RELOC-NEXT:   R_RISCV_ADD16 <null> 0x0
+# RELOC-NEXT:   R_RISCV_SUB16 <null> 0x0
+# RELOC-NEXT:   R_RISCV_ADD16 <null> 0x0
+# RELOC-NEXT:   R_RISCV_SUB16 <null> 0x0
 # RELOC:      }
 
 .section .text.foo,"ax"
 .globl foo
 foo:
 .cfi_startproc
 .Lpcrel_hi0:
   auipc a1, %pcrel_hi(g)

llvm/test/MC/RISCV/cfi-advance.s

 # RUN: llvm-mc -filetype=obj -triple riscv32 %s -o %t.o  
 # RUN: llvm-readobj -r %t.o | FileCheck -check-prefix=CHECK %s
 # RUN: llvm-dwarfdump --debug-frame %t.o 2>&1 \
 # RUN:     | FileCheck -check-prefix=CHECK-DWARFDUMP %s
 
 # CHECK:      .rela.eh_frame {
-# CHECK-NEXT:   0x1C R_RISCV_32_PCREL - 0x0
-# CHECK-NEXT:   0x20 R_RISCV_ADD32 - 0x0
-# CHECK-NEXT:   0x20 R_RISCV_SUB32 - 0x0
+# CHECK-NEXT:   0x1C R_RISCV_32_PCREL <null> 0x0
+# CHECK-NEXT:   0x20 R_RISCV_ADD32 <null> 0x0
+# CHECK-NEXT:   0x20 R_RISCV_SUB32 <null> 0x0
 # CHECK-NEXT: }
 # CHECK-DWARFDUMP: DW_CFA_advance_loc1
 # CHECK-DWARFDUMP-NEXT: DW_CFA_def_cfa_offset
 # CHECK-DWARFDUMP-NEXT: DW_CFA_advance_loc2
 # CHECK-DWARFDUMP-NEXT: DW_CFA_def_cfa_offset
 # CHECK-DWARFDUMP-NEXT: DW_CFA_advance_loc4
 # CHECK-DWARFDUMP-NEXT: DW_CFA_def_cfa_offset
         .text

llvm/test/MC/RISCV/fde-reloc.s

 # RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+relax < %s \
 # RUN:     | llvm-readobj -r - | FileCheck %s
 # RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=-relax < %s \
 # RUN:     | llvm-readobj -r - | FileCheck %s
 
 # Ensure that the eh_frame records the symbolic difference with the paired
 # relocations always.
 
 func:
   .cfi_startproc
   ret
   .cfi_endproc
 
 # CHECK:   Section (4) .rela.eh_frame {
-# CHECK-NEXT:   0x1C R_RISCV_32_PCREL - 0x0
-# CHECK-NEXT:   0x20 R_RISCV_ADD32 - 0x0
-# CHECK-NEXT:   0x20 R_RISCV_SUB32 - 0x0
+# CHECK-NEXT:   0x1C R_RISCV_32_PCREL <null> 0x0
+# CHECK-NEXT:   0x20 R_RISCV_ADD32 <null> 0x0
+# CHECK-NEXT:   0x20 R_RISCV_SUB32 <null> 0x0
 # CHECK-NEXT: }

llvm/test/MC/RISCV/scoped-relaxation.s

 # RUN: llvm-mc -mattr -relax -triple riscv64 -filetype obj %s -o - | llvm-readobj -d -r - | FileCheck %s
 
 .global function
 
 # CHECK: .rela.text {
 
 # Unrelaxed reference, this would normally fail, but the subsequent scoped
 # relaxation forces relaxation on the file.
 .dword function - .
 
 # CHECK: 0x0 R_RISCV_ADD64 function 0x0
-# CHECK-NEXT: 0x0 R_RISCV_SUB64 - 0x0
+# CHECK-NEXT: 0x0 R_RISCV_SUB64 <null> 0x0
 
 # Relaxed reference, this will resolve to a pair of `RISCV_ADD64` and
 # `RISCV_SUB64` relocation.
 .option push
 .option relax
 .dword function - .
 .option pop
 
 # CHECK: 0x8 R_RISCV_ADD64 function 0x0
-# CHECK-NEXT: 0x8 R_RISCV_SUB64 - 0x0
+# CHECK-NEXT: 0x8 R_RISCV_SUB64 <null> 0x0
 
 # Unrelaxed reference, this will resolve to a pair of `RISCV_ADD64` and
 # `RISCV_SUB64` relocation due to relaxation being sticky to the file.
 .option push
 .option norelax
 .dword function - .
 .option pop
 
 # CHECK: 0x10 R_RISCV_ADD64 function 0x0
-# CHECK-NEXT: 0x10 R_RISCV_SUB64 - 0x0
+# CHECK-NEXT: 0x10 R_RISCV_SUB64 <null> 0x0
 
 # CHECK: }

llvm/test/tools/llvm-readobj/ELF/reloc-zero-name-or-value.test

 ## Show that the value field is omitted when a relocation does not reference a symbol.
 ## In other cases, particularly when a symbol has a zero value or when it has an empty
 ## name, we print it. Test for both static and dynamic relocation printing.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf --relocations --dyn-relocations %t 2>&1 | FileCheck %s -DFILE=%t
 
 # CHECK:      Relocation section '.rela.text' at offset {{.*}} contains 5 entries:
 # CHECK-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
 # CHECK-NEXT: 0000000000000000  0000000000000000 R_X86_64_NONE                           1
 # CHECK-NEXT: 0000000000000000  0000000100000000 R_X86_64_NONE          0000000000000000 sym + 1
-# CHECK-NEXT: 0000000000000000  0000000200000000 R_X86_64_NONE          0000000000000123 456
+# CHECK-NEXT: 0000000000000000  0000000200000000 R_X86_64_NONE          0000000000000123 <null> + 456
 # CHECK-NEXT: warning: '[[FILE]]': unable to get section index for symbol with st_shndx = 0x0 (SHN_UNDEF)
 # CHECK-NEXT: 0000000000000000  0000000300000000 R_X86_64_NONE          0000000000000000 <?> + 678
-# CHECK-NEXT: 0000000000000000  0000000400000000 R_X86_64_NONE          0000000000000000 2
+# CHECK-NEXT: 0000000000000000  0000000400000000 R_X86_64_NONE          0000000000000000 <null> + 2
 
 # CHECK:      Relocation section '.rela.dyn' at offset {{.*}} contains 5 entries:
 # CHECK-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
 # CHECK-NEXT: 0000000000000000  0000000000000000 R_X86_64_NONE                           1
 # CHECK-NEXT: 0000000000000000  0000000100000000 R_X86_64_NONE          0000000000000000 sym + 1
-# CHECK-NEXT: 0000000000000000  0000000200000000 R_X86_64_NONE          0000000000000123 456
+# CHECK-NEXT: 0000000000000000  0000000200000000 R_X86_64_NONE          0000000000000123 <null> + 456
 # CHECK-NEXT: 0000000000000000  0000000300000000 R_X86_64_NONE          0000000000000000 <?> + 678
-# CHECK-NEXT: 0000000000000000  0000000400000000 R_X86_64_NONE          0000000000000000 2
+# CHECK-NEXT: 0000000000000000  0000000400000000 R_X86_64_NONE          0000000000000000 <null> + 2
 
 # CHECK:      'RELA' relocation section at offset {{.*}} contains 120 bytes:
 # CHECK-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
 # CHECK-NEXT: 0000000000000000  0000000000000000 R_X86_64_NONE                           1
 # CHECK-NEXT: 0000000000000000  0000000100000000 R_X86_64_NONE          0000000000000000 sym + 1
-# CHECK-NEXT: 0000000000000000  0000000200000000 R_X86_64_NONE          0000000000000123 456
-# CHECK-NEXT: 0000000000000000  0000000300000000 R_X86_64_NONE          0000000000000000 678
-# CHECK-NEXT: 0000000000000000  0000000400000000 R_X86_64_NONE          0000000000000000 2
+# CHECK-NEXT: 0000000000000000  0000000200000000 R_X86_64_NONE          0000000000000123 <null> + 456
+# CHECK-NEXT: 0000000000000000  0000000300000000 R_X86_64_NONE          0000000000000000 <null> + 678
+# CHECK-NEXT: 0000000000000000  0000000400000000 R_X86_64_NONE          0000000000000000 <null> + 2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

llvm/test/tools/yaml2obj/ELF/symbol-name.yaml

 # BOTH-NEXT:   0000: 00666F6F 00 |.foo.|
 # BOTH-NEXT: )
 
 # BOTH:       Relocations [
 # BOTH-NEXT:   Section (1) .rela.data {
 # BOTH-NEXT:     Relocation {
 # BOTH-NEXT:       Offset: 0x0
 # BOTH-NEXT:       Type: R_X86_64_NONE (0)
-# BOTH-NEXT:       Symbol: - (1)
+# BOTH-NEXT:       Symbol: <null> (1)
 # BOTH-NEXT:       Addend: 0x0
 # BOTH-NEXT:     }
 # BOTH-NEXT:   }
 # BOTH-NEXT: ]
 
 # BOTH:      Symbols [
 # BOTH-NEXT:   Symbol {
 # BOTH-NEXT:     Name:  (0)

llvm/tools/llvm-readobj/ELFDumper.cpp

void GNUELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R,
 
   SmallString<32> RelocName;
   this->Obj.getRelocationTypeName(R.Type, RelocName);
   Fields[2].Str = RelocName.c_str();
 
   if (RelSym.Sym)
     Fields[3].Str =
         to_string(format_hex_no_prefix(RelSym.Sym->getValue(), Width));
-
+  if (RelSym.Sym && RelSym.Name.empty())
+    Fields[4].Str = "<null>";
+  else
     Fields[4].Str = std::string(RelSym.Name);
+
   for (const Field &F : Fields)
     printField(F);
 
   std::string Addend;
   if (std::optional<int64_t> A = R.Addend) {
     int64_t RelAddend = *A;
-    if (!RelSym.Name.empty()) {
+    if (!Fields[4].Str.empty()) {
       if (RelAddend < 0) {
         Addend = " - ";
         RelAddend = std::abs(RelAddend);
       } else {
         Addend = " + ";
       }
     }
     Addend += utohexstr(RelAddend, /*LowerCase=*/true);

 template <class ELFT> void LLVMELFDumper<ELFT>::printEmptyGroupMessage() const {
   W.startLine() << "There are no group sections in the file.\n";
 }
 
 template <class ELFT>
 void LLVMELFDumper<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R,
                                             const RelSymbol<ELFT> &RelSym) {
   StringRef SymbolName = RelSym.Name;
+  if (RelSym.Sym && RelSym.Name.empty())
+    SymbolName = "<null>";
   SmallString<32> RelocName;
   this->Obj.getRelocationTypeName(R.Type, RelocName);
 
   if (opts::ExpandRelocs) {
     printExpandedRelRelaReloc(R, SymbolName, RelocName);
   } else {
     printDefaultRelRelaReloc(R, SymbolName, RelocName);
   }