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

(On Diff #221873)

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

2094 ↗

(On Diff #221873)

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

2118 ↗

(On Diff #221873)

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 ↗

(On Diff #221873)

-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

15 ↗

(On Diff #222222)

What's the point of this line?

34 ↗

(On Diff #222222)

Ditto

44 ↗

(On Diff #222222)

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

15 ↗

(On Diff #222222)

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)

lld/trunk/test/ELF/arm-icf-exidx.s

  .fnend
 
  .section .text.h
  .global __aeabi_unwind_cpp_pr0
 __aeabi_unwind_cpp_pr0:
  nop
  bx lr
 
+// CHECK: Contents of section .ARM.exidx:
+// CHECK-NEXT:  100d4 18100000 b0b0b080 14100000 01000000
+
 // CHECK: Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: g:
 // CHECK-NEXT:    110ec:        1e ff 2f e1     bx      lr
 // CHECK: __aeabi_unwind_cpp_pr0:
 // CHECK-NEXT:    110f0:        00 f0 20 e3     nop
 // CHECK-NEXT:    110f4:        1e ff 2f e1     bx      lr
-
-// CHECK: Contents of section .ARM.exidx:
-// CHECK-NEXT:  100d4 18100000 b0b0b080 14100000 01000000

lld/trunk/test/ELF/arm-target1.s

 // RELOC: ]
 
 .text
   .word patatino(target1)
   patatino:
         .word 32
 // Force generation of $d.0 as section is not all data
   nop
+// RELATIVE: SYMBOL TABLE:
+// RELATIVE: 00001154         .text           00000000 patatino
 // RELATIVE: Disassembly of section .text:
 // RELATIVE-EMPTY:
 // RELATIVE: $d.0:
 // RELATIVE:     1150:       04 00 00 00     .word   0x00000004
-// RELATIVE: SYMBOL TABLE:
-// RELATIVE: 00001154         .text           00000000 patatino
 
 // ABS: can't create dynamic relocation R_ARM_TARGET1 against symbol: patatino in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output
 // ABS: >>> defined in {{.*}}.o
 // ABS: >>> referenced by {{.*}}.o:(.text+0x0)

lld/trunk/test/ELF/eh-frame-hdr-abs-fde.s

 # REQUIRES: x86
 # Check reading PC values of FDEs and writing lookup table in the .eh_frame_hdr
 # if CIE augmentation string has 'L' token and PC values are encoded using
 # absolute (not relative) format.
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --eh-frame-hdr %t.o -o %t
 # RUN: llvm-objdump -s -dwarf=frames %t | FileCheck %s
 
+# CHECK: Augmentation:          "zLR"
+# CHECK: Augmentation data:     00 1B
+#                                  ^-- DW_EH_PE_pcrel | DW_EH_PE_udata4 | DW_EH_PE_signed
+
 # CHECK:      Contents of section .eh_frame_hdr:
 # CHECK-NEXT:  200190 011b033b 14000000 01000000 54100000
 #                                                ^-- 0x201000 - 0x200190
 #                                                    .text    - .eh_frame_hdr
 # CHECK-NEXT:  2001a0 30000000
 # CHECK:      Contents of section .text:
 # CHECK-NEXT:  2011e4 90
 
-# CHECK: Augmentation:          "zLR"
-# CHECK: Augmentation data:     00 1B
-#                                  ^-- DW_EH_PE_pcrel | DW_EH_PE_udata4 | DW_EH_PE_signed
-
   .text
   .globl __start
 __start:
   .cfi_startproc
   .cfi_lsda 0, _ex
   nop
   .cfi_endproc
 
   .data
 _ex:
   .word 0

lld/trunk/test/ELF/got32-i386.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -section-headers -d %t | FileCheck %s
 
 ## We have R_386_GOT32 relocation here.
 .globl foo
 .type foo, @function
 foo:
  nop
 
 _start:
  movl foo@GOT, %ebx
 
 ## 73728 == 0x12000 == ADDR(.got)
-# CHECK:       _start:
-# CHECK-NEXT:   4010f5: 8b 1d {{.*}}  movl 4202748, %ebx
 # CHECK: Sections:
 # CHECK:  Name Size     VMA
 # CHECK:  .got 00000004 00000000004020fc
+# CHECK:       _start:
+# CHECK-NEXT:   4010f5: 8b 1d {{.*}}  movl 4202748, %ebx
 
 # RUN: not ld.lld %t.o -o %t -pie 2>&1 | FileCheck %s --check-prefix=ERR
 # ERR: error: symbol 'foo' cannot be preempted; recompile with -fPIE

lld/trunk/test/ELF/got32x-i386.s

 ## R_386_GOT32X is computed as G + A - GOT, but if it used without base
 ## register, it should be calculated as G + A. Using without base register
 ## is only allowed for non-PIC code.
 ##
 # RUN: ld.lld %S/Inputs/i386-got32x-baseless.elf -o %t1
 # RUN: llvm-objdump -section-headers -d %t1 | FileCheck %s
 
 ## 73728 == 0x12000 == ADDR(.got)
+# CHECK: Sections:
+# CHECK:  Name Size     VMA
+# CHECK:  .got.plt 0000000c 0000000000403134
 # CHECK:       _start:
 # CHECK-NEXT:   401115: 8b 05 {{.*}} movl 4202800, %eax
 # CHECK-NEXT:   40111b: 8b 1d {{.*}} movl 4202800, %ebx
 # CHECK-NEXT:   401121: 8b 80 {{.*}} movl -4100(%eax), %eax
 # CHECK-NEXT:   401127: 8b 83 {{.*}} movl -4100(%ebx), %eax
-# CHECK: Sections:
-# CHECK:  Name Size     VMA
-# CHECK:  .got.plt 0000000c 0000000000403134
 
 # RUN: not ld.lld %S/Inputs/i386-got32x-baseless.elf -o %t1 -pie 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ERR
 # ERR-COUNT-2: error: symbol 'foo' cannot be preempted; recompile with -fPIE

lld/trunk/test/ELF/i386-pc8-pc16-addend.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i386-pc-linux-gnu %s -o %t1.o
 
 # RUN: ld.lld %t1.o -o %t.out
 # RUN: llvm-objdump -s -t %t.out | FileCheck %s
+# CHECK: SYMBOL TABLE:
+# CHECK: 004010b7 .und
 # CHECK:      Contents of section .text:
 # CHECK-NEXT:  4010b4 020000
 ## 0x4010b7 - 0x4010b4 + addend(-1) = 0x02
 ## 0x4010b7 - 0x4010b5 + addend(-2) = 0x0000
-# CHECK: SYMBOL TABLE:
-# CHECK: 004010b7 .und
 
 .byte  und-.-1
 .short und-.-2
 
 .section .und, "ax"
 und:

lld/trunk/test/ELF/i386-reloc8-reloc16-addend.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i386-pc-linux-gnu %s -o %t1.o
 
 # RUN: ld.lld -Ttext=0x0 %t1.o -o %t.out
 # RUN: llvm-objdump -s -t %t.out | FileCheck %s
-# CHECK:      Contents of section .text:
-# CHECK-NEXT:  0000 020100
 ## 0x3 + addend(-1) = 0x02
 ## 0x3 + addend(-2) = 0x0100
 # CHECK: SYMBOL TABLE:
 # CHECK: 00000003 .und
+# CHECK:      Contents of section .text:
+# CHECK-NEXT:  0000 020100
 
 .byte  und-1
 .short und-2
 
 .section .und, "ax"
 und:

lld/trunk/test/ELF/i386-retpoline-nopic.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared -soname=t2.so %t2.o -o %t2.so
 
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt
 // RUN: llvm-objdump -d -s --no-show-raw-insn %t.exe | FileCheck %s
 
+// CHECK:      Contents of section .got.plt:
+// CHECK-NEXT: 40224000 00000000 00000000 10124000
+// CHECK-NEXT: 30124000
+
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 4011d0:       pushl   4207276
 // CHECK-NEXT: 4011d6:       pushl   %eax
 // CHECK-NEXT: 4011d7:       movl    4207280, %eax
 // CHECK-NEXT: 4011dc:       calll   15 <.plt+0x20>
 // CHECK-NEXT: 4011e1:       pause

 // CHECK-NEXT: 401235:       jmp     -106 <.plt>
 // CHECK-NEXT: 40123a:       int3
 // CHECK-NEXT: 40123b:       int3
 // CHECK-NEXT: 40123c:       int3
 // CHECK-NEXT: 40123d:       int3
 // CHECK-NEXT: 40123e:       int3
 // CHECK-NEXT: 40123f:       int3
 
-// CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 40224000 00000000 00000000 10124000
-// CHECK-NEXT: 30124000
-
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/i386-retpoline-pic.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared -soname=t2.so %t2.o -o %t2.so
 
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt -pie
 // RUN: llvm-objdump -d -s --no-show-raw-insn %t.exe | FileCheck %s
 
+// CHECK:      Contents of section .got.plt:
+// CHECK-NEXT: 32a8 40220000 00000000 00000000 11120000
+// CHECK-NEXT: 32b8 31120000
+
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 11d0:       pushl   4(%ebx)
 // CHECK-NEXT: 11d6:       pushl   %eax
 // CHECK-NEXT: 11d7:       movl    8(%ebx), %eax
 // CHECK-NEXT: 11dd:       calll   14 <.plt+0x20>
 // CHECK-NEXT: 11e2:       pause

 // CHECK-NEXT: 1231:       pushl   $8
 // CHECK-NEXT: 1236:       jmp     -107 <.plt>
 // CHECK-NEXT: 123b:       int3
 // CHECK-NEXT: 123c:       int3
 // CHECK-NEXT: 123d:       int3
 // CHECK-NEXT: 123e:       int3
 // CHECK-NEXT: 123f:       int3
 
-// CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 32a8 40220000 00000000 00000000 11120000
-// CHECK-NEXT: 32b8 31120000
-
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/mips-32.s

# RUN:   | FileCheck -check-prefix=REL %s
 
   .data
   .globl v2
 v1:
   .word v2+4 # R_MIPS_32 target v2 addend 4
 v2:
   .word v1   # R_MIPS_32 target v1 addend 0
 
+# SYM: SYMBOL TABLE:
+# SYM: 00011000  .data  00000000 v1
+
 # BE: Contents of section .data:
 # BE-NEXT: {{.*}} 00000004 00011000
 #                 ^-- v2+4 ^-- v1
 
 # EL: Contents of section .data:
 # EL-NEXT: {{.*}} 04000000 00100100
 #                 ^-- v2+4 ^-- v1
-
-# SYM: SYMBOL TABLE:
-# SYM: 00011000  .data  00000000 v1
-
 # REL: Relocation section
 # REL:      {{.*}} R_MIPS_REL32
 # REL-NEXT: {{.*}} R_MIPS_REL32 [[V2:[0-9a-f]+]]
 
 # REL: Symbol table
 # REL: {{.*}}: [[V2]] {{.*}} v2
 
 # REL: Dynamic section
 # REL:     (RELSZ)    16
 # REL:     (RELENT)    8
 # REL-NOT: (RELCOUNT)
 
 # REL: Global entries
 # REL: {{.*}} -32744(gp) [[V2]] {{.*}} v2

lld/trunk/test/ELF/mips-64-got.s

 # REQUIRES: mips
 # Check MIPS N64 ABI GOT relocations
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
 # RUN:         %p/Inputs/mips-pic.s -o %t.so.o
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.exe.o
 # RUN: echo "SECTIONS { . = 0x30000; .text : { *(.text) } }" > %t.script
 # RUN: ld.lld %t.so.o -shared -soname=t.so -o %t.so
 # RUN: ld.lld %t.exe.o --script %t.script %t.so -o %t.exe
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s
 # RUN: llvm-readelf -r -s -A %t.exe | FileCheck -check-prefix=GOT %s
 
+# CHECK: {{[0-9a-f]+}}1c8  .text  00000000 foo
+
 # CHECK:      __start:
 # CHECK-NEXT:    {{.*}}  ld      $2, -32736($gp)
 # CHECK-NEXT:    {{.*}}  daddiu  $2,  $2, 456
 # CHECK-NEXT:    {{.*}}  addiu   $2,  $2, -32704
 # CHECK-NEXT:    {{.*}}  addiu   $2,  $2, -32720
 # CHECK-NEXT:    {{.*}}  addiu   $2,  $2, -32712
 
-# CHECK: {{[0-9a-f]+}}1c8  .text  00000000 foo
-
 # GOT: There are no relocations in this file.
 
 # GOT: Symbol table '.symtab'
 # GOT: {{.*}}: [[FOO:[0-9a-f]+]]     {{.*}} foo
 # GOT: {{.*}}: [[GP:[0-9a-f]+]]      {{.*}} _gp
 # GOT: {{.*}}: [[BAR:[0-9a-f]+]]     {{.*}} bar
 
 # GOT:      Primary GOT:

lld/trunk/test/ELF/mips-64-rels.s

 # REQUIRES: mips
 # Check handling multiple MIPS N64 ABI relocations packed
 # into the single relocation record.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:         . = 0x20000; .text ALIGN(0x1000) : { *(.text) } \
 # RUN:         . = 0x30000; .got : { *(.got)  } \
 # RUN:       }" > %t.script
 # RUN: ld.lld %t.o --script %t.script -o %t.exe
 # RUN: llvm-objdump -d -s -t --print-imm-hex --no-show-raw-insn %t.exe | FileCheck %s
 # RUN: llvm-readobj -r %t.exe | FileCheck -check-prefix=REL %s
 
+# CHECK: 0000000000037ff0   .got    00000000 .hidden _gp
+
+# CHECK:      Contents of section .rodata:
+# CHECK-NEXT:  {{[0-9a-f]+}} ffffffff fffe9014
+#                            ^-- 0x21004 - 0x37ff0 = 0xfffffffffffe9014
+
 # CHECK:      __start:
 # CHECK-NEXT:    21000:  lui     $gp, 0x1
 #                                     ^-- 0x21000 - 0x37ff0
 #                                     ^-- 0 - 0xffffffffffff9010
 #                                     ^-- %hi(0x16ff0)
 # CHECK:      loc:
 # CHECK-NEXT:    21004:  daddiu  $gp, $gp, 0x6ff0
 #                                     ^-- 0x21000 - 0x37ff0
 #                                     ^-- 0 - 0xfffffffffffe9010
 #                                     ^-- %lo(0x16ff0)
 
-# CHECK:      Contents of section .rodata:
-# CHECK-NEXT:  {{[0-9a-f]+}} ffffffff fffe9014
-#                            ^-- 0x21004 - 0x37ff0 = 0xfffffffffffe9014
-
-# CHECK: 0000000000037ff0   .got    00000000 .hidden _gp
-
 # REL:      Relocations [
 # REL-NEXT: ]
 
   .text
   .global  __start
 __start:
   lui     $gp,%hi(%neg(%gp_rel(__start)))     # R_MIPS_GPREL16
                                               # R_MIPS_SUB

lld/trunk/test/ELF/mips-64.s

 # REQUIRES: mips
 # Check R_MIPS_64 relocation calculation.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t.so
 # RUN: llvm-objdump -s -t %t.so | FileCheck -check-prefix=SYM %s
 # RUN: llvm-readelf -r -s --dynamic-table -A %t.so | FileCheck %s
 
   .data
   .globl v2
 v1:
   .quad v2+8 # R_MIPS_64 target v2 addend 8
 v2:
   .quad v1   # R_MIPS_64 target v1 addend 0
 
-# SYM: Contents of section .data:
-# SYM-NEXT:  {{.*}} 00000000 00000008 00000000 [[V1:[0-9a-f]+]]
-
 # SYM: SYMBOL TABLE:
-# SYM: 00000000[[V1]]  .data  00000000 v1
+# SYM: 00000000[[V1:[0-9a-f]+]]  .data  00000000 v1
+
+# SYM: Contents of section .data:
+# SYM-NEXT:  {{.*}} 00000000 00000008 00000000 [[V1]]
 
 # CHECK: Relocation section
 # CHECK: [[V2:[0-9a-f]+]]  {{.*}} R_MIPS_REL32/R_MIPS_64/R_MIPS_NONE
 # CHECK: [[V1:[0-9a-f]+]]  {{.*}} R_MIPS_REL32/R_MIPS_64/R_MIPS_NONE [[V2]] v2
 
 # CHECK: Symbol table '.symtab'
 # CHECK: {{.*}}: [[V1]]  {{.*}}  v1
 # CHECK: {{.*}}: [[V2]]  {{.*}}  v2
 
 # CHECK: Dynamic section
 # CHECK: (RELSZ)   32 (bytes)
 # CHECK: (RELENT)  16 (bytes)
 
 # CHECK: Primary GOT:
 # CHECK:  Global entries:
 # CHECK:   {{.*}} -32736(gp) [[V2]] [[V2]] {{.*}} v2

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

 # OBJ-NEXT:           00000000:  R_MIPS_GOT16 .data
 # OBJ-NEXT:   addiu   $4, $25, 0
 # OBJ-NEXT:           00000004:  R_MIPS_LO16  .data
 # OBJ:        lw      $25, 0($gp)
 # OBJ-NEXT:           00000010:  R_MIPS_GOT16 .data
 # OBJ-NEXT:   addiu   $4, $25, 16
 # OBJ-NEXT:           00000014:  R_MIPS_LO16  .data
 
+# SO: SYMBOL TABLE
+# SO: {{0*}}[[D1:[0-9a-f]{1,4}]] .data {{0+}} data
+# SO: {{0*}}[[D2:[0-9a-f]{1,4}]] .data {{0+}} data
+
 # SO:      Disassembly of section .text:
 # SO-EMPTY:
 # SO-NEXT: .text:
 # SO-NEXT:    lw      $25, -0x7fe8($gp)
-# SO-NEXT:    addiu   $4, $25, 0x[[D1:[0-9a-f]+]]
+# SO-NEXT:    addiu   $4, $25, 0x[[D1]]
 # SO:         lw      $25, -0x7fe8($gp)
-# SO-NEXT:    addiu   $4, $25, 0x[[D2:[0-9a-f]+]]
-
-# SO: SYMBOL TABLE
-# SO: [[D1]]
-# SO: [[D2]]
+# SO-NEXT:    addiu   $4, $25, 0x[[D2]]
 
   .text
   lw     $t9, %got(.data)($gp)
   addiu  $a0, $t9, %lo(.data)
 
   .data
 data:
   .word 0

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

 # REQUIRES: mips
 # Check R_MIPS_GOT16 relocation calculation.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:         . = 0x1000;  .text ALIGN(0x1000) : { *(.text) } \
 # RUN:         . = 0x3000;  .data : { *(.data) } \
 # RUN:       }" > %t.script
 # RUN: ld.lld %t.o -shared --script %t.script -o %t.so
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.so | FileCheck %s
 # RUN: llvm-readelf -r -A %t.so | FileCheck -check-prefix=GOT %s
 
+# CHECK: SYMBOL TABLE:
+# CHECK: 00024008         .data           00000000 .hidden bar
+# CHECK: 00000000         *UND*           00000000 foo
+
 # CHECK:       __start:
 # CHECK-NEXT:    lw      $8, -32744($gp)
 # CHECK-NEXT:    addi    $8, $8, 8236
 # CHECK-NEXT:    lw      $8, -32732($gp)
 # CHECK-NEXT:    addi    $8, $8, -16384
 # CHECK-NEXT:    lw      $8, -32728($gp)
 # CHECK-NEXT:    addi    $8, $8, -16380
 # CHECK-NEXT:    lw      $8, -32728($gp)
 # CHECK-NEXT:    addi    $8, $8, 16388
 # CHECK-NEXT:    lw      $8, -32720($gp)
 # CHECK-NEXT:    addi    $8, $8, 16392
 # CHECK-NEXT:    lw      $8, -32716($gp)
-#
-# CHECK: SYMBOL TABLE:
-# CHECK: 00024008         .data           00000000 .hidden bar
-# CHECK: 00000000         *UND*           00000000 foo
 
 # GOT: There are no relocations in this file.
 
 # GOT:       Local entries:
 # GOT-NEXT:        Access  Initial
 # GOT-NEXT:   -32744(gp) 00000000
 #                        ^-- (0x2000 + 0x8000) & ~0xffff
 # GOT-NEXT:   -32740(gp) 00010000

lld/trunk/test/ELF/mips-gp-disp.s

 # RUN: llvm-readelf --symbols %S/Inputs/mips-gp-disp.so \
 # RUN:   | FileCheck -check-prefix=EXT-SO %s
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.so | FileCheck -check-prefix=DIS %s
 # RUN: llvm-readelf -r %t.so | FileCheck -check-prefix=REL %s
 
 # INT-SO: 00000000     0 NOTYPE  LOCAL  HIDDEN   ABS _gp_disp
 # EXT-SO: 00020000     0 NOTYPE  GLOBAL DEFAULT    9 _gp_disp
 
+# DIS: 00037ff0  .got   00000000 .hidden _gp
+# DIS: 00002000  .text  00000000 __start
 # DIS:      Disassembly of section .text:
 # DIS-EMPTY:
 # DIS-NEXT: __start:
 # DIS-NEXT:    lui   $8, 3
 # DIS-NEXT:    addi  $8, $8, 24560
 #                            ^-- (_gp - __start) & 0xffff
-# DIS: 00037ff0  .got   00000000 .hidden _gp
-# DIS: 00002000  .text  00000000 __start
 
 # REL: There are no relocations in this file
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(_gp_disp)
   addi   $t0,$t0,%lo(_gp_disp)
   lw     $v0,%call16(_foo)($gp)

lld/trunk/test/ELF/mips-gp-ext.s

 
 # RUN: echo "SECTIONS { \
 # RUN:          .text : { *(.text) } \
 # RUN:          _gp = 0x200; \
 # RUN:          .got  : { *(.got) } }" > %t.abs.script
 # RUN: ld.lld -shared -o %t.abs.so --script %t.abs.script %t.o
 # RUN: llvm-objdump -s -t %t.abs.so | FileCheck --check-prefix=ABS %s
 
+# REL: 000000e0         .text           00000000 foo
+# REL: 00000000         *ABS*           00000000 .hidden _gp_disp
+# REL: 000001ec         *ABS*           00000000 .hidden _gp
+
 # REL:      Contents of section .reginfo:
 # REL-NEXT:  0018 10000104 00000000 00000000 00000000
 # REL-NEXT:  0028 00000000 000001ec
 #                          ^-- _gp
 
 # REL:      Contents of section .text:
 # REL-NEXT:  00e0 3c080000 2108010c 8f82ff1c
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x1ec - 0x100)
 #                                       G - (GP - .got)
 
 # REL:      Contents of section .data:
 # REL-NEXT:  00f0 fffffef4
 #                 ^-- 0x30-0x1ec
 #                     foo - GP
 
-# REL: 000000e0         .text           00000000 foo
-# REL: 00000000         *ABS*           00000000 .hidden _gp_disp
-# REL: 000001ec         *ABS*           00000000 .hidden _gp
+# ABS: 000000e0         .text           00000000 foo
+# ABS: 00000000         *ABS*           00000000 .hidden _gp_disp
+# ABS: 00000200         *ABS*           00000000 .hidden _gp
 
 # ABS:      Contents of section .reginfo:
 # ABS-NEXT:  0018 10000104 00000000 00000000 00000000
 # ABS-NEXT:  0028 00000000 00000200
 #                          ^-- _gp
 
 # ABS:      Contents of section .text:
 # ABS-NEXT:  00e0 3c080000 21080120 8f82ff08
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x200 - 0x100)
 #                                       G - (GP - .got)
 
 # ABS:      Contents of section .data:
 # ABS-NEXT:  00f0 fffffee0
 #                 ^-- 0xe0-0x200
 #                     foo - GP
 
-# ABS: 000000e0         .text           00000000 foo
-# ABS: 00000000         *ABS*           00000000 .hidden _gp_disp
-# ABS: 00000200         *ABS*           00000000 .hidden _gp
-
   .text
 foo:
   lui    $t0, %hi(_gp_disp)
   addi   $t0, $t0, %lo(_gp_disp)
   lw     $v0, %call16(bar)($gp)
 
   .data
   .gpword foo

lld/trunk/test/ELF/mips-gp-local.s

 # REQUIRES: mips
 # Check handling of relocations against __gnu_local_gp symbol.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:         . = 0x10000; .text ALIGN(0x1000) : { *(.text) } \
 # RUN:         . = 0x30000; .got :  { *(.got) } \
 # RUN:       }" > %t.script
 # RUN: ld.lld --script %t.script -o %t.exe %t.o
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s
 
+# CHECK: 00037ff0  .got  00000000 .hidden _gp
+# CHECK: 00011000  .text 00000000 __start
+
 # CHECK:      __start:
 # CHECK-NEXT:    lui   $8, 3
 # CHECK-NEXT:    addi  $8, $8, 32752
 
-# CHECK: 00037ff0  .got  00000000 .hidden _gp
-# CHECK: 00011000  .text 00000000 __start
-
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(__gnu_local_gp)
   addi   $t0,$t0,%lo(__gnu_local_gp)

lld/trunk/test/ELF/mips-gprel32-relocs-gp0.s

 # REQUIRES: mips
 # Check that relocatable object produced by LLD has zero gp0 value.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld -r -o %t-rel.o %t.o
 # RUN: llvm-readobj -A %t-rel.o | FileCheck --check-prefix=REL %s
 
 # RUN: echo "SECTIONS { \
 # RUN:         .rodata ALIGN(0x1000) : { *(.rodata) } \
 # RUN:         . = 0x20000; .text :  { *(.text) } \
 # RUN:       }" > %t.script
 # RUN: ld.lld -shared --script %t.script -o %t.so %S/Inputs/mips-gp0-non-zero.o
 # RUN: llvm-objdump -s -t %t.so | FileCheck --check-prefix=DUMP %s
 
 # REL: GP: 0x0
 
-# DUMP: Contents of section .rodata:
-# DUMP: 1000 fffffff4 fffffff8
-#            ^ 0x20004 + 0x7ff0 - 0x28000
-#                     ^ 0x20008 + 0x7ff0 - 0x28000
-
 # DUMP: SYMBOL TABLE:
 # DUMP: 00020008         .text          00000000 bar
 # DUMP: 00020004         .text          00000000 foo
 # DUMP: 00028000         .got           00000000 .hidden _gp
 
+# DUMP: Contents of section .rodata:
+# DUMP: 1000 fffffff4 fffffff8
+#            ^ 0x20004 + 0x7ff0 - 0x28000
+#                     ^ 0x20008 + 0x7ff0 - 0x28000
+
   .text
   .global  __start
 __start:
   lw      $t0,%call16(__start)($gp)
 foo:
   nop
 bar:
   nop
 
   .section .rodata, "a"
 v:
   .gpword foo
   .gpword bar

lld/trunk/test/ELF/mips-gprel32-relocs.s

 bar:
   nop
 
   .section .rodata, "a"
 v1:
   .gpword foo
   .gpword bar
 
-# CHECK: Contents of section .rodata:
-# CHECK:  1000 ffff8004 ffff8008
-#              ^ 0x20004 - 0x28000
-#                       ^ 0x20008 - 0x28000
-
 # CHECK: SYMBOL TABLE:
 # CHECK: 00020008         .text           00000000 bar
 # CHECK: 00020004         .text           00000000 foo
 # CHECK: 00028000         .got            00000000 .hidden _gp
+
+# CHECK: Contents of section .rodata:
+# CHECK:  1000 ffff8004 ffff8008
+#              ^ 0x20004 - 0x28000
+#                       ^ 0x20008 - 0x28000

lld/trunk/test/ELF/mips-hilo-gp-disp.s

 __start:
   lui    $t0,%hi(_gp_disp)
   addi   $t0,$t0,%lo(_gp_disp)
   lw     $v0,%call16(_foo)($gp)
 bar:
   lui    $t0,%hi(_gp_disp)
   addi   $t0,$t0,%lo(_gp_disp)
 
+# CHECK: SYMBOL TABLE:
+# CHECK: 0001100c     .text   00000000 bar
+# CHECK: 00037ff0     .got    00000000 .hidden _gp
+# CHECK: 00011000     .text   00000000 __start
+
 # CHECK:      Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:  11000:       lui    $8, 2
 #                                      ^-- %hi(0x37ff0-0x11000)
 # CHECK-NEXT:  11004:       addi   $8, $8, 28656
 #                                          ^-- %lo(0x37ff0-0x11004+4)
 # CHECK:      bar:
 # CHECK-NEXT:  1100c:       lui    $8, 2
 #                                      ^-- %hi(0x37ff0-0x1100c)
 # CHECK-NEXT:  11010:       addi   $8, $8, 28644
 #                                          ^-- %lo(0x37ff0-0x11010+4)
-
-# CHECK: SYMBOL TABLE:
-# CHECK: 0001100c     .text   00000000 bar
-# CHECK: 00037ff0     .got    00000000 .hidden _gp
-# CHECK: 00011000     .text   00000000 __start

lld/trunk/test/ELF/mips-hilo-hi-only.s

 __start:
   lui    $t0,%hi(__start+0x10000)
   addi   $t0,$t0,%lo(_label)
 _label:
   nop
 
 # WARN: can't find matching R_MIPS_LO16 relocation for R_MIPS_HI16
 
+# CHECK: SYMBOL TABLE:
+# CHECK: 00020{{0*}}[[VAL:[0-9a-f]+]] .text   00000000 _label
+# CHECK: 00020{{.*}}                  .text   00000000 __start
+
 # CHECK:      __start:
 # CHECK-NEXT:  lui    $8, 0x3
 #                         ^-- %hi(__start) w/o addend
-# CHECK-NEXT:  addi   $8, $8, 0x[[VAL:[0-9a-f]+]]
+# CHECK-NEXT:  addi   $8, $8, 0x[[VAL]]
 #                             ^-- %lo(_label)
-
-# CHECK: SYMBOL TABLE:
-# CHECK: 00020{{0*}}[[VAL]] .text   00000000 _label
-# CHECK: 00020{{.*}}        .text   00000000 __start

lld/trunk/test/ELF/mips-hilo.s

l1:
   .word 0
 
   .globl g1
   .type  g1,@object
   .size  g1,4
 g1:
   .word 0
 
+# CHECK: SYMBOL TABLE:
+# CHECK: 0021020 l     O .data   00000004 l1
+# CHECK: 0021000         .text   00000000 __start
+# CHECK: 0021024 g     O .data   00000004 g1
+
 # CHECK:      __start:
 # CHECK-NEXT:  21000:   lui    $8, 2
 #                                  ^-- %hi(__start+4)
 # CHECK-NEXT:  21004:   lui    $9, 2
 #                                  ^-- %hi(g1+8)
 # CHECK-NEXT:  21008:   addi   $8, $8, 4100
 #                                      ^-- %lo(__start+4)
 # CHECK-NEXT:  2100c:   addi   $8, $8, 4140
 #                                      ^-- %lo(g1+8)
 # CHECK-NEXT:  21010:   lui    $8, 3
 #                                  ^-- %hi(l1+0x10000-4)
 # CHECK-NEXT:  21014:   lui    $9, 4
 #                                  ^-- %hi(l1+0x20000-4)
 # CHECK-NEXT:  21018:   addi   $8, $8, 4124
 #                                      ^-- %lo(l1-4)
-
-# CHECK: SYMBOL TABLE:
-# CHECK: 0021020 l     O .data   00000004 l1
-# CHECK: 0021000         .text   00000000 __start
-# CHECK: 0021024 g     O .data   00000004 g1

lld/trunk/test/ELF/mips-mgot.s

 # REQUIRES: mips
 # Check MIPS multi-GOT layout.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t0.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %p/Inputs/mips-mgot-1.s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %p/Inputs/mips-mgot-2.s -o %t2.o
 # RUN: echo "SECTIONS { \
 # RUN:         . = 0x10000; .text : { *(.text) } \
 # RUN:         . = 0x70000; .got  : { *(.got)  } \
 # RUN:       }" > %t.script
 # RUN: ld.lld -shared -mips-got-size 52 --script %t.script %t0.o %t1.o %t2.o -o %t.so
 # RUN: llvm-objdump -s -section=.got -t %t.so | FileCheck %s
 # RUN: llvm-readobj -r --dyn-syms -A %t.so | FileCheck -check-prefix=GOT %s
 
+# CHECK: SYMBOL TABLE:
+# CHECK:           00000000 l    O .tdata          00000000 loc0
+# CHECK: [[FOO0:[0-9a-f]+]]        .text           00000000 foo0
+# CHECK:           00000000 g    O .tdata          00000000 tls0
+# CHECK:           00000004 g    O .tdata          00000000 tls1
+# CHECK: [[FOO2:[0-9a-f]+]]        .text           00000000 foo2
+
 # CHECK:      Contents of section .got:
-# CHECK-NEXT:  70000 00000000 80000000 [[FOO0:[0-9a-f]+]] [[FOO2:[0-9a-f]+]]
+# CHECK-NEXT:  70000 00000000 80000000 [[FOO0]] [[FOO2]]
 # CHECK-NEXT:  70010 00000000 00000004 00010000 00020000
 # CHECK-NEXT:  70020 00030000 00040000 00050000 00060000
 # CHECK-NEXT:  70030 00000000 00000000 00000000 00000000
 # CHECK-NEXT:  70040 00000000 00000000 00000000
 
-# CHECK: SYMBOL TABLE:
-# CHECK: 00000000 l    O .tdata          00000000 loc0
-# CHECK: [[FOO0]]        .text           00000000 foo0
-# CHECK: 00000000 g    O .tdata          00000000 tls0
-# CHECK: 00000004 g    O .tdata          00000000 tls1
-# CHECK: [[FOO2]]        .text           00000000 foo2
-
 # GOT:      Relocations [
 # GOT-NEXT:   Section (7) .rel.dyn {
 # GOT-NEXT:     0x70018 R_MIPS_REL32 - 0x0
 # GOT-NEXT:     0x7001C R_MIPS_REL32 - 0x0
 # GOT-NEXT:     0x70020 R_MIPS_REL32 - 0x0
 # GOT-NEXT:     0x70024 R_MIPS_REL32 - 0x0
 # GOT-NEXT:     0x70028 R_MIPS_REL32 - 0x0
 # GOT-NEXT:     0x7002C R_MIPS_REL32 - 0x0

lld/trunk/test/ELF/mips-micro-cross-calls.s

 # REQUIRES: mips
 # Check various cases of microMIPS - regular code cross-calls.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips %s -o %t-eb.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -position-independent -mattr=micromips \
 # RUN:         %S/Inputs/mips-micro.s -o %t-eb-pic.o
 # RUN: ld.lld -o %t-eb.exe %t-eb.o %t-eb-pic.o
 # RUN: llvm-objdump -d -t -mattr=-micromips \
 # RUN:              --no-show-raw-insn --print-imm-hex %t-eb.exe \
 # RUN:   | FileCheck --check-prefixes=SYM,REG %s
 # RUN: llvm-objdump -d -t -mattr=+micromips \
 # RUN:              --no-show-raw-insn --print-imm-hex %t-eb.exe \
 # RUN:   | FileCheck --check-prefixes=SYM,MICRO %s
 
+# REG:  {{0*}}[[FOOT:[0-9a-f]+]]   l     F .text  0000000e 0x80 __microLA25Thunk_foo
+# REG:  {{0*}}[[BAR:[0-9a-f]+]]    g     F .text  00000000 bar
+# REG:  {{0*}}[[MIC:[0-9a-f]+]]            .text  00000000 0x80 micro
+
 # REG:        __start:
-# REG-NEXT:      jalx 0x[[MIC:[0-9a-f]+]] <micro>
+# REG-NEXT:      jalx 0x[[MIC]] <micro>
 # REG-NEXT:      nop
-# REG-NEXT:      jalx 0x[[FOOT:[0-9a-f]+]] <__microLA25Thunk_foo>
+# REG-NEXT:      jalx 0x[[FOOT]] <__microLA25Thunk_foo>
 
 # REG:        __LA25Thunk_bar:
 # REG-NEXT:      lui  $25, 0x2
-# REG-NEXT:      j    0x[[BAR:[0-9a-f]+]] <bar>
+# REG-NEXT:      j    0x[[BAR]] <bar>
+
+# MICRO: {{0*}}[[BART:[0-9a-f]+]]  l     F .text  00000010 __LA25Thunk_bar
+# MICRO: {{0*}}[[START:[0-9a-f]+]]         .text  00000000 __start
+# MICRO: {{0*}}[[FOO:[0-9a-f]+]]   g     F .text  00000000 0x80 foo
 
 # MICRO:      micro:
-# MICRO-NEXT:    jalx 0x[[START:[0-9a-f]+]]
+# MICRO-NEXT:    jalx 0x[[START]]
 # MICRO-NEXT:    nop
-# MICRO-NEXT:    jalx 0x[[BART:[0-9a-f]+]]
+# MICRO-NEXT:    jalx 0x[[BART]]
 
 # MICRO:      __microLA25Thunk_foo:
 # MICRO-NEXT:    lui  $25, 0x2
-# MICRO-NEXT:    j    0x[[FOO:[0-9a-f]+]] <foo>
-
-# REG:  [[FOOT]]   l     F .text  0000000e 0x80 __microLA25Thunk_foo
-# REG:  [[BAR]]    g     F .text  00000000 bar
-# REG:  [[MIC]]            .text  00000000 0x80 micro
-
-# MICRO: [[BART]]  l     F .text  00000010 __LA25Thunk_bar
-# MICRO: [[START]]         .text  00000000 __start
-# MICRO: [[FOO]]   g     F .text  00000000 0x80 foo
+# MICRO-NEXT:    j    0x[[FOO]] <foo>
 
   .text
   .set nomicromips
   .global __start
 __start:
   jal micro
   jal foo
 
   .set micromips
   .global micro
 micro:
   jal __start
   jal bar

lld/trunk/test/ELF/mips-micro-relocs.s

 # RUN:         -mattr=micromips %S/Inputs/mips-micro.s -o %t1el.o
 # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \
 # RUN:         -mattr=micromips %s -o %t2el.o
 # RUN: ld.lld -o %tel.exe -script %t.script %t1el.o %t2el.o
 # RUN: llvm-objdump -d -t -s -mattr=micromips --no-show-raw-insn %tel.exe \
 # RUN:   | FileCheck --check-prefixes=ASM,EL %s
 # RUN: llvm-readelf -h %tel.exe | FileCheck --check-prefix=ELF %s
 
-# ASM:      __start:
-# ASM-NEXT:      20110:  lui     $3, 1
-# ASM-NEXT:              addiu   $3, $3, 32495
-# ASM-NEXT:              lw      $3, -32744($gp)
-# ASM-NEXT:              lw      $3, -32744($3)
-# ASM-NEXT:              beqz16  $6, -32
-# ASM-NEXT:              sll     $3, $fp, 0
-# ASM-NEXT:              b16     -40
-# ASM-NEXT:              nop
-# ASM-NEXT:              b       -44
+# ASM: 00038000         .got   00000000 .hidden _gp
+# ASM: 00020100 g F     .text  00000000 0x80 foo
+# ASM: 00020110         .text  00000000 0x80 __start
 
 # EB:      Contents of section .data:
 # EB-NEXT:  30000 fffe8111
 
 # EB:      Contents of section .debug_info
 # EB-NEXT:  0000 00020111
 
 # EL:      Contents of section .data:
 # EL-NEXT:  30000 1181feff
 
 # EL:      Contents of section .debug_info
 # EL-NEXT:  0000 11010200
 
-# ASM: 00038000         .got   00000000 .hidden _gp
-# ASM: 00020100 g F     .text  00000000 0x80 foo
-# ASM: 00020110         .text  00000000 0x80 __start
+# ASM:      __start:
+# ASM-NEXT:      20110:  lui     $3, 1
+# ASM-NEXT:              addiu   $3, $3, 32495
+# ASM-NEXT:              lw      $3, -32744($gp)
+# ASM-NEXT:              lw      $3, -32744($3)
+# ASM-NEXT:              beqz16  $6, -32
+# ASM-NEXT:              sll     $3, $fp, 0
+# ASM-NEXT:              b16     -40
+# ASM-NEXT:              nop
+# ASM-NEXT:              b       -44
 
 # ELF: Entry point address: 0x20111
 
   .text
   .set micromips
   .global __start
 __start:
   lui     $3, %hi(_gp_disp)       # R_MICROMIPS_HI16

lld/trunk/test/ELF/mips-micror6-relocs.s

 
 # RUN: llvm-mc -filetype=obj -triple=mipsel -mcpu=mips32r6 \
 # RUN:         %S/Inputs/mips-micro.s -o %t1el.o
 # RUN: llvm-mc -filetype=obj -triple=mipsel -mcpu=mips32r6 %s -o %t2el.o
 # RUN: ld.lld -o %tel.exe -script %t.script %t1el.o %t2el.o
 # RUN: llvm-objdump -d -t -mattr=micromips --no-show-raw-insn %tel.exe \
 # RUN:   | FileCheck %s
 
+# CHECK: 00020100 g F     .text  00000000 0x80 foo
+# CHECK: 00020110         .text  00000000 0x80 __start
+
 # CHECK:      __start:
 # CHECK-NEXT:    20110:  lapc   $2, -12
 # CHECK-NEXT:            beqzc  $3, -36
 # CHECK-NEXT:            balc   -24 <foo>
 
-# CHECK: 00020100 g F     .text  00000000 0x80 foo
-# CHECK: 00020110         .text  00000000 0x80 __start
-
   .text
   .set micromips
   .global __start
 __start:
   addiupc $2, foo+4   # R_MICROMIPS_PC19_S2
   beqzc   $3, foo+4   # R_MICROMIPS_PC21_S1
   balc    foo+4       # R_MICROMIPS_PC26_S1

lld/trunk/test/ELF/mips-n32-rels.s

 loc:
   daddiu  $gp,$gp,%lo(%neg(%gp_rel(__start))) # R_MIPS_GPREL16
                                               # R_MIPS_SUB
                                               # R_MIPS_LO16
 
   .section  .rodata,"a",@progbits
   .gpword(loc)                                # R_MIPS_GPREL32
 
+# CHECK: 00020104      .text   00000000 loc
+# CHECK: 00028100      .got    00000000 .hidden _gp
+# CHECK: 00020100 g  F .text   00000000 __start
+
+# CHECK:      Contents of section .rodata:
+# CHECK-NEXT:  {{[0-9a-f]+}} ffff8004
+#                            ^-- loc - _gp
+
 # CHECK:      Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20100:  lui     $gp, 1
 #                                     ^-- 0x20100 - 0x28100
 #                                     ^-- 0 - 0xffff8000
 #                                     ^-- %hi(0x8000)
 # CHECK:      loc:
 # CHECK-NEXT:    20104:  daddiu  $gp, $gp, -32768
 #                                          ^-- 0x20100 - 0x28100
 #                                          ^-- 0 - 0xffff8000
 #                                          ^-- %lo(0x8000)
 
-# CHECK:      Contents of section .rodata:
-# CHECK-NEXT:  {{[0-9a-f]+}} ffff8004
-#                            ^-- loc - _gp
-
-# CHECK: 00020104      .text   00000000 loc
-# CHECK: 00028100      .got    00000000 .hidden _gp
-# CHECK: 00020100 g  F .text   00000000 __start
-
 # ELF: Class:                ELF32
 # ELF: Data:                 2's complement, big endian
 # ELF: Version:              1 (current)
 # ELF: OS/ABI:               UNIX - System V
 # ELF: ABI Version:          0x0
 # ELF: Type:                 EXEC (Executable file)
 # ELF: Machine:              MIPS R3000
 # ELF: Version:              0x1
 # ELF: Entry point address:  0x20100
 # ELF: Flags:                0x60000026, pic, cpic, abi2, mips64

lld/trunk/test/ELF/mips-nonalloc.s

 # REQUIRES: mips
 # Check reading addends for relocations in non-allocatable sections.
 
 # 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-nonalloc.s -o %t2.o
 # RUN: ld.lld %t1.o %t2.o -o %t.exe
 # RUN: llvm-objdump -t -s %t.exe | FileCheck %s
 
+# CHECK: [[SYM:[0-9a-f]+]]  .text  00000000 __start
+
 # CHECK:      Contents of section .debug_info:
-# CHECK-NEXT:  0000 ffffffff [[SYM:[0-9a-f]+]] [[SYM]]
-#                            ^------------------^-- __start
+# CHECK-NEXT:  0000 ffffffff [[SYM]] [[SYM]]
+#                            ^-------^-- __start
 
-# CHECK: [[SYM]]  .text  00000000 __start
 
   .global __start
 __start:
   nop
 
 .section .debug_info
   .word 0xffffffff
   .word __start

lld/trunk/test/ELF/mips-pc-relocs.s

__start:
   beqzc     $9, _foo                # R_MIPS_PC21_S2
   bc        _foo                    # R_MIPS_PC26_S2
   aluipc    $2, %pcrel_hi(_foo)     # R_MIPS_PCHI16
   addiu     $2, $2, %pcrel_lo(_foo) # R_MIPS_PCLO16
 
   .data
   .word _foo+8-.                    # R_MIPS_PC32
 
+# CHECK: 00020000         .text           00000000 __start
+# CHECK: 00020020         .text           00000000 _foo
+
+# CHECK: Contents of section .data:
+# CHECK-NEXT: 30000 ffff0028 00000000 00000000 00000000
+#                   ^-- 0x20020 + 8 - 0x30000
+
 # CHECK:      Disassembly of section .text:
 # CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:       lwpc    $6, 32
 #                                         ^-- (0x20020-0x20000)>>2
 # CHECK-NEXT:    20004:       beqc    $5, $6, 28
 #                                             ^-- (0x20020-4-0x20004)>>2
 # CHECK-NEXT:    20008:       beqzc   $9, 24
 #                                         ^-- (0x20020-4-0x20008)>>2
 # CHECK-NEXT:    2000c:       bc      20
 #                                     ^-- (0x20020-4-0x2000c)>>2
 # CHECK-NEXT:    20010:       aluipc  $2, 0
 #                                         ^-- %hi(0x20020-0x20010)
 # CHECK-NEXT:    20014:       addiu   $2, $2, 12
 #                                             ^-- %lo(0x20020-0x20014)
-
-# CHECK: Contents of section .data:
-# CHECK-NEXT: 30000 ffff0028 00000000 00000000 00000000
-#                   ^-- 0x20020 + 8 - 0x30000
-
-# CHECK: 00020000         .text           00000000 __start
-# CHECK: 00020020         .text           00000000 _foo

lld/trunk/test/ELF/mips-tls-64.s

 # RUN:   | FileCheck -check-prefix=DIS %s
 # RUN: llvm-readobj -r -A %t.exe | FileCheck %s
 
 # RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so
 # RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \
 # RUN:   | FileCheck -check-prefix=DIS-SO %s
 # RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s
 
-# DIS:      __start:
-# DIS-NEXT:    addiu   $2, $3, -32720
-# DIS-NEXT:    addiu   $2, $3, -32736
-# DIS-NEXT:    addiu   $2, $3, -32704
-# DIS-NEXT:    addiu   $2, $3, -32688
-# DIS-NEXT:    addiu   $2, $3, -32728
+# DIS: 0000000000000000 l     O .tdata          00000000 loc
+# DIS: 0000000000000004 g     O .tdata          00000000 bar
+# DIS: 0000000000000000 g     O *UND*           00000000 foo
 
 # DIS:      Contents of section .got:
 # DIS-NEXT:  30000 00000000 00000000 80000000 00000000
 # DIS-NEXT:  30010 00000000 00000000 ffffffff ffff9004
 # DIS-NEXT:  30020 00000000 00000000 00000000 00000000
 # DIS-NEXT:  30030 00000000 00000001 00000000 00000000
 # DIS-NEXT:  30040 00000000 00000001 ffffffff ffff8004
 
-# DIS: 0000000000000000 l     O .tdata          00000000 loc
-# DIS: 0000000000000004 g     O .tdata          00000000 bar
-# DIS: 0000000000000000 g     O *UND*           00000000 foo
+# DIS:      __start:
+# DIS-NEXT:    addiu   $2, $3, -32720
+# DIS-NEXT:    addiu   $2, $3, -32736
+# DIS-NEXT:    addiu   $2, $3, -32704
+# DIS-NEXT:    addiu   $2, $3, -32688
+# DIS-NEXT:    addiu   $2, $3, -32728
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rel.dyn {
 # CHECK-NEXT:     0x30010 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:     0x30020 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:     0x30028 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

lld/trunk/test/ELF/mips-tls-hilo.s

 # REQUIRES: mips
 # Check MIPS R_MIPS_TLS_DTPREL_HI16/LO16 and R_MIPS_TLS_TPREL_HI16/LO16
 # relocations handling.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.exe
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck -check-prefix=DIS %s
 # RUN: llvm-readobj -r -A %t.exe | FileCheck %s
 
 # RUN: ld.lld %t.o -shared -o %t.so
 # RUN: llvm-readobj -r -A %t.so | FileCheck -check-prefix=SO %s
 
+# DIS: 00000000 l    O .tdata          00000000 loc0
+
 # DIS:      __start:
 # DIS-NEXT:    addiu   $2, $3, 0
 #                              ^-- %hi(loc0 - .tdata - 0x8000)
 # DIS-NEXT:    addiu   $2, $3, -32768
 #                              ^-- %lo(loc0 - .tdata - 0x8000)
 # DIS-NEXT:    addiu   $2, $3, 0
 #                              ^-- %hi(loc0 - .tdata - 0x7000)
 # DIS-NEXT:    addiu   $2, $3, -28672
 #                              ^-- %lo(loc0 - .tdata - 0x7000)
 
-# DIS: 00000000 l    O .tdata          00000000 loc0
-
 # CHECK:      Relocations [
 # CHECK-NEXT: ]
 # CHECK-NOT:  Primary GOT
 
 # SO:      Relocations [
 # SO-NEXT: ]
 # SO:      Primary GOT {
 # SO:        Local entries [

lld/trunk/test/ELF/mips-tls-static-64.s

 # REQUIRES: mips
 # Check handling TLS related relocations and symbols when linking
 # a 64-bit static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
 # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
 
-# CHECK:      Contents of section .data:
-# CHECK-NEXT:  {{.*}} [[TGA:[0-9a-f]+]] ffffffff ffff8004 ffffffff
-# CHECK-NEXT:  {{.*}} ffff9004
-#
 # CHECK: SYMBOL TABLE:
-# CHECK:          [[TGA]]        .text           00000000 __tls_get_addr
-# CHECK: 0000000000000000 g    O .tdata          00000000 tls1
+# CHECK: [[TGA:[0-9a-f]{8}]]        .text           00000000 __tls_get_addr
+# CHECK:    0000000000000000 g    O .tdata          00000000 tls1
+#
+# CHECK:      Contents of section .data:
+# CHECK-NEXT:  {{.*}} [[TGA]] ffffffff ffff8004 ffffffff
+# CHECK-NEXT:  {{.*}} ffff9004
 
   .text
   .global __start
 __start:
   nop
 
   .global __tls_get_addr
 __tls_get_addr:

lld/trunk/test/ELF/mips-tls-static.s

 # REQUIRES: mips
 # Check handling TLS related relocations and symbols when linking
 # a static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
 # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
 
+# CHECK: SYMBOL TABLE:
+# CHECK:  [[TGA:[0-9a-f]+]]        .text           00000000 __tls_get_addr
+# CHECK:           00000000 g    O .tdata          00000000 tls1
+#
 # CHECK:      Contents of section .data:
-# CHECK-NEXT:  {{.*}} [[TGA:[0-9a-f]+]] ffff8004 ffff9004
+# CHECK-NEXT:  {{.*}} [[TGA]] ffff8004 ffff9004
 # CHECK:      Contents of section .got:
 # CHECK-NEXT:  {{.*}} 00000000 80000000 ffff9000 00000001
 # CHECK-NEXT:  {{.*}} ffff8000 00000001 00000000
-#
-# CHECK: SYMBOL TABLE:
-# CHECK:  [[TGA]]        .text           00000000 __tls_get_addr
-# CHECK: 00000000 g    O .tdata          00000000 tls1
 
   .text
   .global __start
 __start:
   addiu $2, $3, %tlsgd(tls1)      # R_MIPS_TLS_GD
   addiu $2, $3, %tlsldm(tls2)     # R_MIPS_TLS_LDM
   addiu $2, $3, %gottprel(tls1)   # R_MIPS_TLS_GOTTPREL
 

lld/trunk/test/ELF/mips-tls.s

 # RUN:   | FileCheck -check-prefix=DIS %s
 # RUN: llvm-readobj -r -A %t.exe | FileCheck %s
 
 # RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so
 # RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \
 # RUN:   | FileCheck -check-prefix=DIS-SO %s
 # RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s
 
-# DIS:      __start:
-# DIS-NEXT:    addiu   $2, $3, -32736
-# DIS-NEXT:    addiu   $2, $3, -32744
-# DIS-NEXT:    addiu   $2, $3, -32728
-# DIS-NEXT:    addiu   $2, $3, -32720
-# DIS-NEXT:    addiu   $2, $3, -32740
+# DIS: 00000000 l    O .tdata          00000000 loc
+# DIS: 00000004 g    O .tdata          00000000 bar
+# DIS: 00000000 g    O *UND*           00000000 foo
 
 # DIS:      Contents of section .got:
 # DIS-NEXT:  30000 00000000 80000000 00000000 ffff9004
 # DIS-NEXT:  30010 00000000 00000000 00000001 00000000
 # DIS-NEXT:  30020 00000001 ffff8004
 
-# DIS: 00000000 l    O .tdata          00000000 loc
-# DIS: 00000004 g    O .tdata          00000000 bar
-# DIS: 00000000 g    O *UND*           00000000 foo
+# DIS:      __start:
+# DIS-NEXT:    addiu   $2, $3, -32736
+# DIS-NEXT:    addiu   $2, $3, -32744
+# DIS-NEXT:    addiu   $2, $3, -32728
+# DIS-NEXT:    addiu   $2, $3, -32720
+# DIS-NEXT:    addiu   $2, $3, -32740
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rel.dyn {
 # CHECK-NEXT:     0x30008 R_MIPS_TLS_TPREL32 foo 0x0
 # CHECK-NEXT:     0x30010 R_MIPS_TLS_DTPMOD32 foo 0x0
 # CHECK-NEXT:     0x30014 R_MIPS_TLS_DTPREL32 foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

lld/trunk/test/ELF/msp430.s

 ; REQUIRES: msp430
 ; RUN: llvm-mc -filetype=obj -triple=msp430-elf -o %t1.o %s
 ; RUN: echo -e '.global _start\n _start: nop' | llvm-mc -filetype=obj -triple=msp430-elf -o %t2.o -
 ; RUN: ld.lld -o %t.exe --Tdata=0x2000 --Ttext=0x8000 --defsym=_byte=0x21 -z separate-code %t2.o %t1.o
 ; RUN: llvm-objdump -s -d %t.exe | FileCheck %s
 
 ;; Check handling of basic msp430 relocation types.
 
+  .data
+;; R_MSP430_8
+  .byte _byte
+;; R_MSP430_16
+  .word _start
+;; R_MSP430_32
+  .long _start
+
+; CHECK:      Contents of section .data:
+; CHECK-NEXT: 2000 21008000 800000
+
   .text
   .global foo
 foo:
 ;; R_MSP430_10_PCREL
   jmp _start
 
 ; CHECK:      Disassembly of section .text:
 ; CHECK-EMPTY:
 ; CHECK-NEXT: _start:
 ; CHECK-NEXT: 8000: {{.*}} nop
 ; CHECK:      foo:
 ; CHECK-NEXT: 8004: {{.*}} jmp $-4
 
 ;; R_MSP430_16_BYTE
   call #_start
 
 ; CHECK:      call #32768
 
 ;; R_MSP430_16_PCREL_BYTE
   mov #-1, _start
 
 ; CHECK:      800a: {{.*}} mov #-1, -12
 
-  .data
-;; R_MSP430_8
-  .byte _byte
-;; R_MSP430_16
-  .word _start
-;; R_MSP430_32
-  .long _start
-
-; CHECK:      Contents of section .data:
-; CHECK-NEXT: 2000 21008000 800000
-
 ; RUN: od -x %t.exe | FileCheck -check-prefix=TRAP %s
 ; TRAP: 4343 4343 4343 4343 4343 4343 4343 4343

lld/trunk/test/ELF/non-alloc-link-order-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t1 --gc-sections
 # RUN: llvm-objdump -section-headers -D %t1 | FileCheck %s
 
 ## Check that we are able to GC non-allocatable metadata sections without crash.
 
+# CHECK:      Name          Size
+# CHECK:      .stack_sizes  00000001
+
 # CHECK:      Disassembly of section .stack_sizes:
 # CHECK-EMPTY:
 # CHECK-NEXT:   .stack_sizes:
 # CHECK-NEXT:    01
 
-# CHECK:      Name          Size
-# CHECK:      .stack_sizes  00000001
-
 .section .text.live,"ax",@progbits
 .globl live
 live:
  nop
 
 .section .stack_sizes,"o",@progbits,.text.live,unique,0
 .byte 1
 

lld/trunk/test/ELF/relocation-common.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -t -d %t | FileCheck %s
 
 .global _start
 _start:
   movl $1, sym1(%rip)
 
 .global sym1
 .comm sym1,4,4
 
-# CHECK: 201158: {{.*}} movl    $1, 4098(%rip)
 # CHECK: 0000000000202164 g     O .bss            00000004 sym1
+# CHECK: 201158: {{.*}} movl    $1, 4098(%rip)

lld/trunk/test/ELF/relocation.s

 // SEC-NEXT:   Offset: 0x468
 // SEC-NEXT:   Size: 40
 // SEC-NEXT:   Link: 0
 // SEC-NEXT:   Info: 0
 // SEC-NEXT:   AddressAlignment: 8
 // SEC-NEXT:   EntrySize: 0
 // SEC-NEXT:   }
 
+.section .R_X86_64_64,"a",@progbits
+.global R_X86_64_64
+R_X86_64_64:
+ .quad R_X86_64_64
+
+// CHECK:      Contents of section .R_X86_64_64:
+// CHECK-NEXT:   2002f8 f8022000 00000000
+
+.section .R_X86_64_GOTPCREL,"a",@progbits
+.global R_X86_64_GOTPCREL
+R_X86_64_GOTPCREL:
+ .long zed@gotpcrel
+
+// 0x202460(.got) - 0x200300(.R_X86_64_GOTPCREL) = 0x2160
+// CHECK:      Contents of section .R_X86_64_GOTPCREL
+// CHECK-NEXT:   200300 60210000
+
+.section .R_X86_64_GOT32,"a",@progbits
+.global R_X86_64_GOT32
+R_X86_64_GOT32:
+        .long zed@got
+
+// CHECK: Contents of section .R_X86_64_GOT32:
+// CHECK-NEXT: f8efffff
+
+
+// CHECK: Contents of section .R_X86_64_GOT64:
+// CHECK-NEXT: f8efffff ffffffff
+.section .R_X86_64_GOT64,"a",@progbits
+.global R_X86_64_GOT64
+R_X86_64_GOT64:
+        .quad zed@got
+
 .section       .text,"ax",@progbits,unique,1
 .global _start
 _start:
   call lulz
 
 .section       .text,"ax",@progbits,unique,2
 .zero 4
 .global lulz

 .global R_X86_64_32S_2
 R_X86_64_32S_2:
   mov bar2, %eax
 // plt is  at 0x201340. The second plt entry is at 0x201360 == 2102112
 // CHECK:      Disassembly of section .R_X86_64_32S_2:
 // CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_32S_2:
 // CHECK-NEXT: 201331: {{.*}}  movl    2102112, %eax
-
-.section .R_X86_64_64,"a",@progbits
-.global R_X86_64_64
-R_X86_64_64:
- .quad R_X86_64_64
-
-// CHECK:      Contents of section .R_X86_64_64:
-// CHECK-NEXT:   2002f8 f8022000 00000000
-
-.section .R_X86_64_GOTPCREL,"a",@progbits
-.global R_X86_64_GOTPCREL
-R_X86_64_GOTPCREL:
- .long zed@gotpcrel
-
-// 0x202460(.got) - 0x200300(.R_X86_64_GOTPCREL) = 0x2160
-// CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   200300 60210000
-
-.section .R_X86_64_GOT32,"a",@progbits
-.global R_X86_64_GOT32
-R_X86_64_GOT32:
-        .long zed@got
-
-// CHECK: Contents of section .R_X86_64_GOT32:
-// CHECK-NEXT: f8efffff
-
-
-// CHECK: Contents of section .R_X86_64_GOT64:
-// CHECK-NEXT: f8efffff ffffffff
-.section .R_X86_64_GOT64,"a",@progbits
-.global R_X86_64_GOT64
-R_X86_64_GOT64:
-        .quad zed@got

lld/trunk/test/ELF/x86-64-retpoline-znow.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -soname=so -o %t2.so
 
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt -z now
 // RUN: llvm-objdump -d -s --no-show-raw-insn %t.exe | FileCheck %s
 
+// CHECK:      Contents of section .got.plt:
+// CHECK-NEXT: 23f0 10230000 00000000 00000000 00000000
+// CHECK-NEXT: 2400 00000000 00000000 00000000 00000000
+// CHECK-NEXT: 2410 00000000 00000000
+
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 12d0:       callq   11 <.plt+0x10>
 // CHECK-NEXT:             pause
 // CHECK-NEXT:             lfence
 // CHECK-NEXT:             jmp     -7 <.plt+0x5>
 // CHECK-NEXT:             int3

 // CHECK-NEXT:             int3
 // CHECK-NEXT: 1300:       movq    4361(%rip), %r11
 // CHECK-NEXT:             jmp     -60 <.plt>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 
-// CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 23f0 10230000 00000000 00000000 00000000
-// CHECK-NEXT: 2400 00000000 00000000 00000000 00000000
-// CHECK-NEXT: 2410 00000000 00000000
-
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/x86-64-retpoline.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -soname=so -o %t2.so
 
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt
 // RUN: llvm-objdump -d -s --no-show-raw-insn %t.exe | FileCheck %s
 
+// CHECK:      Contents of section .got.plt:
+// CHECK-NEXT: 3430 70230000 00000000 00000000 00000000
+// CHECK-NEXT: 3440 00000000 00000000 41130000 00000000
+// CHECK-NEXT: 3450 61130000 00000000
+
 // CHECK:      Disassembly of section .plt:
 // CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 1300:       pushq   8498(%rip)
 // CHECK-NEXT:             movq    8499(%rip), %r11
 // CHECK-NEXT:             callq   14 <.plt+0x20>
 // CHECK-NEXT:             pause
 // CHECK-NEXT:             lfence

 // CHECK-NEXT:             pushq   $1
 // CHECK-NEXT:             jmp     -107 <.plt>
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 // CHECK-NEXT:             int3
 
-// CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 3430 70230000 00000000 00000000 00000000
-// CHECK-NEXT: 3440 00000000 00000000 41130000 00000000
-// CHECK-NEXT: 3450 61130000 00000000
-
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

llvm/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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.
+## 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 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: RELOCATION RECORDS FOR [.text]:
 # 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:
+# ARCHIVE: RELOCATION RECORDS FOR [.text]:
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
-  Type:            ET_EXEC
+  Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
+  - Name: .text
+    Type: SHT_PROGBITS
+  - Name: .rel.text
+    Type: SHT_REL
+    Info: .text
+    Relocations:
+      - Offset: 0x1
+        Symbol: foo
+        Type: R_X86_64_32
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    EntSize:         0x0000000000000010
+    Entries:
+      - Tag:             DT_INIT
+        Value:           0x00000000000006A0
+      - Tag:             DT_NULL
+        Value:           0x0000000000000000
+Symbols:
+  - Name:    foo
+    Section: .text

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

+# RUN: yaml2obj %s > %t.o
+# RUN: llvm-objdump --file-headers --private-headers --section-headers --syms \
+# RUN:   --full-contents --dwarf=frames \
+# RUN:   --reloc %t.o | FileCheck %s --check-prefixes=CHECK,RELOC
+# RUN: llvm-objdump --file-headers --private-headers --section-headers --syms \
+# RUN:   --full-contents --dwarf=frames \
+# RUN:   --disassemble %t.o | FileCheck %s --check-prefixes=CHECK,DISASM
+
+## Test the ordering of most of the output. Note that --disassemble suppresses
+## --reloc, so we test them independently.
+
+## File headers (-f)
+# CHECK: file format ELF64-x86-64
+# CHECK: architecture: x86_64
+# CHECK: start address: 0x0000000000000000
+## Private headers (-p)
+# CHECK: Program Header:
+# CHECK: Dynamic Section:
+## Section headers (-h)
+# CHECK: Sections:
+## Symbol table (-t)
+# CHECK: SYMBOL TABLE:
+## DWARF contents:
+# CHECK: .eh_frame contents:
+## Relocations (-r)
+# RELOC: RELOCATION RECORDS FOR [.text]:
+## Section contents (-s)
+# CHECK: Contents of section .rel.text:
+# CHECK: Contents of section .dynamic:
+# CHECK: Contents of section .symtab:
+# CHECK: Contents of section .strtab:
+# CHECK: Contents of section .shstrtab:
+## Disassembly (-d)
+# DISASM: Disassembly of section .text:
+
+!ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content: e800000000e800000000
+  - Name: .rel.text
+    Type: SHT_REL
+    Info: .text
+    Relocations:
+      - Offset: 0x1
+        Symbol: foo
+        Type: R_X86_64_32
+  - Name:    .dynamic
+    Type:    SHT_DYNAMIC
+    Flags:   [ SHF_WRITE, SHF_ALLOC ]
+    EntSize: 0x0000000000000010
+    Entries:
+      - Tag:   DT_INIT
+        Value: 0x00000000000006A0
+      - Tag:   DT_NULL
+        Value: 0x0000000000000000
+  - Name:         .eh_frame
+    Type:         SHT_X86_64_UNWIND
+    Flags:        [ SHF_ALLOC ]
+    AddressAlign: 0x0000000000000001
+    Content:      00000000
+Symbols:
+  - Name:    foo
+    Section: .text

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

if (!RawClangAST) {
     else
       outs() << O->getFileName();
     outs() << ":\tfile format " << O->getFileFormatName() << "\n\n";
   }
 
   if (StartAddress.getNumOccurrences() || StopAddress.getNumOccurrences())
     checkForInvalidStartStopAddress(O, StartAddress, StopAddress);
 
+  // Note: the order here matches GNU objdump for compatability.
   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 (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);
+  }
+  if (Relocations && !Disassemble)
+    printRelocations(O);
+  if (DynamicRelocations)
+    printDynamicRelocations(O);
+  if (SectionContents)
+    printSectionContents(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);
-  }
 }
 
 static void dumpObject(const COFFImportFile *I, const Archive *A,
                        const Archive::Child *C = nullptr) {
   StringRef ArchiveName = A ? A->getFileName() : "";
 
   // Avoid other output when using a raw option.
   if (!RawClangAST)