[llvm-objdump,ARM] Make dumpARMELFData line up with instructions.

[simon_tatham]

Summary

The whitespace in output lines containing disassembled instructions
was extremely mismatched against that in .word lines produced from
dumping literal pools and other data in Arm ELF files. This patch
adjusts dumpARMELFData so that it uses the same alignment system as
in the instruction pretty-printers. Now the two classes of line are
aligned sensibly alongside each other.

[DavidSpickett]

LGTM

Makes me wonder if .word should also print the bytes together like you're changing instructions to do but that's a separate thing.

$ objdump -d /tmp/test.o
<...>
   0:   cafef00d        .word   0xcafef00d
$ ./bin/llvm-objdump -d /tmp/test.o
<...>
0000000000000000 <fn>:
       0:       0d f0 fe ca     .word   0xcafef00d

llvm/tools/llvm-objdump/llvm-objdump.cpp

1019

This becomes Bytes[Index] when you rebase to include https://reviews.llvm.org/D130360 I assume.

[simon_tatham]

In D130359#3676245, @DavidSpickett wrote:

Makes me wonder if .word should also print the bytes together like you're changing instructions to do but that's a separate thing.

I agree that it's separate. In particular, that's data rather than code, so you do have to pay attention to endianness, and I wasn't sure if it would get confusing in a big-endian disassembly to have code and data lines right next to each other both showing 32-bit hex numbers which are implicitly representing the contents of memory in conflicting endiannesses!

llvm/tools/llvm-objdump/llvm-objdump.cpp

1019

Yes, I reordered the patches because D130360 got review attention first, and haven't rebased this one yet.

llvm/test/tools/llvm-objdump/ELF/AArch64/disassemble-align.s

 # RUN: llvm-mc -filetype=obj -triple=aarch64 %s -o %t
 # RUN: llvm-objdump -d %t | tr '\t' '|' | FileCheck --match-full-lines --strict-whitespace %s
 
 ## Use '|' to show where the tabs line up.
 #       CHECK:0000000000000000 <$x.0>:
 #  CHECK-NEXT:       0: 91001062     |add|x2, x3, #4{{$}}
 #  CHECK-NEXT:       4: d503201f     |nop
 # CHECK-EMPTY:
 #  CHECK-NEXT:0000000000000008 <$d.1>:
-#  CHECK-NEXT:       8:|ff ff 00 00|.word|0x0000ffff
+#  CHECK-NEXT:       8: ff ff 00 00  |.word|0x0000ffff
 
   add x2, x3, #4
   nop
   .word 0xffff

llvm/tools/llvm-objdump/llvm-objdump.cpp

if (It == MappingSymbols.begin())
     return '\x00';
   return (It - 1)->second;
 }
 
 static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index,
                                uint64_t End, const ObjectFile &Obj,
                                ArrayRef<uint8_t> Bytes,
                                ArrayRef<MappingSymbolPair> MappingSymbols,
-                               raw_ostream &OS) {
+                               const MCSubtargetInfo &STI, raw_ostream &OS) {
   support::endianness Endian =
       Obj.isLittleEndian() ? support::little : support::big;
-  OS << format("%8" PRIx64 ":\t", SectionAddr + Index);
+  size_t Start = OS.tell();
+  OS << format("%8" PRIx64 ": ", SectionAddr + Index);
   if (Index + 4 <= End) {
     dumpBytes(Bytes.slice(Index, 4), OS);
+    AlignToInstStartColumn(Start, STI, OS);
     OS << "\t.word\t"
            << format_hex(support::endian::read32(Bytes.data() + Index, Endian),
                          10);
     return 4;
   }
   if (Index + 2 <= End) {
     dumpBytes(Bytes.slice(Index, 2), OS);
-    OS << "\t\t.short\t"
-           << format_hex(support::endian::read16(Bytes.data() + Index, Endian),
-                         6);
+    AlignToInstStartColumn(Start, STI, OS);
+    OS << "\t.short\t"
+       << format_hex(support::endian::read16(Bytes.data() + Index, Endian), 6);
     return 2;
   }
   dumpBytes(Bytes.slice(Index, 1), OS);
-  OS << "\t\t.byte\t" << format_hex(Bytes[0], 4);
+  AlignToInstStartColumn(Start, STI, OS);
+  OS << "\t.byte\t" << format_hex(Bytes[0], 4);
   return 1;
 }
 
 static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End,
                         ArrayRef<uint8_t> Bytes) {
   // print out data up to 8 bytes at a time in hex and ascii
   uint8_t AsciiData[9] = {'\0'};
   uint8_t Byte;
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
               STI = PrimaryIsThumb ? PrimarySTI : SecondarySTI;
               DisAsm = PrimaryIsThumb ? PrimaryDisAsm : SecondaryDisAsm;
             }
           }
         }
 
         if (DumpARMELFData) {
           Size = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes,
-                                MappingSymbols, FOS);
+                                MappingSymbols, *STI, FOS);
         } else {
           // 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)