[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 ↗

(On Diff #179621)

and that can force -> and can force

23 ↗

(On Diff #179621)

zeroes blocks. -> blocks of zeroes.

tools/llvm-objdump/llvm-objdump.cpp

272–273 ↗

(On Diff #179621)

"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 ↗

(On Diff #179621)

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 ↗

(On Diff #179621)

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

1317 ↗

(On Diff #179621)

amount -> number

Also, please rename the variable accordingly.

1322–1323 ↗

(On Diff #179621)

earlier than -> unless (I think)

llvm/trunk/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

llvm/trunk/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:

llvm/trunk/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.
 

llvm/trunk/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 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 blocks of zeroes.
+// 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

llvm/trunk/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"),
+    StopAddress("stop-address",
+                cl::desc("Do not skip blocks of zeroes when disassembling"),
                 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
+// 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])
+    ++N;
+
+  // We may want to skip blocks of zero bytes, but unless we see
+  // at least 8 of them in a row.
+  if (N < 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 N & ~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 =
+                countSkippableZeroBytes(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;