[llvm-objdump] - Implement -z/--disassemble-zeroes

[grimar]

Summary

This is https://bugs.llvm.org/show_bug.cgi?id=37151,

GNU objdump spec says that "Normally the disassembly output will skip blocks of zeroes.",
but currently, llvm-objdump prints them.

The patch implements the -z/--disassemble-zeroes option and switches the default to always
skip blocks of zeroes.

GNU objdump has a bit more complex heuristic for this option. For example, it tries to
skip the last zero bytes in a section if the amount of them > 3:
https://github.com/CyberGrandChallenge/binutils/blob/master/binutils/objdump.c#L1489
so it tries to avoid disassembling zeroes inserted by section alignment.
I think it is too brittle and probably not very useful. Modern linkers like LLD insert/align sections with
trap instructions and not zeroes. Hence I tried to implement simple and clear rules in this patch
(see my comments in the code).

[atanasyan]

test/ELF/mips-26.s

9 ↗

(On Diff #179507)

Output of llvm-objdump without -z option for at least this test case looks strange:

__start:
   20008:       0c 00 80 00     jal     131072 <bar>
   2000c:       00 00 00 00     nop
   20010:       0c 00 80 10     jal     131136 <foo0+0x20040>
                ...
   20018:       00 00 00 00     nop

loc:
   20018:       00 00 00 00     nop

We skip the first nop at 20014 offset, but show nop at 20018 twice. I apply the patch at r350033.

[grimar]

test/ELF/mips-26.s

9 ↗

(On Diff #179507)

I knew this skips the nops in this test because they are encoded as zero bytes for mips, but did not notice it shows the same offset twice. Will recheck it, thanks for looking!

[grimar]

• Updated the implementation and test cases.
• Rebased on top of D56123.

[atanasyan]

LGTM

[jhenderson]

A few suggested comment improvements and one function name from me. Otherwise looks good.

test/MC/X86/disassemble-zeroes.s

5

and that can force -> and can force

23

zeroes blocks. -> blocks of zeroes.

tools/llvm-objdump/llvm-objdump.cpp

272–273

"Do not skip blocks of zeroes when disassembling the blocks of zeroes"

I think this should be simply "Do not skip blocks of zeroes when disassembling"

1309–1311

I'd reword the second sentence as:

"This function returns the number of zero bytes that can be skipped when dumping the disassembly of the instructions in Buf."

1312

Since this function isn't actually doing the skipping, perhaps this should be something like "countSkippableZeroBytes" or something along those lines?

1317

amount -> number

Also, please rename the variable accordingly.

1322–1323

earlier than -> unless (I think)

test/CodeGen/Mips/micromips-b-range.ll

 ; CHECK-NEXT:    86:  fb fd 00 00   sw  $ra, 0($sp)
 ; CHECK-NEXT:    8a:  41 a1 00 01   lui $1, 1
 ; CHECK-NEXT:    8e:  40 60 00 02   bal 8 <foo+0x96>
 ; CHECK-NEXT:    92:  30 21 04 2c   addiu $1, $1, 1068
 ; CHECK-NEXT:    96:  00 3f 09 50   addu  $1, $ra, $1
 ; CHECK-NEXT:    9a:  ff fd 00 00   lw  $ra, 0($sp)
 ; CHECK-NEXT:    9e:  00 01 0f 3c   jr  $1
 ; CHECK-NEXT:    a2:  33 bd 00 08   addiu $sp, $sp, 8
-
-; CHECK:      10466:  00 00 00 00   nop
+; CHECK:                ...
 ; CHECK-NEXT: 1046a:  94 00 00 02   b 8 <foo+0x10472>
 ; CHECK-NEXT: 1046e:  00 00 00 00   nop
 ; CHECK-NEXT: 10472:  33 bd ff f8   addiu $sp, $sp, -8
 ; CHECK-NEXT: 10476:  fb fd 00 00   sw  $ra, 0($sp)
 ; CHECK-NEXT: 1047a:  41 a1 00 01   lui $1, 1
 ; CHECK-NEXT: 1047e:  40 60 00 02   bal 8 <foo+0x10486>
 ; CHECK-NEXT: 10482:  30 21 04 00   addiu $1, $1, 1024
 ; CHECK-NEXT: 10486:  00 3f 09 50   addu  $1, $ra, $1

test/ELF/mips-micro-jal.s

 # EB-NEXT:    20014:       ff 23 00 00     lw      $25, 0($3)
 # EB-NEXT:    20018:       05 35           subu16  $2, $2, $3
 # EB-NEXT:    2001a:       25 25           srl16   $2, $2, 2
 # EB-NEXT:    2001c:       33 02 ff fe     addiu   $24, $2, -2
 # EB-NEXT:    20020:       0d ff           move    $15, $ra
 # EB-NEXT:    20022:       45 f9           jalrs16 $25
 # EB-NEXT:    20024:       0f 83           move    $gp, $3
 # EB-NEXT:    20026:       0c 00           nop
-# EB-NEXT:    20028:       00 00 00 00     nop
-# EB-NEXT:    2002c:       00 00 00 00     nop
-
+# EB-NEXT:                 ...
 # EB-NEXT:    20030:       79 00 3f f7     addiupc $2, 65500
 # EB-NEXT:    20034:       ff 22 00 00     lw      $25, 0($2)
 # EB-NEXT:    20038:       45 99           jr16    $25
 # EB-NEXT:    2003a:       0f 02           move    $24, $2
 
 # EL:      Disassembly of section .plt:
 # EL-NEXT: .plt:
 # EL-NEXT:    20010:       80 79 fd 3f     addiupc $3, 65524
 # EL-NEXT:    20014:       23 ff 00 00     lw      $25, 0($3)
 # EL-NEXT:    20018:       35 05           subu16  $2, $2, $3
 # EL-NEXT:    2001a:       25 25           srl16   $2, $2, 2
 # EL-NEXT:    2001c:       02 33 fe ff     addiu   $24, $2, -2
 # EL-NEXT:    20020:       ff 0d           move    $15, $ra
 # EL-NEXT:    20022:       f9 45           jalrs16 $25
 # EL-NEXT:    20024:       83 0f           move    $gp, $3
 # EL-NEXT:    20026:       00 0c           nop
-# EL-NEXT:    20028:       00 00 00 00     nop
-# EL-NEXT:    2002c:       00 00 00 00     nop
-
+# EL-NEXT:                 ...
 # EL-NEXT:    20030:       00 79 f7 3f     addiupc $2, 65500
 # EL-NEXT:    20034:       22 ff 00 00     lw      $25, 0($2)
 # EL-NEXT:    20038:       99 45           jr16    $25
 # EL-NEXT:    2003a:       02 0f           move    $24, $2
 
 # EBR6:      Disassembly of section .plt:
 # EBR6-NEXT: .plt:
 # EBR6-NEXT:    20010:       78 60 3f fd     lapc    $3, 65524

 # MIXED-NEXT:    20024:       ff 23 00 00     lw      $25, 0($3)
 # MIXED-NEXT:    20028:       05 35           subu16  $2, $2, $3
 # MIXED-NEXT:    2002a:       25 25           srl16   $2, $2, 2
 # MIXED-NEXT:    2002c:       33 02 ff fe     addiu   $24, $2, -2
 # MIXED-NEXT:    20030:       0d ff           move    $15, $ra
 # MIXED-NEXT:    20032:       45 f9           jalrs16 $25
 # MIXED-NEXT:    20034:       0f 83           move    $gp, $3
 # MIXED-NEXT:    20036:       0c 00           nop
-# MIXED-NEXT:    20038:       00 00 00 00     nop
-# MIXED-NEXT:    2003c:       00 00 00 00     nop
-
+# MIXED-NEXT:                 ...
 # MIXED-NEXT:    20040:       79 00 3f f3     addiupc $2, 65484
 # MIXED-NEXT:    20044:       ff 22 00 00     lw      $25, 0($2)
 # MIXED-NEXT:    20048:       45 99           jr16    $25
 # MIXED-NEXT:    2004a:       0f 02           move    $24, $2
 
 # PLT:      Entries [
 # PLT-NEXT:   Entry {
 # PLT-NEXT:     Address: 0x3000C

test/ELF/relocation-size-shared.s

 // DISASM-NEXT: 201002: 00 00
 // DISASM-NEXT: 201004: 00 00
 // DISASM-NEXT: 201006: 00 00
 // DISASM-NEXT: 201008: 1a 00
 // DISASM-NEXT: 20100a: 00 00
 // DISASM-NEXT: 20100c: 00 00
 // DISASM-NEXT: 20100e: 00 00
 // DISASM-NEXT: 201010: 1b 00
-// DISASM-NEXT: 201012: 00 00
-// DISASM-NEXT: 201014: 00 00
-// DISASM-NEXT: 201016: 00 00
-// DISASM-NEXT: 201018: 00 00
-// DISASM-NEXT: 20101a: 00 00
-// DISASM-NEXT: 20101c: 00 00
-// DISASM-NEXT: 20101e: 00 00
-// DISASM-NEXT: 201020: 00 00
-// DISASM-NEXT: 201022: 00 00
-// DISASM-NEXT: 201024: 00 00
-// DISASM-NEXT: 201026: 00 00
-// DISASM-NEXT: 201028: 00 00
-// DISASM-NEXT: 20102a: 00 00
-// DISASM-NEXT: 20102c: 00 00
+// DISASM-NEXT: ...
 // DISASM-NEXT: 20102e: 00 00
 // DISASM:      _start:
 // DISASM-NEXT: 201030: 8b 04 25 19 00 00 00 movl 25, %eax
 // DISASM-NEXT: 201037: 8b 04 25 1a 00 00 00 movl 26, %eax
 // DISASM-NEXT: 20103e: 8b 04 25 1b 00 00 00 movl 27, %eax
 // DISASM-NEXT: 201045: 8b 04 25 00 00 00 00 movl 0, %eax
 // DISASM-NEXT: 20104c: 8b 04 25 00 00 00 00 movl 0, %eax
 // DISASM-NEXT: 201053: 8b 04 25 00 00 00 00 movl 0, %eax

test/ELF/relocation-size.s

 // RELOCSHARED-NEXT:    0x1033 R_X86_64_SIZE32 foo 0xFFFFFFFFFFFFFFFF
 // RELOCSHARED-NEXT:    0x103A R_X86_64_SIZE32 foo 0x0
 // RELOCSHARED-NEXT:    0x1041 R_X86_64_SIZE32 foo 0x1
 // RELOCSHARED-NEXT:  }
 // RELOCSHARED-NEXT: ]
 
 // DISASMSHARED:      Disassembly of section test:
 // DISASMSHARED-NEXT: _data:
-// DISASMSHARED-NEXT: 1000: 00 00
-// DISASMSHARED-NEXT: 1002: 00 00
-// DISASMSHARED-NEXT: 1004: 00 00
-// DISASMSHARED-NEXT: 1006: 00 00
-// DISASMSHARED-NEXT: 1008: 00 00
-// DISASMSHARED-NEXT: 100a: 00 00
-// DISASMSHARED-NEXT: 100c: 00 00
-// DISASMSHARED-NEXT: 100e: 00 00
-// DISASMSHARED-NEXT: 1010: 00 00
-// DISASMSHARED-NEXT: 1012: 00 00
-// DISASMSHARED-NEXT: 1014: 00 00
-// DISASMSHARED-NEXT: 1016: 00 00
+// DISASMSHARED-NEXT: ...
 // DISASMSHARED-NEXT: 1018: 19 00
 // DISASMSHARED-NEXT: 101a: 00 00
 // DISASMSHARED-NEXT: 101c: 00 00
 // DISASMSHARED-NEXT: 101e: 00 00
 // DISASMSHARED-NEXT: 1020: 1a 00
 // DISASMSHARED-NEXT: 1022: 00 00
 // DISASMSHARED-NEXT: 1024: 00 00
 // DISASMSHARED-NEXT: 1026: 00 00

test/MC/Mips/cpsetup.s

 # RUN: llvm-mc -triple mips-unknown-linux -target-abi o32 -filetype=obj -o - %s | \
-# RUN:   llvm-objdump -d -r - | FileCheck -check-prefixes=ALL,O32 %s
+# RUN:   llvm-objdump -d -r -z - | FileCheck -check-prefixes=ALL,O32 %s
 
 # RUN: llvm-mc -triple mips-unknown-linux -target-abi o32 %s | \
 # RUN:   FileCheck -check-prefixes=ALL,ASM,ASM-O32 %s
 
 # FIXME: Now we check .cpsetup expansion for `-mno-shared` case only.
 #        We also need to implement/check the `-mshared` case.
 # RUN: llvm-mc -triple mips64-unknown-linux -target-abi n32 -filetype=obj -o - %s | \
-# RUN:   llvm-objdump -d -r - | \
+# RUN:   llvm-objdump -d -r -z - | \
 # RUN:   FileCheck -check-prefixes=ALL,NXX,N32 %s
 
 # RUN: llvm-mc -triple mips64-unknown-linux -target-abi n32 %s | \
 # RUN:   FileCheck -check-prefixes=ALL,ASM,ASM-N32 %s
 
 # RUN: llvm-mc -triple mips64-unknown-linux %s -filetype=obj -o - | \
-# RUN:   llvm-objdump -d -r - | \
+# RUN:   llvm-objdump -d -r -z - | \
 # RUN:   FileCheck -check-prefixes=ALL,NXX,N64 %s
 
 # RUN: llvm-mc -triple mips64-unknown-linux %s | \
 # RUN:   FileCheck -check-prefixes=ALL,ASM,ASM-N64 %s
 
         .text
         .option pic2
 t1:

test/MC/Mips/nacl-mask.s

 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-nacl %s \
-# RUN:   | llvm-objdump -disassemble -no-show-raw-insn - | FileCheck %s
+# RUN:   | llvm-objdump -disassemble -z -no-show-raw-insn - | FileCheck %s
 
 # This test tests that address-masking sandboxing is added when given assembly
 # input.
 
 
 # Test that address-masking sandboxing is added before indirect branches and
 # returns.
 

test/MC/X86/disassemble-zeroes.s

+// RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t
+// RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=NODISASM
+
+// The exact rules of skipping the bytes you can find in the code.
+// This test checks that we follow these rules and that can force
+// dissasembly of zero blocks with the -z and --disassemble-zeroes options.
+
+// NODISASM:      Disassembly of section .text:
+// NODISASM-NEXT:  0000000000000000 main:
+// NODISASM-NEXT:   0:  00 00               addb %al, (%rax)
+// NODISASM-NEXT:   2:  00 00               addb %al, (%rax)
+// NODISASM-NEXT:   4:  00 00               addb %al, (%rax)
+// NODISASM-NEXT:   6:  00 90 00 00 00 00   addb %dl, (%rax)
+// NODISASM-NEXT:       ...
+// NODISASM-NEXT:   20: 90                  nop
+// NODISASM-NEXT:       ...
+// NODISASM:      0000000000000031 foo:
+// NODISASM-NEXT:   31: 00 00               addb %al, (%rax)
+// NODISASM-NEXT:   33: 00 00               addb %al, (%rax)
+// NODISASM:      0000000000000035 bar:
+// NODISASM-NEXT:       ...
+
+// Check that with -z we disassemble zeroes blocks.
+// RUN: llvm-objdump -d -z %t | FileCheck %s --check-prefix=DISASM
+
+// DISASM: Disassembly of section .text:
+// DISASM-NEXT: 0000000000000000 main:
+// DISASM-NEXT:   0: 00 00              addb %al, (%rax)
+// DISASM-NEXT:   2: 00 00              addb %al, (%rax)
+// DISASM-NEXT:   4: 00 00              addb %al, (%rax)
+// DISASM-NEXT:   6: 00 90 00 00 00 00  addb %dl, (%rax)
+// DISASM-NEXT:   c: 00 00              addb %al, (%rax)
+// DISASM-NEXT:   e: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  10: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  12: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  14: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  16: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  18: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  1a: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  1c: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  1e: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  20: 90                 nop
+// DISASM-NEXT:  21: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  23: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  25: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  27: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  29: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  2b: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  2d: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  2f: 00 00              addb %al, (%rax)
+// DISASM:      0000000000000031 foo:
+// DISASM-NEXT:  31: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  33: 00 00              addb %al, (%rax)
+// DISASM:      0000000000000035 bar:
+// DISASM-NEXT:  35: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  37: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  39: 00 00              addb %al, (%rax)
+// DISASM-NEXT:  3b: 00 00              addb %al, (%rax)
+
+// Check that --disassemble-zeroes work as alias for -z.
+// RUN: llvm-objdump -d --disassemble-zeroes %t | FileCheck %s --check-prefix=DISASM
+
+.text
+.globl main
+.type main, @function
+main:
+ .long 0
+ .byte 0
+ .byte 0
+ .byte 0
+ nop
+ .quad 0
+ .quad 0
+ .quad 0
+ nop
+ .quad 0
+ .quad 0
+foo:
+ .long 0
+bar:
+ .quad 0

tools/llvm-objdump/llvm-objdump.cpp

cl::alias PrintLinesShort("l", cl::desc("Alias for -line-numbers"),
                           cl::aliasopt(PrintLines));
 
 cl::opt<unsigned long long>
     StartAddress("start-address", cl::desc("Disassemble beginning at address"),
                  cl::value_desc("address"), cl::init(0));
 cl::opt<unsigned long long>
     StopAddress("stop-address", cl::desc("Stop disassembly at address"),
                 cl::value_desc("address"), cl::init(UINT64_MAX));
+
+cl::opt<bool> DisassembleZeroes("disassemble-zeroes",
+                                cl::desc("Do not skip blocks of zeroes when "
+                                         "disassembling the blocks of zeroes"));
+cl::alias DisassembleZeroesShort("z",
+                                 cl::desc("Alias for --disassemble-zeroes"),
+                                 cl::aliasopt(DisassembleZeroes));
+
 static StringRef ToolName;
 
 typedef std::vector<std::tuple<uint64_t, StringRef, uint8_t>> SectionSymbolsTy;
 
 namespace {
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
 
 class SectionFilterIterator {
for (auto PltEntry : ElfObj->getPltAddresses()) {
         continue;
       StringRef Name = Saver.save((*NameOrErr + "@plt").str());
 
       AllSymbols[*Plt].emplace_back(PltEntry.second, Name, SymbolType);
     }
   }
 }
 
+// Normally the disassembly output will skip blocks of zeroes. This function for
+// the given buffer Buf with the instructions returns the number of zero bytes
+// that can be skipped during dumping the disassembly output.
+static size_t skipZeroesBlock(ArrayRef<uint8_t> Buf) {
+  // When -z or --disassemble-zeroes are given we always dissasemble them.
+  if (DisassembleZeroes)
+    return 0;
+
+  // Find the amount of leading zeroes.
+  size_t Amount = 0;
+  while (Amount < Buf.size() && !Buf[Amount])
+    ++Amount;
+
+  // We may want to skip blocks of zero bytes, but not earlier
+  // than we see at least 8 of them in a row.
+  if (Amount < 8)
+    return 0;
+
+  // We skip zeroes in multiples of 4 because do not want to truncate an
+  // instruction if it starts with a zero byte.
+  return Amount & ~0x3;
+}
+
 static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   if (StartAddress > StopAddress)
     error("Start address should be less than stop address");
 
   const Target *TheTarget = getTarget(Obj);
 
   // Package up features to be passed to target/subtarget
   SubtargetFeatures Features = Obj->getFeatures();
#endif
               outs() << '\n';
               NumBytes = 0;
             }
           }
         }
         if (Index >= End)
           break;
 
+        if (size_t N = skipZeroesBlock(Bytes.slice(Index, End - Index))) {
+          outs() << "\t\t..." << '\n';
+          Index += N;
+          if (Index >= End)
+            break;
+        }
+
         // Disassemble a real instruction or a data when disassemble all is
         // provided
         bool Disassembled = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                                    SectionAddr + Index, DebugOut,
                                                    CommentStream);
         if (Size == 0)
           Size = 1;