[llvm-objdump] Further rearrange llvm-objdump sections for compatability

[rupprecht]

Summary

rL371826 rearranged some output from llvm-objdump for GNU objdump compatability, but there still seem to be some more.

I think this rearrangement is a little closer. Overview of the ordering which matches GNU objdump:

• Archive headers
• File headers
• Section headers
• Symbol table
• Dwarf debugging
• Relocations (if --disassemble is not used)
• Section contents
• Disassembly

[jhenderson]

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

2090–2091

GNU objdump section contents appear after relocations in the version I'm using.

2094

Is there a test case for this behaviour, i.e. suppressing -R output (also -r) when --disassemble is specified?

2118

Not sure if this is the right bit to comment on, but --dwarf=frames output for GNU objdump appears immediately after the symbol table, and llvm-objdump doesn't appear to be doing this currently, even with these changes.

[rupprecht]

• Rearrange section contents & dwarf output to correct locations
• Add test cases for orderings not covered by all-headers.test
• Add test case for --disassemble + --dyn-relocs (--disassemble + --reloc already exists)
• Update lld tests

[rupprecht]

Thanks, sorry for missing the sections contents & dwarf output ordering. Fixed those and added tests for the missing pieces.

I didn't run check-lld when mailing, and it turns a lot of those test make frequent use of llvm-objdump. Most cases were just rearranging lines, but a few places required tweaking the matchers for variable captures.

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

2094

-r is covered by elf-disassemble-relocs.test. I forked one that runs on a dynamic object and covers this case.

[justice_adams]

@rupprecht A bit of a beginner to LLVM, but why add the suppression for DynamicRelocations when --disassemble is provided?

[jhenderson]

In D68066#1687377, @justice_adams wrote:

@rupprecht A bit of a beginner to LLVM, but why add the suppression for DynamicRelocations when --disassemble is provided?

The LLVM binutils, like llvm-objdump, aim to produce output identical to the equivalent GNU binutils (with some exceptions for various specific reasons). This change aims to improve that compatibility. It could be argued however, that the dynamic relocations change should be put in a separate change, since it's a slightly different issue.

lld/test/ELF/mips-32.s

29 ↗

(On Diff #222222)

Delete the extra blank line.

lld/test/ELF/mips-got16-relocatable.s

25–26 ↗

(On Diff #222222)

What's the purpose of the new 00020{{0*}}? I'm guessing the address printed by the disassembly is not the exact value? Could this be improved using some extra switches, so that the pattern is robust to future changes, e.g. different base addresses?

llvm/test/tools/llvm-objdump/X86/elf-disassemble-dynamic-relocs.test

1 ↗

(On Diff #222222)

This test doesn't make any checks for relocations being printed inline as far as I can see.

56 ↗

(On Diff #222222)

Is this needed any more? I know @grimar has been making various improvements to yaml2obj to fix things like this.

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

14

What's the point of this line?

31

Ditto

39

Ditto

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

1 ↗

(On Diff #222222)

I'd rename the file "output-ordering.test" - it tests things other than just headers.

2–3 ↗

(On Diff #222222)

I think it would be better to be explicit with all the switches rather than use --all-headers. It would help figure out what output to actually expect.

17 ↗

(On Diff #222222)

Do you need this?

18 ↗

(On Diff #222222)

-h

[rupprecht]

In D68066#1687776, @jhenderson wrote:

In D68066#1687377, @justice_adams wrote:

@rupprecht A bit of a beginner to LLVM, but why add the suppression for DynamicRelocations when --disassemble is provided?

The LLVM binutils, like llvm-objdump, aim to produce output identical to the equivalent GNU binutils (with some exceptions for various specific reasons). This change aims to improve that compatibility. It could be argued however, that the dynamic relocations change should be put in a separate change, since it's a slightly different issue.

Good point, I split that off to D68303. Will remove it from this revision and address the other points shortly.

[rupprecht]

• Remove --dyn-relocs + --disassemble change and move it to a different patch
• Delete whitespace
• Rename test to output-ordering
• Remove dynamic section content checks (INIT)
• Expand -x flag in test

lld/test/ELF/mips-got16-relocatable.s

25–26 ↗

(On Diff #222222)

The instruction printed is: addiu $4, $25, 0x220. This corresponds to symbol value 00020220.

I'm not familiar with this test (or mips in general), and I can't quite figure out where the 0002xxxx offset is coming from. Does this regex look better? It should get the last 4 digits, zeroes removed, so the base address can change (as long as the offset is a multiple of 00010000).

Alternatively, I could just force the old ordering by using an intermediate file, e.g.
llvm-objdump -d file.o > tmp
llvm-objdump -t file.o >> tmp
FileCheck --input-file=tmp

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

14

I suppose I don't need it anymore.

GNU objdump doesn't print "Dynamic Section:" if there is nothing there, but llvm-objdump does. To compare sections, I added it to the test data. I think it's still useful to keep in the test data, but we don't need to assert on it -- just the header.

[rupprecht]

In D68066#1687377, @justice_adams wrote:

@rupprecht A bit of a beginner to LLVM, but why add the suppression for DynamicRelocations when --disassemble is provided?

As James mentioned, this is to emulate GNU objdump better; and AIUI the original intention is that --disassemble should include relocations inline in the assembly output, so including a separate section is redundant.

[jhenderson]

lld/test/ELF/mips-got16-relocatable.s

25–26 ↗

(On Diff #222222)

I'm not familiar with this test (or mips in general), and I can't quite figure out where the 0002xxxx offset is coming from

Without looking in detail, I'd guess it's just the standard image base, so effectively the default value of '.' in the internal linker script.

llvm/test/tools/llvm-objdump/output-ordering.test

9 ↗

(On Diff #222737)

headers -> output

54–67 ↗

(On Diff #222737)

Get rid of the excessive spacing

[rupprecht]

• Fix comments and whitespace

[justice_adams]

@rupprecht With most of the lit test adjustments here the only change was the ordering, which makes sense. Could you help me understand why the addition of the various [1-9] style regex expressions were also added to certain tests? Are those just ensuring more verbose matches with FileCheck?

[jhenderson]

LGTM. I'll leave @rupprecht to answer @justice_adams's comment.

[rupprecht]

In D68066#1692390, @justice_adams wrote:

@rupprecht With most of the lit test adjustments here the only change was the ordering, which makes sense. Could you help me understand why the addition of the various [1-9] style regex expressions were also added to certain tests? Are those just ensuring more verbose matches with FileCheck?

In llvm/test/MC/COFF/symidx.s for example, the thing we're matching was originally:

Contents of section .data:
  0000 0b000000 0a000000
SYMBOL TABLE:
  [ a] ... foo
  [ b] ... bar

where a and b are single digit numbers. We don't necessarily know or care what those values are, just that they should have the same value in both places. So we capture it the first time we see the pattern, and then match against it the second time we see it.

For the line:

// CHECK-NEXT:  0000 0[[BAR:[1-9]]]000000 0[[FOO:[1-9]]]000000

The [[BAR:[1-9]]] means to look for the regex [1-9] and capture it in variable BAR. We can then subsequently write a check that verifies we see a line with that previously captured value:

// CHECK-NEXT: [ [[BAR]]](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000001 bar

e.g. if BAR is captured to be 7, the test is equivalent to:

// CHECK-NEXT: [ 7](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000001 bar

This is described in more detail here: http://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-string-substitution-blocks

Anyway: this patch changes the order of sections to:

SYMBOL TABLE:
  [ a] ... foo
  [ b] ... bar
Contents of section .data:
  0000 0b000000 0a000000

[rupprecht]

(hit submit too soon)

Because the order of sections changes, we have to move the regex definition to the first place we capture the variable. That's why the :[1-9] part moves to the first var match.

@justice_adams I hope this answers your question, if not I'm happy to elaborate some more.

[justice_adams]

@rupprecht Thanks for the explanation, that makes perfect sense. This LGTM (but note that I'm fairly new to the binutils)

llvm/test/MC/COFF/symidx.s

 // RUN: llvm-mc -triple x86_64-pc-win32 -filetype=obj %s | llvm-objdump -s -t - | FileCheck %s
 .text
 foo:
   ret
 bar:
   ret
 .data
 .symidx bar
 .symidx foo
 
-// CHECK:      Contents of section .data:
-// CHECK-NEXT:  0000 0[[BAR:[1-9]]]000000 0[[FOO:[1-9]]]000000
 // CHECK:      SYMBOL TABLE:
-// CHECK:      [ [[FOO]]](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000000 foo
-// CHECK-NEXT: [ [[BAR]]](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000001 bar
+// CHECK:      [ [[FOO:[1-9]]]](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000000 foo
+// CHECK-NEXT: [ [[BAR:[1-9]]]](sec  1)(fl 0x00)(ty   0)(scl   3) (nx 0) 0x00000001 bar
+// CHECK:      Contents of section .data:
+// CHECK-NEXT:  0000 0[[BAR]]000000 0[[FOO]]000000

llvm/test/tools/llvm-objdump/X86/adjust-vma.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objdump --all-headers -D -z %t | FileCheck %s --check-prefixes=COMMON,NOADJUST
 # RUN: llvm-objdump --all-headers -D -z --adjust-vma=0x0 %t | FileCheck %s --check-prefixes=COMMON,NOADJUST
 # RUN: llvm-objdump --all-headers -D -z --adjust-vma=0x123000 %t | FileCheck %s --check-prefixes=COMMON,ADJUST
 
+# NOADJUST:      Sections:
+# NOADJUST-NEXT: Idx Name           Size     VMA              Type
+# NOADJUST-NEXT:  0                 00000000 0000000000000000
+# NOADJUST-NEXT:  1 .text           00000002 0000000000000000 TEXT
+# NOADJUST-NEXT:  2 .debug_str      00000004 0000000000000000
+# NOADJUST-NEXT:  3 .rela.debug_str 00000018 0000000000000000
+# NOADJUST-NEXT:  4 .data           00000004 0000000000000000 DATA
+# NOADJUST-NEXT:  5 .rela.data      00000018 0000000000000000
+# NOADJUST-NEXT:  6 .symtab         00000060 0000000000000000
+# NOADJUST-NEXT:  7 .strtab         00000010 0000000000000000
+# NOADJUST-NEXT:  8 .shstrtab       0000003c 0000000000000000
+
+# ADJUST:        Sections:
+# ADJUST-NEXT:   Idx Name           Size     VMA              Type
+# ADJUST-NEXT:    0                 00000000 0000000000000000
+# ADJUST-NEXT:    1 .text           00000002 0000000000123000 TEXT
+# ADJUST-NEXT:    2 .debug_str      00000004 0000000000000000
+# ADJUST-NEXT:    3 .rela.debug_str 00000018 0000000000000000
+# ADJUST-NEXT:    4 .data           00000004 0000000000123000 DATA
+# ADJUST-NEXT:    5 .rela.data      00000018 0000000000000000
+# ADJUST-NEXT:    6 .symtab         00000060 0000000000000000
+# ADJUST-NEXT:    7 .strtab         00000010 0000000000000000
+# ADJUST-NEXT:    8 .shstrtab       0000003c 0000000000000000
+
+# COMMON:      SYMBOL TABLE:
+# COMMON-NEXT:  0000000000000001  l F .text 00000000 func
+# COMMON-NEXT:  0000000000000000      .text 00000000 sym
+# COMMON-NEXT:  0000000000000000  l d .text 00000000 .text
+
 # NOADJUST:      0000000000000000 sym:
 # NOADJUST-NEXT:   0: {{.*}}  nop
 # NOADJUST:      0000000000000001 func:
 # NOADJUST-NEXT:   1: {{.*}}  retq
 
 # ADJUST:        0000000000123000 sym:
 # ADJUST-NEXT:     123000: {{.*}} nop
 # ADJUST:        0000000000123001 func:

 # ADJUST-NEXT:    123000: {{.*}}  addb    %al, (%rax)
 # ADJUST-NEXT:   0000000000123000: R_X86_64_32  .text
 # ADJUST-NEXT:    123002: {{.*}}  addb    %al, (%rax)
 
 # COMMON:        0000000000000000   .rela.data:
 # COMMON-NEXT:    0: {{.*}} addb %al, (%rax)
 ## ... There are more lines here. We do not care.
 
-# NOADJUST:      Sections:
-# NOADJUST-NEXT: Idx Name           Size     VMA              Type
-# NOADJUST-NEXT:  0                 00000000 0000000000000000
-# NOADJUST-NEXT:  1 .text           00000002 0000000000000000 TEXT
-# NOADJUST-NEXT:  2 .debug_str      00000004 0000000000000000
-# NOADJUST-NEXT:  3 .rela.debug_str 00000018 0000000000000000
-# NOADJUST-NEXT:  4 .data           00000004 0000000000000000 DATA
-# NOADJUST-NEXT:  5 .rela.data      00000018 0000000000000000
-# NOADJUST-NEXT:  6 .symtab         00000060 0000000000000000
-# NOADJUST-NEXT:  7 .strtab         00000010 0000000000000000
-# NOADJUST-NEXT:  8 .shstrtab       0000003c 0000000000000000
-
-# ADJUST:        Sections:
-# ADJUST-NEXT:   Idx Name           Size     VMA              Type
-# ADJUST-NEXT:    0                 00000000 0000000000000000
-# ADJUST-NEXT:    1 .text           00000002 0000000000123000 TEXT
-# ADJUST-NEXT:    2 .debug_str      00000004 0000000000000000
-# ADJUST-NEXT:    3 .rela.debug_str 00000018 0000000000000000
-# ADJUST-NEXT:    4 .data           00000004 0000000000123000 DATA
-# ADJUST-NEXT:    5 .rela.data      00000018 0000000000000000
-# ADJUST-NEXT:    6 .symtab         00000060 0000000000000000
-# ADJUST-NEXT:    7 .strtab         00000010 0000000000000000
-# ADJUST-NEXT:    8 .shstrtab       0000003c 0000000000000000
-
-# COMMON:      SYMBOL TABLE:
-# COMMON-NEXT:  0000000000000001  l F .text 00000000 func
-# COMMON-NEXT:  0000000000000000      .text 00000000 sym
-# COMMON-NEXT:  0000000000000000  l d .text 00000000 .text
-
 --- !ELF
 FileHeader:      
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:        
   - Name:            .text

llvm/test/tools/llvm-objdump/X86/demangle.s

 # RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t
 # RUN: llvm-objdump -t -r --demangle %t | FileCheck %s
 
-## Check we demangle symbols when printing relocations.
-# CHECK:      000000000000001 R_X86_64_PLT32 foo()-4
-
 ## Check we demangle symbols when printing symbol table.
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT: 0000000000000000 g     F .text           00000000 foo()
 
+## Check we demangle symbols when printing relocations.
+# CHECK:      000000000000001 R_X86_64_PLT32 foo()-4
+
 ## Check the case when relocations are inlined into disassembly.
 # RUN: llvm-objdump -d -r --demangle %t | FileCheck %s --check-prefix=INLINE
 # INLINE:      foo():
 # INLINE-NEXT:  0: {{.*}}  callq   0 <_Z3foov+0x5>
 # INLINE-NEXT:  0000000000000001:  R_X86_64_PLT32 foo()-4
 
 .text
 .globl _Z3foov
 .type _Z3foov,@function
 _Z3foov:
  callq _Z3foov@PLT

llvm/test/tools/llvm-objdump/X86/out-of-section-sym.test

 // Check that llvm-objdump does not attempt to disassemble symbols outside
 // of section boundaries.
 // RUN: llvm-objdump -d -t %p/Inputs/out-of-section-sym.elf-i386 >%t0
 // RUN: llvm-objdump -dt %p/Inputs/out-of-section-sym.elf-i386 >%t1
 // RUN: cmp %t0 %t1
 // RUN: FileCheck --input-file %t0 %s
 
-CHECK: Disassembly of section .text:
-CHECK-EMPTY:
-CHECK-NEXT: _start:
-CHECK-NEXT:   10:  c3  retl
-CHECK-NEXT: SYMBOL TABLE:
+CHECK: SYMBOL TABLE:
 CHECK-NEXT: 00000010 l    d  .text  00000000 .text
 CHECK-NEXT: 00000010         .text  00000000 _start
 CHECK-NEXT: 00000020         .text  00000000 _fdata
 CHECK-NEXT: 00000010         .text  00000000 _ftext
+CHECK-EMPTY:
+CHECK-NEXT: Disassembly of section .text:
+CHECK-EMPTY:
+CHECK-NEXT: _start:
+CHECK-NEXT:   10:  c3  retl

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

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objdump --all-headers %t | FileCheck %s
 
 ## Check we print file format, architecture and start address followed by the
 ## other data when using --all-headers.
 
 # 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 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
 
 # ARCHIVE: {{.*}}.a({{.*}}):   file format ELF64-x86-64
+# ARCHIVE: rw-r--r--
 # ARCHIVE: architecture: x86_64
 # ARCHIVE: start address: 0x0000000000000000
-# ARCHIVE: rw-r--r--
 # ARCHIVE: Program Header:
 # ARCHIVE: Dynamic Section:
 # ARCHIVE: Sections:
 # ARCHIVE: SYMBOL TABLE:
 # ARCHIVE: {{.*}}.a({{.*}}2):   file format ELF64-x86-64
+# ARCHIVE: rw-r--r--
 # ARCHIVE: architecture: x86_64
 # ARCHIVE: start address: 0x0000000000000000
-# ARCHIVE: rw-r--r--
 # ARCHIVE: Program Header:
 # ARCHIVE: Dynamic Section:
 # ARCHIVE: Sections:
 # ARCHIVE: SYMBOL TABLE:
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:

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

else
       outs() << O->getFileName();
     outs() << ":\tfile format " << O->getFileFormatName() << "\n\n";
   }
 
   if (StartAddress.getNumOccurrences() || StopAddress.getNumOccurrences())
     checkForInvalidStartStopAddress(O, StartAddress, StopAddress);
 
   StringRef ArchiveName = A ? A->getFileName() : "";
-  if (FileHeaders)
-    printFileHeaders(O);
   if (ArchiveHeaders && !MachOOpt && C)
     printArchiveChild(ArchiveName, *C);
-  if (Disassemble)
-    disassembleObject(O, Relocations);
-  if (Relocations && !Disassemble)
-    printRelocations(O);
-  if (DynamicRelocations)
-    printDynamicRelocations(O);
+  if (FileHeaders)
+    printFileHeaders(O);
   if (PrivateHeaders || FirstPrivateHeader)
     printPrivateFileHeaders(O, FirstPrivateHeader);
   if (SectionHeaders)
     printSectionHeaders(O);
-  if (SectionContents)
-    printSectionContents(O);
   if (SymbolTable)
     printSymbolTable(O, ArchiveName);
+  if (SectionContents)
+    printSectionContents(O);
+  if (Relocations && !Disassemble)
+    printRelocations(O);
+  if (DynamicRelocations && !Disassemble)
+    printDynamicRelocations(O);
+  if (Disassemble)
+    disassembleObject(O, Relocations);
   if (UnwindInfo)
     printUnwindInfo(O);
+
+  // Mach-O specific options:
   if (ExportsTrie)
     printExportsTrie(O);
   if (Rebase)
     printRebaseTable(O);
   if (Bind)
     printBindTable(O);
   if (LazyBind)
     printLazyBindTable(O);
   if (WeakBind)
     printWeakBindTable(O);
+
+  // Other special sections:
   if (RawClangAST)
     printRawClangAST(O);
   if (FaultMapSection)
     printFaultMaps(O);
   if (DwarfDumpType != DIDT_Null) {
     std::unique_ptr<DIContext> DICtx = DWARFContext::create(*O);
     // Dump the complete DWARF structure.
     DIDumpOptions DumpOpts;
     DumpOpts.DumpType = DwarfDumpType;
     DICtx->dump(outs(), DumpOpts);
   }
 }