[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

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

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

6

and that can force -> and can force

24

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/ELF/mips-26.s

 # REQUIRES: mips
 # Check R_MIPS_26 relocation handling.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %S/Inputs/mips-dynamic.s -o %t2.o
 # RUN: ld.lld %t2.o -shared -o %t.so
 # RUN: ld.lld %t1.o %t.so -o %t.exe
-# RUN: llvm-objdump -d %t.exe | FileCheck %s
+# RUN: llvm-objdump -d -z %t.exe | FileCheck %s
 # RUN: llvm-readobj -dynamic-table -s -r -mips-plt-got %t.exe \
 # RUN:   | FileCheck -check-prefix=REL %s
 
 # CHECK:      Disassembly of section .text:
 # CHECK-NEXT: bar:
 # CHECK-NEXT:   20000:       0c 00 80 06     jal     131096 <loc>
 # CHECK-NEXT:   20004:       00 00 00 00     nop
 #

test/ELF/mips-micro-jal.s

 # REQUIRES: mips
 # Check PLT creation for microMIPS to microMIPS calls.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips %S/Inputs/mips-micro.s -o %t1eb.o
 # RUN: ld.lld -shared -o %teb.so %t1eb.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips %s -o %t2eb.o
 # RUN: ld.lld -o %teb.exe %t2eb.o %teb.so
-# RUN: llvm-objdump -d -mattr=micromips %teb.exe | FileCheck --check-prefix=EB %s
+# RUN: llvm-objdump -d -z -mattr=micromips %teb.exe | FileCheck --check-prefix=EB %s
 # RUN: llvm-readobj -mips-plt-got %teb.exe | FileCheck --check-prefix=PLT %s
 
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \
 # RUN:         -mattr=micromips %S/Inputs/mips-micro.s -o %t1el.o
 # RUN: ld.lld -shared -o %tel.so %t1el.o
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \
 # RUN:         -mattr=micromips %s -o %t2el.o
 # RUN: ld.lld -o %tel.exe %t2el.o %tel.so
-# RUN: llvm-objdump -d -mattr=micromips %tel.exe | FileCheck --check-prefix=EL %s
+# RUN: llvm-objdump -d -z -mattr=micromips %tel.exe | FileCheck --check-prefix=EL %s
 # RUN: llvm-readobj -mips-plt-got %tel.exe | FileCheck --check-prefix=PLT %s
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips -mcpu=mips32r6 %S/Inputs/mips-micro.s -o %t1eb.o
 # RUN: ld.lld -shared -o %teb.so %t1eb.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips -mcpu=mips32r6 %s -o %t2eb.o
 # RUN: ld.lld -o %teb.exe %t2eb.o %teb.so
-# RUN: llvm-objdump -d -mattr=micromips %teb.exe | FileCheck --check-prefix=EBR6 %s
+# RUN: llvm-objdump -d -z -mattr=micromips %teb.exe | FileCheck --check-prefix=EBR6 %s
 
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \
 # RUN:         -mattr=micromips -mcpu=mips32r6 %S/Inputs/mips-micro.s -o %t1el.o
 # RUN: ld.lld -shared -o %tel.so %t1el.o
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \
 # RUN:         -mattr=micromips -mcpu=mips32r6 %s -o %t2el.o
 # RUN: ld.lld -o %tel.exe %t2el.o %tel.so
-# RUN: llvm-objdump -d -mattr=micromips %tel.exe | FileCheck --check-prefix=ELR6 %s
+# RUN: llvm-objdump -d -z -mattr=micromips %tel.exe | FileCheck --check-prefix=ELR6 %s
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips %S/Inputs/mips-micro.s -o %t1eb.o
 # RUN: ld.lld -shared -o %teb.so %t1eb.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %S/Inputs/mips-fpic.s -o %t-reg.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips %s -o %t2eb.o
 # RUN: ld.lld --no-threads -o %teb.exe %t-reg.o %t2eb.o %teb.so
-# RUN: llvm-objdump -d -mattr=micromips %teb.exe \
+# RUN: llvm-objdump -d -z -mattr=micromips %teb.exe \
 # RUN:   | FileCheck --check-prefix=MIXED %s
 
 # EB:      Disassembly of section .plt:
 # EB-NEXT: .plt:
 # EB-NEXT:    20010:       79 80 3f fd     addiupc $3, 65524
 # 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

test/ELF/mips-npic-call-pic-os.s

 # REQUIRES: mips
 # Check LA25 stubs creation with caller in different Output Section to callee.
 # This stub code is necessary when non-PIC code calls PIC function.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fpic.s -o %t-fpic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fnpic.s -o %t-fnpic.o
 # RUN: ld.lld -r %t-fpic.o %t-fnpic.o -o %t-sto-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: ld.lld %t-npic.o %t-pic.o %t-sto-pic.o -o %t.exe
-# RUN: llvm-objdump -d %t.exe | FileCheck %s
+# RUN: llvm-objdump -d -z %t.exe | FileCheck %s
 
 # CHECK: Disassembly of section .text:
 # CHECK-NEXT: __LA25Thunk_foo1a:
 # CHECK-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # CHECK-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # CHECK-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
 

 # CHECK-NEXT:    20098:       00 00 00 00     nop
 # CHECK-NEXT:    2009c:       0c 00 80 1c     jal     131184 <fnpic>
 # CHECK-NEXT:    200a0:       00 00 00 00     nop
 
 # Make sure the thunks are created properly no matter how
 # objects are laid out.
 #
 # RUN: ld.lld %t-pic.o %t-npic.o %t-sto-pic.o -o %t.exe
-# RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=REVERSE %s
+# RUN: llvm-objdump -d -z %t.exe | FileCheck -check-prefix=REVERSE %s
 
 # REVERSE: Disassembly of section .text:
 # REVERSE-NEXT: __LA25Thunk_foo1a:
 # REVERSE-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # REVERSE-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # REVERSE-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # REVERSE-NEXT:    2000c:       00 00 00 00     nop
 

test/ELF/mips-npic-call-pic-script.s

 # REQUIRES: mips
 # Check LA25 stubs creation. This stub code is necessary when
 # non-PIC code calls PIC function.
 # RUN: echo "SECTIONS { .out 0x20000 : { *(.text.*) . = . + 0x100 ;  *(.text) }  }" > %t1.script
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fpic.s -o %t-fpic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fnpic.s -o %t-fnpic.o
 # RUN: ld.lld -r %t-fpic.o %t-fnpic.o -o %t-sto-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: ld.lld --script %t1.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t.exe
-# RUN: llvm-objdump -d %t.exe | FileCheck %s
+# RUN: llvm-objdump -d -z %t.exe | FileCheck %s
 
 # CHECK: Disassembly of section .out:
 # CHECK-NEXT: __LA25Thunk_foo1a:
 # CHECK-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # CHECK-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # CHECK-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
 
__start:
   jal foo2
   jal fpic
   jal fnpic
 
 # Test script with orphans added to existing OutputSection, the .text.1 and
 # .text.2 sections will be added to .text
 # RUN: echo "SECTIONS { .text 0x20000 : { *(.text) }  }" > %t2.script
 # RUN: ld.lld --script %t2.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t2.exe
-# RUN: llvm-objdump -d %t2.exe | FileCheck -check-prefix=ORPH1 %s
+# RUN: llvm-objdump -d -z %t2.exe | FileCheck -check-prefix=ORPH1 %s
 
 # ORPH1: Disassembly of section .text:
 # ORPH1-NEXT: __start:
 # ORPH1-NEXT:    20000:       0c 00 80 15     jal     131156 <__LA25Thunk_foo1a>
 # ORPH1-NEXT:    20004:       00 00 00 00     nop
 # ORPH1-NEXT:    20008:       0c 00 80 22     jal     131208 <__LA25Thunk_foo2>
 # ORPH1-NEXT:    2000c:       00 00 00 00     nop
 # ORPH1-NEXT:    20010:       0c 00 80 19     jal     131172 <__LA25Thunk_foo1b>

 
 # ORPH1: foo2:
 # ORPH1-NEXT:    200a0:       00 00 00 00     nop
 
 # Test script with orphans added to new OutputSection, the .text.1 and
 # .text.2 sections will form a new OutputSection .text
 # RUN: echo "SECTIONS { .out 0x20000 : { *(.text) }  }" > %t3.script
 # RUN: ld.lld --script %t3.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t3.exe
-# RUN: llvm-objdump -d %t3.exe | FileCheck -check-prefix=ORPH2 %s
+# RUN: llvm-objdump -d -z %t3.exe | FileCheck -check-prefix=ORPH2 %s
 
 # ORPH2: Disassembly of section .out:
 # ORPH2-NEXT: __start:
 # ORPH2-NEXT:    20000:       0c 00 80 18     jal     131168 <__LA25Thunk_foo1a>
 # ORPH2-NEXT:    20004:       00 00 00 00     nop
 # ORPH2-NEXT:    20008:       0c 00 80 22     jal     131208 <__LA25Thunk_foo2>
 # ORPH2-NEXT:    2000c:       00 00 00 00     nop
 # ORPH2-NEXT:    20010:       0c 00 80 1c     jal     131184 <__LA25Thunk_foo1b>

test/ELF/mips-npic-call-pic.s

 # REQUIRES: mips
 # Check LA25 stubs creation. This stub code is necessary when
 # non-PIC code calls PIC function.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fpic.s -o %t-fpic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fnpic.s -o %t-fnpic.o
 # RUN: ld.lld -r %t-fpic.o %t-fnpic.o -o %t-sto-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: ld.lld %t-npic.o %t-pic.o %t-sto-pic.o -o %t.exe
-# RUN: llvm-objdump -d %t.exe | FileCheck %s
+# RUN: llvm-objdump -d -z %t.exe | FileCheck %s
 
 # CHECK:     Disassembly of section .text:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:       0c 00 80 0c     jal     131120 <__LA25Thunk_foo1a>
 # CHECK-NEXT:    20004:       00 00 00 00     nop
 # CHECK-NEXT:    20008:       0c 00 80 16     jal     131160 <__LA25Thunk_foo2>
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
 # CHECK-NEXT:    20010:       0c 00 80 10     jal     131136 <__LA25Thunk_foo1b>

 
 # CHECK: fnpic:
 # CHECK-NEXT:    200a0:       00 00 00 00     nop
 
 # Make sure the thunks are created properly no matter how
 # objects are laid out.
 #
 # RUN: ld.lld %t-pic.o %t-npic.o %t-sto-pic.o -o %t.exe
-# RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=REVERSE %s
+# RUN: llvm-objdump -d -z %t.exe | FileCheck -check-prefix=REVERSE %s
 
 # REVERSE: Disassembly of section .text:
 # REVERSE-NEXT: __LA25Thunk_foo1a:
 # REVERSE-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # REVERSE-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # REVERSE-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # REVERSE-NEXT:    2000c:       00 00 00 00     nop
 

test/ELF/ppc64-dtprel.s

 // REQUIRES: ppc
 
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readelf -r %t.o | FileCheck --check-prefix=InputRelocs %s
 // RUN: llvm-readelf -r %t.so | FileCheck --check-prefix=OutputRelocs %s
-// RUN: llvm-objdump -D %t.so | FileCheck --check-prefix=Dis %s
-// RUN: llvm-objdump -D %t.so | FileCheck --check-prefix=GotDisLE %s
+// RUN: llvm-objdump -D -z %t.so | FileCheck --check-prefix=Dis %s
+// RUN: llvm-objdump -D -z %t.so | FileCheck --check-prefix=GotDisLE %s
 
 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readelf -r %t.o | FileCheck --check-prefix=InputRelocs %s
 // RUN: llvm-readelf -r %t.so | FileCheck --check-prefix=OutputRelocs %s
-// RUN: llvm-objdump -D %t.so | FileCheck --check-prefix=Dis %s
-// RUN: llvm-objdump -D %t.so | FileCheck --check-prefix=GotDisBE %s
+// RUN: llvm-objdump -D -z %t.so | FileCheck --check-prefix=Dis %s
+// RUN: llvm-objdump -D -z %t.so | FileCheck --check-prefix=GotDisBE %s
 
         .text
         .abiversion 2
         .globl  test
         .p2align        4
         .type   test,@function
 test:
 .Lfunc_gep0:

test/ELF/relocation-size-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocation-size-shared.s -o %tso.o
 // RUN: ld.lld -shared %tso.o -o %tso
 // RUN: ld.lld %t.o %tso -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=RELOCSHARED %s
-// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
+// RUN: llvm-objdump -d -z %t1 | FileCheck --check-prefix=DISASM %s
 
 // RELOCSHARED:       Relocations [
 // RELOCSHARED-NEXT:  Section ({{.*}}) .rela.dyn {
 // RELOCSHARED-NEXT:    0x201018 R_X86_64_SIZE64 fooshared 0xFFFFFFFFFFFFFFFF
 // RELOCSHARED-NEXT:    0x201020 R_X86_64_SIZE64 fooshared 0x0
 // RELOCSHARED-NEXT:    0x201028 R_X86_64_SIZE64 fooshared 0x1
 // RELOCSHARED-NEXT:    0x201048 R_X86_64_SIZE32 fooshared 0xFFFFFFFFFFFFFFFF
 // RELOCSHARED-NEXT:    0x20104F R_X86_64_SIZE32 fooshared 0x0

test/ELF/relocation-size.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=NORELOC %s
-// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
+// RUN: llvm-objdump -d -z %t1 | FileCheck --check-prefix=DISASM %s
 // RUN: ld.lld -shared %t.o -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=RELOCSHARED %s
-// RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASMSHARED %s
+// RUN: llvm-objdump -d -z %t1 | FileCheck --check-prefix=DISASMSHARED %s
 
 // NORELOC:      Relocations [
 // NORELOC-NEXT: ]
 
 // DISASM:      Disassembly of section test:
 // DISASM-NEXT: _data:
 // DISASM-NEXT: 201000: 19 00
 // DISASM-NEXT: 201002: 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: 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:  14: 00 00             addb   %al, (%rax)
+// NODISASM-NEXT:  16: 00 00             addb   %al, (%rax)
+// NODISASM-NEXT:  18: 90                nop
+// NODISASM-NEXT:      ...
+// NODISASM-NEXT:  25: 00 00             addb   %al, (%rax)
+// NODISASM-NEXT:  27: 00 00             addb   %al, (%rax)
+
+// 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:   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: 90                 nop
+// DISASM-NEXT:     19: 00 00              addb  %al, (%rax)
+// DISASM-NEXT:     1b: 00 00              addb  %al, (%rax)
+// DISASM-NEXT:     1d: 00 00              addb  %al, (%rax)
+// DISASM-NEXT:     1f: 00 00              addb  %al, (%rax)
+// 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)
+
+// 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
+ nop
+ .quad 0
+ .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 keep at least 4 zero bytes because may have an instruction
+  // that starts from a zero byte and we do not want to trunctate it.
+  return Amount - 4;
+}
+
 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))) {
+          outs() << "\t\t..." << '\n';
+          Index += N;
+        }
+
         // 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;