[yaml2obj] - Do not skip zeroes blocks if there are relocations against them.
This is for -D -reloc combination.
With this patch, we do not skip the zero bytes that have a relocation against
them when -reloc is used. If -reloc is not used, then the behavior will be the same.
Differential revision: https://reviews.llvm.org/D58174
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@354319 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/tools/llvm-objdump/disasm-zeroes-relocations.test b/test/tools/llvm-objdump/disasm-zeroes-relocations.test
new file mode 100644
index 0000000..7bdc7fd
--- /dev/null
+++ b/test/tools/llvm-objdump/disasm-zeroes-relocations.test
@@ -0,0 +1,52 @@
+# RUN: yaml2obj %s > %t
+
+## Check we do not skip zeroes blocks if have relocations pointed to these places.
+# RUN: llvm-objdump -D -reloc %t
+
+# CHECK: Disassembly of section .rodata:
+# CHECK-NEXT: 0000000000000000 .rodata:
+# CHECK-NEXT: 0: 00 00 addb %al, (%rax)
+# CHECK-NEXT: 0000000000000000: R_X86_64_64 *ABS*
+# CHECK-NEXT: 2: 00 00 addb %al, (%rax)
+# CHECK-NEXT: 4: 00 00 addb %al, (%rax)
+# CHECK-NEXT: 6: 00 00 addb %al, (%rax)
+# CHECK-NEXT: 8: 00 00 addb %al, (%rax)
+# CHECK-NEXT: 0000000000000008: R_X86_64_64 *ABS*
+# CHECK-NEXT: a: 00 00 addb %al, (%rax)
+# CHECK-NEXT: c: 00 00 addb %al, (%rax)
+# CHECK-NEXT: e: 00 00 addb %al, (%rax)
+
+## Check that without -reloc all zeroes would be omitted.
+# RUN: llvm-objdump -D %t | FileCheck %s --check-prefix=SKIP
+
+# SKIP: Disassembly of section .rodata:
+# SKIP-NEXT: 0000000000000000 .rodata:
+# SKIP-NEXT: ...
+# SKIP-NEXT: Disassembly of section .rela.rodata:
+
+--- !ELF
+FileHeader:
+ Class: ELFCLASS64
+ Data: ELFDATA2LSB
+ Type: ET_REL
+ Machine: EM_X86_64
+Sections:
+ - Name: .rodata
+ Type: SHT_PROGBITS
+ Flags: [ SHF_ALLOC ]
+ AddressAlign: 0x0000000000000001
+ Content: '00000000000000000000000000000000'
+ - Name: .rela.rodata
+ Type: SHT_RELA
+ Flags: [ SHF_INFO_LINK ]
+ Link: .symtab
+ AddressAlign: 0x0000000000000008
+ EntSize: 0x0000000000000018
+ Info: .rodata
+ Relocations:
+ - Offset: 0x0000000000000000
+ Symbol: x
+ Type: R_X86_64_64
+ - Offset: 0x0000000000000008
+ Symbol: x
+ Type: R_X86_64_64
diff --git a/tools/llvm-objdump/llvm-objdump.cpp b/tools/llvm-objdump/llvm-objdump.cpp
index 735025b..283a1f9 100644
--- a/tools/llvm-objdump/llvm-objdump.cpp
+++ b/tools/llvm-objdump/llvm-objdump.cpp
@@ -863,10 +863,6 @@
// returns the number of zero bytes that can be skipped when dumping the
// disassembly of the instructions in Buf.
static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) {
- // When -z or --disassemble-zeroes are given we always dissasemble them.
- if (DisassembleZeroes)
- return 0;
-
// Find the number of leading zeroes.
size_t N = 0;
while (N < Buf.size() && !Buf[N])
@@ -1284,12 +1280,22 @@
if (Index >= End)
break;
- if (size_t N =
- countSkippableZeroBytes(Bytes.slice(Index, End - Index))) {
- outs() << "\t\t..." << '\n';
- Index += N;
- if (Index >= End)
- break;
+ // When -z or --disassemble-zeroes are given we always dissasemble them.
+ // Otherwise we might want to skip zero bytes we see.
+ if (!DisassembleZeroes) {
+ uint64_t MaxOffset = End - Index;
+ // For -reloc: print zero blocks patched by relocations, so that
+ // relocations can be shown in the dump.
+ if (RelCur != RelEnd)
+ MaxOffset = RelCur->getOffset() - Index;
+
+ if (size_t N =
+ countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
+ outs() << "\t\t..." << '\n';
+ Index += N;
+ if (Index >= End)
+ break;
+ }
}
// Disassemble a real instruction or a data when disassemble all is