[llvm-objdump] Improve newline consistency between different pieces of information

[MaskRay]

Summary

When dumping multiple pieces of information (e.g. --all-headers),
there is sometimes no separator between two pieces.
This patch uses the "\nheader:\n" style, which generally improves
compatibility with GNU objdump.

Note: objdump -t/-T does not add a newline before "SYMBOL TABLE:" and "DYNAMIC SYMBOL TABLE:".
We add a newline to be consistent with other information.

objdump -d prints two empty lines before the first 'Disassembly of section'.
We print just one with this patch.

[jhenderson]

Generally looks good to me. Are all the changes covered by testing? I struggled a little to follow the impact of the changes, and didn't necessarily see the sort of testing I'd have expected, given the changes (e.g. "Dynamic Section:" preceded by a CHECK-EMPTY or equivalent).

llvm/test/tools/llvm-objdump/all-headers.test

12–13

Indentation looks a bit off between these two lines.

[MaskRay]

improve test

lld/test/MachO/arm64-32-reloc-got-load.s

 # STATIC-DAG:   {{0*}}[[#%x,PAGE+BAR_OFF]] g     F __TEXT,__text _bar
 
 # DYLIB-LABEL: _main:
 # DYLIB-NEXT:  adrp x8, [[#]] ; 0x[[#%x,GOT:]]
 # DYLIB-NEXT:  ldr  w8, [x8, #4]
 # DYLIB-NEXT:  adrp x8, [[#]] ; 0x[[#GOT]]
 # DYLIB-NEXT:  ldr  w8, [x8]
 # DYLIB-NEXT:  ret
+# DYLIB-EMPTY:
 # DYLIB-NEXT:  Sections:
 # DYLIB-NEXT:  Idx   Name   Size      VMA            Type
 # DYLIB:       [[#]] __got  00000008  [[#%.8x,GOT]]  DATA
 
 #--- main.s
 .globl _main, _foo, _bar
 .p2align 2
 _main:

lld/test/MachO/arm64-reloc-got-load.s

 # STATIC-DAG:   {{0*}}[[#%x,PAGE+BAR_OFF]] g     F __TEXT,__text _bar
 
 # DYLIB-LABEL: _main:
 # DYLIB-NEXT:  adrp x8, [[#]] ; 0x[[#%x,GOT:]]
 # DYLIB-NEXT:  ldr  x8, [x8, #8] ; literal pool symbol address: _foo
 # DYLIB-NEXT:  adrp x8, [[#]] ; 0x[[#GOT]]
 # DYLIB-NEXT:  ldr  x8, [x8] ; literal pool symbol address: _bar
 # DYLIB-NEXT:  ret
+# DYLIB-EMPTY:
 # DYLIB-NEXT:  Sections:
 # DYLIB-NEXT:  Idx   Name          Size     VMA              Type
 # DYLIB:       [[#]] __got         00000010 {{0*}}[[#GOT]]   DATA
 
 #--- main.s
 .globl _main, _foo, _bar
 .p2align 2
 _main:

lld/test/MachO/arm64-reloc-tlv-load.s

 # STATIC-DAG:   {{0*}}[[#%x,PAGE+BAR_OFF]] g     O __DATA,__thread_vars _bar
 
 # DYLIB-LABEL: _main:
 # DYLIB-NEXT:  adrp x8, [[#]] ; 0x[[#%x,TLV:]]
 # DYLIB-NEXT:  ldr  x8, [x8, #8] ; literal pool symbol address: _foo
 # DYLIB-NEXT:  adrp x8, [[#]] ; 0x[[#TLV]]
 # DYLIB-NEXT:  ldr  x8, [x8] ; literal pool symbol address: _bar
 # DYLIB-NEXT:  ret
+# DYLIB-EMPTY:
 # DYLIB-NEXT:  Sections:
 # DYLIB-NEXT:  Idx   Name          Size     VMA              Type
 # DYLIB:       [[#]] __thread_ptrs 00000010 {{0*}}[[#TLV]]   DATA
 
 #--- main.s
 .globl _main, _foo, _bar
 .p2align 2
 _main:

llvm/test/tools/llvm-objdump/ELF/AMDGPU/kd-failure.s

 ;; Failure test. We create a malformed kernel descriptor (KD) by manually
 ;; setting the bytes, because one can't create a malformed KD using the
 ;; assembler directives.
 
 ; RUN: llvm-mc %s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -filetype=obj -o %t.o
 
 ; RUN: printf ".type  my_kernel.kd, @object \nmy_kernel.kd:\n.size my_kernel.kd, 64\n" > %t1.sym_info
 ; RUN: llvm-objdump --disassemble-symbols=my_kernel.kd %t.o \
-; RUN: | tail -n +9 > %t1.sym_content
+; RUN: | tail -n +8 > %t1.sym_content
 ; RUN: cat %t1.sym_info %t1.sym_content > %t1.s
 
 ; RUN: llvm-mc %t1.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -filetype=obj -o %t-re-assemble.o
 ; RUN: diff %t.o %t-re-assemble.o
 
 ;; Test failure by setting one of the reserved bytes to non-zero value.
 
 .type my_kernel.kd, @object

llvm/test/tools/llvm-objdump/ELF/AMDGPU/kd-sgpr.s

 ;; Test disassembly for GRANULATED_WAVEFRONT_SGPR_COUNT in the kernel descriptor.
 
 ; RUN: split-file %s %t.dir
 
 ; RUN: llvm-mc %t.dir/1.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t1
-; RUN: llvm-objdump --disassemble-symbols=my_kernel_1.kd %t1 | tail -n +8 \
+; RUN: llvm-objdump --disassemble-symbols=my_kernel_1.kd %t1 | tail -n +7 \
 ; RUN: | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t1-re-assemble
 ; RUN: diff %t1 %t1-re-assemble
 
 ; RUN: llvm-mc %t.dir/2.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2
-; RUN: llvm-objdump --disassemble-symbols=my_kernel_2.kd %t2 | tail -n +8 \
+; RUN: llvm-objdump --disassemble-symbols=my_kernel_2.kd %t2 | tail -n +7 \
 ; RUN: | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2-re-assemble
 ; RUN: diff %t2 %t2-re-assemble
 
 ; RUN: llvm-mc %t.dir/3.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t3
-; RUN: llvm-objdump --disassemble-symbols=my_kernel_3.kd %t3 | tail -n +8 \
+; RUN: llvm-objdump --disassemble-symbols=my_kernel_3.kd %t3 | tail -n +7 \
 ; RUN: | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t3-re-assemble
 ; RUN: diff %t3 %t3-re-assemble
 
 
 ;--- 1.s
 ;; Only set next_free_sgpr.
 .amdhsa_kernel my_kernel_1
   .amdhsa_next_free_vgpr 0

llvm/test/tools/llvm-objdump/ELF/AMDGPU/kd-vgpr.s

 ;; Test disassembly for GRANULATED_WORKITEM_VGPR_COUNT in the kernel descriptor.
 
 ; RUN: split-file %s %t.dir
 
 ; RUN: llvm-mc %t.dir/1.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t1
-; RUN: llvm-objdump --disassemble-symbols=my_kernel_1.kd %t1 | tail -n +8 \
+; RUN: llvm-objdump --disassemble-symbols=my_kernel_1.kd %t1 | tail -n +7 \
 ; RUN: | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t1-re-assemble
 ; RUN: diff %t1 %t1-re-assemble
 
 ; RUN: llvm-mc %t.dir/2.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2
-; RUN: llvm-objdump --disassemble-symbols=my_kernel_2.kd %t2 | tail -n +8 \
+; RUN: llvm-objdump --disassemble-symbols=my_kernel_2.kd %t2 | tail -n +7 \
 ; RUN: | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2-re-assemble
 ; RUN: diff %t2 %t2-re-assemble
 
 ; RUN: llvm-mc %t.dir/3.s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t3
-; RUN: llvm-objdump --disassemble-symbols=my_kernel_3.kd %t3 | tail -n +8 \
+; RUN: llvm-objdump --disassemble-symbols=my_kernel_3.kd %t3 | tail -n +7 \
 ; RUN: | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t3-re-assemble
 ; RUN: diff %t3 %t3-re-assemble
 
 ;--- 1.s
 .amdhsa_kernel my_kernel_1
   .amdhsa_next_free_vgpr 23
   .amdhsa_next_free_sgpr 0
 .end_amdhsa_kernel

llvm/test/tools/llvm-objdump/ELF/AMDGPU/kd-zeroed-gfx9.s

 ;; Entirely zeroed kernel descriptor (for GFX9).
 
 ; RUN: llvm-mc %s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t1
 ; RUN: llvm-objdump --disassemble-symbols=my_kernel.kd %t1 \
-; RUN: | tail -n +8 | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2
+; RUN: | tail -n +7 | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2
 ; RUN: diff %t1 %t2
 
 ; RUN: llvm-objdump -s -j .text %t1 | FileCheck --check-prefix=OBJDUMP %s
 
 ; OBJDUMP:      0000 00000000 00000000 00000000 00000000
 ; OBJDUMP-NEXT: 0010 00000000 00000000 00000000 00000000
 ; OBJDUMP-NEXT: 0020 00000000 00000000 00000000 00000000
 ; OBJDUMP-NEXT: 0030 00000000 00000000 00000000 00000000

llvm/test/tools/llvm-objdump/ELF/AMDGPU/kd-zeroed-raw.s

 ; RUN: llvm-mc %s --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t1
 ; RUN: llvm-objdump --disassemble-symbols=my_kernel.kd %t1 \
-; RUN: | tail -n +8 | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2
+; RUN: | tail -n +7 | llvm-mc --triple=amdgcn-amd-amdhsa -mcpu=gfx908 -mattr=-xnack -filetype=obj -o %t2
 ; RUN: llvm-objdump -s -j .text %t2 | FileCheck --check-prefix=OBJDUMP %s
 
 ;; Not running lit-test over gfx10 (see kd-zeroed-gfx10.s for details).
 ;; kd-zeroed-raw.s and kd-zeroed-*.s should produce the same output for the
 ;; kernel descriptor - a block of 64 zeroed bytes.
 
 ;; The disassembly will produce the contents of kd-zeroed-*.s which on being
 ;; assembled contains additional relocation info. A diff over the entire object

llvm/test/tools/llvm-objdump/ELF/symbol-table.test

 ## Test how --syms/-t prints the static symbol table.
 # RUN: yaml2obj --docnum=1 %s -o %t
 # RUN: llvm-objdump --syms %t > %t.txt
 # RUN: llvm-objdump -t %t | cmp - %t.txt
 # RUN: FileCheck %s --input-file=%t.txt --match-full-lines --strict-whitespace
 
-#      CHECK:SYMBOL TABLE:
+#      CHECK:{{.*}}file format elf64-x86-64
+#CHECK-EMPTY:
+# CHECK-NEXT:SYMBOL TABLE:
 # CHECK-NEXT:0000000000000000 l    df *ABS* 0000000000000000 a.c
 # CHECK-NEXT:0000000000000000 l    d  .text 0000000000000000 .text
 # CHECK-NEXT:0000000000002000 l     O .data 0000000000000000 local_object
 # CHECK-NEXT:0000000000001fff l     F .text 0000000000000000 local_func
 # CHECK-NEXT:0000000000000000 l       *ABS* 0000000000000000 local_abs
 # CHECK-NEXT:0000000000000000 g       .data 0000000000000000 notype
 # CHECK-NEXT:0000000000000000 g     O .data 0000000000000010 object
 # CHECK-NEXT:0000000000000000 g     F .text 000000000000000f func

llvm/test/tools/llvm-objdump/ELF/verdef.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objdump -p %t | FileCheck --strict-whitespace %s
 
-# CHECK:      Version definitions:
+# CHECK:      Dynamic Section:
+# CHECK-EMPTY:
+# CHECK-NEXT: Version definitions:
 # CHECK-NEXT: 1 0x01 0x075bcd15 foo
 # CHECK-NEXT: 2 0x02 0x3ade68b1 VERSION_1
 # CHECK-NEXT:                   VERSION_2 
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB

llvm/test/tools/llvm-objdump/ELF/verneed.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-objdump -p %t | FileCheck %s
+# RUN: llvm-objdump -p %t | FileCheck %s --strict-whitespace --match-full-lines
 
-# CHECK:      Version References:
-# CHECK-NEXT:   required from dso.so.0:
-# CHECK-NEXT:     0x000004d2 0x0a 03 v1
-# CHECK-NEXT:     0x0000162e 0x0b 04 v2
-# CHECK-NEXT:   required from dso.so.1:
-# CHECK-NEXT:     0x000011d7 0x0c 02 v3
+#       CHECK:Dynamic Section:
+# CHECK-EMPTY:
+#  CHECK-NEXT:Version References:
+#  CHECK-NEXT:  required from dso.so.0:
+#  CHECK-NEXT:    0x000004d2 0x0a 03 v1
+#  CHECK-NEXT:    0x0000162e 0x0b 04 v2
+#  CHECK-NEXT:  required from dso.so.1:
+#  CHECK-NEXT:    0x000011d7 0x0c 02 v3
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x0000000000201000

llvm/test/tools/llvm-objdump/MachO/section-headers.test

-RUN: llvm-objdump --macho -h %p/Inputs/hello.obj.macho-x86_64 | FileCheck %s
+RUN: llvm-objdump --macho -h %p/Inputs/hello.obj.macho-x86_64 | FileCheck %s --strict-whitespace --match-full-lines
 
-CHECK: Sections:
-CHECK: Idx Name          Size     VMA              Type
-CHECK:   0 __text        0000003b 0000000000000000 TEXT 
-CHECK:   1 __cstring     0000000d 000000000000003b DATA 
-CHECK:   2 __compact_unwind 00000020 0000000000000048 DATA 
-CHECK:   3 __eh_frame    00000040 0000000000000068 DATA 
+      CHECK:{{^$}}
+ CHECK-NEXT:Sections:
+ CHECK-NEXT:Idx Name             Size     VMA              Type
+ CHECK-NEXT:  0 __text           0000003b 0000000000000000 TEXT
+ CHECK-NEXT:  1 __cstring        0000000d 000000000000003b DATA
+ CHECK-NEXT:  2 __compact_unwind 00000020 0000000000000048 DATA
+ CHECK-NEXT:  3 __eh_frame       00000040 0000000000000068 DATA

llvm/test/tools/llvm-objdump/X86/disassemble-section-name.s

 # RUN: yaml2obj %p/Inputs/simple-executable-x86_64.yaml -o %t
 # RUN: llvm-objdump -d %t | FileCheck %s
 
 # CHECK:       :      file format elf64-x86-64
 # CHECK-EMPTY:
-# CHECK-EMPTY:
 # CHECK-NEXT:  Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT:  0000000000000000 <foo>:

llvm/test/tools/llvm-objdump/X86/elf-dynamic-symbols.test

 ## Test that llvm-objdump can dump dynamic symbols.
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-objdump --dynamic-syms %t1 | \
 # RUN:   FileCheck %s --match-full-lines --strict-whitespace --check-prefix=DYNSYM
 # RUN: llvm-objdump -T %t1 | \
 # RUN:   FileCheck %s --match-full-lines --strict-whitespace --check-prefix=DYNSYM
 
-#       DYNSYM:DYNAMIC SYMBOL TABLE:
+#       DYNSYM:{{.*}}file format elf64-x86-64
+# DYNSYM-EMPTY:
+#  DYNSYM-NEXT:DYNAMIC SYMBOL TABLE:
 #  DYNSYM-NEXT:0000000000000000 l    DO .data 0000000000000000 localsym
 #  DYNSYM-NEXT:0000000000000000 g    DO .data 0000000000000000 globalsym
 #  DYNSYM-NEXT:0000000000000000 u    DO .data 0000000000000000 uniqueglobalsym
 #  DYNSYM-NEXT:0000000000000000  w   DO .data 0000000000000000 weaksym
 #  DYNSYM-NEXT:0000000000000000 g    Df .data 0000000000000000 filesym
 #  DYNSYM-NEXT:0000000000000000 g    DF .data 0000000000000000 funcsym
 # DYNSYM-EMPTY:
 

llvm/test/tools/llvm-objdump/all-headers.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objdump --all-headers %t | FileCheck %s
 # RUN: llvm-objdump -x %t | FileCheck %s
 
 ## Note: --all-headers (-x) is an alias for --archive-headers --file-headers
 ## --section-headers --private-headers --reloc --syms (-afhprt). Test for them
 ## in the following order which provides GNU objdump compatability.
 
 # CHECK:       file format elf64-x86-64
-# CHECK-EMPTY:
 # CHECK-NEXT:  architecture: x86_64
 # CHECK-NEXT:  start address: 0x0000000000000000
 # CHECK-EMPTY:
-# CHECK-NEXT: Program Header:
-# CHECK: Dynamic Section:
-# CHECK: Sections:
-# CHECK: SYMBOL TABLE:
-# CHECK: RELOCATION RECORDS FOR [.text]:
+# CHECK-NEXT:  Program Header:
+# CHECK-EMPTY:
+# CHECK-NEXT:  Dynamic Section:
+# CHECK:         INIT
+# CHECK-EMPTY:
+# CHECK-NEXT:  Sections:
+# CHECK:         6 .shstrtab   0000002e 0000000000000000
+# CHECK-EMPTY:
+# CHECK-NEXT:  SYMBOL TABLE:
+# CHECK-NEXT:  0000000000000000 l       .text  0000000000000000 foo
+# CHECK-EMPTY:
+# CHECK-NEXT:  RELOCATION RECORDS FOR [.text]:
 
 ## Check how we dump the archives.
 ## Check we dump the appropriate headers for each file in the archive.
 
 # RUN: cp %t %t2
 # RUN: rm -f %t.a
 # RUN: llvm-ar rcs %t.a %t %t2
 # RUN: llvm-objdump --all-headers %t.a | FileCheck %s --check-prefix=ARCHIVE

llvm/tools/llvm-objdump/ELFDump.cpp

ArrayRef<typename ELFT::Dyn> DynamicEntries =
       unwrapOrError(Elf.dynamicEntries(), Filename);
 
   // Find the maximum tag name length to format the value column properly.
   size_t MaxLen = 0;
   for (const typename ELFT::Dyn &Dyn : DynamicEntries)
     MaxLen = std::max(MaxLen, Elf.getDynamicTagAsString(Dyn.d_tag).size());
   std::string TagFmt = "  %-" + std::to_string(MaxLen) + "s ";
 
-  outs() << "Dynamic Section:\n";
+  outs() << "\nDynamic Section:\n";
   for (const typename ELFT::Dyn &Dyn : DynamicEntries) {
     if (Dyn.d_tag == ELF::DT_NULL)
       continue;
 
     std::string Str = Elf.getDynamicTagAsString(Dyn.d_tag);
     outs() << format(TagFmt.c_str(), Str.c_str());
 
     const char *Fmt =
if (Dyn.d_tag == ELF::DT_NEEDED || Dyn.d_tag == ELF::DT_RPATH ||
       consumeError(StrTabOrErr.takeError());
     }
     outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
   }
 }
 
 template <class ELFT>
 static void printProgramHeaders(const ELFFile<ELFT> &Obj, StringRef FileName) {
-  outs() << "Program Header:\n";
+  outs() << "\nProgram Header:\n";
   auto ProgramHeaderOrError = Obj.program_headers();
   if (!ProgramHeaderOrError) {
     reportWarning("unable to read program headers: " +
                       toString(ProgramHeaderOrError.takeError()),
                   FileName);
     return;
   }
 
outs() << "off    " << format(Fmt, (uint64_t)Phdr.p_offset) << "vaddr "
            << format("align 2**%u\n",
                      countTrailingZeros<uint64_t>(Phdr.p_align))
            << "         filesz " << format(Fmt, (uint64_t)Phdr.p_filesz)
            << "memsz " << format(Fmt, (uint64_t)Phdr.p_memsz) << "flags "
            << ((Phdr.p_flags & ELF::PF_R) ? "r" : "-")
            << ((Phdr.p_flags & ELF::PF_W) ? "w" : "-")
            << ((Phdr.p_flags & ELF::PF_X) ? "x" : "-") << "\n";
   }
-  outs() << "\n";
 }
 
 template <class ELFT>
 static void printSymbolVersionDependency(ArrayRef<uint8_t> Contents,
                                          StringRef StrTab) {
-  outs() << "Version References:\n";
+  outs() << "\nVersion References:\n";
 
   const uint8_t *Buf = Contents.data();
   while (Buf) {
     auto *Verneed = reinterpret_cast<const typename ELFT::Verneed *>(Buf);
     outs() << "  required from "
            << StringRef(StrTab.drop_front(Verneed->vn_file).data()) << ":\n";
 
     const uint8_t *BufAux = Buf + Verneed->vn_aux;
while (Buf) {
     Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr;
   }
 }
 
 template <class ELFT>
 static void printSymbolVersionDefinition(const typename ELFT::Shdr &Shdr,
                                          ArrayRef<uint8_t> Contents,
                                          StringRef StrTab) {
-  outs() << "Version definitions:\n";
+  outs() << "\nVersion definitions:\n";
 
   const uint8_t *Buf = Contents.data();
   uint32_t VerdefIndex = 1;
   // sh_info contains the number of entries in the SHT_GNU_verdef section. To
   // make the index column have consistent width, we should insert blank spaces
   // according to sh_info.
   uint16_t VerdefIndexWidth = std::to_string(Shdr.sh_info).size();
   while (Buf) {

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

if (!SecOrErr)
                   "section (" + Twine(Ndx) +
                       "): unable to get a relocation target: " +
                       toString(SecOrErr.takeError()));
     SecToRelSec[**SecOrErr].push_back(Section);
   }
 
   for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) {
     StringRef SecName = unwrapOrError(P.first.getName(), Obj->getFileName());
-    outs() << "RELOCATION RECORDS FOR [" << SecName << "]:\n";
+    outs() << "\nRELOCATION RECORDS FOR [" << SecName << "]:\n";
     uint32_t OffsetPadding = (Obj->getBytesInAddress() > 4 ? 16 : 8);
     uint32_t TypePadding = 24;
     outs() << left_justify("OFFSET", OffsetPadding) << " "
            << left_justify("TYPE", TypePadding) << " "
            << "VALUE\n";
 
     for (SectionRef Section : P.second) {
       for (const RelocationRef &Reloc : Section.relocations()) {
         uint64_t Address = Reloc.getOffset();
         SmallString<32> RelocName;
         SmallString<32> ValueStr;
         if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
           continue;
         Reloc.getTypeName(RelocName);
         if (Error E = getRelocationValueString(Reloc, ValueStr))
           reportError(std::move(E), Obj->getFileName());
 
         outs() << format(Fmt.data(), Address) << " "
                << left_justify(RelocName, TypePadding) << " " << ValueStr
                << "\n";
       }
     }
-    outs() << "\n";
   }
 }
 
 void objdump::printDynamicRelocations(const ObjectFile *Obj) {
   // For the moment, this option is for ELF only
   if (!Obj->isELF())
     return;
 
static size_t getMaxSectionNameWidth(const ObjectFile *Obj) {
   }
   return MaxWidth;
 }
 
 void objdump::printSectionHeaders(const ObjectFile *Obj) {
   size_t NameWidth = getMaxSectionNameWidth(Obj);
   size_t AddressWidth = 2 * Obj->getBytesInAddress();
   bool HasLMAColumn = shouldDisplayLMA(Obj);
+  outs() << "\nSections:\n";
   if (HasLMAColumn)
-    outs() << "Sections:\n"
-              "Idx "
-           << left_justify("Name", NameWidth) << " Size     "
+    outs() << "Idx " << left_justify("Name", NameWidth) << " Size     "
            << left_justify("VMA", AddressWidth) << " "
            << left_justify("LMA", AddressWidth) << " Type\n";
   else
-    outs() << "Sections:\n"
-              "Idx "
-           << left_justify("Name", NameWidth) << " Size     "
+    outs() << "Idx " << left_justify("Name", NameWidth) << " Size     "
            << left_justify("VMA", AddressWidth) << " Type\n";
 
   uint64_t Idx;
   for (const SectionRef &Section : ToolSectionFilter(*Obj, &Idx)) {
     StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
     uint64_t VMA = Section.getAddress();
     if (shouldAdjustVA(Section))
       VMA += AdjustVMA;
if (HasLMAColumn)
              << format_hex_no_prefix(VMA, AddressWidth) << " "
              << format_hex_no_prefix(getELFSectionLMA(Section), AddressWidth)
              << " " << Type << "\n";
     else
       outs() << format("%3" PRIu64 " %-*s %08" PRIx64 " ", Idx, NameWidth,
                        Name.str().c_str(), Size)
              << format_hex_no_prefix(VMA, AddressWidth) << " " << Type << "\n";
   }
-  outs() << "\n";
 }
 
 void objdump::printSectionContents(const ObjectFile *Obj) {
   const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj);
 
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
     uint64_t BaseAddr = Section.getAddress();
for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) {
       outs() << "\n";
     }
   }
 }
 
 void objdump::printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
                                StringRef ArchitectureName, bool DumpDynamic) {
   if (O->isCOFF() && !DumpDynamic) {
-    outs() << "SYMBOL TABLE:\n";
+    outs() << "\nSYMBOL TABLE:\n";
     printCOFFSymbolTable(cast<const COFFObjectFile>(O));
     return;
   }
 
   const StringRef FileName = O->getFileName();
 
   if (!DumpDynamic) {
-    outs() << "SYMBOL TABLE:\n";
+    outs() << "\nSYMBOL TABLE:\n";
     for (auto I = O->symbol_begin(); I != O->symbol_end(); ++I)
       printSymbol(O, *I, FileName, ArchiveName, ArchitectureName, DumpDynamic);
     return;
   }
 
-  outs() << "DYNAMIC SYMBOL TABLE:\n";
+  outs() << "\nDYNAMIC SYMBOL TABLE:\n";
   if (!O->isELF()) {
     reportWarning(
         "this operation is not currently supported for this file format",
         FileName);
     return;
   }
 
   const ELFObjectFileBase *ELF = cast<const ELFObjectFileBase>(O);
if (!O->isELF() && !O->isCOFF())
     reportError(O->getFileName(), "Invalid/Unsupported object file format");
 
   Triple::ArchType AT = O->getArch();
   outs() << "architecture: " << Triple::getArchTypeName(AT) << "\n";
   uint64_t Address = unwrapOrError(O->getStartAddress(), O->getFileName());
 
   StringRef Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64 : "%08" PRIx64;
   outs() << "start address: "
-         << "0x" << format(Fmt.data(), Address) << "\n\n";
+         << "0x" << format(Fmt.data(), Address) << "\n";
 }
 
 static void printArchiveChild(StringRef Filename, const Archive::Child &C) {
   Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
   if (!ModeOrErr) {
     WithColor::error(errs(), ToolName) << "ill-formed archive entry.\n";
     consumeError(ModeOrErr.takeError());
     return;
static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
                        const Archive::Child *C = nullptr) {
   // Avoid other output when using a raw option.
   if (!RawClangAST) {
     outs() << '\n';
     if (A)
       outs() << A->getFileName() << "(" << O->getFileName() << ")";
     else
       outs() << O->getFileName();
-    outs() << ":\tfile format " << O->getFileFormatName().lower() << "\n\n";
+    outs() << ":\tfile format " << O->getFileFormatName().lower() << "\n";
   }
 
   if (HasStartAddressFlag || HasStopAddressFlag)
     checkForInvalidStartStopAddress(O, StartAddress, StopAddress);
 
   // Note: the order here matches GNU objdump for compatability.
   StringRef ArchiveName = A ? A->getFileName() : "";
   if (ArchiveHeaders && !MachOOpt && C)