[llvm-objdump] Print newlines before and after "Disassembly of section ...:"

[MaskRay]

This is what GNU objdump does. I don't know why llvm-objdump didn't do this in the first place..

    5a64:       e9 57 be ff ff          jmp    18c0 <__cxa_atexit@plt>                                         

Disassembly of section .fini:

0000000000005a6c <.fini>:

[MaskRay]

Add 3 missed tests

[jhenderson]

Does GNU objdump print the blank line even before the first section?

It would be good to have, in one of the llvm-objdump-specific tests, a test for both this point, and more generally the blank lines before and after the section name. As far as I can tell, there is no direct testing for the before-newline in the llvm-objdump tests you've modified, except for where a very specific different feature of llvm-objdump is being tested.

lld/test/ELF/arm-tls-gd32.s

94 ↗

(On Diff #196633)

This doesn't seem like a direct match to what was there before. What's the motivation here?

llvm/test/MC/X86/disassemble-zeroes.s

26 ↗

(On Diff #196633)

Not that I'm particularly bothered either way, but is there a reason you've removed this?

[MaskRay]

lld/test/ELF/arm-tls-gd32.s

94 ↗

(On Diff #196633)

GNU objdump

Disassembly of section .fini:

0000000000005a6c <.fini>:
    5a6c:       48 83 ec 08             sub    rsp,0x8

llvm-objdump

Disassembly of section .fini:
0000000000005a6c .fini:
    5a6c: 48 83 ec 08                   subq    $8, %rsp

Note that in llvm-objdump, there are two lines matching .fini:. I have to prepend the address to make the check line match the second line. Since I'm changing it, using CHECK-LABEL: improves error messages in case the address changes.

llvm/test/MC/X86/disassemble-zeroes.s

26 ↗

(On Diff #196633)

I think the .text section was not intended to check in this test.

[MaskRay]

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

GNU objdump prints the blank line even before the first section.

[jhenderson]

LGTM.

test/COFF/arm64-import2.test

 # REQUIRES: aarch64
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s -check-prefix BEFORE
 # RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t.obj %p/Inputs/library-arm64.lib %p/Inputs/library2-arm64.lib
 # RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix AFTER
 # RUN: llvm-readobj --coff-imports %t.exe | FileCheck %s -check-prefix IMPORTS
 
 # BEFORE: Disassembly of section .text:
+# BEFORE-EMPTY:
 # BEFORE:        0:       00 00 00 94     bl      #0
 # BEFORE:        4:       00 00 00 94     bl      #0
 # BEFORE:        8:       c0 03 5f d6     ret
 
 # AFTER: Disassembly of section .text:
+# AFTER-EMPTY:
 # AFTER:  140001000:      03 00 00 94     bl      #12
 # AFTER:  140001004:      05 00 00 94     bl      #20
 # AFTER:  140001008:      c0 03 5f d6     ret
 # AFTER:  14000100c:      10 00 00 b0     adrp    x16, #4096
 # AFTER:  140001010:      10 32 40 f9     ldr     x16, [x16, #96]
 # AFTER:  140001014:      00 02 1f d6     br      x16
 # AFTER:  140001018:      10 00 00 b0     adrp    x16, #4096
 # AFTER:  14000101c:      10 3a 40 f9     ldr     x16, [x16, #112]

test/COFF/arm64-relocs-imports.test

 # REQUIRES: aarch64
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s -check-prefix BEFORE
 # RUN: lld-link /entry:main /subsystem:console /out:%t.exe %t.obj %p/Inputs/library-arm64.lib
 # RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix AFTER
 
 # BEFORE: Disassembly of section .text:
+# BEFORE-EMPTY:
 # BEFORE:        0:       fe 0f 1f f8     str     x30, [sp, #-16]!
 # BEFORE:        4:       00 00 00 90     adrp    x0, #0
 # BEFORE:        8:       00 08 00 91     add     x0, x0, #2
 # BEFORE:        c:       00 00 00 94     bl      #0
 # BEFORE:       10:       00 01 40 39     ldrb    w0, [x8]
 # BEFORE:       14:       00 01 40 79     ldrh    w0, [x8]
 # BEFORE:       18:       00 01 40 b9     ldr     w0, [x8]
 # BEFORE:       1c:       00 01 40 f9     ldr     x0, [x8]

 # BEFORE:       88:       00 00 40 f9     ldr     x0, [x0]
 # BEFORE:       8c:       01 00 00 00     udf #1
 # BEFORE:       90:       20 1a 09 30     adr x0, #74565
 # BEFORE:       94:       01 00 00 54     b.ne    #0
 # BEFORE:       98:       00 00 00 36     tbz     w0, #0, #0
 # BEFORE:       9c:       01 00 00 00     udf #1
 
 # AFTER: Disassembly of section .text:
+# AFTER-EMPTY:
 # AFTER:  140001000:      fe 0f 1f f8     str     x30, [sp, #-16]!
 # AFTER:  140001004:      00 00 00 b0     adrp    x0, #4096
 # AFTER:  140001008:      00 18 00 91     add     x0, x0, #6
 # AFTER:  14000100c:      25 00 00 94     bl      #148
 # AFTER:  140001010:      00 21 40 39     ldrb    w0, [x8, #8]
 # AFTER:  140001014:      00 11 40 79     ldrh    w0, [x8, #8]
 # AFTER:  140001018:      00 09 40 b9     ldr     w0, [x8, #8]
 # AFTER:  14000101c:      00 05 40 f9     ldr     x0, [x8, #8]

test/COFF/armnt-blx23t.test

 # REQUIRES: arm
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s -check-prefix BEFORE
 # RUN: lld-link /entry:function /subsystem:console /out:%t.exe %t.obj
 # RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix AFTER
 
 # BEFORE: Disassembly of section .text:
+# BEFORE-EMPTY:
 # BEFORE:        0: 70 47         bx lr
 # BEFORE:        2: 00 bf         nop
 # BEFORE:        4: 2d e9 00 48   push.w {r11, lr}
 # BEFORE:        8: eb 46         mov r11, sp
 # BEFORE:        a: 20 20         movs r0, #32
 # BEFORE:        c: 00 f0 00 f8   bl #0
 # BEFORE:       10: 01 30         adds r0, #1
 # BEFORE:       12: bd e8 00 88   pop.w {r11, pc}
 
 # AFTER: Disassembly of section .text:
+# AFTER-EMPTY:
 # AFTER:     1000: 70 47         bx lr
 # AFTER:     1002: 00 bf         nop
 # AFTER:     1004: 2d e9 00 48   push.w {r11, lr}
 # AFTER:     1008: eb 46         mov r11, sp
 # AFTER:     100a: 20 20         movs r0, #32
 # AFTER:     100c: ff f7 f8 ff   bl #-16
 # AFTER:     1010: 01 30         adds r0, #1
 # AFTER:     1012: bd e8 00 88   pop.w {r11, pc}

test/COFF/armnt-branch24t.test

 # REQUIRES: arm
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s -check-prefix BEFORE
 # RUN: lld-link /entry:function /subsystem:console /out:%t.exe %t.obj
 # RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix AFTER
 
 # BEFORE: Disassembly of section .text:
+# BEFORE-EMPTY:
 # BEFORE:        0: 70 47         bx lr
 # BEFORE:        2: 00 bf         nop
 # BEFORE:        4: 20 20         movs r0, #32
 # BEFORE:        6: 00 f0 00 b8   b.w #0
 
 # AFTER: Disassembly of section .text:
+# AFTER-EMPTY:
 # AFTER: .text:
 # AFTER:     1000: 70 47         bx lr
 # AFTER:     1002: 00 bf         nop
 # AFTER:     1004: 20 20         movs r0, #32
 # AFTER:     1006: ff f7 fb bf   b.w #-10
 
 --- !COFF
 header:

test/COFF/armnt-mov32t-exec.test

 # REQUIRES: arm
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s -check-prefix BEFORE
 # RUN: lld-link /out:%t.exe /subsystem:console /entry:get_function %t.obj
 # RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix AFTER
 
 # BEFORE: Disassembly of section .text:
+# BEFORE-EMPTY:
 # BEFORE:        0: 70 47         bx lr
 # BEFORE:        2: 00 bf         nop
 # BEFORE:        4: 40 f2 00 00   movw r0, #0
 # BEFORE:        8: c0 f2 00 00   movt r0, #0
 # BEFORE:        c: 70 47         bx lr
 
 # AFTER: Disassembly of section .text:
+# AFTER-EMPTY:
 # AFTER:     1000: 70 47         bx lr
 # AFTER:     1002: 00 bf         nop
 # AFTER:     1004: 41 f2 01 00   movw r0, #4097
 # AFTER:     1008: c0 f2 40 00   movt r0, #64
 # AFTER:     100c: 70 47         bx lr
 
 --- !COFF
 header:

test/COFF/armnt-movt32t.test

 # REQUIRES: arm
 
 # RUN: yaml2obj < %s > %t.obj
 # RUN: llvm-objdump -d %t.obj | FileCheck %s -check-prefix BEFORE
 # RUN: lld-link /entry:get_buffer /subsystem:console /out:%t.exe %t.obj
 # RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix AFTER
 
 # BEFORE: Disassembly of section .text:
+# BEFORE-EMPTY:
 # BEFORE:        0: 40 f2 00 00   movw r0, #0
 # BEFORE:        4: c0 f2 00 00   movt r0, #0
 # BEFORE:        8: 70 47         bx lr
 
 # AFTER: Disassembly of section .text:
+# AFTER-EMPTY:
 # AFTER:        0: 42 f2 00 00   movw r0, #8192
 # AFTER:        4: c0 f2 40 00   movt r0, #64
 # AFTER:        8: 70 47         bx lr
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_ARMNT
   Characteristics: [  ]

test/COFF/autoimport-refptr.s

 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-refptr.s.tmp-lib.dll
 # IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
 # IMPORTS-NEXT: ImportAddressTableRVA: 0x2060
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # DISASM: Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM: .text:
 # Relative offset at 0x1002 pointing at the IAT at 0x2060
 # DISASM: 140001000:      48 8b 05 59 10 00 00    movq    4185(%rip), %rax
 # DISASM: 140001007:      8b 00   movl    (%rax), %eax
 # Relative offset at 0x100b pointing at the .refptr.localvar stub at
 # 0x2000
 # DISASM: 140001009:      48 8b 0d f0 0f 00 00    movq    4080(%rip), %rcx
 # DISASM: 140001010:      03 01   addl    (%rcx), %eax

test/COFF/autoimport-x86.s

 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-x86.s.tmp-lib.dll
 # IMPORTS-NEXT: ImportLookupTableRVA: 0x2070
 # IMPORTS-NEXT: ImportAddressTableRVA: 0x2080
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # DISASM: Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM: .text:
 # Relative offset at 0x1002 pointing at the IAT at 0x2080.
 # DISASM: 140001000:      8b 05 7a 10 00 00       movl    4218(%rip), %eax
 # DISASM: 140001006:      c3      retq
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
 # First runtime pseudo reloc, with import from 0x2080,
 # applied at 0x1002, with a size of 32 bits.

test/COFF/imports.test

 # REQUIRES: x86
 # Verify that the lld can handle .lib files and emit .idata sections.
 #
 # RUN: lld-link /out:%t.exe /entry:main /subsystem:console \
 # RUN:   %p/Inputs/hello64.obj %p/Inputs/std64.lib
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=TEXT %s
 # RUN: llvm-readobj --coff-imports %t.exe | FileCheck -check-prefix=IMPORT %s
 
 # RUN: lld-link /out:%t.exe /entry:main /subsystem:console \
 # RUN:   %p/Inputs/hello64.obj %p/Inputs/std64.lib /include:ExitProcess
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=TEXT %s
 # RUN: llvm-readobj --coff-imports %t.exe | FileCheck -check-prefix=IMPORT %s
 
 TEXT: Disassembly of section .text:
+TEXT-EMPTY:
 TEXT-NEXT: .text:
 TEXT-NEXT: subq    $40, %rsp
 TEXT-NEXT: movq    $0, %rcx
 TEXT-NEXT: leaq    8180(%rip), %rdx
 TEXT-NEXT: leaq    8167(%rip), %r8
 TEXT-NEXT: movl    $0, %r9d
 TEXT-NEXT: callq   60
 TEXT-NEXT: movl    $0, %ecx

test/COFF/lto-comdat.ll

 ; RUN: llvm-readobj --file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-10 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-10 %s
 ; RUN: lld-link /out:%T/comdat-main.exe /entry:main /subsystem:console %T/comdat-main.lto.obj %T/comdat.lib
 ; RUN: llvm-readobj --file-headers %T/comdat-main.exe | FileCheck -check-prefix=HEADERS-10 %s
 ; RUN: llvm-objdump -d %T/comdat-main.exe | FileCheck -check-prefix=TEXT-10 %s
 
 ; HEADERS-11: AddressOfEntryPoint: 0x1000
 ; TEXT-11: Disassembly of section .text:
+; TEXT-11-EMPTY:
 ; TEXT-11-NEXT: .text:
 ; TEXT-11-NEXT: xorl  %eax, %eax
 ; TEXT-11-NEXT: retq
 
 ; HEADERS-01: AddressOfEntryPoint: 0x1000
 ; TEXT-01: Disassembly of section .text:
+; TEXT-01-EMPTY:
 ; TEXT-01-NEXT: .text:
 ; TEXT-01-NEXT: subq  $40, %rsp
 ; TEXT-01-NEXT: callq 23
 ; TEXT-01-NEXT: callq 18
 ; TEXT-01-NEXT: callq 13
 ; TEXT-01-NEXT: xorl  %eax, %eax
 ; TEXT-01-NEXT: addq  $40, %rsp
 ; TEXT-01: retq
 ; TEXT-01-NOT: callq
 ; TEXT-01: retq
 ; TEXT-01: int3
 ; TEXT-01: int3
 ; TEXT-01: int3
 ; TEXT-01-NOT: {{.}}
 
 ; HEADERS-10: AddressOfEntryPoint: 0x1020
 ; TEXT-10: Disassembly of section .text:
+; TEXT-10-EMPTY:
 ; TEXT-10-NEXT: .text:
 ; TEXT-10-NEXT: subq  $40, %rsp
 ; TEXT-10-NEXT: callq 55
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: addq  $40, %rsp
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NEXT: int3
 ; TEXT-10-NEXT: subq  $40, %rsp

test/COFF/lto.ll

 ; RUN: lld-link /out:%T/main.exe /entry:main /subsystem:console %T/main.lto.obj %T/foo.lib
 ; RUN: llvm-readobj --file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-10 %s
 ; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-10 %s
 
 ; VERBOSE: foo.lto.lib({{.*}}foo.lto.obj)
 
 ; HEADERS-11: AddressOfEntryPoint: 0x1000
 ; TEXT-11: Disassembly of section .text:
+; TEXT-11-EMPTY:
 ; TEXT-11-NEXT: .text:
 ; TEXT-11-NEXT: xorl  %eax, %eax
 ; TEXT-11-NEXT: retq
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: int3
 ; TEXT-11-NEXT: movl  $2, %eax
 ; TEXT-11-NEXT: retq
 
 ; HEADERS-01: AddressOfEntryPoint: 0x1000
 ; TEXT-01: Disassembly of section .text:
+; TEXT-01-EMPTY:
 ; TEXT-01-NEXT: .text:
 ; TEXT-01-NEXT: subq  $40, %rsp
 ; TEXT-01-NEXT: callq 23
 ; TEXT-01-NEXT: xorl  %eax, %eax
 ; TEXT-01-NEXT: addq  $40, %rsp
 ; TEXT-01-NEXT: retq
 ; TEXT-01-NEXT: retq
 ; TEXT-01-NEXT: int3

 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: int3
 ; TEXT-01-NEXT: retq
 
 ; HEADERS-10: AddressOfEntryPoint: 0x1020
 ; TEXT-10: Disassembly of section .text:
+; TEXT-10-EMPTY:
 ; TEXT-10-NEXT: .text:
 ; TEXT-10-NEXT: retq
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: nop
 ; TEXT-10-NEXT: nop

test/ELF/aarch64-call26-thunk.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %S/Inputs/abs.s -o %tabs
 // RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %s -o %t
 // RUN: ld.lld %t %tabs -o %t2 2>&1
 // RUN: llvm-objdump -d -triple=aarch64-pc-freebsd %t2 | FileCheck %s
 
 .text
 .globl _start
 _start:
     bl big
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    210000:        02 00 00 94     bl      #8
 // CHECK: __AArch64AbsLongThunk_big:
 // CHECK-NEXT:    210008:        50 00 00 58     ldr     x16, #8
 // CHECK-NEXT:    21000c:        00 02 1f d6     br      x16
 // CHECK: $d:
 // CHECK-NEXT:    210010:        00 00 00 00     .word   0x00000000
 // CHECK-NEXT:    210014:        10 00 00 00     .word   0x00000010
 

test/ELF/aarch64-condb-reloc.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %p/Inputs/aarch64-condb-reloc.s -o %t1
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %t2
 # RUN: ld.lld %t1 %t2 -o %t
 # RUN: llvm-objdump -d %t | FileCheck %s
 # RUN: ld.lld -shared %t1 %t2 -o %t3
 # RUN: llvm-objdump -d %t3 | FileCheck -check-prefix=DSO %s
 # RUN: llvm-readobj -S -r %t3 | FileCheck -check-prefix=DSOREL %s
 
 # 0x11024 - 36 = 0x11000
 # 0x11028 - 24 = 0x11010
 # 0x1102c - 16 = 0x1101c
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: _foo:
 # CHECK-NEXT:    210000: {{.*}} nop
 # CHECK-NEXT:    210004: {{.*}} nop
 # CHECK-NEXT:    210008: {{.*}} nop
 # CHECK-NEXT:    21000c: {{.*}} nop
 # CHECK:      _bar:
 # CHECK-NEXT:    210010: {{.*}} nop
 # CHECK-NEXT:    210014: {{.*}} nop

 #DSOREL-NEXT:  Section ({{.*}}) .rela.plt {
 #DSOREL-NEXT:    0x30018 R_AARCH64_JUMP_SLOT _foo
 #DSOREL-NEXT:    0x30020 R_AARCH64_JUMP_SLOT _bar
 #DSOREL-NEXT:    0x30028 R_AARCH64_JUMP_SLOT _dah
 #DSOREL-NEXT:  }
 #DSOREL-NEXT:]
 
 #DSO:      Disassembly of section .text:
+#DSO-EMPTY:
 #DSO-NEXT: _foo:
 #DSO-NEXT:     10000: {{.*}} nop
 #DSO-NEXT:     10004: {{.*}} nop
 #DSO-NEXT:     10008: {{.*}} nop
 #DSO-NEXT:     1000c: {{.*}} nop
 #DSO:      _bar:
 #DSO-NEXT:     10010: {{.*}} nop
 #DSO-NEXT:     10014: {{.*}} nop
 #DSO-NEXT:     10018: {{.*}} nop
 #DSO:      _dah:
 #DSO-NEXT:     1001c: {{.*}} nop
 #DSO-NEXT:     10020: {{.*}} nop
 #DSO:      _start:
 #DSO-NEXT:     10024: {{.*}} b.eq #44
 #DSO-NEXT:     10028: {{.*}} b.eq #56
 #DSO-NEXT:     1002c: {{.*}} b.eq #68
+#DSO-EMPTY:
 #DSO-NEXT: Disassembly of section .plt:
+#DSO-EMPTY:
 #DSO-NEXT: .plt:
 #DSO-NEXT:     10030: {{.*}} stp x16, x30, [sp, #-16]!
 #DSO-NEXT:     10034: {{.*}} adrp x16, #131072
 #DSO-NEXT:     10038: {{.*}} ldr x17, [x16, #16]
 #DSO-NEXT:     1003c: {{.*}} add x16, x16, #16
 #DSO-NEXT:     10040: {{.*}} br x17
 #DSO-NEXT:     10044: {{.*}} nop
 #DSO-NEXT:     10048: {{.*}} nop

test/ELF/aarch64-copy.s

 // CHECK-NEXT:     Size: 4
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: Object
 // CHECK-NEXT:     Other:
 // CHECK-NEXT:     Section: .bss
 // CHECK: ]
 
 // CODE: Disassembly of section .text:
+// CODE-EMPTY:
 // CODE-NEXT: _start:
 // S(x) = 0x230000, A = 0, P = 0x210000
 // S + A - P = 0x20000 = 131072
 // CODE-NEXT:  210000: {{.*}} adr  x1, #131072
 // S(y) = 0x230010, A = 0, P = 0x210004
 // Page(S + A) - Page(P) = 0x230000 - 0x210000 = 0x20000 = 131072
 // CODE-NEXT:  210004: {{.*}} adrp x2, #131072
 // S(y) = 0x230010, A = 0
 // (S + A) & 0xFFF = 0x10 = 16
 // CODE-NEXT:  210008: {{.*}} add  x2, x2, #16
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x230014
 // RODATA-NEXT:  200318 14002300

test/ELF/aarch64-gnu-ifunc-address-pie.s

 # CHECK: 0000000000010000 myfunc_resolver:
 # CHECK-NEXT:    10000: c0 03 5f d6   ret
 # CHECK: 0000000000010004 main:
 # CHECK-NEXT:    10004: 08 00 00 90   adrp  x8, #0
 # x8 = 0x10000
 # CHECK-NEXT:    10008: 08 41 00 91   add x8, x8, #16
 # x8 = 0x10010 = .plt for myfunc
 # CHECK-NEXT:    1000c: c0 03 5f d6   ret
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: 0000000000010010 myfunc:
 # CHECK-NEXT:    10010: 10 01 00 90   adrp  x16, #131072
 # CHECK-NEXT:    10014: 11 02 40 f9   ldr x17, [x16]
 # CHECK-NEXT:    10018: 10 02 00 91   add x16, x16, #0
 # CHECK-NEXT:    1001c: 20 02 1f d6   br  x17
 
 # CHECK-RELOCS: Relocations [
 # CHECK-RELOCS-NEXT:   Section {{.*}} .rela.plt {
 # CHECK-RELOCS-NEXT:     0x30000 R_AARCH64_IRELATIVE - 0x10000
 # CHECK-RELOCS-NEXT:   }
 # CHECK-RELOCS-NEXT: ]

test/ELF/aarch64-gnu-ifunc-address.s

 # CHECK:   0000000000010004 main:
 # x8 = 0x20000
 # CHECK-NEXT:    10004: 88 00 00 90     adrp    x8, #65536
 # x8 = 0x200a0 = .got entry for myfunc with R_AARCH64_GLOB_DAT
 # CHECK-NEXT:    10008: 08 51 40 f9     ldr     x8, [x8, #160]
 # CHECK-NEXT:    1000c: c0 03 5f d6     ret
 
 # CHECK: Disassembly of section .got:
+# CHECK-EMPTY:
 # CHECK-NEXT: 00000000000200a0 .got:
 
 # CHECK-RELOCS: Relocations [
 # CHECK-RELOCS-NEXT:   Section {{.*}} .rela.dyn {
 # CHECK-RELOCS-NEXT:     0x200A0 R_AARCH64_GLOB_DAT myfunc 0x0
 # CHECK-RELOCS-NEXT:   }
 # CHECK-RELOCS-NEXT: ]

test/ELF/aarch64-gnu-ifunc-plt.s

 // GOTPLT-NEXT:  230030 20002100 00000000
 
 // Check that the PLTRELSZ tag includes the IRELATIVE relocations
 // CHECK: DynamicSection [
 // CHECK:   0x0000000000000002 PLTRELSZ             96 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    210000: {{.*}} ret
 // DISASM:      bar:
 // DISASM-NEXT:    210004: {{.*}} ret
 // DISASM:      _start:
 // DISASM-NEXT:    210008: {{.*}} bl      #88
 // DISASM-NEXT:    21000c: {{.*}} bl      #100
 // DISASM-NEXT:    210010: {{.*}} bl      #48
 // DISASM-NEXT:    210014: {{.*}} bl      #60
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:    210020: {{.*}} stp     x16, x30, [sp, #-16]!
 // DISASM-NEXT:    210024: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210028: {{.*}} ldr     x17, [x16, #16]
 // DISASM-NEXT:    21002c: {{.*}} add     x16, x16, #16
 // DISASM-NEXT:    210030: {{.*}} br      x17
 // DISASM-NEXT:    210034: {{.*}} nop
 // DISASM-NEXT:    210038: {{.*}} nop

test/ELF/aarch64-gnu-ifunc.s

 // CHECK-NEXT:    Section: .text
 // CHECK-NEXT:  }
 // CHECK-NEXT: ]
 
 // 344 = 0x158
 // 392 = 0x188
 
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:  210000: c0 03 5f d6 ret
 // DISASM: bar:
 // DISASM-NEXT:  210004: c0 03 5f d6 ret
 // DISASM:      _start:
 // DISASM-NEXT:  210008: 06 00 00 94 bl #24
 // DISASM-NEXT:  21000c: 09 00 00 94     bl      #36
 // DISASM-NEXT:  210010: 42 60 05 91     add     x2, x2, #344
 // DISASM-NEXT:  210014: 42 20 06 91     add     x2, x2, #392
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:  210020: 90 00 00 90 adrp x16, #65536
 // DISASM-NEXT:  210024: 11 02 40 f9 ldr x17, [x16]
 // DISASM-NEXT:  210028: 10 02 00 91 add x16, x16, #0
 // DISASM-NEXT:  21002c: 20 02 1f d6 br x17
 // DISASM-NEXT:  210030: 90 00 00 90 adrp x16, #65536
 // DISASM-NEXT:  210034: 11 06 40 f9 ldr x17, [x16, #8]
 // DISASM-NEXT:  210038: 10 22 00 91 add x16, x16, #8

test/ELF/aarch64-gnu-ifunc2.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 # RUN: ld.lld -static %t.o -o %tout
 # RUN: llvm-objdump -D %tout | FileCheck %s
 # RUN: llvm-readobj -r %tout | FileCheck %s --check-prefix=RELOC
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: myfunc:
 # CHECK-NEXT:   210000:
 
 # CHECK:      main:
 # adrp x8, 0x220000, 0x220000 == address in .got.plt
 # CHECK-NEXT:   210004: {{.*}} adrp    x8, #65536
 # CHECK-NEXT:   210008: {{.*}} ldr     x8, [x8]
 # CHECK-NEXT:   21000c: {{.*}} ret
 
 # CHECK:      Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .plt:
 # adrp x16, 0x220000, 0x220000 == address in .got.plt
 # CHECK-NEXT:   210010: {{.*}} adrp    x16, #65536
 # CHECK-NEXT:   210014: {{.*}} ldr     x17, [x16]
 # CHECK-NEXT:   210018: {{.*}} add     x16, x16, #0
 # CHECK-NEXT:   21001c: {{.*}} br      x17
 
 # CHECK:      Disassembly of section .got.plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .got.plt:
 # CHECK-NEXT:   220000:
 
 # RELOC:      Relocations [
 # RELOC-NEXT:   Section {{.*}} .rela.plt {
 # RELOC-NEXT:     0x220000 R_AARCH64_IRELATIVE - 0x210000
 # RELOC-NEXT:   }
 # RELOC-NEXT: ]

test/ELF/aarch64-gnu-ifunc3.s

 .globl _start
 .type _start,@function
 _start:
  adrp x8, myfunc
  add  x8, x8, :lo12:myfunc
  ret
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: myfunc_resolver:
 # CHECK-NEXT:   210000: c0 03 5f d6   ret
 # CHECK: _start:
 # adrp x8, 0x210000 + 0x10 from add == .plt entry
 # CHECK-NEXT:   210004: 08 00 00 90   adrp  x8, #0
 # CHECK-NEXT:   210008: 08 41 00 91   add x8, x8, #16
 # CHECK-NEXT:   21000c: c0 03 5f d6   ret
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: myfunc:
 # adrp x16, 0x220000, 0x220000 == address in .got.plt
 # CHECK-NEXT:   210010: 90 00 00 90   adrp  x16, #65536
 # CHECK-NEXT:   210014: 11 02 40 f9   ldr x17, [x16]
 # CHECK-NEXT:   210018: 10 02 00 91   add x16, x16, #0
 # CHECK-NEXT:   21001c: 20 02 1f d6   br  x17
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .got.plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .got.plt:
 # 0x210010 == address in .plt
 # CHECK-NEXT:   220000: 10 00 21 00
 # CHECK-NEXT:   220004: 00 00 00 00
 
 # RELOC: Relocations [
 # RELOC-NEXT:  Section (1) .rela.plt {
 # RELOC-NEXT:    0x220000 R_AARCH64_IRELATIVE - 0x210000
 # RELOC-NEXT:  }
 # RELOC-NEXT: ]

test/ELF/aarch64-jump26-thunk.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %S/Inputs/abs.s -o %tabs
 // RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %s -o %t
 // RUN: ld.lld %t %tabs -o %t2 2>&1
 // RUN: llvm-objdump -d -triple=aarch64-pc-freebsd %t2 | FileCheck %s
 
 .text
 .globl _start
 _start:
     b big
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    210000:        02 00 00 14     b       #8
 // CHECK: __AArch64AbsLongThunk_big:
 // CHECK-NEXT:    210008:        50 00 00 58     ldr     x16, #8
 // CHECK-NEXT:    21000c:        00 02 1f d6     br      x16
 // CHECK: $d:
 // CHECK-NEXT:    210010:        00 00 00 00     .word   0x00000000
 // CHECK-NEXT:    210014:        10 00 00 00     .word   0x00000010

test/ELF/aarch64-relocs.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %t
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %p/Inputs/uabs_label.s -o %t2.o
 # RUN: ld.lld %t %t2.o -o %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s
 
 .section .R_AARCH64_ADR_PREL_LO21,"ax",@progbits
 .globl _start
 _start:
   adr x1,msg
 msg:  .asciz  "Hello, world\n"
 msgend:
 
 # CHECK: Disassembly of section .R_AARCH64_ADR_PREL_LO21:
+# CHECK-EMPTY:
 # CHECK: _start:
 # CHECK:        0:       21 00 00 10     adr     x1, #4
 # CHECK: msg:
 # CHECK:        4:
 # #4 is the adr immediate value.
 
 .section .R_AARCH64_ADR_PREL_PG_H121,"ax",@progbits
   adrp x1,mystr
 mystr:
   .asciz "blah"
   .size mystr, 4
 
 # S = 0x210012, A = 0x4, P = 0x210012
 # PAGE(S + A) = 0x210000
 # PAGE(P) = 0x210000
 #
 # CHECK: Disassembly of section .R_AARCH64_ADR_PREL_PG_H121:
+# CHECK-EMPTY:
 # CHECK-NEXT: $x.2:
 # CHECK-NEXT:   210012:       01 00 00 90     adrp    x1, #0
 
 .section .R_AARCH64_ADD_ABS_LO12_NC,"ax",@progbits
   add x0, x0, :lo12:.L.str
 .L.str:
   .asciz "blah"
   .size mystr, 4
 
 # S = 0x21001b, A = 0x4
 # R = (S + A) & 0xFFF = 0x1f
 # R << 10 = 0x7c00
 #
 # CHECK: Disassembly of section .R_AARCH64_ADD_ABS_LO12_NC:
+# CHECK-EMPTY:
 # CHECK-NEXT: $x.4:
 # CHECK-NEXT:   21001b:       00 7c 00 91     add     x0, x0, #31
 
 .section .R_AARCH64_LDST64_ABS_LO12_NC,"ax",@progbits
   ldr x28, [x27, :lo12:foo]
 foo:
   .asciz "foo"
   .size mystr, 3
 
 # S = 0x210024, A = 0x4
 # R = ((S + A) & 0xFFF) << 7 = 0x00001400
 # 0x00001400 | 0xf940177c = 0xf940177c
 # CHECK: Disassembly of section .R_AARCH64_LDST64_ABS_LO12_NC:
+# CHECK-EMPTY:
 # CHECK-NEXT: $x.6:
 # CHECK-NEXT:   210024:       7c 17 40 f9     ldr     x28, [x27, #40]
 
 .section .SUB,"ax",@progbits
   nop
 sub:
   nop
 
 # CHECK: Disassembly of section .SUB:
+# CHECK-EMPTY:
 # CHECK-NEXT: $x.8:
 # CHECK-NEXT:   21002c:       1f 20 03 d5     nop
 # CHECK: sub:
 # CHECK-NEXT:   210030:       1f 20 03 d5     nop
 
 .section .R_AARCH64_CALL26,"ax",@progbits
 call26:
         bl sub
 
 # S = 0x21002c, A = 0x4, P = 0x210034
 # R = S + A - P = -0x4 = 0xfffffffc
 # (R & 0x0ffffffc) >> 2 = 0x03ffffff
 # 0x94000000 | 0x03ffffff = 0x97ffffff
 # CHECK: Disassembly of section .R_AARCH64_CALL26:
+# CHECK-EMPTY:
 # CHECK-NEXT: call26:
 # CHECK-NEXT:   210034:       ff ff ff 97     bl     #-4
 
 .section .R_AARCH64_JUMP26,"ax",@progbits
 jump26:
         b sub
 
 # S = 0x21002c, A = 0x4, P = 0x210038
 # R = S + A - P = -0x8 = 0xfffffff8
 # (R & 0x0ffffffc) >> 2 = 0x03fffffe
 # 0x14000000 | 0x03fffffe = 0x17fffffe
 # CHECK: Disassembly of section .R_AARCH64_JUMP26:
+# CHECK-EMPTY:
 # CHECK-NEXT: jump26:
 # CHECK-NEXT:   210038:       fe ff ff 17     b      #-8
 
 .section .R_AARCH64_LDST32_ABS_LO12_NC,"ax",@progbits
 ldst32:
   ldr s4, [x5, :lo12:foo32]
 foo32:
   .asciz "foo"
   .size mystr, 3
 
 # S = 0x21003c, A = 0x4
 # R = ((S + A) & 0xFFC) << 8 = 0x00004000
 # 0x00004000 | 0xbd4000a4 = 0xbd4040a4
 # CHECK: Disassembly of section .R_AARCH64_LDST32_ABS_LO12_NC:
+# CHECK-EMPTY:
 # CHECK-NEXT: ldst32:
 # CHECK-NEXT:   21003c:       a4 40 40 bd     ldr s4, [x5, #64]
 
 .section .R_AARCH64_LDST8_ABS_LO12_NC,"ax",@progbits
 ldst8:
   ldrsb x11, [x13, :lo12:foo8]
 foo8:
   .asciz "foo"
   .size mystr, 3
 
 # S = 0x210044, A = 0x4
 # R = ((S + A) & 0xFFF) << 10 = 0x00012000
 # 0x00012000 | 0x398001ab = 0x398121ab
 # CHECK: Disassembly of section .R_AARCH64_LDST8_ABS_LO12_NC:
+# CHECK-EMPTY:
 # CHECK-NEXT: ldst8:
 # CHECK-NEXT:   210044:       ab 21 81 39     ldrsb x11, [x13, #72]
 
 .section .R_AARCH64_LDST128_ABS_LO12_NC,"ax",@progbits
 ldst128:
   ldr q20, [x19, #:lo12:foo128]
 foo128:
   .asciz "foo"
   .size mystr, 3
 
 # S = 0x21004c, A = 0x4
 # R = ((S + A) & 0xFF8) << 6 = 0x00001400
 # 0x00001400 | 0x3dc00274 = 0x3dc01674
 # CHECK: Disassembly of section .R_AARCH64_LDST128_ABS_LO12_NC:
+# CHECK-EMPTY:
 # CHECK: ldst128:
 # CHECK:   21004c:       74 16 c0 3d     ldr     q20, [x19, #80]
 #foo128:
 #   210050:       66 6f 6f 00     .word
 
 .section .R_AARCH64_LDST16_ABS_LO12_NC,"ax",@progbits
 ldst16:
   ldr h17, [x19, :lo12:foo16]
   ldrh w1, [x19, :lo12:foo16]
   ldrh w2, [x19, :lo12:foo16 + 2]
 foo16:
   .asciz "foo"
   .size mystr, 4
 
 # S = 0x210054, A = 0x4
 # R = ((S + A) & 0x0FFC) << 9 = 0xb000
 # 0xb000 | 0x7d400271 = 0x7d40b271
 # CHECK: Disassembly of section .R_AARCH64_LDST16_ABS_LO12_NC:
+# CHECK-EMPTY:
 # CHECK-NEXT: ldst16:
 # CHECK-NEXT:   210054:       71 c2 40 7d     ldr     h17, [x19, #96]
 # CHECK-NEXT:   210058:       61 c2 40 79     ldrh    w1, [x19, #96]
 # CHECK-NEXT:   21005c:       62 c6 40 79     ldrh    w2, [x19, #98]
 
 .section .R_AARCH64_MOVW_UABS,"ax",@progbits
 movz1:
    movk x12, #:abs_g0_nc:uabs_label
    movk x13, #:abs_g1_nc:uabs_label
    movk x14, #:abs_g2_nc:uabs_label
    movz x15, #:abs_g3:uabs_label
    movk x16, #:abs_g3:uabs_label
 
 ## 4222124650659840 == (0xF << 48)
 # CHECK: Disassembly of section .R_AARCH64_MOVW_UABS:
+# CHECK-EMPTY:
 # CHECK-NEXT: movz1:
 # CHECK-NEXT: 8c 01 80 f2   movk  x12, #12
 # CHECK-NEXT: ad 01 a0 f2   movk  x13, #13, lsl #16
 # CHECK-NEXT: ce 01 c0 f2   movk  x14, #14, lsl #32
 # CHECK-NEXT: ef 01 e0 d2   mov x15, #4222124650659840
 # CHECK-NEXT: f0 01 e0 f2   movk  x16, #15, lsl #48

test/ELF/aarch64-thunk-pi.s

 // Expect Thunk for .text.high
 
 // CHECK: __AArch64ADRPThunk_low_target2:
 // CHECK-NEXT: 10000010:  10 00 f8 90   adrp  x16, #-268435456
 // CHECK-NEXT: 10000014:  10 82 03 91   add x16, x16, #224
 // CHECK-NEXT: 10000018:  00 02 1f d6   br  x16
 
 // CHECK: Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 10000020:       f0 7b bf a9     stp     x16, x30, [sp, #-16]!
 // CHECK-NEXT: 10000024:       10 00 00 90     adrp    x16, #0
 // CHECK-NEXT: 10000028:       11 92 40 f9     ldr     x17, [x16, #288]
 // CHECK-NEXT: 1000002c:       10 82 04 91     add     x16, x16, #288
 // CHECK-NEXT: 10000030:       20 02 1f d6     br      x17
 // CHECK-NEXT: 10000034:       1f 20 03 d5     nop
 // CHECK-NEXT: 10000038:       1f 20 03 d5     nop

test/ELF/aarch64-thunk-script.s

  .globl high_target
  .type high_target, %function
 high_target:
  // No Thunk needed as we are within signed immediate range
  bl _start
  ret
 
 // CHECK: Disassembly of section .text_low:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:     2000:       02 00 00 94     bl      #8
 // CHECK-NEXT:     2004:       c0 03 5f d6     ret
 // CHECK: __AArch64AbsLongThunk_high_target:
 // CHECK-NEXT:     2008:       50 00 00 58     ldr     x16, #8
 // CHECK-NEXT:     200c:       00 02 1f d6     br      x16
 // CHECK: $d:
 // CHECK-NEXT:     2010:       00 20 00 08     .word   0x08002000
 // CHECK-NEXT:     2014:       00 00 00 00     .word   0x00000000
 // CHECK: Disassembly of section .text_high:
+// CHECK-EMPTY:
 // CHECK-NEXT: high_target:
 // CHECK-NEXT:  8002000:       00 00 00 96     bl      #-134217728
 // CHECK-NEXT:  8002004:       c0 03 5f d6     ret

test/ELF/aarch64-tls-gdle.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %p/Inputs/aarch64-tls-ie.s -o %ttlsie.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %s -o %tmain.o
 # RUN: ld.lld %tmain.o %ttlsie.o -o %tout
 # RUN: llvm-objdump -d %tout | FileCheck %s
 # RUN: llvm-readobj -S -r %tout | FileCheck -check-prefix=RELOC %s
 
 #Local-Dynamic to Local-Exec relax creates no
 #RELOC:      Relocations [
 #RELOC-NEXT: ]
 
 # TCB size = 64 and foo is first element from TLS register.
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK: _start:
 # CHECK:  210000: 00 00 a0 d2 movz  x0, #0, lsl #16
 # CHECK:  210004: 00 08 80 f2   movk  x0, #64
 # CHECK:  210008: 1f 20 03 d5   nop
 # CHECK:  21000c: 1f 20 03 d5   nop
 
 .globl _start
 _start:
  adrp    x0, :tlsdesc:foo
  ldr     x1, [x0, :tlsdesc_lo12:foo]
  add     x0, x0, :tlsdesc_lo12:foo
  .tlsdesccall foo
  blr     x1

test/ELF/aarch64-tls-iele.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %p/Inputs/aarch64-tls-ie.s -o %ttlsie.o
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %s -o %tmain.o
 # RUN: ld.lld %tmain.o %ttlsie.o -o %tout
 # RUN: llvm-objdump -d %tout | FileCheck %s
 # RUN: llvm-readobj -S -r %tout | FileCheck -check-prefix=RELOC %s
 
 # Initial-Exec to Local-Exec relax creates no dynamic relocations.
 # RELOC:      Relocations [
 # RELOC-NEXT: ]
 
 # TCB size = 64 and foo is first element from TLS register.
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK: _start:
 # CHECK-NEXT: 210000:  00 00 a0 d2   movz   x0, #0, lsl #16
 # CHECK-NEXT: 210004:  80 08 80 f2   movk   x0, #68
 # CHECK-NEXT: 210008:  00 00 a0 d2   movz   x0, #0, lsl #16
 # CHECK-NEXT: 21000c:  00 08 80 f2   movk   x0, #64
 
 .section .tdata
 .align 2

test/ELF/aarch64-tstbr14-reloc.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %p/Inputs/aarch64-tstbr14-reloc.s -o %t1
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %t2
 # RUN: ld.lld %t1 %t2 -o %t
 # RUN: llvm-objdump -d %t | FileCheck %s
 # RUN: ld.lld -shared %t1 %t2 -o %t3
 # RUN: llvm-objdump -d %t3 | FileCheck -check-prefix=DSO %s
 # RUN: llvm-readobj -S -r %t3 | FileCheck -check-prefix=DSOREL %s
 
 # 0x1101c - 28 = 0x20000
 # 0x11020 - 16 = 0x20010
 # 0x11024 - 36 = 0x20000
 # 0x11028 - 24 = 0x20010
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: _foo:
 # CHECK-NEXT:  210000: {{.*}} nop
 # CHECK-NEXT:  210004: {{.*}} nop
 # CHECK-NEXT:  210008: {{.*}} nop
 # CHECK-NEXT:  21000c: {{.*}} nop
 # CHECK:      _bar:
 # CHECK-NEXT:  210010: {{.*}} nop
 # CHECK-NEXT:  210014: {{.*}} nop

 #DSOREL:      Relocations [
 #DSOREL-NEXT:  Section ({{.*}}) .rela.plt {
 #DSOREL-NEXT:    0x30018 R_AARCH64_JUMP_SLOT _foo
 #DSOREL-NEXT:    0x30020 R_AARCH64_JUMP_SLOT _bar
 #DSOREL-NEXT:  }
 #DSOREL-NEXT:]
 
 #DSO:      Disassembly of section .text:
+#DSO-EMPTY:
 #DSO-NEXT: _foo:
 #DSO-NEXT:  10000: {{.*}} nop
 #DSO-NEXT:  10004: {{.*}} nop
 #DSO-NEXT:  10008: {{.*}} nop
 #DSO-NEXT:  1000c: {{.*}} nop
 #DSO:      _bar:
 #DSO-NEXT:  10010: {{.*}} nop
 #DSO-NEXT:  10014: {{.*}} nop
 #DSO-NEXT:  10018: {{.*}} nop
 #DSO:      _start:
 # 0x1001c + 52 = 0x10050 = PLT[1]
 # 0x10020 + 64 = 0x10060 = PLT[2]
 # 0x10024 + 44 = 0x10050 = PLT[1]
 # 0x10028 + 56 = 0x10060 = PLT[2]
 #DSO-NEXT:  1001c: {{.*}} tbnz w3, #15, #52
 #DSO-NEXT:  10020: {{.*}} tbnz w3, #15, #64
 #DSO-NEXT:  10024: {{.*}} tbz x6, #45, #44
 #DSO-NEXT:  10028: {{.*}} tbz x6, #45, #56
+#DSO-EMPTY:
 #DSO-NEXT: Disassembly of section .plt:
+#DSO-EMPTY:
 #DSO-NEXT: .plt:
 #DSO-NEXT:  10030: {{.*}} stp x16, x30, [sp, #-16]!
 #DSO-NEXT:  10034: {{.*}} adrp x16, #131072
 #DSO-NEXT:  10038: {{.*}} ldr x17, [x16, #16]
 #DSO-NEXT:  1003c: {{.*}} add x16, x16, #16
 #DSO-NEXT:  10040: {{.*}} br x17
 #DSO-NEXT:  10044: {{.*}} nop
 #DSO-NEXT:  10048: {{.*}} nop

test/ELF/aarch64-undefined-weak.s

 // R_AARCH64_PREL64
  .xword target - .
 // R_AARCH64_PREL16
  .hword target - .
 // R_AARCH64_LD_PREL_LO19
  ldr x8, target
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // 2162688 = 0x210000
 // CHECK:         210000: {{.*}} b       #4
 // CHECK-NEXT:    210004: {{.*}} bl      #4
 // CHECK-NEXT:    210008: {{.*}} b.eq    #4
 // CHECK-NEXT:    21000c: {{.*}} cbz     x1, #4
 // CHECK-NEXT:    210010: {{.*}} adr     x0, #0
 // CHECK-NEXT:    210014: {{.*}} adrp    x0, #0
 // CHECK:         210018: {{.*}} .word   0x00000000
 // CHECK-NEXT:    21001c: {{.*}} .word   0x00000000
 // CHECK-NEXT:    210020: {{.*}} .word   0x00000000
 // CHECK-NEXT:    210024: {{.*}} .short  0x0000
 // CHECK:         $x.2:
 // CHECK-NEXT:    210026: {{.*}} ldr     x8, #0

test/ELF/arm-bl-v6-inrange.s

_start:
   bx lr
 
   .section .callee_low, "ax", %progbits
   .globl thumbfunc
   .type thumbfunc, %function
 thumbfunc:
   bx lr
 // CHECK-THUMB: Disassembly of section .callee1:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: thumbfunc:
 // CHECK-THUMB-NEXT:   100004:       70 47   bx      lr
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: Disassembly of section .caller:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: _start:
 // CHECK-THUMB-NEXT:   500000:       00 f4 00 f8     bl      #-4194304
 // CHECK-THUMB-NEXT:   500004:       ff f3 fe ef     blx     #4194300
 // CHECK-THUMB-NEXT:   500008:       70 47   bx      lr
 
   .arm
   .section .callee_high, "ax", %progbits
   .globl armfunc
   .type armfunc, %function
 armfunc:
   bx lr
 // CHECK-ARM: Disassembly of section .callee2:
+// CHECK-ARM-EMPTY:
 // CHECK-ARM-NEXT: armfunc:
 // CHECK-ARM-NEXT:   900004:       1e ff 2f e1     bx      lr

test/ELF/arm-bl-v6.s

  .globl _start
  .type   _start,%function
  .balign 0x1000
 _start:
   bl thumbfunc
   bx lr
 
 // CHECK-ARM1: Disassembly of section .text:
+// CHECK-ARM1-EMPTY:
 // CHECK-ARM1-NEXT: _start:
 // CHECK-ARM1-NEXT:    11000:   00 00 00 fa     blx     #0 <thumbfunc>
 // CHECK-ARM1-NEXT:    11004:   1e ff 2f e1     bx      lr
  .thumb
  .section .text.2, "ax", %progbits
  .globl thumbfunc
  .type thumbfunc,%function
 thumbfunc:

test/ELF/arm-blx.s

  .section .callee_arm_high, "ax",%progbits
  .arm
  .balign 0x100
  .type callee_arm_high,%function
 callee_arm_high:
   bx lr
 
 // CHECK-THUMB: Disassembly of section .callee1:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: callee_low:
 // CHECK-THUMB-NEXT:    b4:       70 47   bx      lr
 // CHECK-THUMB: callee_low2:
 // CHECK-THUMB-NEXT:    b6:       70 47   bx      lr
 
 // CHECK-ARM: Disassembly of section .callee2:
+// CHECK-ARM-EMPTY:
 // CHECK-ARM-NEXT: callee_arm_low:
 // CHECK-ARM-NEXT:    100:        1e ff 2f e1     bx      lr
 
 // CHECK-ARM: Disassembly of section .caller:
+// CHECK-ARM-EMPTY:
 // CHECK-ARM-NEXT: _start:
 // CHECK-ARM-NEXT:   10000:       2b c0 ff fa     blx     #-65364 <callee_low>
 // CHECK-ARM-NEXT:   10004:       2a c0 ff fa     blx     #-65368 <callee_low>
 // CHECK-ARM-NEXT:   10008:       29 c0 ff fb     blx     #-65370 <callee_low2>
 // CHECK-ARM-NEXT:   1000c:       28 c0 ff fb     blx     #-65374 <callee_low2>
 // CHECK-ARM-NEXT:   10010:       3a 00 00 fa     blx     #232 <callee_high>
 // CHECK-ARM-NEXT:   10014:       39 00 00 fa     blx     #228 <callee_high>
 // CHECK-ARM-NEXT:   10018:       38 00 00 fb     blx     #226 <callee_high2>
 // CHECK-ARM-NEXT:   1001c:       37 00 00 fb     blx     #222 <callee_high2>
 // 10020 + 1FFFFFC + 8 = 0x2010024 = blx_far
 // CHECK-ARM-NEXT:   10020:       ff ff 7f fa     blx     #33554428
 // 10024 + 1FFFFFC + 8 = 0x2010028 = blx_far2
 // CHECK-ARM-NEXT:   10024:       ff ff 7f fa     blx     #33554428
 // CHECK-ARM-NEXT:   10028:       34 c0 ff eb     bl      #-65328 <callee_arm_low>
 // CHECK-ARM-NEXT:   1002c:       33 c0 ff eb     bl      #-65332 <callee_arm_low>
 // CHECK-ARM-NEXT:   10030:       72 00 00 eb     bl      #456 <callee_arm_high>
 // CHECK-ARM-NEXT:   10034:       71 00 00 eb     bl      #452 <callee_arm_high>
 // CHECK-ARM-NEXT:   10038:       1e ff 2f e1     bx      lr
 
 // CHECK-THUMB: Disassembly of section .callee3:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB: callee_high:
 // CHECK-THUMB-NEXT:    10100:       70 47   bx      lr
 // CHECK-THUMB: callee_high2:
 // CHECK-THUMB-NEXT:    10102:       70 47   bx      lr
 
 // CHECK-ARM: Disassembly of section .callee4:
+// CHECK-ARM-EMPTY:
 // CHECK-NEXT-ARM: callee_arm_high:
 // CHECK-NEXT-ARM:   10200:     1e ff 2f e1     bx      lr

test/ELF/arm-branch-rangethunk.s

 _start:
  // address of too_far symbols are just out of range of ARM branch with
  // 26-bit immediate field and an addend of -8
  bl  too_far1
  b   too_far2
  beq too_far3
 
 // SHORT: Disassembly of section .text:
+// SHORT-EMPTY:
 // SHORT-NEXT: _start:
 // SHORT-NEXT:    20000:       01 00 00 eb     bl      #4 <__ARMv7ABSLongThunk_too_far1>
 // SHORT-NEXT:    20004:       01 00 00 ea     b       #4 <__ARMv7ABSLongThunk_too_far2>
 // SHORT-NEXT:    20008:       01 00 00 0a     beq     #4 <__ARMv7ABSLongThunk_too_far3>
 // SHORT: __ARMv7ABSLongThunk_too_far1:
 // SHORT-NEXT:    2000c:       fd ff 7f ea     b       #33554420 <__ARMv7ABSLongThunk_too_far3+0x1fffff4>
 // SHORT: __ARMv7ABSLongThunk_too_far2:
 // SHORT-NEXT:    20010:       fd ff 7f ea     b       #33554420 <__ARMv7ABSLongThunk_too_far3+0x1fffff8>
 // SHORT: __ARMv7ABSLongThunk_too_far3:
 // SHORT-NEXT:    20014:       fd ff 7f ea     b       #33554420 <__ARMv7ABSLongThunk_too_far3+0x1fffffc>
 
 // LONG: Disassembly of section .text:
+// LONG-EMPTY:
 // LONG-NEXT: _start:
 // LONG-NEXT:    20000:       01 00 00 eb     bl      #4 <__ARMv7ABSLongThunk_too_far1>
 // LONG-NEXT:    20004:       03 00 00 ea     b       #12 <__ARMv7ABSLongThunk_too_far2>
 // LONG-NEXT:    20008:       05 00 00 0a     beq     #20 <__ARMv7ABSLongThunk_too_far3>
 // LONG: __ARMv7ABSLongThunk_too_far1:
 // LONG-NEXT:    2000c:       14 c0 00 e3     movw    r12, #20
 // LONG-NEXT:    20010:       02 c2 40 e3     movt    r12, #514
 // LONG-NEXT:    20014:       1c ff 2f e1     bx      r12
 // LONG: __ARMv7ABSLongThunk_too_far2:
 // LONG-NEXT:    20018:       20 c0 00 e3     movw    r12, #32
 // LONG-NEXT:    2001c:       02 c2 40 e3     movt    r12, #514
 // LONG-NEXT:    20020:       1c ff 2f e1     bx      r12
 // LONG: __ARMv7ABSLongThunk_too_far3:
 // LONG-NEXT:    20024:       2c c0 00 e3     movw    r12, #44
 // LONG-NEXT:    20028:       02 c2 40 e3     movt    r12, #514
 // LONG-NEXT:    2002c:       1c ff 2f e1     bx      r12

test/ELF/arm-branch-undef-weak-plt-thunk.s

  b undefined_weak_we_expect_a_plt_entry_for
  bl bar2
 // Create 32 Mb gap between the call to the weak reference and the PLT so that
 // the b and bl need a range-extension thunk.
  .section .text.1, "ax", %progbits
  .space 32 * 1024 * 1024
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    11000:       00 00 00 ea     b       #0 <__ARMv7ABSLongThunk_undefined_weak_we_expect_a_plt_entry_for>
 // CHECK-NEXT:    11004:       02 00 00 eb     bl      #8 <__ARMv7ABSLongThunk_bar2>
 // CHECK: __ARMv7ABSLongThunk_undefined_weak_we_expect_a_plt_entry_for:
 // CHECK-NEXT:    11008:        40 c0 01 e3     movw    r12, #4160
 // CHECK-NEXT:    1100c:        01 c2 40 e3     movt    r12, #513
 // CHECK-NEXT:    11010:        1c ff 2f e1     bx      r12
 // CHECK: __ARMv7ABSLongThunk_bar2:
 // CHECK-NEXT:    11014:        50 c0 01 e3     movw    r12, #4176
 // CHECK-NEXT:    11018:        01 c2 40 e3     movt    r12, #513
 // CHECK-NEXT:    1101c:        1c ff 2f e1     bx      r12

test/ELF/arm-branch.s

 
  .section .callee_high, "ax",%progbits
  .align 2
  .type callee_high,%function
 callee_high:
  bx lr
 
 // CHECK: Disassembly of section .caller:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // S(callee_low) = 0xb4 P = 0x10000 A = -8 = -0xff54 = -65364
 // CHECK-NEXT:   10000:       2b c0 ff eb          bl      #-65364 <callee_low>
 // S(callee_low) = 0xb4 P = 0x10004 A = -8 = -0xff58 = -65368
 // CHECK-NEXT:   10004:       2a c0 ff ea          b       #-65368 <callee_low>
 // S(callee_low) = 0xb4 P = 0x10008 A = -8 = -0xff5c -65372
 // CHECK-NEXT:   10008:       29 c0 ff 0a          beq     #-65372 <callee_low>
 // S(callee_high) = 0x10028 P = 0x1000c A = -8 = 0x14 = 20

test/ELF/arm-copy.s

 // CHECK-NEXT:    Value: 0x13004
 // CHECK-NEXT:    Size: 4
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: Object
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: .bss
 
 // CODE: Disassembly of section .text:
+// CODE-EMPTY:
 // CODE-NEXT: _start:
 // S(y) = 0x13000, A = 0
 // (S + A) & 0x0000ffff = 0x3000 = #12288
 // CODE-NEXT:   11000:  00 20 03 e3    movw    r2, #12288
 // S(y) = 0x13000, A = 0
 // ((S + A) & 0xffff0000) >> 16 = 0x1
 // CODE-NEXT:   11004:       01 20 40 e3    movt    r2, #1
 // CODE-NEXT:   11008:       04 30 9f e5    ldr     r3, [pc, #4]
 // CODE-NEXT:   1100c:       00 30 93 e5    ldr     r3, [r3]
 
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x13004
 // RODATA-NEXT: 101b0 04300100

test/ELF/arm-data-relocs.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/abs256.s -o %t256.o
 // RUN: ld.lld %t %t256.o -o %t2
 // RUN: llvm-objdump -d %t2 | FileCheck %s
  .syntax unified
  .globl _start
 _start:
  .section .R_ARM_ABS32POS, "ax",%progbits
  .word foo + 0x24
 
 // S = 0x100, A = 0x24
 // S + A = 0x124
 // CHECK: Disassembly of section .R_ARM_ABS32POS:
+// CHECK-EMPTY:
 // CHECK: 11000: 24 01 00 00
  .section .R_ARM_ABS32NEG, "ax",%progbits
  .word foo - 0x24
 // S = 0x100, A = -0x24
 // CHECK: Disassembly of section .R_ARM_ABS32NEG:
+// CHECK-EMPTY:
 // CHECK: 11004: dc 00 00 00

test/ELF/arm-exidx-canunwind.s

  .text
  .global _start
 _start:
  bl func1
  bl func2
  bx lr
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    11000:       01 00 00 eb     bl      #4 <func1>
 // CHECK-NEXT:    11004:       01 00 00 eb     bl      #4 <func2>
 // CHECK-NEXT:    11008:       1e ff 2f e1     bx      lr
 // CHECK:      func1:
 // CHECK-NEXT:    1100c:       1e ff 2f e1     bx      lr
 // CHECK:      func2:
 // CHECK-NEXT:    11010:       1e ff 2f e1     bx      lr

test/ELF/arm-exidx-gc.s

  bl func1
  bl func2
  bx lr
 
 // GC should have only removed unusedfunc1 and unusedfunc2 the personality
 // routines are kept alive by references from live .ARM.exidx and .ARM.extab
 // sections
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:   11000:       01 00 00 eb     bl      #4 <func1>
 // CHECK-NEXT:   11004:       01 00 00 eb     bl      #4 <func2>
 // CHECK-NEXT:   11008:       1e ff 2f e1     bx      lr
 // CHECK: func1:
 // CHECK-NEXT:   1100c:       1e ff 2f e1     bx      lr
 // CHECK: func2:
 // CHECK-NEXT:   11010:       1e ff 2f e1     bx      lr

test/ELF/arm-exidx-order.s

  .fnstart
  bx lr
  .cantunwind
  .fnend
 
 // Check default no linker script order.
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK: _start:
 // CHECK-NEXT:    11000:       1e ff 2f e1     bx      lr
 // CHECK: f1:
 // CHECK-NEXT:    11004:       1e ff 2f e1     bx      lr
 // CHECK: f2:
 // CHECK-NEXT:    11008:       1e ff 2f e1     bx      lr
 // CHECK: f3:
 // CHECK-NEXT:    1100c:       1e ff 2f e1     bx      lr
 // CHECK: func4:
 // CHECK-NEXT:    11010:       1e ff 2f e1     bx      lr
 // CHECK: func5:
 // CHECK-NEXT:    11014:       1e ff 2f e1     bx      lr
 // CHECK: Disassembly of section .func1:
+// CHECK-EMPTY:
 // CHECK-NEXT: func1:
 // CHECK-NEXT:    11018:       1e ff 2f e1     bx      lr
 // CHECK: Disassembly of section .func2:
+// CHECK-EMPTY:
 // CHECK-NEXT: func2:
 // CHECK-NEXT:    1101c:       1e ff 2f e1     bx      lr
 // CHECK: Disassembly of section .func3:
+// CHECK-EMPTY:
 // CHECK-NEXT: func3:
 // CHECK-NEXT:    11020:       1e ff 2f e1     bx      lr
 
 // Each .ARM.exidx section has two 4 byte fields
 // Field 1 is the 31-bit offset to the function. The top bit is used to
 // indicate whether Field 2 is a pointer or an inline table entry.
 // Field 2 is either a pointer to a .ARM.extab section or an inline table
 // In this example all Field 2 entries are inline can't unwind (0x1)

 // CHECK-PT-NEXT:     Alignment: 4
 // CHECK-PT-NEXT:   }
 
 
 // Check linker script order. The .ARM.exidx section will be inserted after
 // the .text section but before the orphan sections
 
 // CHECK-SCRIPT: Disassembly of section .text:
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: func4:
 // CHECK-SCRIPT-NEXT:    11000:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      func5:
 // CHECK-SCRIPT-NEXT:    11004:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      _start:
 // CHECK-SCRIPT-NEXT:    11008:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      f1:
 // CHECK-SCRIPT-NEXT:    1100c:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      f2:
 // CHECK-SCRIPT-NEXT:    11010:       1e ff 2f e1     bx      lr
 // CHECK-SCRIPT:      f3:
 // CHECK-SCRIPT-NEXT:    11014:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: Disassembly of section .func1:
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: func1:
 // CHECK-SCRIPT-NEXT:    11018:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: Disassembly of section .func2:
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: func2:
 // CHECK-SCRIPT-NEXT:    1101c:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: Disassembly of section .func3:
+// CHECK-SCRIPT-EMPTY:
 // CHECK-SCRIPT-NEXT: func3:
 // CHECK-SCRIPT-NEXT:    11020:       1e ff 2f e1     bx      lr
 
 // Check that the .ARM.exidx section is sorted in order as the functions
 // The offset in field 1, is 32-bit so in the binary the most significant bit
 // 11024 - 24 = 11000 func4
 // 1102c - 28 = 11004 func5
 // CHECK-SCRIPT-EXIDX:       11024 dcffff7f 01000000 d8ffff7f 01000000

test/ELF/arm-extreme-range-pi-thunk.s

  .type high, %function
 high:
  bl _start
  bx lr
 
 // ARMv7a instructions and relocations.
 
 // CHECK: Disassembly of section .text_low:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:      130:        00 00 00 eb     bl      #0 <__ARMV7PILongThunk_high>
 // CHECK-NEXT:      134:        1e ff 2f e1     bx      lr
 
 // CHECK: __ARMV7PILongThunk_high:
 // CHECK-NEXT:      138:        b8 ce 0f e3     movw    r12, #65208
 // CHECK-NEXT:      13c:        ff cf 4e e3     movt    r12, #61439
 // 0x140 + 0xEFFF0000 + 0x0000FEB8 + 8 = 0xf0000000 = high
 // CHECK-NEXT:      140:        0f c0 8c e0     add     r12, r12, pc
 // CHECK-NEXT:      144:        1c ff 2f e1     bx      r12
 
 // CHECK: Disassembly of section .text_high:
+// CHECK-EMPTY:
 // CHECK-NEXT: high:
 // CHECK-NEXT: f0000000:        00 00 00 eb     bl      #0 <__ARMV7PILongThunk__start>
 // CHECK-NEXT: f0000004:        1e ff 2f e1     bx      lr
 
 // CHECK: __ARMV7PILongThunk__start:
 // CHECK-NEXT: f0000008:        18 c1 00 e3     movw    r12, #280
 // CHECK-NEXT: f000000c:        00 c0 41 e3     movt    r12, #4096
 // 0xf0000010 + 0x10000000 + 0x0000118 + 8 = bits32(0x100000130),0x130 = _start
 // CHECK-NEXT: f0000010:        0f c0 8c e0     add     r12, r12, pc
 // CHECK-NEXT: f0000014:        1c ff 2f e1     bx      r12
 
 // Thumbv7a instructions and relocations
 // CHECK-THUMB: Disassembly of section .text_low:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: _start:
 // CHECK-THUMB-NEXT:      130:  00 f0 02 f8     bl      #4
 // CHECK-THUMB-NEXT:      134:  70 47   bx      lr
 // CHECK-THUMB-NEXT:      136:  d4 d4   bmi     #-88
 
 // CHECK-THUMB: __ThumbV7PILongThunk_high:
 // CHECK-THUMB-NEXT:      138:  4f f6 bd 6c     movw    r12, #65213
 // CHECK-THUMB-NEXT:      13c:  ce f6 ff 7c     movt    r12, #61439
 // 0x140 + 0xEFFF0000 + 0x0000FEBD + 4 = 0xf0000001 = high
 // CHECK-THUMB-NEXT:      140:  fc 44   add     r12, pc
 // CHECK-THUMB-NEXT:      142:  60 47   bx      r12
 
 // CHECK-THUMB: Disassembly of section .text_high:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: high:
 // CHECK-THUMB-NEXT: f0000000:  00 f0 02 f8     bl      #4
 // CHECK-THUMB-NEXT: f0000004:  70 47   bx      lr
 
 // CHECK-THUMB: __ThumbV7PILongThunk__start:
 // CHECK-THUMB-NEXT: f0000008:  40 f2 1d 1c     movw    r12, #285
 // CHECK-THUMB-NEXT: f000000c:  c1 f2 00 0c     movt    r12, #4096
 // 0xf0000010 + 0x10000000 + 0x000011d +4 = bits32(0x100000131),0x131 = _start
 // CHECK-THUMB-NEXT: f0000010:  fc 44   add     r12, pc
 // CHECK-THUMB-NEXT: f0000012:  60 47   bx      r12

test/ELF/arm-force-pi-thunk.s

  .thumb
  .globl low_target2
  .type low_target2, %function
 low_target2:
  bl high_target
  bl high_target2
 
 // CHECK: Disassembly of section .text_low:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:       94:        70 47   bx      lr
 // CHECK: low_target:
 // CHECK-NEXT:       96:        00 f0 03 f8     bl      #6
 // CHECK-NEXT:       9a:        00 f0 07 f8     bl      #14
 // CHECK-NEXT:       9e:        d4 d4   bmi     #-88
 // CHECK: __ThumbV7PILongThunk_high_target:
 // CHECK-NEXT:       a0:        4f f6 55 7c     movw    r12, #65365

  .thumb
  .globl high_target2
  .type high_target2, %function
 high_target2:
  bl low_target
  bl low_target2
 
 // CHECK: Disassembly of section .text_high:
+// CHECK-EMPTY:
 // CHECK-NEXT: high_target:
 // CHECK-NEXT:  2000000:        00 f0 02 f8     bl      #4
 // CHECK-NEXT:  2000004:        00 f0 06 f8     bl      #12
 // CHECK: __ThumbV7PILongThunk_low_target:
 // CHECK-NEXT:  2000008:        40 f2 83 0c     movw    r12, #131
 // CHECK-NEXT:  200000c:        cf f6 00 6c     movt    r12, #65024
 // CHECK-NEXT:  2000010:        fc 44   add     r12, pc
 // CHECK-NEXT:  2000012:        60 47   bx      r12
 // CHECK: __ThumbV7PILongThunk_low_target2:
 // CHECK-NEXT:  2000014:        40 f2 99 0c     movw    r12, #153
 // CHECK-NEXT:  2000018:        cf f6 00 6c     movt    r12, #65024
 // CHECK-NEXT:  200001c:        fc 44   add     r12, pc
 // CHECK-NEXT:  200001e:        60 47   bx      r12
 // CHECK: high_target2:
 // CHECK-NEXT:  2000020:        ff f7 f2 ff     bl      #-28
 // CHECK-NEXT:  2000024:        ff f7 f6 ff     bl      #-20

test/ELF/arm-fpic-got.s

 // SYMBOLS-NEXT:    Value: 0x13000
 // SYMBOLS-NEXT:    Size: 4
 // SYMBOLS-NEXT:    Binding: Global
 // SYMBOLS-NEXT:    Type: Object
 // SYMBOLS-NEXT:    Other:
 // SYMBOLS-NEXT:    Section: .data
 
 // CODE: Disassembly of section .text:
+// CODE-EMPTY:
 // CODE-NEXT: _start:
 // CODE-NEXT:   11000:  08 00 9f e5     ldr     r0, [pc, #8]
 // CODE-NEXT:   11004:  00 00 9f e7     ldr     r0, [pc, r0]
 // CODE-NEXT:   11008:  00 00 90 e5     ldr     r0, [r0]
 // CODE-NEXT:   1100c:  1e ff 2f e1     bx      lr
 // CODE: $d.1:
 // 0x11004 + 0x0ff4 + 8 = 0x12000 = .got
 // CODE-NEXT:   11010:  f4 0f 00 00

test/ELF/arm-gnu-ifunc-plt.s

 // Check that the GOT entries refer back to the ifunc resolver
 // GOTPLT: Contents of section .got:
 // GOTPLT-NEXT:  12078 00000000 00000000 00100100 04100100
 // GOTPLT: Contents of section .got.plt:
 // GOTPLT-NEXT:  13000 00000000 00000000 00000000 20100100
 // GOTPLT-NEXT:  13010 20100100
 
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    11000:       1e ff 2f e1     bx      lr
 // DISASM: bar:
 // DISASM-NEXT:    11004:       1e ff 2f e1     bx      lr
 // DISASM: _start:
 // DISASM-NEXT:    11008:       14 00 00 eb     bl      #80
 // DISASM-NEXT:    1100c:       17 00 00 eb     bl      #92
 // DISASM: $d.1:
 // DISASM-NEXT:    11010:       00 00 00 00     .word   0x00000000
 // DISASM-NEXT:    11014:       04 00 00 00     .word   0x00000004
 // DISASM:         11018:       08 00 00 eb     bl      #32
 // DISASM-NEXT:    1101c:       0b 00 00 eb     bl      #44
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: $a:
 // DISASM-NEXT:    11020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // DISASM-NEXT:    11024:       00 e6 8f e2     add     lr, pc, #0, #12
 // DISASM-NEXT:    11028:       01 ea 8e e2     add     lr, lr, #4096
 // DISASM-NEXT:    1102c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // DISASM: $d:
 // DISASM-NEXT:    11030:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM-NEXT:    11034:       d4 d4 d4 d4     .word   0xd4d4d4d4

test/ELF/arm-gnu-ifunc.s

 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: GNU_IFunc
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: .text
 // CHECK-NEXT:  }
 
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    11000:      1e ff 2f e1     bx      lr
 // DISASM: bar:
 // DISASM-NEXT:    11004:      1e ff 2f e1     bx      lr
 // DISASM: _start:
 // DISASM-NEXT:    11008:      04 00 00 eb     bl      #16
 // DISASM-NEXT:    1100c:      07 00 00 eb     bl      #28
 // 1 * 65536 + 244 = 0x100f4 __rel_iplt_start
 // DISASM-NEXT:    11010:      f4 00 00 e3     movw    r0, #244
 // DISASM-NEXT:    11014:      01 00 40 e3     movt    r0, #1
 // 1 * 65536 + 260 = 0x10104 __rel_iplt_end
 // DISASM-NEXT:    11018:      04 01 00 e3     movw    r0, #260
 // DISASM-NEXT:    1101c:      01 00 40 e3     movt    r0, #1
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: $a:
 // DISASM-NEXT:    11020:       00 c6 8f e2     add     r12, pc, #0, #12
 // DISASM-NEXT:    11024:       00 ca 8c e2     add     r12, r12, #0, #20
 // DISASM-NEXT:    11028:       d8 ff bc e5     ldr     pc, [r12, #4056]!
 // DISASM: $d:
 // DISASM-NEXT:    1102c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM: $a:
 // DISASM-NEXT:    11030:       00 c6 8f e2     add     r12, pc, #0, #12
 // DISASM-NEXT:    11034:       00 ca 8c e2     add     r12, r12, #0, #20
 // DISASM-NEXT:    11038:       cc ff bc e5     ldr     pc, [r12, #4044]!
 // DISASM: $d:
 // DISASM-NEXT:    1103c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 

test/ELF/arm-got-relative.s

 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Section: .got
 
 // CODE: Disassembly of section .text:
+// CODE-EMPTY:
 // CODE-NEXT: _start:
 // CODE-NEXT:    1000:        08 30 9f e5    ldr     r3, [pc, #8]
 // CODE-NEXT:    1004:        08 20 9f e5    ldr     r2, [pc, #8]
 // CODE-NEXT:    1008:        03 00 8f e0    add     r0, pc, r3
 // CODE-NEXT:    100c:        1e ff 2f e1    bx      lr
 // CODE:$d.1:
 // (_GLOBAL_OFFSET_TABLE_ = 0x2048) - (0x1008 + 8) 0x1038
 // CODE-NEXT:    1010:        38 10 00 00
 // (Got(function) - GotBase = 0x0
 // CODE-NEXT:    1014:        00 00 00 00

test/ELF/arm-gotoff.s

 // CHECK-NEXT:    Value: 0x1200A
 // CHECK-NEXT:    Size: 10
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: Object
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: .bss
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT :_start:
 // DISASM-NEXT   11000:       1e ff 2f e1     bx      lr
 // Offset 0 from .got = bar
 // DISASM        11004:       00 00 00 00
 // Offset 10 from .got = obj
 // DISASM-NEXT   11008:       0a 00 00 00
 // Offset 15 from .got = obj +5
 // DISASM-NEXT   1100c:       0f 00 00 00

test/ELF/arm-icf-exidx.s

 
  .section .text.h
  .global __aeabi_unwind_cpp_pr0
 __aeabi_unwind_cpp_pr0:
  nop
  bx lr
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: g:
 // CHECK-NEXT:    11000:        1e ff 2f e1     bx      lr
 // CHECK: __aeabi_unwind_cpp_pr0:
 // CHECK-NEXT:    11004:        00 f0 20 e3     nop
 // CHECK-NEXT:    11008:        1e ff 2f e1     bx      lr
 
 // CHECK: Contents of section .ARM.exidx:
 // CHECK-NEXT:  100d4 2c0f0000 b0b0b080 280f0000 01000000

test/ELF/arm-mov-relocs.s

 _start:
  .section .R_ARM_MOVW_ABS_NC, "ax",%progbits
  movw r0, :lower16:label
  movw r1, :lower16:label1
  movw r2, :lower16:label2 + 4
  movw r3, :lower16:label3
  movw r4, :lower16:label3 + 4
 // CHECK: Disassembly of section .R_ARM_MOVW_ABS_NC
+// CHECK-EMPTY:
 // CHECK: movw  r0, #0
 // CHECK: movw  r1, #4
 // CHECK: movw  r2, #12
 // CHECK: movw  r3, #65532
 // CHECK: movw  r4, #0
  .section .R_ARM_MOVT_ABS, "ax",%progbits
  movt r0, :upper16:label
  movt r1, :upper16:label1
  movt r2, :upper16:label2 + 4
  movt r3, :upper16:label3
  movt r4, :upper16:label3 + 4
 // CHECK: Disassembly of section .R_ARM_MOVT_ABS
+// CHECK-EMPTY:
 // CHECK: movt  r0, #2
 // CHECK: movt  r1, #2
 // CHECK: movt  r2, #2
 // CHECK: movt  r3, #2
 // CHECK: movt  r4, #3
 
 .section .R_ARM_MOVW_PREL_NC, "ax",%progbits
  movw r0, :lower16:label - .

test/ELF/arm-plt-reloc.s

  .type  _start,%function
 _start:
  b func1
  bl func2
  beq func3
 
 // Executable, expect no PLT
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: func1:
 // CHECK-NEXT:   11000:        1e ff 2f e1    bx      lr
 // CHECK: func2:
 // CHECK-NEXT:   11004:        1e ff 2f e1    bx      lr
 // CHECK: func3:
 // CHECK-NEXT:   11008:        1e ff 2f e1    bx      lr
 // CHECK: _start:
 // CHECK-NEXT:   1100c:        fb ff ff ea    b       #-20 <func1>
 // CHECK-NEXT:   11010:        fb ff ff eb    bl      #-20 <func2>
 // CHECK-NEXT:   11014:        fb ff ff 0a    beq     #-20 <func3>
 
 // Expect PLT entries as symbols can be preempted
 // The .got.plt and .plt displacement is small so we can use small PLT entries.
 // DSO: Disassembly of section .text:
+// DSO-EMPTY:
 // DSO-NEXT: func1:
 // DSO-NEXT:     1000:       1e ff 2f e1     bx      lr
 // DSO: func2:
 // DSO-NEXT:     1004:       1e ff 2f e1     bx      lr
 // DSO: func3:
 // DSO-NEXT:     1008:       1e ff 2f e1     bx      lr
 // DSO: _start:
 // S(0x1040) - P(0x100c) + A(-8) = 0x2c = 32
 // DSO-NEXT:     100c:       0b 00 00 ea     b       #44
 // S(0x1050) - P(0x1010) + A(-8) = 0x38 = 56
 // DSO-NEXT:     1010:       0e 00 00 eb     bl      #56
 // S(0x10160) - P(0x1014) + A(-8) = 0x44 = 68
 // DSO-NEXT:     1014:       11 00 00 0a     beq     #68
+// DSO-EMPTY:
 // DSO-NEXT: Disassembly of section .plt:
+// DSO-EMPTY:
 // DSO-NEXT: $a:
 // DSO-NEXT:     1020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // (0x1024 + 8) + (0 RoR 12) + 4096 + (0xfdc) = 0x3008 = .got.plt[3]
 // DSO-NEXT:     1024:       00 e6 8f e2     add     lr, pc, #0, #12
 // DSO-NEXT:     1028:       01 ea 8e e2     add     lr, lr, #4096
 // DSO-NEXT:     102c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // DSO: $d:
 // DSO-NEXT:     1030:       d4 d4 d4 d4     .word   0xd4d4d4d4

 // RUN:       .plt  0x2000 : { *(.plt) *(.plt.*) } \
 // RUN:       .got.plt 0x1100000 : { *(.got.plt) } \
 // RUN:       }" > %t.script
 // RUN: ld.lld --hash-style=sysv --script %t.script -shared %t1 %t2 -o %t4
 // RUN: llvm-objdump -triple=armv7a-none-linux-gnueabi -d %t4 | FileCheck --check-prefix=CHECKHIGH %s
 // RUN: llvm-readobj -S -r %t4 | FileCheck --check-prefix=DSORELHIGH %s
 
 // CHECKHIGH: Disassembly of section .text:
+// CHECKHIGH-EMPTY:
 // CHECKHIGH-NEXT: func1:
 // CHECKHIGH-NEXT:     1000:       1e ff 2f e1     bx      lr
 // CHECKHIGH: func2:
 // CHECKHIGH-NEXT:     1004:       1e ff 2f e1     bx      lr
 // CHECKHIGH: func3:
 // CHECKHIGH-NEXT:     1008:       1e ff 2f e1     bx      lr
 // CHECKHIGH: _start:
 // CHECKHIGH-NEXT:     100c:       03 04 00 ea     b       #4108 <$a>
 // CHECKHIGH-NEXT:     1010:       06 04 00 eb     bl      #4120 <$a>
 // CHECKHIGH-NEXT:     1014:       09 04 00 0a     beq     #4132 <$a>
+// CHECKHIGH-EMPTY:
 // CHECKHIGH-NEXT: Disassembly of section .plt:
+// CHECKHIGH-EMPTY:
 // CHECKHIGH-NEXT: $a:
 // CHECKHIGH-NEXT:     2000:       04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECKHIGH-NEXT:     2004:       10 e6 8f e2     add     lr, pc, #16, #12
 // CHECKHIGH-NEXT:     2008:       fd ea 8e e2     add     lr, lr, #1036288
 // CHECKHIGH-NEXT:     200c:       fc ff be e5     ldr     pc, [lr, #4092]!
 // CHECKHIGH: $d:
 // CHECKHIGH-NEXT:     2010:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECKHIGH-NEXT:     2014:       d4 d4 d4 d4     .word   0xd4d4d4d4

 // RUN:       .plt  0x2000 : { *(.plt) *(.plt.*) } \
 // RUN:       .got.plt 0x11111100 : { *(.got.plt) } \
 // RUN:       }" > %t2.script
 // RUN: ld.lld --hash-style=sysv --script %t2.script -shared %t1 %t2 -o %t5
 // RUN: llvm-objdump -triple=armv7a-none-linux-gnueabi -d %t5 | FileCheck --check-prefix=CHECKLONG %s
 // RUN: llvm-readobj -S -r %t5 | FileCheck --check-prefix=DSORELLONG %s
 
 // CHECKLONG: Disassembly of section .text:
+// CHECKLONG-EMPTY:
 // CHECKLONG-NEXT: func1:
 // CHECKLONG-NEXT:     1000:       1e ff 2f e1     bx      lr
 // CHECKLONG: func2:
 // CHECKLONG-NEXT:     1004:       1e ff 2f e1     bx      lr
 // CHECKLONG: func3:
 // CHECKLONG-NEXT:     1008:       1e ff 2f e1     bx      lr
 // CHECKLONG: _start:
 // CHECKLONG-NEXT:     100c:       03 04 00 ea     b       #4108 <$a>
 // CHECKLONG-NEXT:     1010:       06 04 00 eb     bl      #4120 <$a>
 // CHECKLONG-NEXT:     1014:       09 04 00 0a     beq     #4132 <$a>
+// CHECKLONG-EMPTY:
 // CHECKLONG-NEXT: Disassembly of section .plt:
+// CHECKLONG-EMPTY:
 // CHECKLONG-NEXT: $a:
 // CHECKLONG-NEXT:     2000:       04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECKLONG-NEXT:     2004:       04 e0 9f e5     ldr     lr, [pc, #4]
 // CHECKLONG-NEXT:     2008:       0e e0 8f e0     add     lr, pc, lr
 // CHECKLONG-NEXT:     200c:       08 f0 be e5     ldr     pc, [lr, #8]!
 // CHECKLONG: $d:
 // CHECKLONG-NEXT:     2010:       f0 f0 10 11     .word   0x1110f0f0
 // CHECKLONG-NEXT:     2014:       d4 d4 d4 d4     .word   0xd4d4d4d4

 // RUN:       .plt  0x2000 : { *(.plt) *(.plt.*) } \
 // RUN:       .got.plt 0x8002020 : { *(.got.plt) } \
 // RUN:       }" > %t3.script
 // RUN: ld.lld --hash-style=sysv --script %t3.script -shared %t1 %t2 -o %t6
 // RUN: llvm-objdump -triple=armv7a-none-linux-gnueabi -d %t6 | FileCheck --check-prefix=CHECKMIX %s
 // RUN: llvm-readobj -S -r %t6 | FileCheck --check-prefix=DSORELMIX %s
 
 // CHECKMIX: Disassembly of section .text:
+// CHECKMIX-EMPTY:
 // CHECKMIX-NEXT: func1:
 // CHECKMIX-NEXT:     1000:     1e ff 2f e1     bx      lr
 // CHECKMIX: func2:
 // CHECKMIX-NEXT:     1004:     1e ff 2f e1     bx      lr
 // CHECKMIX: func3:
 // CHECKMIX-NEXT:     1008:     1e ff 2f e1     bx      lr
 // CHECKMIX: _start:
 // CHECKMIX-NEXT:     100c:     03 04 00 ea     b       #4108 <$a>
 // CHECKMIX-NEXT:     1010:     06 04 00 eb     bl      #4120 <$a>
 // CHECKMIX-NEXT:     1014:     09 04 00 0a     beq     #4132 <$a>
+// CHECKMIX-EMPTY:
 // CHECKMIX-NEXT: Disassembly of section .plt:
+// CHECKMIX-EMPTY:
 // CHECKMIX-NEXT: $a:
 // CHECKMIX-NEXT:     2000:     04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECKMIX-NEXT:     2004:     04 e0 9f e5     ldr     lr, [pc, #4]
 // CHECKMIX-NEXT:     2008:     0e e0 8f e0     add     lr, pc, lr
 // CHECKMIX-NEXT:     200c:     08 f0 be e5     ldr     pc, [lr, #8]!
 // CHECKMIX: $d:
 // CHECKMIX-NEXT:     2010:     10 00 00 08     .word   0x08000010
 // CHECKMIX-NEXT:     2014:     d4 d4 d4 d4     .word   0xd4d4d4d4

test/ELF/arm-sbrel32.s

 foo:    .word 10
 foo2:   .word 20
 
         .bss
 foo3:   .space 4
 foo4:   .space 4
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    11000:        1e ff 2f e1     bx      lr
 // CHECK:         11004:        00 00 00 00     .word   0x00000000
 // CHECK-NEXT:    11008:        04 00 00 00     .word   0x00000004
 // CHECK-NEXT:    1100c:        08 00 00 00     .word   0x00000008
 // CHECK-NEXT:    11010:        0c 00 00 00     .word   0x0000000c

test/ELF/arm-target1.s

 
 .text
   .word patatino(target1)
   patatino:
         .word 32
 // Force generation of $d.0 as section is not all data
   nop
 // RELATIVE: Disassembly of section .text:
+// RELATIVE-EMPTY:
 // RELATIVE: $d.0:
 // RELATIVE:     1000:       04 00 00 00     .word   0x00000004
 // RELATIVE: SYMBOL TABLE:
 // RELATIVE: 00001004         .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)

test/ELF/arm-thumb-blx.s

  nop
 // Expect BLX to thumb target to be written out as a BL
  blx   callee_thumb_low
  nop
  blx   callee_thumb_high
  bx lr
 
 // CHECK-ARM: Disassembly of section .R_ARM_CALL24_callee1:
+// CHECK-ARM-EMPTY:
 // CHECK-NEXT-ARM: callee_low:
 // CHECK-NEXT-ARM:      b4:     1e ff 2f e1     bx      lr
 
 // CHECK-THUMB: Disassembly of section .R_ARM_CALL24_callee2:
+// CHECK-THUMB-EMPTY:
 // CHECK-NEXT-THUMB: callee_thumb_low:
 // CHECK-NEXT-THUMB:     100: 70 47   bx  lr
 
 // CHECK-THUMB: Disassembly of section .caller:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB: _start:
 // Align(0x10000,4) - 0xff50 (65360) + 4 = 0xb4 = callee_low
 // CHECK-NEXT-THUMB:   10000:       f0 f7 58 e8     blx     #-65360
 // CHECK-NEXT-THUMB:   10004:       00 bf   nop
 // Align(0x10006,4) - 0xff54 (65364) + 4 = 0xb4 = callee_low
 // CHECK-NEXT-THUMB:   10006:       f0 f7 56 e8     blx     #-65364
 // CHECK-NEXT-THUMB:   1000a:       00 bf   nop
 // Align(0x1000c,4) + 0xf0 (240) + 4 = 0x10100 = callee_high

 // CHECK-NEXT-THUMB:   10024:       f0 f7 6c f8     bl      #-65320
 // CHECK-NEXT-THUMB:   10028:       00 bf   nop
 // 1002a + 0x1d2 (466) + 4 = 0x10200 = callee_thumb_high
 // CHECK-NEXT-THUMB:   1002a:       00 f0 e9 f8     bl      #466
 // CHECK-NEXT-THUMB:   1002e:       70 47   bx      lr
 
 
 // CHECK-ARM: Disassembly of section .R_ARM_CALL24_callee3:
+// CHECK-ARM-EMPTY:
 // CHECK-NEXT-ARM: callee_high:
 // CHECK-NEXT-ARM:   10100:     1e ff 2f e1     bx      lr
 
 // CHECK: Disassembly of section .R_ARM_CALL24_callee4:
+// CHECK-EMPTY:
 // CHECK-NEXT-THUMB:callee_thumb_high:
 // CHECK-NEXT-THUMB:   10200:   70 47   bx      lr

test/ELF/arm-thumb-branch-rangethunk.s

 _start:
  // address of too_far symbols are just out of range of ARM branch with
  // 26-bit immediate field and an addend of -8
  bl  too_far1
  b   too_far2
  beq.w too_far3
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    20000:       00 f0 04 f8     bl      #8
 // CHECK-NEXT:    20004:       00 f0 07 b8     b.w     #14 <__Thumbv7ABSLongThunk_too_far2>
 // CHECK-NEXT:    20008:       00 f0 0a 80     beq.w   #20 <__Thumbv7ABSLongThunk_too_far3>
 // CHECK: __Thumbv7ABSLongThunk_too_far1:
 // CHECK-NEXT:    2000c:       40 f2 05 0c     movw    r12, #5
 // CHECK-NEXT:    20010:       c0 f2 02 1c     movt    r12, #258
 // CHECK-NEXT:    20014:       60 47   bx      r12

test/ELF/arm-thumb-branch.s

 
  .section .callee_high, "ax",%progbits
  .align 2
  .type callee_high,%function
 callee_high:
  bx lr
 
 // CHECK: Disassembly of section .callee1:
+// CHECK-EMPTY:
 // CHECK-NEXT: callee_low:
 // CHECK-NEXT:      b4:       70 47   bx      lr
+// CHECK-EMPTY:
 // CHECK-NEXT: Disassembly of section .caller:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:   10000:       f0 f7 58 f8     bl      #-65360
 // CHECK-NEXT:   10004:       f0 f7 56 b8     b.w     #-65364
 // CHECK-NEXT:   10008:       30 f4 54 a8     beq.w   #-65368
 // CHECK-NEXT:   1000c:       00 f0 0c f8     bl      #24
 // CHECK-NEXT:   10010:       00 f0 0a b8     b.w     #20
 // CHECK-NEXT:   10014:       40 f0 08 80     bne.w   #16
 // CHECK-NEXT:   10018:       ff f3 ff d7     bl      #16777214
 // CHECK-NEXT:   1001c:       ff f3 fd 97     b.w     #16777210
 // CHECK-NEXT:   10020:       3f f3 ff af     bgt.w   #1048574
 // CHECK-NEXT:   10024:       70 47   bx      lr
 // CHECK-NEXT:   10026:
+// CHECK-EMPTY:
 // CHECK-NEXT: Disassembly of section .callee2:
+// CHECK-EMPTY:
 // CHECK-NEXT: callee_high:
 // CHECK-NEXT:   10028:       70 47   bx      lr

test/ELF/arm-thumb-condbranch-thunk.s

 
  .globl _start
 _start:
  FUNCTION 00
 // Long Range Thunk needed for 16Mb range branch, can reach pre-created Thunk
 // Section
  bl tfunc33
 // CHECK1: Disassembly of section .text:
+// CHECK1-EMPTY:
 // CHECK1-NEXT: tfunc00:
 // CHECK1-NEXT:    80000:       70 47   bx      lr
 // CHECK1-NEXT:    80002:       7f f3 ff d7     bl      #16252926
 // CHECK1: __Thumbv7ABSLongThunk_tfunc05:
 // CHECK1-NEXT:    80008:       7f f2 fa bf     b.w     #2621428 <tfunc05>
 // CHECK1: __Thumbv7ABSLongThunk_tfunc00:
 // CHECK1-NEXT:    8000c:       ff f7 f8 bf     b.w     #-16 <tfunc00>
  FUNCTION 01

test/ELF/arm-thumb-interwork-shared.s

 sym1:
  b.w elsewhere
  b.w weakref
 
 // Check that we generate a thunk for an undefined symbol called via a plt
 // entry.
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: sym1:
 // CHECK-NEXT: 1000: 00 f0 02 b8 b.w #4 <__ThumbV7PILongThunk_elsewhere>
 // CHECK-NEXT: 1004: 00 f0 06 b8 b.w #12 <__ThumbV7PILongThunk_weakref>
 // CHECK: __ThumbV7PILongThunk_elsewhere:
 // CHECK-NEXT:     1008:       40 f2 2c 0c     movw    r12, #44
 // CHECK-NEXT:     100c:       c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:     1010:       fc 44   add     r12, pc
 // CHECK-NEXT:     1012:       60 47   bx      r12
 // CHECK: __ThumbV7PILongThunk_weakref:
 // CHECK-NEXT:     1014:       40 f2 30 0c     movw    r12, #48
 // CHECK-NEXT:     1018:       c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:     101c:       fc 44   add     r12, pc
 // CHECK-NEXT:     101e:       60 47   bx      r12
 
 // PLT: Disassembly of section .plt:
+// PLT-EMPTY:
 // PLT-NEXT: $a:
 // PLT-NEXT:     1020:  04 e0 2d e5     str     lr, [sp, #-4]!
 // PLT-NEXT:     1024:  00 e6 8f e2     add     lr, pc, #0, #12
 // PLT-NEXT:     1028:  01 ea 8e e2     add     lr, lr, #4096
 // PLT-NEXT:     102c:  dc ff be e5     ldr     pc, [lr, #4060]!
 // PLT: $d:
 // PLT-NEXT:     1030:  d4 d4 d4 d4     .word   0xd4d4d4d4
 // PLT-NEXT:     1034:  d4 d4 d4 d4     .word   0xd4d4d4d4

test/ELF/arm-thumb-interwork-thunk.s

  .thumb
  .balign 0x1000
  .globl thumb_callee1
  .type thumb_callee1, %function
 thumb_callee1:
  bx lr
 
 // CHECK-THUMB: Disassembly of section .R_ARM_JUMP24_callee_1:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB: thumb_callee1:
 // CHECK-THUMB: 1000:       70 47   bx
  .section .R_ARM_THM_JUMP_callee_low, "ax", %progbits
  .arm
  .balign 0x100
  .globl arm_callee1
  .type arm_callee1, %function
 arm_callee1:

  b thumb_callee2
  b thumb_callee3
  // In range ARM targets do not require interworking thunks
  b arm_callee1
  beq arm_callee2
  bne arm_callee3
  bx lr
 // CHECK-ARM-ABS-ARM: Disassembly of section .arm_caller:
+// CHECK-ARM-ABS-ARM-EMPTY:
 // CHECK-ARM-ABS-ARM-NEXT: arm_caller:
 // CHECK-ARM-ABS-ARM-NEXT:     1300:       3e ff ff fa     blx     #-776 <thumb_callee1>
 // CHECK-ARM-ABS-ARM-NEXT:     1304:       3d ff ff fa     blx     #-780 <thumb_callee1>
 // CHECK-ARM-ABS-ARM-NEXT:     1308:       06 00 00 ea     b       #24 <__ARMv7ABSLongThunk_thumb_callee1>
 // CHECK-ARM-ABS-ARM-NEXT:     130c:       05 00 00 ea     b       #20 <__ARMv7ABSLongThunk_thumb_callee1>
 // CHECK-ARM-ABS-ARM-NEXT:     1310:       07 00 00 ea     b       #28 <__ARMv7ABSLongThunk_thumb_callee2>
 // CHECK-ARM-ABS-ARM-NEXT:     1314:       09 00 00 ea     b       #36 <__ARMv7ABSLongThunk_thumb_callee3>
 // CHECK-ARM-ABS-ARM-NEXT:     1318:       78 ff ff ea     b       #-544 <arm_callee1>

 // CHECK-ARM-ABS-ARM-NEXT:     133c:       1c ff 2f e1     bx      r12
 // 0x1503 = thumb_callee3
 // CHECK-ARM-ABS-ARM: __ARMv7ABSLongThunk_thumb_callee3:
 // CHECK-ARM-ABS-ARM-NEXT:     1340:       03 c5 01 e3     movw    r12, #5379
 // CHECK-ARM-ABS-ARM-NEXT:     1344:       00 c0 40 e3     movt    r12, #0
 // CHECK-ARM-ABS-ARM-NEXT:     1348:       1c ff 2f e1     bx      r12
 
 // CHECK-PI-ARM: Disassembly of section .arm_caller:
+// CHECK-PI-ARM-EMPTY:
 // CHECK-PI-ARM-NEXT: arm_caller:
 // CHECK-PI-ARM-NEXT:     1300:       3e ff ff fa     blx     #-776 <thumb_callee1>
 // CHECK-PI-ARM-NEXT:     1304:       3d ff ff fa     blx     #-780 <thumb_callee1>
 // CHECK-PI-ARM-NEXT:     1308:       06 00 00 ea     b       #24 <__ARMV7PILongThunk_thumb_callee1>
 // CHECK-PI-ARM-NEXT:     130c:       05 00 00 ea     b       #20 <__ARMV7PILongThunk_thumb_callee1>
 // CHECK-PI-ARM-NEXT:     1310:       08 00 00 ea     b       #32 <__ARMV7PILongThunk_thumb_callee2>
 // CHECK-PI-ARM-NEXT:     1314:       0b 00 00 ea     b       #44 <__ARMV7PILongThunk_thumb_callee3>
 // CHECK-PI-ARM-NEXT:     1318:       78 ff ff ea     b       #-544 <arm_callee1>

 // CHECK-PI-ARM-NEXT:     1348:       ab c1 00 e3     movw    r12, #427
 // CHECK-PI-ARM-NEXT:     134c:       00 c0 40 e3     movt    r12, #0
 // CHECK-PI-ARM-NEXT:     1350:       0f c0 8c e0     add     r12, r12, pc
 // CHECK-PI-ARM-NEXT:     1354:       1c ff 2f e1     bx      r12
 // 1350 + 8 + 0x1ab = 0x1503
 
 // All PLT entries are ARM, no need for interworking thunks
 // CHECK-PI-ARM-PLT: Disassembly of section .arm_caller:
+// CHECK-PI-ARM-PLT-EMPTY:
 // CHECK-PI-ARM-PLT-NEXT: arm_caller:
 // 0x17e4 PLT(thumb_callee1)
 // CHECK-PI-ARM-PLT-NEXT:    1300:       37 01 00 eb     bl      #1244
 // 0x17e4 PLT(thumb_callee1)
 // CHECK-PI-ARM-PLT-NEXT:    1304:       36 01 00 eb     bl      #1240
 // 0x17e4 PLT(thumb_callee1)
 // CHECK-PI-ARM-PLT-NEXT:    1308:       35 01 00 ea     b       #1236
 // 0x17e4 PLT(thumb_callee1)

  // There can be more than one thunk associated with a section
  b.w arm_callee3
  // Conditional branches also require interworking thunks, they can use the
  // same interworking thunks.
  beq.w arm_callee1
  beq.w arm_callee2
  bne.w arm_callee3
 // CHECK-ABS-THUMB: Disassembly of section .thumb_caller:
+// CHECK-ABS-THUMB-EMPTY:
 // CHECK-ABS-THUMB-NEXT: thumb_caller:
 // CHECK-ABS-THUMB-NEXT:     1400:       ff f7 7e ee     blx     #-772
 // CHECK-ABS-THUMB-NEXT:     1404:       ff f7 7c ee     blx     #-776
 // CHECK-ABS-THUMB-NEXT:     1408:       00 f0 0a b8     b.w     #20 <__Thumbv7ABSLongThunk_arm_callee1>
 // CHECK-ABS-THUMB-NEXT:     140c:       00 f0 0d b8     b.w     #26 <__Thumbv7ABSLongThunk_arm_callee2>
 // CHECK-ABS-THUMB-NEXT:     1410:       00 f0 10 b8     b.w     #32 <__Thumbv7ABSLongThunk_arm_callee3>
 // CHECK-ABS-THUMB-NEXT:     1414:       00 f0 04 80     beq.w   #8 <__Thumbv7ABSLongThunk_arm_callee1>
 // CHECK-ABS-THUMB-NEXT:     1418:       00 f0 07 80     beq.w   #14 <__Thumbv7ABSLongThunk_arm_callee2>

 // CHECK-ABS-THUMB-NEXT:     1432:       60 47   bx      r12
 // 0x1604 = arm_callee3
 // CHECK-ABS-THUMB: __Thumbv7ABSLongThunk_arm_callee3:
 // CHECK-ABS-THUMB-NEXT:     1434:   41 f2 04 6c     movw    r12, #5636
 // CHECK-ABS-THUMB-NEXT:     1438:       c0 f2 00 0c     movt    r12, #0
 // CHECK-ABS-THUMB-NEXT:     143c:       60 47   bx      r12
 
 // CHECK-PI-THUMB: Disassembly of section .thumb_caller:
+// CHECK-PI-THUMB-EMPTY:
 // CHECK-PI-THUMB-NEXT: thumb_caller:
 // CHECK-PI-THUMB-NEXT:     1400:       ff f7 7e ee     blx     #-772
 // CHECK-PI-THUMB-NEXT:     1404:       ff f7 7c ee     blx     #-776
 // CHECK-PI-THUMB-NEXT:     1408:       00 f0 0a b8     b.w     #20 <__ThumbV7PILongThunk_arm_callee1>
 // CHECK-PI-THUMB-NEXT:     140c:       00 f0 0e b8     b.w     #28 <__ThumbV7PILongThunk_arm_callee2>
 // CHECK-PI-THUMB-NEXT:     1410:       00 f0 12 b8     b.w     #36 <__ThumbV7PILongThunk_arm_callee3>
 // CHECK-PI-THUMB-NEXT:     1414:       00 f0 04 80     beq.w   #8 <__ThumbV7PILongThunk_arm_callee1>
 // CHECK-PI-THUMB-NEXT:     1418:       00 f0 08 80     beq.w   #16 <__ThumbV7PILongThunk_arm_callee2>

 // CHECK-PI-THUMB: __ThumbV7PILongThunk_arm_callee3:
 // 0x1440 + 4 + 0x1c0 = 0x1604 = arm_callee3
 // CHECK-PI-THUMB-NEXT:     1438:       40 f2 c0 1c     movw    r12, #448
 // CHECK-PI-THUMB-NEXT:     143c:       c0 f2 00 0c     movt    r12, #0
 // CHECK-PI-THUMB-NEXT:     1440:       fc 44   add     r12, pc
 // CHECK-PI-THUMB-NEXT:     1442:       60 47   bx      r12
 
 // CHECK-PI-THUMB-PLT: Disassembly of section .arm_caller:
+// CHECK-PI-THUMB-PLT-EMPTY:
 // CHECK-PI-THUMB-PLT-NEXT: thumb_caller:
 // 0x1400 + 4 + 0x410 = 0x1814 = PLT(arm_callee1)
 // CHECK-PI-THUMB-PLT-NEXT:    1400:    00 f0 08 ea     blx     #1040
 // 0x1404 + 4 + 0x40c = 0x1814 = PLT(arm_callee1)
 // CHECK-PI-THUMB-PLT-NEXT:    1404:    00 f0 06 ea     blx     #1036
 // 0x1408 + 4 + 0x14 = 0x1420 = IWV(PLT(arm_callee1)
 // CHECK-PI-THUMB-PLT-NEXT:    1408:    00 f0 0a b8     b.w     #20
 // 0x140c + 4 + 0x1c = 0x142c = IWV(PLT(arm_callee2)

 thumb_callee2:
  bx lr
 
  .globl thumb_callee3
  .type thumb_callee3, %function
 thumb_callee3:
  bx lr
 // CHECK-THUMB:  Disassembly of section .R_ARM_JUMP24_callee_2:
+// CHECK-THUMB-EMPTY:
 // CHECK-THUMB-NEXT: thumb_callee2:
 // CHECK-THUMB-NEXT: 1500:       70 47   bx      lr
 // CHECK-THUMB: thumb_callee3:
 // CHECK-THUMB-NEXT: 1502:       70 47   bx      lr
 
  .section .R_ARM_THM_JUMP_callee_high, "ax", %progbits
  .arm
  .balign 0x100
  .globl arm_callee2
  .type arm_callee2, %function
 arm_callee2:
  bx lr
  .globl arm_callee3
  .type arm_callee3, %function
 arm_callee3:
  bx lr
 // CHECK-ARM: Disassembly of section .R_ARM_THM_JUMP_callee_2:
+// CHECK-ARM-EMPTY:
 // CHECK-ARM-NEXT: arm_callee2:
 // CHECK-ARM-NEXT:     1600:     1e ff 2f e1     bx      lr
 // CHECK-ARM: arm_callee3:
 // CHECK-ARM-NEXT:     1604:     1e ff 2f e1     bx      lr
 
 // _start section just calls the arm and thumb calling sections
  .text
  .arm
  .globl _start
  .balign 0x100
  .type _start, %function
 _start:
  bl arm_caller
  bl thumb_caller
  bx lr
 
 
 // CHECK-PI-ARM-PLT: Disassembly of section .plt:
+// CHECK-PI-ARM-PLT-EMPTY:
 // CHECK-PI-ARM-PLT-NEXT: .plt:
 // CHECK-PI-ARM-PLT-NEXT: 17b0:         04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECK-PI-ARM-PLT-NEXT: 17b4:         04 e0 9f e5     ldr     lr, [pc, #4]
 // CHECK-PI-ARM-PLT-NEXT: 17b8:         0e e0 8f e0     add     lr, pc, lr
 // CHECK-PI-ARM-PLT-NEXT: 17bc:         08 f0 be e5     ldr     pc, [lr, #8]!
 // CHECK-PI-ARM-PLT-NEXT: 17c0:         d4 00 00 00
 // 0x17c8 + 8 + 0xd0 = 0x18a0 arm_caller
 // CHECK-PI-ARM-PLT-NEXT: 17c4:         04 c0 9f e5     ldr     r12, [pc, #4]

test/ELF/arm-thumb-narrow-branch-check.s

 callee_high:
  bx lr
 
 .global callee_high_far
 .type callee_high_far,%function
 callee_high_far = 0x180d
 
 // CHECK: Disassembly of section .R_ARM_PC11_1:
+// CHECK-EMPTY:
 // CHECK-NEXT: callee_low:
 // CHECK-NEXT:    1000:       70 47   bx      lr
+// CHECK-EMPTY:
 // CHECK-NEXT: Disassembly of section .caller:
+// CHECK-EMPTY:
 // CHECK-NEXT: callers:
 // 1004 - 0x800 (2048) + 4 = 0x808 = callee_low_far
 // CHECK-NEXT:    1004:       00 e4   b       #-2048
 // 1006 - 0xa (10) + 4 = 0x1000 = callee_low
 // CHECK-NEXT:    1006:       fb e7   b       #-10
 // 1008 + 4 + 4 = 0x1010 = callee_high
 // CHECK-NEXT:    1008:       02 e0   b       #4
 // 100a + 0x7fe (2046) + 4 = 0x180c = callee_high_far
 // CHECK-NEXT:    100a:       ff e3   b       #2046
 // CHECK-NEXT:    100c:       70 47   bx      lr
 // CHECK-NEXT:    100e:       00 bf   nop
+// CHECK-EMPTY:
 // CHECK-NEXT: Disassembly of section .R_ARM_PC11_2:
+// CHECK-EMPTY:
 // CHECK-NEXT: callee_high:
 // CHECK-NEXT:    1010:       70 47   bx      lr
+// CHECK-EMPTY:
 // CHECK-NEXT: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:    1014:       ff f7 f6 ff     bl      #-20
 // CHECK-NEXT:    1018:       70 47   bx      lr

test/ELF/arm-thumb-no-undefined-thunk.s

  .thumb
  .global
 _start:
  bl target
  b target
  b.w target
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // 69636 = 0x11004 = next instruction
 // CHECK:         11000: {{.*}} bl      #0
 // CHECK-NEXT:    11004: {{.*}} b.w     #0 <_start+0x8>
 // CHECK-NEXT:    11008: {{.*}} b.w     #0 <_start+0xc>

test/ELF/arm-thumb-plt-range-thunk-os.s

  bl preemptible
  bx lr
 preemptible:
  bl far_preemptible
  bl far_nonpreemptible
  bl far_nonpreemptible_alias
  bx lr
 // CHECK1: Disassembly of section .text:
+// CHECK1-EMPTY:
 // CHECK1-NEXT: sym1:
 // CHECK1-NEXT:  2000000:       00 f0 00 d8     bl      #8388608
 // CHECK1-NEXT:  2000004:       00 f0 04 d8     bl      #8388616
 // CHECK1-NEXT:  2000008:       70 47   bx      lr
 // CHECK1: preemptible:
 // CHECK1-NEXT:  200000a:       00 f0 07 d8     bl      #8388622
 // CHECK1-NEXT:  200000e:       00 f0 0b d8     bl      #8388630
 // CHECK1-NEXT:  2000012:       00 f0 09 d8     bl      #8388626

 .balign 0x2000000
 far_nonpreemptible_alias:
  bl elsewhere
 
 // CHECK3: far_preemptible:
 // CHECK3:  4000000:       00 f0 16 e8     blx     #44
 
 // CHECK4: Disassembly of section .plt:
+// CHECK4-EMPTY:
 // CHECK4-NEXT: $a:
 // CHECK4-NEXT:  4000010: 04 e0 2d e5   str lr, [sp, #-4]!
 // CHECK4-NEXT:  4000014: 00 e6 8f e2   add lr, pc, #0, #12
 // CHECK4-NEXT:  4000018: 01 ea 8e e2   add lr, lr, #4096
 // CHECK4-NEXT:  400001c: ec ff be e5   ldr pc, [lr, #4076]!
 // CHECK4: $d:
 // CHECK4-NEXT:  4000020: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4-NEXT:  4000024: d4 d4 d4 d4   .word 0xd4d4d4d4

test/ELF/arm-thumb-plt-reloc.s

 // interworking thunks are available for b.w and b<cond>.w this can be altered
 // to test the different forms of interworking.
  bl func1
  bl func2
  bl func3
 
 // Executable, expect no PLT
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: func1:
 // CHECK-NEXT:   11000: 70 47   bx      lr
 // CHECK: func2:
 // CHECK-NEXT:   11002: 70 47   bx      lr
 // CHECK: func3:
 // CHECK-NEXT:   11004: 70 47   bx      lr
 // CHECK-NEXT:   11006: d4 d4
 // CHECK: _start:
 // 11008 + 4 -12 = 0x11000 = func1
 // CHECK-NEXT:   11008: ff f7 fa ff     bl      #-12
 // 1100c + 4 -14 = 0x11002 = func2
 // CHECK-NEXT:   1100c: ff f7 f9 ff     bl      #-14
 // 11010 + 4 -16 = 0x11004 = func3
 // CHECK-NEXT:   11010: ff f7 f8 ff     bl      #-16
 
 // Expect PLT entries as symbols can be preempted
 // .text is Thumb and .plt is ARM, llvm-objdump can currently only disassemble
 // as ARM or Thumb. Work around by disassembling twice.
 // DSOTHUMB: Disassembly of section .text:
+// DSOTHUMB-EMPTY:
 // DSOTHUMB-NEXT: func1:
 // DSOTHUMB-NEXT:     1000:     70 47   bx      lr
 // DSOTHUMB: func2:
 // DSOTHUMB-NEXT:     1002:     70 47   bx      lr
 // DSOTHUMB: func3:
 // DSOTHUMB-NEXT:     1004:     70 47   bx      lr
 // DSOTHUMB-NEXT:     1006:     d4 d4   bmi     #-88
 // DSOTHUMB: _start:
 // 0x1008 + 0x34 + 4 = 0x1040 = PLT func1
 // DSOTHUMB-NEXT:     1008:     00 f0 1a e8     blx     #52
 // 0x100c + 0x40 + 4 = 0x1050 = PLT func2
 // DSOTHUMB-NEXT:     100c:     00 f0 20 e8     blx     #64
 // 0x1010 + 0x4C + 4 = 0x1060 = PLT func3
 // DSOTHUMB-NEXT:     1010:     00 f0 26 e8     blx     #76
 // DSOARM: Disassembly of section .plt:
+// DSOARM-EMPTY:
 // DSOARM-NEXT: $a:
 // DSOARM-NEXT:     1020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // (0x1024 + 8) + (0 RoR 12) + 4096 + (0xfdc) = 0x3008 = .got.plt[3]
 // DSOARM-NEXT:     1024:       00 e6 8f e2     add     lr, pc, #0, #12
 // DSOARM-NEXT:     1028:       01 ea 8e e2     add     lr, lr, #4096
 // DSOARM-NEXT:     102c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // DSOARM: $d:
 

test/ELF/arm-thumb-range-thunk-os.s

 _start:
 // tfunc00 and tfunc15 are within 16Mb no Range Thunks expected
  bl tfunc00
  bl tfunc15
 // tfunc16 is > 16Mb away, expect a Range Thunk to be generated, to go into
 // the first of the pre-created ThunkSections.
  bl tfunc16
 // CHECK1: Disassembly of section .text:
+// CHECK1-EMPTY:
 // CHECK1-NEXT: _start:
 // CHECK1-NEXT:   100000:       ff f0 fe ff     bl      #1048572
 // CHECK1-NEXT:   100004:       ff f3 fc d7     bl      #16777208
 // CHECK1-NEXT:   100008:       ff f2 fc d7     bl      #15728632
 
  FUNCTION 00
 // CHECK2:  tfunc00:
 // CHECK2-NEXT:   200000:       70 47   bx      lr

test/ELF/arm-thumb-thunk-empty-pass.s

  .section .text.dummy1,"ax",%progbits
  .space 0xfffffe
  .section .text.foo,"ax",%progbits
   .type foo, %function
 foo:
  bl _start
 
 // CHECK1: Disassembly of section .text:
+// CHECK1-EMPTY:
 // CHECK1-NEXT: _start:
 // CHECK1-NEXT:    11000:       ff f7 fe ff     bl      #-4
 // CHECK1: __Thumbv7ABSLongThunk__start:
 // CHECK1-NEXT:    11004:       ff f7 fc bf     b.w     #-8 <_start>
 
 // CHECK2: __Thumbv7ABSLongThunk__start:
 // CHECK2:       1011008:       41 f2 01 0c     movw    r12, #4097
 // CHECK2-NEXT:  101100c:       c0 f2 01 0c     movt    r12, #1
 // CHECK2-NEXT:  1011010:       60 47   bx      r12
 // CHECK2: foo:
 // CHECK2-NEXT:  1011012:       ff f7 f9 ff     bl      #-14

test/ELF/arm-thumb-thunk-v6m.s

 
  .section .text_high, "ax", %progbits
  .globl far
  .type far, %function
 far:
  bx lr
 
 // CHECK: Disassembly of section .text_low:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:       94:        00 f0 00 f8     bl      #0
 // CHECK: __Thumbv6MABSLongThunk_far:
 // CHECK-NEXT:       98:        03 b4   push    {r0, r1}
 // CHECK-NEXT:       9a:        01 48   ldr     r0, [pc, #4]
 // CHECK-NEXT:       9c:        01 90   str     r0, [sp, #4]
 // CHECK-NEXT:       9e:        01 bd   pop     {r0, pc}
 // CHECK:       a0:     01 00 00 02     .word   0x02000001
 // CHECK: Disassembly of section .text_high:
+// CHECK-EMPTY:
 // CHECK-NEXT: far:
 // CHECK-NEXT:  2000000:        70 47   bx      lr
 
 // CHECK-PI: Disassembly of section .text_low:
+// CHECK-PI-EMPTY:
 // CHECK-PI-NEXT: _start:
 // CHECK-PI-NEXT:      130:     00 f0 00 f8     bl      #0
 // CHECK-PI: __Thumbv6MPILongThunk_far:
 // CHECK-PI-NEXT:      134:     01 b4   push    {r0}
 // CHECK-PI-NEXT:      136:     02 48   ldr     r0, [pc, #8]
 // CHECK-PI-NEXT:      138:     84 46   mov     r12, r0
 // CHECK-PI-NEXT:      13a:     01 bc   pop     {r0}
 // pc = pc (0x13c + 4) + r12 (1fffec1) = 0x2000001 = .far
 // CHECK-PI-NEXT:      13c:     e7 44   add     pc, r12
 // CHECK-PI-NEXT:      13e:     c0 46   mov     r8, r8
 // CHECK-PI:           140:     c1 fe ff 01     .word   0x01fffec1
 
 // CHECK-PI: Disassembly of section .text_high:
+// CHECK-PI-EMPTY:
 // CHECK-PI-NEXT: far:
 // CHECK-PI-NEXT:  2000000:     70 47   bx      lr

test/ELF/arm-thumb-undefined-weak-narrow.test

 # REQUIRES: arm
 # RUN: yaml2obj %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -triple=thumbv7a-linux-gnueabi -d %t | FileCheck %s
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT:_start:
 # CHECK-NEXT:    11000:       ff e7   b       #-2
 
 # Test the R_ARM_THM_JUMP11 relocation (102) to an undefined weak reference
 # It should resolve to the next instruction, which is an offset of -2 which
 # when added to the Thumb PC-bias of 4 is +2. We can't use llvm-mc to construct
 # the object as it relaxes b.n to b.w (R_ARM_JUMP24).
 

test/ELF/arm-thumb-undefined-weak.s

 // R_ARM_THM_CALL with exchange
  blx target
 // R_ARM_THM_MOVT_PREL
  movt r0, :upper16:target - .
 // R_ARM_THM_MOVW_PREL_NC
  movw r0, :lower16:target - .
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // 69636 = 0x11004
 // CHECK:         11000: {{.*}} beq.w   #0 <_start+0x4>
 // CHECK-NEXT:    11004: {{.*}} b.w     #0 <_start+0x8>
 // CHECK-NEXT:    11008: {{.*}} bl      #0
 // blx is transformed into bl so we don't change state
 // CHECK-NEXT:    1100c: {{.*}} bl      #0
 // CHECK-NEXT:    11010: {{.*}} movt    r0, #0
 // CHECK-NEXT:    11014: {{.*}} movw    r0, #0

test/ELF/arm-thunk-largesection.s

  .thumb
  .text
  .globl _start
  .type _start, %function
 _start:
  bx lr
  .space 0x1000
 // CHECK1: Disassembly of section .text:
+// CHECK1-EMPTY:
 // CHECK1-NEXT:_start:
 // CHECK1-NEXT:   11000:       70 47   bx      lr
 // CHECK1-EMPTY:
 // CHECK-NEXT:$d.1:
 // CHECK-NEXT:  11002:       00 00           .short  0x0000
 
 
 // CHECK2: __Thumbv7ABSLongThunk__start:

test/ELF/arm-thunk-linkerscript-dotexpr.s

  .section .text_low2, "ax", %progbits
  .thumb
  .globl low_target2
  .type low_target2, %function
 low_target2:
  bl high_target
  bl high_target2
 // CHECK1: Disassembly of section .text_low:
+// CHECK1-EMPTY:
 // CHECK1-NEXT: _start:
 // CHECK1-NEXT:       94:       70 47   bx      lr
 // CHECK1: low_target:
 // CHECK1-NEXT:       96:       00 f0 03 f8     bl      #6
 // CHECK1-NEXT:       9a:       00 f0 06 f8     bl      #12
 // CHECK1: __Thumbv7ABSLongThunk_high_target:
 // CHECK1-NEXT:       a0:       40 f2 bd 0c     movw    r12, #189
 // CHECK1-NEXT:       a4:       c0 f2 00 2c     movt    r12, #512

test/ELF/arm-thunk-linkerscript-large.s

  .section .text, "ax", %progbits
  .thumb
  .globl _start
 _start:
  bl tfuncl00
  // Expect a range extension thunk in .text OutputSection
  bl tfunch31
 // CHECK1: Disassembly of section .text:
+// CHECK1-EMPTY:
 // CHECK1-NEXT: _start:
 // CHECK1-NEXT:   100000:       ff f0 fe ff     bl      #1048572
 // CHECK1-NEXT:   100004:       00 f0 00 f8     bl      #0
 // CHECK1: __Thumbv7ABSLongThunk_tfunch31:
 // CHECK1-NEXT:   100008:       40 f2 01 0c     movw    r12, #1
 // CHECK1-NEXT:   10000c:       c0 f2 10 4c     movt    r12, #1040
 // CHECK1-NEXT:   100010:       60 47   bx      r12
  FUNCTIONL 00
  // Create a range extension thunk in .textl
  bl tfuncl24
  // We can reuse existing thunk in .text
  bl tfunch31
 // CHECK2: Disassembly of section .textl:
+// CHECK2-EMPTY:
 // CHECK2-NEXT: tfuncl00:
 // CHECK2-NEXT:   200000: 70 47   bx  lr
 // CHECK2-NEXT:   200002: ff f0 ff df   bl  #9437182
 // CHECK2-NEXT:   200006: ff f6 ff ff   bl  #-1048578
  FUNCTIONL 01
  FUNCTIONL 02
  FUNCTIONL 03
  FUNCTIONL 04

 // CHECK4-NEXT:  2100018:       60 47   bx      r12
  FUNCTIONH 00
  // Can reuse existing thunks in .textl
  bl tfuncl00
  bl tfuncl24
  // Shouldn't need a thunk
         bl tfuncl31
 // CHECK5:  Disassembly of section .texth:
+// CHECK5-EMPTY:
 // CHECK5-NEXT: tfunch00:
 // CHECK5-NEXT:  2200000:       70 47   bx      lr
 // CHECK5-NEXT:  2200002:       00 f7 05 f8     bl      #-1048566
 // CHECK5-NEXT:  2200006:       ff f7 fb df     bl      #-8388618
 // CHECK5-NEXT:  220000a:       ff f6 f9 ff     bl      #-1048590
  FUNCTIONH 01
  FUNCTIONH 02
  FUNCTIONH 03

test/ELF/arm-thunk-linkerscript-orphan.s

  .globl _start
 _start: bx lr
  .globl low_target
  .type low_target, %function
 low_target:
  bl high_target
  bl orphan_target
 // CHECK: Disassembly of section .text_low:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:   100000:        70 47   bx      lr
 // CHECK: low_target:
 // CHECK-NEXT:   100002:        00 f0 03 f8     bl      #6
 // CHECK-NEXT:   100006:        00 f0 06 f8     bl      #12
 // CHECK: __Thumbv7ABSLongThunk_high_target:
 // CHECK-NEXT:   10000c:        40 f2 01 0c     movw    r12, #1
 // CHECK-NEXT:   100010:        c0 f2 00 2c     movt    r12, #512
 // CHECK-NEXT:   100014:        60 47   bx      r12
 // CHECK: __Thumbv7ABSLongThunk_orphan_target:
 // CHECK-NEXT:   100016:        40 f2 15 0c     movw    r12, #21
 // CHECK-NEXT:   10001a:        c0 f2 00 2c     movt    r12, #512
 // CHECK-NEXT:   10001e:        60 47   bx      r12
   .section .text_high, "ax", %progbits
  .thumb
  .globl high_target
  .type high_target, %function
 high_target:
  bl low_target
  bl orphan_target
 // CHECK: Disassembly of section .text_high:
+// CHECK-EMPTY:
 // CHECK-NEXT: high_target:
 // CHECK-NEXT:  2000000:        00 f0 02 f8     bl      #4
 // CHECK-NEXT:  2000004:        00 f0 06 f8     bl      #12
 // CHECK: __Thumbv7ABSLongThunk_low_target:
 // CHECK-NEXT:  2000008:        40 f2 03 0c     movw    r12, #3
 // CHECK-NEXT:  200000c:        c0 f2 10 0c     movt    r12, #16
 // CHECK-NEXT:  2000010:        60 47   bx      r12
 
  .section orphan, "ax", %progbits
  .thumb
  .globl orphan_target
  .type orphan_target, %function
 orphan_target:
  bl low_target
  bl high_target
 // CHECK: Disassembly of section orphan:
+// CHECK-EMPTY:
 // CHECK-NEXT: orphan_target:
 // CHECK-NEXT:  2000014:        ff f7 f8 ff     bl      #-16
 // CHECK-NEXT:  2000018:        ff f7 f2 ff     bl      #-28
 
  .data
  .word 10

test/ELF/arm-thunk-linkerscript.s

  .thumb
  .globl low_target2
  .type low_target2, %function
 low_target2:
  bl high_target
  bl high_target2
 
 // CHECK: Disassembly of section .text_low:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:       94:        70 47   bx      lr
 // CHECK: low_target:
 // CHECK-NEXT:       96:        00 f0 03 f8     bl      #6
 // CHECK-NEXT:       9a:        00 f0 06 f8     bl      #12
 // CHECK: __Thumbv7ABSLongThunk_high_target:
 // CHECK-NEXT:       a0:        40 f2 01 0c     movw    r12, #1
 // CHECK-NEXT:       a4:        c0 f2 00 2c     movt    r12, #512

  .thumb
  .globl high_target2
  .type high_target2, %function
 high_target2:
  bl low_target
  bl low_target2
 
 // CHECK: Disassembly of section .text_high:
+// CHECK-EMPTY:
 // CHECK-NEXT: high_target:
 // CHECK-NEXT:  2000000:        00 f0 02 f8     bl      #4
 // CHECK-NEXT:  2000004:        00 f0 05 f8     bl      #10
 // CHECK: __Thumbv7ABSLongThunk_low_target:
 // CHECK-NEXT:  2000008:        40 f2 97 0c     movw    r12, #151
 // CHECK-NEXT:  200000c:        c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:  2000010:        60 47   bx      r12
 // CHECK: __Thumbv7ABSLongThunk_low_target2:
 // CHECK-NEXT:  2000012:        40 f2 b5 0c     movw    r12, #181
 // CHECK-NEXT:  2000016:        c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:  200001a:        60 47   bx      r12
 // CHECK: high_target2:
 // CHECK-NEXT:  200001c:        ff f7 f4 ff     bl      #-24
 // CHECK-NEXT:  2000020:        ff f7 f7 ff     bl      #-18

test/ELF/arm-thunk-multipass-plt.s

preemptible2:
         bx lr
 
 
         .section .text.11, "ax", %progbits
         .space (5 * 1024 * 1024)
 
 
 // CHECK-PLT: Disassembly of section .plt:
+// CHECK-PLT-EMPTY:
 // CHECK-PLT-NEXT: 0000000000d00020 $a:
 // CHECK-PLT-NEXT:   d00020:    04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECK-PLT-NEXT:   d00024:    00 e6 8f e2     add     lr, pc, #0, #12
 // CHECK-PLT-NEXT:   d00028:    01 ea 8e e2     add     lr, lr, #4096
 // CHECK-PLT-NEXT:   d0002c:    dc ff be e5     ldr     pc, [lr, #4060]!
 // CHECK-PLT: 0000000000d00030 $d:
 // CHECK-PLT-NEXT:   d00030:    d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK-PLT-NEXT:   d00034:    d4 d4 d4 d4     .word   0xd4d4d4d4

test/ELF/arm-thunk-re-add.s

 // CHECK2-NEXT:  1100010:       fc 44   add     r12, pc
 // CHECK2-NEXT:  1100012:       60 47   bx      r12
 // CHECK2: callers:
 // CHECK2-NEXT:  1100014:       ff f6 f6 bf     b.w     #-1048596 <__ThumbV7PILongThunk_imported>
 // CHECK2-NEXT:  1100018:       3f f4 f6 af     beq.w   #-20 <__ThumbV7PILongThunk_imported>
 // CHECK2-NEXT:  110001c:       ff f6 f8 bf     b.w     #-1048592 <__ThumbV7PILongThunk_imported2>
 
 // CHECK3: Disassembly of section .plt:
+// CHECK3-EMPTY:
 // CHECK3-NEXT: $a:
 // CHECK3-NEXT:  1100020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECK3-NEXT:  1100024:       00 e6 8f e2     add     lr, pc, #0, #12
 // CHECK3-NEXT:  1100028:       01 ea 8e e2     add     lr, lr, #4096
 // CHECK3-NEXT:  110002c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // CHECK3: $d:
 // CHECK3-NEXT:  1100030:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK3-NEXT:  1100034:       d4 d4 d4 d4     .word   0xd4d4d4d4

test/ELF/arm-tls-gd32.s

 // SEC: Dynamic Relocations {
 // SEC-NEXT: 0x205C R_ARM_TLS_DTPMOD32 -
 // SEC-NEXT: 0x204C R_ARM_TLS_DTPMOD32 x
 // SEC-NEXT: 0x2050 R_ARM_TLS_DTPOFF32 x
 // SEC-NEXT: 0x2054 R_ARM_TLS_DTPMOD32 y
 // SEC-NEXT: 0x2058 R_ARM_TLS_DTPOFF32 y
 
 
-// CHECK: Disassembly
-// CHECK-NEXT: func:
+// CHECK-LABEL: 0000000000001000 func:
 // CHECK-NEXT:    1000:      00 f0 20 e3     nop
 // CHECK-NEXT:    1004:      00 f0 20 e3     nop
 // CHECK-NEXT:    1008:      00 f0 20 e3     nop
 
 // (0x204c - 0x100c) + (0x100c - 0x1000 - 8) = 0x1044
 // CHECK:    100c:  44 10 00 00
 // (0x2054 - 0x1010) + (0x1010 - 0x1004 - 8) = 0x1048
 // CHECK-NEXT:    1010: 48 10 00 00
 // (0x205c - 0x1014) + (0x1014 - 0x1008 - 8) = 0x104c
 // CHECK-NEXT:    1014: 4c 10 00 00
 

test/ELF/arm-tls-ie32.s

 
 
 // SEC: Dynamic Relocations {
 // SEC:  0x2054 R_ARM_TLS_TPOFF32
 // SEC:  0x204C R_ARM_TLS_TPOFF32 x
 // SEC:  0x2050 R_ARM_TLS_TPOFF32 y
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: func:
 // CHECK-NEXT:    1000: 00 f0 20 e3     nop
 // CHECK-NEXT:    1004: 00 f0 20 e3     nop
 // CHECK-NEXT:    1008: 00 f0 20 e3     nop
 
 // (0x204c - 0x100c) + (0x100c - 0x1000 - 8) = 0x1044
 // CHECK:         100c: 44 10 00 00
 // (0x2050 - 0x1010) + (0x1010 - 0x1004 - 8) = 0x1044
 // CHECK-NEXT:    1010: 44 10 00 00
 // (0x2054 - 0x1014) + (0x1014 - 0x1008 - 8) = 0x1044
 // CHECK-NEXT:    1014: 44 10 00 00

test/ELF/arm-tls-ldm32.s

 // SEC-NEXT: ]
 // SEC-NEXT: Address: 0x2004
 // SEC:      Size: 4
 
 // SEC: Dynamic Relocations {
 // SEC-NEXT:  0x204C R_ARM_TLS_DTPMOD32 - 0x0
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT: 1000:       00 f0 20 e3     nop
 
 // (0x204c - 0x1004) + (0x1004 - 0x1000 - 8) = 0x1044
 // CHECK:      1004:       44 10 00 00
 // CHECK-NEXT: 1008:       00 00 00 00
 // CHECK-NEXT: 100c:       04 00 00 00
 
 // CHECK-EXE: Disassembly of section .text:
+// CHECK-EXE-EMPTY:
 // CHECK-NEXT-EXE: _start:
 // CHECK-NEXT-EXE:   11000:       00 f0 20 e3     nop
 
 // CHECK-EXE:   11004:       fc 0f 00 00
 // CHECK-EXE:   11008:       00 00 00 00
 // CHECK-EXE:   1100c:       04 00 00 00

test/ELF/arm-tls-le32.s

 // SEC-NEXT: ]
 // SEC-NEXT: Address: 0x12004
 // SEC:      Size: 8
 
 // SEC: Dynamic Relocations {
 // SEC-NEXT: }
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // offset of x from Thread pointer = (TcbSize + 0x0 = 0x20)
 // CHECK-NEXT:   11000:         20 00 00 00
 // offset of z from Thread pointer = (TcbSize + 0x8 = 0x28)
 // CHECK-NEXT:   11004:         28 00 00 00
 // offset of y from Thread pointer = (TcbSize + 0x4 = 0x24)
 // CHECK-NEXT:   11008:         24 00 00 00

test/ELF/arm-undefined-weak.s

 // R_ARM_MOVT_PREL
  movt r0, :upper16:target - .
 // R_ARM_MOVW_PREL_NC
  movw r0, :lower16:target - .
 // R_ARM_REL32
  .word target - .
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // 69636 = 0x11004
 // CHECK:         11000: {{.*}} b       #-4 <_start+0x4>
 // CHECK-NEXT:    11004: {{.*}} bl      #-4 <_start+0x8>
 // blx is transformed into bl so we don't change state
 // CHECK-NEXT:    11008: {{.*}} bl      #-4 <_start+0xc>
 // CHECK-NEXT:    1100c: {{.*}} movt    r0, #0
 // CHECK-NEXT:    11010: {{.*}} movw    r0, #0
 // CHECK:         11014: {{.*}} .word   0x00000000
 

test/ELF/comdat.s

 // GC: removing unused section {{.*}}.o:(.text)
 // GC: removing unused section {{.*}}.o:(.text)
 
         .section  .text2,"axG",@progbits,foo,comdat,unique,0
 foo:
         nop
 
 // CHECK: Disassembly of section .text2:
+// CHECK-EMPTY:
 // CHECK-NEXT: foo:
 // CHECK-NEXT:   1000: {{.*}}  nop
 // CHECK-NOT: nop
 
         .section bar, "ax"
         call foo
 
 // CHECK: Disassembly of section bar:
+// CHECK-EMPTY:
 // CHECK-NEXT: bar:
 // 0x1000 - 0x1001 - 5 = -6
 // 0      - 0x1006 - 5 = -4107
 // CHECK-NEXT:   1001:  {{.*}}  callq  -6
 // CHECK-NEXT:   1006:  {{.*}}  callq  -4107
 
         .section .text3,"axG",@progbits,zed,comdat,unique,0
 

test/ELF/copy-rel-pie.s

 // CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT bar 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // (0x1010 + 0x10) - 0x1005 = 27
 // 0x3020          - 0x100a = 8214
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT:     1000:       e8 1b 00 00 00  callq   27
 // DISASM-NEXT:     1005:       e8 16 20 00 00  callq   8214 <foo>

test/ELF/defsym.s

 # CHECK-NEXT:   Binding: Global
 # CHECK-NEXT:   Type:
 # CHECK-NEXT:   Other:
 # CHECK-NEXT:   Section: Absolute
 # CHECK-NEXT: }
 
 ## Check we can use foo2 and it that it is an alias for foo1.
 # USE:       Disassembly of section .text:
+# USE-EMPTY:
 # USE-NEXT:  _start:
 # USE-NEXT:    movl $0x123, %edx
 
 # RUN: ld.lld -o %t %t.o --defsym=foo2=1
 # RUN: llvm-readobj --symbols -S %t | FileCheck %s --check-prefix=ABS
 
 # ABS:      Symbol {
 # ABS:        Name: foo2

test/ELF/eh-frame-hdr.s

 .globl _start
 _start:
 
 // NOHDR:       Sections [
 // NOHDR-NOT:    Name: .eh_frame_hdr
 // NOHDR:      ProgramHeaders [
 // NOHDR-NOT:   PT_GNU_EH_FRAME
 
-//HDRDISASM:      Disassembly of section foo:
-//HDRDISASM-NEXT: foo:
-//HDRDISASM-NEXT:    201000: 90 nop
-//HDRDISASM-NEXT: Disassembly of section bar:
-//HDRDISASM-NEXT: bar:
-//HDRDISASM-NEXT:    201001: 90 nop
-//HDRDISASM-NEXT: Disassembly of section dah:
-//HDRDISASM-NEXT: dah:
-//HDRDISASM-NEXT:    201002: 90 nop
+// HDRDISASM:      Disassembly of section foo:
+// HDRDISASM-EMPTY:
+// HDRDISASM-NEXT: foo:
+// HDRDISASM-NEXT:    201000: 90 nop
+// HDRDISASM-EMPTY:
+// HDRDISASM-NEXT: Disassembly of section bar:
+// HDRDISASM-EMPTY:
+// HDRDISASM-NEXT: bar:
+// HDRDISASM-NEXT:    201001: 90 nop
+// HDRDISASM-EMPTY:
+// HDRDISASM-NEXT: Disassembly of section dah:
+// HDRDISASM-EMPTY:
+// HDRDISASM-NEXT: dah:
+// HDRDISASM-NEXT:    201002: 90 nop
 
 // HDR:       Section {
 // HDR:         Index:
 // HDR:         Name: .eh_frame_hdr
 // HDR-NEXT:    Type: SHT_PROGBITS
 // HDR-NEXT:    Flags [
 // HDR-NEXT:      SHF_ALLOC
 // HDR-NEXT:    ]

test/ELF/ehframe-relocation.s

 // CHECK-NEXT: Address: 0x200120
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 52
 // CHECK-NOT: .eh_frame
 
 // 0x200120 = 2097440
 // 0x200120 + 5 = 2097445
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT:   201000: {{.*}} movq 2097440, %rax
 // DISASM-NEXT:   201008: {{.*}} movq 2097445, %rax
 
 .section .eh_frame,"ax",@unwind
 
 .section .text
 .globl _start
 _start:
  movq .eh_frame, %rax
  movq .eh_frame + 5, %rax

test/ELF/gdb-index.s

 # RUN:   %p/Inputs/gdb-index.s -o %t2.o
 # RUN: ld.lld --gdb-index %t1.o %t2.o -o %t
 
 # RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=DISASM
 # RUN: llvm-dwarfdump -gdb-index %t | FileCheck %s --check-prefix=DWARF
 # RUN: llvm-readelf -sections %t | FileCheck %s --check-prefix=SECTION
 
 # DISASM:       Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM:       entrypoint:
 # DISASM-CHECK:   201000: 90 nop
 # DISASM-CHECK:   201001: cc int3
 # DISASM-CHECK:   201002: cc int3
 # DISASM-CHECK:   201003: cc int3
 # DISASM:       aaaaaaaaaaaaaaaa:
 # DISASM-CHECK:   201004: 90 nop
 # DISASM-CHECK:   201005: 90 nop

test/ELF/gnu-ifunc-i386.s

 // CHECK-NEXT:   Binding: Global
 // CHECK-NEXT:   Type: Function
 // CHECK-NEXT:   Other: 0
 // CHECK-NEXT:   Section: .text
 // CHECK-NEXT: }
 // CHECK-NEXT:]
 
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo_resolver:
 // DISASM-NEXT:    401000: c3 retl
 // DISASM: bar_resolver:
 // DISASM-NEXT:    401001: c3 retl
 // DISASM:      _start:
 // DISASM-NEXT:    401002: e8 19 00 00 00 calll 25
 // DISASM-NEXT:    401007: e8 24 00 00 00 calll 36
 // DISASM-NEXT:    40100c: ba d4 00 40 00 movl $4194516, %edx
 // DISASM-NEXT:    401011: ba e4 00 40 00 movl $4194532, %edx
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    401020: ff 25 00 20 40 00 jmpl *4202496
 // DISASM-NEXT:    401026: 68 10 00 00 00 pushl $16
 // DISASM-NEXT:    40102b: e9 e0 ff ff ff jmp -32 <_start+0xe>
 // DISASM:      bar:
 // DISASM-NEXT:    401030: ff 25 04 20 40 00 jmpl *4202500
 // DISASM-NEXT:    401036: 68 18 00 00 00 pushl $24
 // DISASM-NEXT:    40103b: e9 d0 ff ff ff jmp -48 <_start+0xe>

test/ELF/gnu-ifunc-plt-i386.s

 // GOTPLT-NEXT:  403010 46104000 00104000 01104000
 
 // Check that the PLTRELSZ tag includes the IRELATIVE relocations
 // CHECK: DynamicSection [
 // CHECK:  0x00000002 PLTRELSZ             32 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    401000:       c3      retl
 // DISASM:      bar:
 // DISASM-NEXT:    401001:       c3      retl
 // DISASM:      _start:
 // DISASM-NEXT:    401002:       e8 49 00 00 00          calll   73
 // DISASM-NEXT:    401007:       e8 54 00 00 00          calll   84
 // DISASM-NEXT:    40100c:       e8 1f 00 00 00          calll   31
 // DISASM-NEXT:    401011:       e8 2a 00 00 00          calll   42
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:    401020:       ff 35 04 30 40 00       pushl   4206596
 // DISASM-NEXT:    401026:       ff 25 08 30 40 00       jmpl    *4206600
 // DISASM-NEXT:    40102c:       90      nop
 // DISASM-NEXT:    40102d:       90      nop
 // DISASM-NEXT:    40102e:       90      nop
 // DISASM-NEXT:    40102f:       90      nop
 // DISASM-EMPTY:

test/ELF/gnu-ifunc-plt.s

 // GOTPLT-NEXT:  203030 66102000 00000000
 
 // Check that the PLTRELSZ tag includes the IRELATIVE relocations
 // CHECK: DynamicSection [
 // CHECK:   0x0000000000000002 PLTRELSZ             96 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:   201000:       c3      retq
 // DISASM:      bar:
 // DISASM-NEXT:   201001:       c3      retq
 // DISASM:      _start:
 // DISASM-NEXT:   201002:       e8 49 00 00 00          callq   73
 // DISASM-NEXT:   201007:       e8 54 00 00 00          callq   84
 // DISASM-NEXT:   20100c:       e8 1f 00 00 00          callq   31
 // DISASM-NEXT:   201011:       e8 2a 00 00 00          callq   42
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:   201020:       ff 35 e2 1f 00 00       pushq   8162(%rip)
 // DISASM-NEXT:   201026:       ff 25 e4 1f 00 00       jmpq    *8164(%rip)
 // DISASM-NEXT:   20102c:       0f 1f 40 00     nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar2@plt:
 // DISASM-NEXT:   201030:       ff 25 e2 1f 00 00       jmpq    *8162(%rip)
 // DISASM-NEXT:   201036:       68 00 00 00 00          pushq   $0

test/ELF/gnu-ifunc-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv --shared -o %t.so %t.o
 // RUN: llvm-objdump -d %t.so | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r %t.so | FileCheck %s
 
 // Check that an IRELATIVE relocation is used for a non-preemptible ifunc
 // handler and a JUMP_SLOT is used for a preemptible ifunc
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: fct:
 // DISASM-NEXT:     1000:       c3      retq
 // DISASM:     fct2:
 // DISASM-NEXT:     1001:       c3      retq
 // DISASM:     f1:
 // DISASM-NEXT:     1002:       e8 49 00 00 00          callq   73
 // DISASM-NEXT:     1007:       e8 24 00 00 00          callq   36
 // DISASM-NEXT:     100c:       e8 2f 00 00 00          callq   47
 // DISASM-NEXT:     1011:       c3      retq
 // DISASM:     f2:
 // DISASM-NEXT:     1012:       c3      retq
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:     1020:       ff 35 e2 1f 00 00       pushq   8162(%rip)
 // DISASM-NEXT:     1026:       ff 25 e4 1f 00 00       jmpq    *8164(%rip)
 // DISASM-NEXT:     102c:       0f 1f 40 00     nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   fct2@plt:
 // DISASM-NEXT:     1030:       ff 25 e2 1f 00 00       jmpq    *8162(%rip)
 // DISASM-NEXT:     1036:       68 00 00 00 00          pushq   $0

test/ELF/gnu-ifunc.s

 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: GNU_IFunc
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: .text
 // CHECK-NEXT:  }
 // CHECK-NEXT: ]
 
 // DISASM: Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:  201000: {{.*}} retq
 // DISASM:      bar:
 // DISASM-NEXT:  201001: {{.*}} retq
 // DISASM:      _start:
 // DISASM-NEXT:  201002: {{.*}} callq 25
 // DISASM-NEXT:  201007: {{.*}} callq 36
 // DISASM-NEXT:  20100c: {{.*}} movl $2097496, %edx
 // DISASM-NEXT:  201011: {{.*}} movl $2097544, %edx
 // DISASM-NEXT:  201016: {{.*}} movl $2097545, %edx
+// DISASM-EMPTY:
 // DISASM-NEXT: Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:  201020: {{.*}} jmpq *4058(%rip)
 // DISASM-NEXT:  201026: {{.*}} pushq $0
 // DISASM-NEXT:  20102b: {{.*}} jmp -32 <_start+0xe>
 // DISASM-NEXT:  201030: {{.*}} jmpq *4050(%rip)
 // DISASM-NEXT:  201036: {{.*}} pushq $1
 // DISASM-NEXT:  20103b: {{.*}} jmp -48 <_start+0xe>
 

test/ELF/got-i386.s

 // CHECK-NEXT:  Other: 0
 // CHECK-NEXT:  Section: .bss
 // CHECK-NEXT: }
 
 // 0x402000 - 0 = addr(.got) = 0x402000
 // 0x40200A - 10 = addr(.got) = 0x402000
 // 0x40200A + 5 - 15 = addr(.got) = 0x402000
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT: 401000: c7 81 0c 00 00 00 01 00 00 00 movl $1, 12(%ecx)
 // DISASM-NEXT: 40100a: c7 81 16 00 00 00 02 00 00 00 movl $2, 22(%ecx)
 // DISASM-NEXT: 401014: c7 81 1b 00 00 00 03 00 00 00 movl $3, 27(%ecx)
 
 .global _start
 _start:
   movl $1, bar@GOTOFF(%ecx)
   movl $2, obj@GOTOFF(%ecx)
   movl $3, obj+5@GOTOFF(%ecx)
   .type bar, @object
   .comm bar, 10
   .type obj, @object
   .comm obj, 10

test/ELF/gotpc-relax-nopic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -relax-relocations -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld --hash-style=sysv %t.o -o %t1
 # RUN: llvm-readobj --symbols -r %t1 | FileCheck --check-prefix=SYMRELOC %s
 # RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
 
 ## There is no relocations.
 # SYMRELOC:      Relocations [
 # SYMRELOC-NEXT: ]
 # SYMRELOC:      Symbols [
 # SYMRELOC:       Symbol {
 # SYMRELOC:        Name: bar
 # SYMRELOC-NEXT:   Value: 0x202000
 
 ## 2105344 = 0x202000 (bar)
 # DISASM:      Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM-NEXT: _start:
 # DISASM-NEXT:   201000: {{.*}} adcq  $2105344, %rax
 # DISASM-NEXT:   201007: {{.*}} addq  $2105344, %rbx
 # DISASM-NEXT:   20100e: {{.*}} andq  $2105344, %rcx
 # DISASM-NEXT:   201015: {{.*}} cmpq  $2105344, %rdx
 # DISASM-NEXT:   20101c: {{.*}} orq   $2105344, %rdi
 # DISASM-NEXT:   201023: {{.*}} sbbq  $2105344, %rsi
 # DISASM-NEXT:   20102a: {{.*}} subq  $2105344, %rbp

 # SEC-PIC-NEXT:   }
 # SEC-PIC-NEXT: ]
 # SEC-PIC:      0x000000006FFFFFF9 RELACOUNT            1
 
 ## Check that there was no relaxation performed. All values refer to got entry.
 ## Ex: 0x1000 + 4249 + 7 = 0x20A0
 ##     0x102a + 4207 + 7 = 0x20A0
 # DISASM-PIC:      Disassembly of section .text:
+# DISASM-PIC-EMPTY:
 # DISASM-PIC-NEXT: _start:
 # DISASM-PIC-NEXT: 1000: {{.*}} adcq  4249(%rip), %rax
 # DISASM-PIC-NEXT: 1007: {{.*}} addq  4242(%rip), %rbx
 # DISASM-PIC-NEXT: 100e: {{.*}} andq  4235(%rip), %rcx
 # DISASM-PIC-NEXT: 1015: {{.*}} cmpq  4228(%rip), %rdx
 # DISASM-PIC-NEXT: 101c: {{.*}} orq   4221(%rip), %rdi
 # DISASM-PIC-NEXT: 1023: {{.*}} sbbq  4214(%rip), %rsi
 # DISASM-PIC-NEXT: 102a: {{.*}} subq  4207(%rip), %rbp

test/ELF/gotpc-relax-und-dso.s

 # RELOC-NEXT:     R_X86_64_GLOB_DAT foo 0x0
 # RELOC-NEXT:     R_X86_64_GLOB_DAT und 0x0
 # RELOC-NEXT:   }
 # RELOC-NEXT: ]
 
 # 0x101e + 7 - 36 = 0x1001
 # 0x1025 + 7 - 43 = 0x1001
 # DISASM:      Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM-NEXT: foo:
 # DISASM-NEXT:     nop
 # DISASM:      hid:
 # DISASM-NEXT:     nop
 # DISASM:      _start:
 # DISASM-NEXT:    movq    4247(%rip), %rax
 # DISASM-NEXT:    movq    4240(%rip), %rax
 # DISASM-NEXT:    movq    4241(%rip), %rax

test/ELF/gotpc-relax.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -relax-relocations -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t1
 # RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=RELOC %s
 # RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
 
 ## There is no relocations.
 # RELOC:    Relocations [
 # RELOC:    ]
 
 # 0x201003 + 7 - 10 = 0x201000
 # 0x20100a + 7 - 17 = 0x201000
 # 0x201011 + 7 - 23 = 0x201001
 # 0x201018 + 7 - 30 = 0x201001
 # DISASM:      Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM-NEXT: foo:
 # DISASM-NEXT:   201000: 90 nop
 # DISASM:      hid:
 # DISASM-NEXT:   201001: 90 nop
 # DISASM:      ifunc:
 # DISASM-NEXT:   201002: c3 retq
 # DISASM:      _start:
 # DISASM-NEXT: leaq -10(%rip), %rax

test/ELF/i386-gotpc.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.o -o %t.so -shared
 // RUN: llvm-readelf -S %t.so | FileCheck %s
 // RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 
 movl $_GLOBAL_OFFSET_TABLE_, %eax
 
 // CHECK: .got.plt          PROGBITS        00003000
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: .text:
 // DISASM-NEXT:    1000: {{.*}}         movl    $8192, %eax
 //                                              0x3000 (.got.plt) - 0x1000 = 8192

test/ELF/i386-reloc-large-addend.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -triple i386-pc-linux-code16 -filetype=obj
 
 // RUN: echo ".global foo; foo = 0x1" > %t1.s
 // RUN: llvm-mc %t1.s -o %t1.o -triple i386-pc-linux -filetype=obj
 
 // RUN: ld.lld -Ttext 0x7000 %t.o %t1.o -o %t
 // RUN: llvm-objdump -d -triple=i386-pc-linux-code16 %t | FileCheck %s
 
 // CHECK:        Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:     7000:       e9 fe 1f        jmp     8190
 //                            0x1 + 0x9000 - 0x7003 == 8190
         .global _start
 _start:
 jmp foo + 0x9000

test/ELF/i386-reloc-range.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -triple i386-pc-linux-code16 -filetype=obj
 
 // RUN: echo ".global foo; foo = 0x10202" > %t1.s
 // RUN: llvm-mc %t1.s -o %t1.o -triple i386-pc-linux -filetype=obj
 // RUN: echo ".global foo; foo = 0x10203" > %t2.s
 // RUN: llvm-mc %t2.s -o %t2.o -triple i386-pc-linux -filetype=obj
 
 // RUN: ld.lld -Ttext 0x200 %t.o %t1.o -o %t1
 // RUN: llvm-objdump -d -triple=i386-pc-linux-code16 %t1 | FileCheck %s
 
 // CHECK:        Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:      200: {{.*}} jmp -1
 //              0x10202 - 0x203 == 0xffff
 
 // RUN: not ld.lld -Ttext 0x200 %t.o %t2.o -o /dev/null 2>&1 | FileCheck --check-prefix=ERR %s
 
 // ERR: {{.*}}:(.text+0x1): relocation R_386_PC16 out of range: 65536 is not in [-65536, 65535]
 
         .global _start
 _start:
         jmp foo

test/ELF/i386-retpoline-nopic-linkerscript.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 %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 10:       ff 35 ec 00 00 00       pushl   236
 // CHECK-NEXT: 16:       50      pushl   %eax
 // CHECK-NEXT: 17:       a1 f0 00 00 00 movl    240, %eax
 // CHECK-NEXT: 1c:       e8 0f 00 00 00  calll   15 <.plt+0x20>
 // CHECK-NEXT: 21:       f3 90   pause
 // CHECK-NEXT: 23:       0f ae e8        lfence
 // CHECK-NEXT: 26:       eb f9   jmp     -7 <.plt+0x11>

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 %t2.o -o %t2.so
 
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 401010:       ff 35 04 30 40 00       pushl   4206596
 // CHECK-NEXT: 401016:       50      pushl   %eax
 // CHECK-NEXT: 401017:       a1 08 30 40 00  movl    4206600, %eax
 // CHECK-NEXT: 40101c:       e8 0f 00 00 00  calll   15 <.plt+0x20>
 // CHECK-NEXT: 401021:       f3 90   pause
 // CHECK-NEXT: 401023:       0f ae e8        lfence
 // CHECK-NEXT: 401026:       eb f9   jmp     -7 <.plt+0x11>

test/ELF/i386-retpoline-pic-linkerscript.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 %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt -pie --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 10:       ff b3 04 00 00 00       pushl   4(%ebx)
 // CHECK-NEXT: 16:       50      pushl   %eax
 // CHECK-NEXT: 17:       8b 83 08 00 00 00 movl    8(%ebx), %eax
 // CHECK-NEXT: 1d:       e8 0e 00 00 00  calll   14 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
 // CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>

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 %t2.o -o %t2.so
 
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt -pie
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 1010:       ff b3 04 00 00 00       pushl   4(%ebx)
 // CHECK-NEXT: 1016:       50      pushl   %eax
 // CHECK-NEXT: 1017:       8b 83 08 00 00 00       movl    8(%ebx), %eax
 // CHECK-NEXT: 101d:       e8 0e 00 00 00  calll   14 <.plt+0x20>
 // CHECK-NEXT: 1022:       f3 90   pause
 // CHECK-NEXT: 1024:       0f ae e8        lfence
 // CHECK-NEXT: 1027:       eb f9   jmp     -7 <.plt+0x12>

test/ELF/i386-tls-ie-shared.s

 // GOTRELSHARED-NEXT:     0x2064 R_386_TLS_TPOFF tlslocal1 0x0
 // GOTRELSHARED-NEXT:     0x2068 R_386_TLS_TPOFF tlsshared0 0x0
 // GOTRELSHARED-NEXT:     0x206C R_386_TLS_TPOFF tlsshared1 0x0
 // GOTRELSHARED-NEXT:   }
 // GOTRELSHARED-NEXT: ]
 // GOTRELSHARED:      0x6FFFFFFA RELCOUNT             8
 
 // DISASMSHARED:       Disassembly of section test:
+// DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT:  _start:
 // (.got)[0] = 0x2060 = 8288
 // (.got)[1] = 0x2064 = 8292
 // (.got)[2] = 0x2068 = 8296
 // (.got)[3] = 0x206C = 8300
 // DISASMSHARED-NEXT:  1000: {{.*}} movl  8288, %ecx
 // DISASMSHARED-NEXT:  1006: {{.*}} movl  %gs:(%ecx), %eax
 // DISASMSHARED-NEXT:  1009: {{.*}} movl  8288, %eax

test/ELF/linkerscript/excludefile.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/include.s -o %t2
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/notinclude.s -o %t3.notinclude
 
 # RUN: echo "SECTIONS {} " > %t.script
 # RUN: ld.lld -o %t --script %t.script %t1 %t2 %t3.notinclude
 # RUN: llvm-objdump -d %t | FileCheck %s
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK: _start:
 # CHECK-NEXT: :       48 c7 c0 3c 00 00 00    movq    $60, %rax
 # CHECK-NEXT: :       48 c7 c7 2a 00 00 00    movq    $42, %rdi
 # CHECK-NEXT: :       cc      int3
 # CHECK-NEXT: :       cc      int3
 # CHECK: _potato:
 # CHECK-NEXT: :       90      nop
 # CHECK-NEXT: :       90      nop
 # CHECK-NEXT: :       cc      int3
 # CHECK-NEXT: :       cc      int3
 # CHECK: tomato:
 # CHECK-NEXT: :       b8 01 00 00 00  movl    $1, %eax
 
 # RUN: echo "SECTIONS { .patatino : \
 # RUN: { KEEP(*(EXCLUDE_FILE(*notinclude) .text)) } }" \
 # RUN:  > %t.script
 # RUN: ld.lld -o %t4 --script %t.script %t1 %t2 %t3.notinclude
 # RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=EXCLUDE
 
 # EXCLUDE: Disassembly of section .patatino:
+# EXCLUDE-EMPTY:
 # EXCLUDE: _start:
 # EXCLUDE-NEXT: :       48 c7 c0 3c 00 00 00    movq    $60, %rax
 # EXCLUDE-NEXT: :       48 c7 c7 2a 00 00 00    movq    $42, %rdi
 # EXCLUDE-NEXT: :       cc      int3
 # EXCLUDE-NEXT: :       cc      int3
 # EXCLUDE: _potato:
 # EXCLUDE-NEXT: :       90      nop
 # EXCLUDE-NEXT: :       90      nop
 # EXCLUDE: Disassembly of section .text:
+# EXCLUDE-EMPTY:
 # EXCLUDE: tomato:
 # EXCLUDE-NEXT: :       b8 01 00 00 00  movl    $1, %eax
 
 .section .text
 .globl _start
 _start:
     mov $60, %rax
     mov $42, %rdi

test/ELF/linkerscript/non-absolute.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 # RUN: echo "SECTIONS { A = . - 0x10; B = A + 0x1; }" > %t.script
 # RUN: ld.lld -shared %t1.o --script %t.script -o %t
 # RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=DUMP
 # RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=SYMBOL
 
 # B = A + 0x1 = -0x10 + 0x1 = -0xf -> 0xFFFFFFFFFFFFFFF1
 # B - (0x94+6) = -0xf - (0x94+6) = -169
 # DUMP:       Disassembly of section .text:
+# DUMP-EMPTY:
 # DUMP-NEXT:  foo:
 # DUMP-NEXT:   94: {{.*}} -169(%rip), %eax
 
 # SYMBOL:     Symbol {
 # SYMBOL:        Name: B
 # SYMBOL-NEXT:   Value: 0xFFFFFFFFFFFFFFF1
 # SYMBOL-NEXT:   Size: 0
 # SYMBOL-NEXT:   Binding: Local

test/ELF/local-got-pie.s

 
  .hidden foo
  .global foo
 foo:
  nop
 
 // 0x20B0 - 1001 - 5 = 4266
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT:   1000: {{.*}} callq 4267
 // DISASM:      foo:
 // DISASM-NEXT:   1005: {{.*}} nop
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [

test/ELF/merge.s

 // CHECK-NEXT:   Section: .mysec
 
  // CHECK: ]
 
         .text
         .globl  _start
 _start:
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 
         movl .mysec, %eax
 // addr(0x10) = 2097440
 // DISASM-NEXT:   movl    2097440, %eax
 
         movl .mysec+7, %eax
 // addr(0x42) + 3 = 2097444 + 3 = 2097447

test/ELF/mips-26-mask.s

 # REQUIRES: mips
 # Check reading/writing implicit addend for R_MIPS_26 relocation.
 
 # 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.exe | FileCheck %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK:      __start:
 # CHECK-NEXT:   20000:       0e 00 80 00     jal     134348800
 
   .text
   .global __start
 __start:
   jal __start+0x8000000

test/ELF/mips-26-n32-n64.s

 # REQUIRES: mips
 # Check R_MIPS_26 relocation handling in case of N64 ABIs.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
 # RUN:         %S/Inputs/mips-dynamic.s -o %t-so.o
 # RUN: ld.lld %t-so.o -shared -o %t.so
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o %t.so -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefixes=CHECK,DEFAULT
 # RUN: ld.lld %t-so.o -shared -o %t.so -z hazardplt
 # RUN: ld.lld %t.o %t.so -o %t.exe -z hazardplt
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefixes=CHECK,HAZARDPLT
 
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:       0c 00 80 0c     jal     131120
 # CHECK-NEXT:    20004:       00 00 00 00     nop
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .plt:
 # CHECK-NEXT:    20010:       3c 0e 00 03     lui     $14, 3
 # CHECK-NEXT:    20014:       dd d9 00 08     ld      $25, 8($14)
 # CHECK-NEXT:    20018:       25 ce 00 08     addiu   $14, $14, 8
 # CHECK-NEXT:    2001c:       03 0e c0 23     subu    $24, $24, $14
 # CHECK-NEXT:    20020:       03 e0 78 25     move    $15, $ra
 # CHECK-NEXT:    20024:       00 18 c0 c2     srl     $24, $24, 3
 # DEFAULT:       20028:       03 20 f8 09     jalr    $25

test/ELF/mips-26.s

 # REQUIRES: mips
 # Check R_MIPS_26 relocation handling.
 
 # 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-dynamic.s -o %t2.o
 # RUN: ld.lld %t2.o -shared -o %t.so
 # RUN: ld.lld %t1.o %t.so -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s
 # RUN: llvm-readobj --dynamic-table -S -r --mips-plt-got %t.exe \
 # RUN:   | FileCheck -check-prefix=REL %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: bar:
 # CHECK-NEXT:   20000:       0c 00 80 06     jal     131096 <loc>
 # CHECK-NEXT:   20004:       00 00 00 00     nop
 #
 # CHECK:      __start:
 # CHECK-NEXT:   20008:       0c 00 80 00     jal     131072 <bar>
 # CHECK-NEXT:   2000c:       00 00 00 00     nop
 # CHECK-NEXT:   20010:       0c 00 80 10     jal     131136
 #                                                    ^-- 0x20040 gotplt[foo0]
 # CHECK-NEXT:   20014:       00 00 00 00     nop
 #
 # CHECK:      loc:
 # CHECK-NEXT:   20018:       00 00 00 00     nop
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .plt:
 # CHECK-NEXT:   20020:       3c 1c 00 03     lui     $gp, 3
 # CHECK-NEXT:   20024:       8f 99 00 04     lw      $25, 4($gp)
 # CHECK-NEXT:   20028:       27 9c 00 04     addiu   $gp, $gp, 4
 # CHECK-NEXT:   2002c:       03 1c c0 23     subu    $24, $24, $gp
 # CHECK-NEXT:   20030:       03 e0 78 25     move    $15, $ra
 # CHECK-NEXT:   20034:       00 18 c0 82     srl     $24, $24, 2
 # CHECK-NEXT:   20038:       03 20 f8 09     jalr    $25

test/ELF/mips-64-gprel-so.s

 # REQUIRES: mips
 # Check setup of GP relative offsets in a function's prologue.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -o %t.so
 # RUN: llvm-objdump -d -t %t.so | FileCheck %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: foo:
 # CHECK-NEXT:    10000:    3c 1c 00 01    lui     $gp, 1
 # CHECK-NEXT:    10004:    03 99 e0 2d    daddu   $gp, $gp, $25
 # CHECK-NEXT:    10008:    67 9c 7f f0    daddiu  $gp, $gp, 32752
 
 # CHECK: 0000000000027ff0   .got    00000000 .hidden _gp
 # CHECK: 0000000000010000   .text   00000000 foo
 
   .text
   .global foo
 foo:
   lui     $gp,%hi(%neg(%gp_rel(foo)))
   daddu   $gp,$gp,$t9
   daddiu  $gp,$gp,%lo(%neg(%gp_rel(foo)))

test/ELF/mips-call-hilo.s

 # REQUIRES: mips
 # Check R_MIPS_CALL_HI16 / R_MIPS_CALL_LO16 relocations calculation.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -o %t.so
 # RUN: llvm-objdump -d %t.so | FileCheck %s
 # RUN: llvm-readobj -r --mips-plt-got %t.so | FileCheck -check-prefix=GOT %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: foo:
 # CHECK-NEXT:    10000:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    10004:       8c 42 80 20     lw      $2, -32736($2)
 # CHECK-NEXT:    10008:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    1000c:       8c 42 80 18     lw      $2, -32744($2)
 # CHECK-NEXT:    10010:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    10014:       8c 42 80 1c     lw      $2, -32740($2)
 

test/ELF/mips-call16.s

__start:
   lw      $t0,%call16(g1)($gp)
 
   .globl g1
   .type  g1,@function
 g1:
   nop
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:      10000:   8f 88 80 18   lw   $8, -32744
 
 # GOT:      Name: g1
 # GOT-NEXT: Value: 0x[[ADDR:[0-9A-F]+]]
 
 # GOT:      Local entries [
 # GOT-NEXT: ]

test/ELF/mips-got-hilo.s

 # REQUIRES: mips
 # Check R_MIPS_GOT_HI16 / R_MIPS_GOT_LO16 relocations calculation.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -o %t.so
 # RUN: llvm-objdump -d %t.so | FileCheck %s
 # RUN: llvm-readobj -r --mips-plt-got %t.so | FileCheck -check-prefix=GOT %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: foo:
 # CHECK-NEXT:    10000:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    10004:       8c 42 80 20     lw      $2, -32736($2)
 # CHECK-NEXT:    10008:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    1000c:       8c 42 80 18     lw      $2, -32744($2)
 # CHECK-NEXT:    10010:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    10014:       8c 42 80 1c     lw      $2, -32740($2)
 

test/ELF/mips-got16-relocatable.s

 # REQUIRES: mips
 # Check writing updated addend for R_MIPS_GOT16 relocation,
 # when produce a relocatable output.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux -o %t.o %s
 # RUN: ld.lld -r -o %t %t.o %t.o
 # RUN: llvm-objdump -d -r %t | FileCheck -check-prefix=OBJ %s
 # RUN: ld.lld -shared -o %t.so %t
 # RUN: llvm-objdump -d %t.so | FileCheck -check-prefix=SO %s
 
 # OBJ:      Disassembly of section .text:
+# OBJ-EMPTY:
 # OBJ-NEXT: .text:
 # OBJ-NEXT:        0:       8f 99 00 00     lw      $25, 0($gp)
 # OBJ-NEXT:                         00000000:  R_MIPS_GOT16 .data
 # OBJ-NEXT:        4:       27 24 00 00     addiu   $4, $25, 0
 # OBJ-NEXT:                         00000004:  R_MIPS_LO16  .data
 # OBJ:            10:       8f 99 00 00     lw      $25, 0($gp)
 # OBJ-NEXT:                         00000010:  R_MIPS_GOT16 .data
 # OBJ-NEXT:       14:       27 24 00 10     addiu   $4, $25, 16
 # OBJ-NEXT:                         00000014:  R_MIPS_LO16  .data
 
 # SO:      Disassembly of section .text:
+# SO-EMPTY:
 # SO-NEXT: .text:
 # SO-NEXT:    10000:       8f 99 80 18     lw      $25, -32744($gp)
 # SO-NEXT:    10004:       27 24 00 00     addiu   $4, $25, 0
 # SO:         10010:       8f 99 80 18     lw      $25, -32744($gp)
 # SO-NEXT:    10014:       27 24 00 10     addiu   $4, $25, 16
 
   .text
   lw     $t9, %got(.data)($gp)
   addiu  $a0, $t9, %lo(.data)
 
   .data
 data:
   .word 0

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: ld.lld %t.o -shared -o %t.so
 # RUN: llvm-objdump -d -t %t.so | FileCheck %s
 # RUN: llvm-readobj -r --mips-plt-got %t.so | FileCheck -check-prefix=GOT %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    10000:       8f 88 80 18     lw      $8, -32744($gp)
 # CHECK-NEXT:    10004:       21 08 00 2c     addi    $8, $8, 44
 # CHECK-NEXT:    10008:       8f 88 80 24     lw      $8, -32732($gp)
 # CHECK-NEXT:    1000c:       21 08 90 00     addi    $8, $8, -28672
 # CHECK-NEXT:    10010:       8f 88 80 28     lw      $8, -32728($gp)
 # CHECK-NEXT:    10014:       21 08 90 04     addi    $8, $8, -28668
 # CHECK-NEXT:    10018:       8f 88 80 28     lw      $8, -32728($gp)

test/ELF/mips-gp-disp.s

 # INT-SO-NEXT: Value:
 # INT-SO-NEXT: Size:
 # INT-SO-NEXT: Binding: Local
 
 # EXT-SO:      Name: _gp_disp
 # EXT-SO-NEXT: Value: 0x20000
 
 # DIS:      Disassembly of section .text:
+# DIS-EMPTY:
 # DIS-NEXT: __start:
 # DIS-NEXT:    10000:  3c 08 00 01  lui   $8, 1
 # DIS-NEXT:    10004:  21 08 7f f0  addi  $8, $8, 32752
 #                                                 ^-- 0x37ff0 & 0xffff
 # DIS: 00027ff0  .got  00000000 .hidden _gp
 
 # REL:      Relocations [
 # REL-NEXT: ]
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(_gp_disp)
   addi   $t0,$t0,%lo(_gp_disp)
   lw     $v0,%call16(_foo)($gp)

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: ld.lld -o %t.exe %t.o
 # RUN: llvm-objdump -d -t %t.exe | FileCheck %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:  3c 08 00 03  lui   $8, 3
 # CHECK-NEXT:    20004:  21 08 7f f0  addi  $8, $8, 32752
 
 # CHECK: 00037ff0  .got  00000000 .hidden _gp
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(__gnu_local_gp)
   addi   $t0,$t0,%lo(__gnu_local_gp)

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)
 
 # EXE:      Disassembly of section .text:
+# EXE-EMPTY:
 # EXE-NEXT: __start:
 # EXE-NEXT:  20000:   3c 08 00 02   lui    $8, 2
 #                                              ^-- %hi(0x47ff0-0x20000)
 # EXE-NEXT:  20004:   21 08 80 00   addi   $8, $8, -32768
 #                                                  ^-- %lo(0x38000-0x20004+4)
 # EXE:      bar:
 # EXE-NEXT:  2000c:   3c 08 00 01   lui    $8, 1
 #                                              ^-- %hi(0x38000-0x2000c)
 # EXE-NEXT:  20010:   21 08 7f f4   addi   $8, $8, 32756
 #                                                  ^-- %lo(0x38000-0x20010+4)
 
 # EXE: SYMBOL TABLE:
 # EXE: 0002000c     .text   00000000 bar
 # EXE: 00038000     .got    00000000 .hidden _gp
 # EXE: 00020000     .text   00000000 __start
 
 # SO:      Disassembly of section .text:
+# SO-EMPTY:
 # SO-NEXT: __start:
 # SO-NEXT:  10000:   3c 08 00 02   lui    $8, 2
 #                                             ^-- %hi(0x28000-0x10000)
 # SO-NEXT:  10004:   21 08 80 00   addi   $8, $8, -32768
 #                                                 ^-- %lo(0x28000-0x10004+4)
 # SO:       bar:
 # SO-NEXT:   1000c:   3c 08 00 01   lui    $8, 1
 #                                              ^-- %hi(0x28000-0x1000c)
 # SO-NEXT:   10010:   21 08 7f f4   addi   $8, $8, 32756
 #                                                  ^-- %lo(0x28000-0x10010+4)
 
 # SO: SYMBOL TABLE:
 # SO: 0001000c     .text   00000000 bar
 # SO: 00028000     .got    00000000 .hidden _gp
 # SO: 00010000     .text   00000000 __start

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:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:  20000:   3c 08 00 03   lui    $8, 3
 #                                                ^-- %hi(__start) w/o addend
 # CHECK-NEXT   20004:   21 08 00 08   addi   $8, $8, 8
 #                                                    ^-- %lo(_label)
 
 # CHECK: SYMBOL TABLE:
 # CHECK: 00020008    .text   00000000 _label
 # CHECK: 00020000    .text   00000000 __start

test/ELF/mips-hilo.s

l1:
 
   .globl g1
   .type  g1,@object
   .size  g1,4
 g1:
   .word 0
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:  20000:   3c 08 00 02   lui    $8, 2
 #                                                ^-- %hi(__start+4)
 # CHECK-NEXT:  20004:   3c 09 00 03   lui    $9, 3
 #                                                ^-- %hi(g1+8)
 # CHECK-NEXT:  20008:   21 08 00 04   addi   $8, $8, 4
 #                                                    ^-- %lo(__start+4)
 # CHECK-NEXT:  2000c:   21 08 00 0c   addi   $8, $8, 12

test/ELF/mips-micro-jal.s

 # RUN:         %S/Inputs/mips-fpic.s -o %t-reg.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mattr=micromips %s -o %t2eb.o
 # RUN: ld.lld --no-threads -o %teb.exe %t-reg.o %t2eb.o %teb.so
 # RUN: llvm-objdump -d -mattr=micromips %teb.exe \
 # RUN:   | FileCheck --check-prefix=MIXED %s
 
 # EB:      Disassembly of section .plt:
+# EB-EMPTY:
 # EB-NEXT: .plt:
 # EB-NEXT:    20010:       79 80 3f fd     addiupc $3, 65524
 # EB-NEXT:    20014:       ff 23 00 00     lw      $25, 0($3)
 # EB-NEXT:    20018:       05 35           subu16  $2, $2, $3
 # EB-NEXT:    2001a:       25 25           srl16   $2, $2, 2
 # EB-NEXT:    2001c:       33 02 ff fe     addiu   $24, $2, -2
 # EB-NEXT:    20020:       0d ff           move    $15, $ra
 # EB-NEXT:    20022:       45 f9           jalrs16 $25
 # EB-NEXT:    20024:       0f 83           move    $gp, $3
 # EB-NEXT:    20026:       0c 00           nop
 # EB-NEXT:                 ...
 # EB-NEXT:    20030:       79 00 3f f7     addiupc $2, 65500
 # EB-NEXT:    20034:       ff 22 00 00     lw      $25, 0($2)
 # EB-NEXT:    20038:       45 99           jr16    $25
 # EB-NEXT:    2003a:       0f 02           move    $24, $2
 
 # EL:      Disassembly of section .plt:
+# EL-EMPTY:
 # EL-NEXT: .plt:
 # EL-NEXT:    20010:       80 79 fd 3f     addiupc $3, 65524
 # EL-NEXT:    20014:       23 ff 00 00     lw      $25, 0($3)
 # EL-NEXT:    20018:       35 05           subu16  $2, $2, $3
 # EL-NEXT:    2001a:       25 25           srl16   $2, $2, 2
 # EL-NEXT:    2001c:       02 33 fe ff     addiu   $24, $2, -2
 # EL-NEXT:    20020:       ff 0d           move    $15, $ra
 # EL-NEXT:    20022:       f9 45           jalrs16 $25
 # EL-NEXT:    20024:       83 0f           move    $gp, $3
 # EL-NEXT:    20026:       00 0c           nop
 # EL-NEXT:                 ...
 # EL-NEXT:    20030:       00 79 f7 3f     addiupc $2, 65500
 # EL-NEXT:    20034:       22 ff 00 00     lw      $25, 0($2)
 # EL-NEXT:    20038:       99 45           jr16    $25
 # EL-NEXT:    2003a:       02 0f           move    $24, $2
 
 # EBR6:      Disassembly of section .plt:
+# EBR6-EMPTY:
 # EBR6-NEXT: .plt:
 # EBR6-NEXT:    20010:       78 60 3f fd     lapc    $3, 65524
 # EBR6-NEXT:    20014:       ff 23 00 00     lw      $25, 0($3)
 # EBR6-NEXT:    20018:       05 35           subu16  $2, $2, $3
 # EBR6-NEXT:    2001a:       25 25           srl16   $2, $2, 2
 # EBR6-NEXT:    2001c:       33 02 ff fe     addiu   $24, $2, -2
 # EBR6-NEXT:    20020:       0d ff           move16  $15, $ra
 # EBR6-NEXT:    20022:       0f 83           move16  $gp, $3
 # EBR6-NEXT:    20024:       47 2b           jalr    $25
 
 # EBR6:         20030:       78 40 3f f7     lapc    $2, 65500
 # EBR6-NEXT:    20034:       ff 22 00 00     lw      $25, 0($2)
 # EBR6-NEXT:    20038:       0f 02           move16  $24, $2
 # EBR6-NEXT:    2003a:       47 23           jrc16   $25
 
 # ELR6:      Disassembly of section .plt:
+# ELR6-EMPTY:
 # ELR6-NEXT: .plt:
 # ELR6-NEXT:    20010:       60 78 fd 3f     lapc    $3, 65524
 # ELR6-NEXT:    20014:       23 ff 00 00     lw      $25, 0($3)
 # ELR6-NEXT:    20018:       35 05           subu16  $2, $2, $3
 # ELR6-NEXT:    2001a:       25 25           srl16   $2, $2, 2
 # ELR6-NEXT:    2001c:       02 33 fe ff     addiu   $24, $2, -2
 # ELR6-NEXT:    20020:       ff 0d           move16  $15, $ra
 # ELR6-NEXT:    20022:       83 0f           move16  $gp, $3
 # ELR6-NEXT:    20024:       2b 47           jalr    $25
 
 # ELR6:         20030:       40 78 f7 3f     lapc    $2, 65500
 # ELR6-NEXT:    20034:       22 ff 00 00     lw      $25, 0($2)
 # ELR6-NEXT:    20038:       02 0f           move16  $24, $2
 # ELR6-NEXT:    2003a:       23 47           jrc16   $25
 
 # MIXED:      Disassembly of section .plt:
+# MIXED-EMPTY:
 # MIXED-NEXT: .plt:
 # MIXED-NEXT:    20020:       79 80 3f f9     addiupc $3, 65508
 # MIXED-NEXT:    20024:       ff 23 00 00     lw      $25, 0($3)
 # MIXED-NEXT:    20028:       05 35           subu16  $2, $2, $3
 # MIXED-NEXT:    2002a:       25 25           srl16   $2, $2, 2
 # MIXED-NEXT:    2002c:       33 02 ff fe     addiu   $24, $2, -2
 # MIXED-NEXT:    20030:       0d ff           move    $15, $ra
 # MIXED-NEXT:    20032:       45 f9           jalrs16 $25

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:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:  3c 1c 00 01  lui     $gp, 1
 #                                                  ^-- 0x20000 - 0x37ff0
 #                                                  ^-- 0 - 0xfffe8010
 #                                                  ^-- %hi(0x17ff0)
 # CHECK:      loc:
 # CHECK-NEXT:    20004:  67 9c 7f f0  daddiu  $gp, $gp, 32752
 #                                                       ^-- 0x20000 - 0x37ff0

test/ELF/mips-npic-call-pic-os.s

 # REQUIRES: mips
 # Check LA25 stubs creation with caller in different Output Section to callee.
 # This stub code is necessary when non-PIC code calls PIC function.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fpic.s -o %t-fpic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fnpic.s -o %t-fnpic.o
 # RUN: ld.lld -r %t-fpic.o %t-fnpic.o -o %t-sto-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: ld.lld %t-npic.o %t-pic.o %t-sto-pic.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __LA25Thunk_foo1a:
 # CHECK-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # CHECK-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # CHECK-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
 
 # CHECK: __LA25Thunk_foo1b:
 # CHECK-NEXT:    20010:       3c 19 00 02     lui     $25, 2

 # CHECK-NEXT:    2004c:       27 39 00 60     addiu   $25, $25, 96
 # CHECK-NEXT:    20050:       00 00 00 00     nop
 
 # CHECK: fpic:
 # CHECK-NEXT:    20060:       00 00 00 00     nop
 
 # CHECK: fnpic:
 # CHECK-NEXT:    20070:       00 00 00 00     nop
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section differentos:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20074:       0c 00 80 00     jal     131072 <__LA25Thunk_foo1a>
 # CHECK-NEXT:    20078:       00 00 00 00     nop
 # CHECK-NEXT:    2007c:       0c 00 80 0a     jal     131112 <__LA25Thunk_foo2>
 # CHECK-NEXT:    20080:       00 00 00 00     nop
 # CHECK-NEXT:    20084:       0c 00 80 04     jal     131088 <__LA25Thunk_foo1b>
 # CHECK-NEXT:    20088:       00 00 00 00     nop
 # CHECK-NEXT:    2008c:       0c 00 80 0a     jal     131112 <__LA25Thunk_foo2>
 # CHECK-NEXT:    20090:       00 00 00 00     nop
 # CHECK-NEXT:    20094:       0c 00 80 11     jal     131140 <__LA25Thunk_fpic>
 # CHECK-NEXT:    20098:       00 00 00 00     nop
 # CHECK-NEXT:    2009c:       0c 00 80 1c     jal     131184 <fnpic>
 # CHECK-NEXT:    200a0:       00 00 00 00     nop
 
 # Make sure the thunks are created properly no matter how
 # objects are laid out.
 #
 # RUN: ld.lld %t-pic.o %t-npic.o %t-sto-pic.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=REVERSE %s
 
 # REVERSE: Disassembly of section .text:
+# REVERSE-EMPTY:
 # REVERSE-NEXT: __LA25Thunk_foo1a:
 # REVERSE-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # REVERSE-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # REVERSE-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # REVERSE-NEXT:    2000c:       00 00 00 00     nop
 
 # REVERSE: __LA25Thunk_foo1b:
 # REVERSE-NEXT:    20010:       3c 19 00 02     lui     $25, 2

 
 # REVERSE: fpic:
 # REVERSE-NEXT:    20060:       00 00 00 00     nop
 
 # REVERSE: fnpic:
 # REVERSE-NEXT:    20070:       00 00 00 00     nop
 
 # REVERSE: Disassembly of section differentos:
+# REVERSE-EMPTY:
 # REVERSE-NEXT: __start:
 # REVERSE-NEXT:    20074:       0c 00 80 00     jal     131072 <__LA25Thunk_foo1a>
 # REVERSE-NEXT:    20078:       00 00 00 00     nop
 # REVERSE-NEXT:    2007c:       0c 00 80 0a     jal     131112 <__LA25Thunk_foo2>
 # REVERSE-NEXT:    20080:       00 00 00 00     nop
 # REVERSE-NEXT:    20084:       0c 00 80 04     jal     131088 <__LA25Thunk_foo1b>
 # REVERSE-NEXT:    20088:       00 00 00 00     nop
 # REVERSE-NEXT:    2008c:       0c 00 80 0a     jal     131112 <__LA25Thunk_foo2>

test/ELF/mips-npic-call-pic-script.s

 # REQUIRES: mips
 # Check LA25 stubs creation. This stub code is necessary when
 # non-PIC code calls PIC function.
 # RUN: echo "SECTIONS { .out 0x20000 : { *(.text.*) . = . + 0x100 ;  *(.text) }  }" > %t1.script
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fpic.s -o %t-fpic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-fnpic.s -o %t-fnpic.o
 # RUN: ld.lld -r %t-fpic.o %t-fnpic.o -o %t-sto-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: ld.lld --script %t1.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s
 
 # CHECK: Disassembly of section .out:
+# CHECK-EMPTY:
 # CHECK-NEXT: __LA25Thunk_foo1a:
 # CHECK-NEXT:    20000:       3c 19 00 02     lui     $25, 2
 # CHECK-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
 # CHECK-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
 
 # CHECK: __LA25Thunk_foo1b:
 # CHECK-NEXT:    20010:       3c 19 00 02     lui     $25, 2

 
 # Test script with orphans added to existing OutputSection, the .text.1 and
 # .text.2 sections will be added to .text
 # RUN: echo "SECTIONS { .text 0x20000 : { *(.text) }  }" > %t2.script
 # RUN: ld.lld --script %t2.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t2.exe
 # RUN: llvm-objdump -d %t2.exe | FileCheck -check-prefix=ORPH1 %s
 
 # ORPH1: Disassembly of section .text:
+# ORPH1-EMPTY:
 # ORPH1-NEXT: __start:
 # ORPH1-NEXT:    20000:       0c 00 80 15     jal     131156 <__LA25Thunk_foo1a>
 # ORPH1-NEXT:    20004:       00 00 00 00     nop
 # ORPH1-NEXT:    20008:       0c 00 80 22     jal     131208 <__LA25Thunk_foo2>
 # ORPH1-NEXT:    2000c:       00 00 00 00     nop
 # ORPH1-NEXT:    20010:       0c 00 80 19     jal     131172 <__LA25Thunk_foo1b>
 # ORPH1-NEXT:    20014:       00 00 00 00     nop
 # ORPH1-NEXT:    20018:       0c 00 80 22     jal     131208 <__LA25Thunk_foo2>

 
 # Test script with orphans added to new OutputSection, the .text.1 and
 # .text.2 sections will form a new OutputSection .text
 # RUN: echo "SECTIONS { .out 0x20000 : { *(.text) }  }" > %t3.script
 # RUN: ld.lld --script %t3.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t3.exe
 # RUN: llvm-objdump -d %t3.exe | FileCheck -check-prefix=ORPH2 %s
 
 # ORPH2: Disassembly of section .out:
+# ORPH2-EMPTY:
 # ORPH2-NEXT: __start:
 # ORPH2-NEXT:    20000:       0c 00 80 18     jal     131168 <__LA25Thunk_foo1a>
 # ORPH2-NEXT:    20004:       00 00 00 00     nop
 # ORPH2-NEXT:    20008:       0c 00 80 22     jal     131208 <__LA25Thunk_foo2>
 # ORPH2-NEXT:    2000c:       00 00 00 00     nop
 # ORPH2-NEXT:    20010:       0c 00 80 1c     jal     131184 <__LA25Thunk_foo1b>
 # ORPH2-NEXT:    20014:       00 00 00 00     nop
 # ORPH2-NEXT:    20018:       0c 00 80 22     jal     131208 <__LA25Thunk_foo2>

 # ORPH2-NEXT:    20038:       27 39 00 40     addiu   $25, $25, 64
 # ORPH2-NEXT:    2003c:       00 00 00 00     nop
 
 # ORPH2: fpic:
 # ORPH2-NEXT:    20040:       00 00 00 00     nop
 
 # ORPH2: fnpic:
 # ORPH2-NEXT:    20050:       00 00 00 00     nop
+# ORPH2-EMPTY:
 # ORPH2-NEXT: Disassembly of section .text:
+# ORPH2-EMPTY:
 
 # ORPH2-NEXT: __LA25Thunk_foo1a:
 # ORPH2-NEXT:    20060:       3c 19 00 02     lui     $25, 2
 # ORPH2-NEXT:    20064:       08 00 80 20     j       131200 <foo1a>
 # ORPH2-NEXT:    20068:       27 39 00 80     addiu   $25, $25, 128
 # ORPH2-NEXT:    2006c:       00 00 00 00     nop
 
 # ORPH2: __LA25Thunk_foo1b:

test/ELF/mips-npic-call-pic.s

 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux -mcpu=mips32r6 \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic-r6.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux -mcpu=mips32r6 \
 # RUN:   %s -o %t-npic-r6.o
 # RUN: ld.lld %t-npic-r6.o %t-pic-r6.o %t-sto-pic-r6.o -o %t-r6.exe
 # RUN: llvm-objdump -d %t-r6.exe | FileCheck --check-prefixes=CHECK,R6 %s
 
 # CHECK:     Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:       0c 00 80 0c     jal     131120 <__LA25Thunk_foo1a>
 # CHECK-NEXT:    20004:       00 00 00 00     nop
 # CHECK-NEXT:    20008:       0c 00 80 16     jal     131160 <__LA25Thunk_foo2>
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
 # CHECK-NEXT:    20010:       0c 00 80 10     jal     131136 <__LA25Thunk_foo1b>
 # CHECK-NEXT:    20014:       00 00 00 00     nop
 # CHECK-NEXT:    20018:       0c 00 80 16     jal     131160 <__LA25Thunk_foo2>

 #
 # RUN: ld.lld %t-pic-r2.o %t-npic-r2.o %t-sto-pic-r2.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefixes=REVERSE,REV-R2 %s
 #
 # RUN: ld.lld %t-pic-r6.o %t-npic-r6.o %t-sto-pic-r6.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefixes=REVERSE,REV-R6 %s
 
 # REVERSE: Disassembly of section .text:
+# REVERSE-EMPTY:
 # REVERSE-NEXT: __LA25Thunk_foo1a:
 # REV-R2:          20000:       3c 19 00 02     lui     $25, 2
 # REV-R6:          20000:       3c 19 00 02     aui     $25, $zero, 2
 # REVERSE:         20004:       08 00 80 08     j       131104 <foo1a>
 # REVERSE-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
 # REVERSE-NEXT:    2000c:       00 00 00 00     nop
 
 # REVERSE: __LA25Thunk_foo1b:

test/ELF/mips-pc-relocs.s

__start:
   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:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:       ec c8 00 08     lwpc    $6, 32
 #                                      ^-- (0x20020-0x20000)>>2
 # CHECK-NEXT:    20004:       20 a6 00 06     beqc    $5, $6, 28
 #                                      ^-- (0x20020-4-0x20004)>>2
 # CHECK-NEXT:    20008:       d9 20 00 05     beqzc   $9, 24
 #                                      ^-- (0x20020-4-0x20008)>>2
 # CHECK-NEXT:    2000c:       c8 00 00 04     bc      20

test/ELF/mips-plt-n32.s

 # REQUIRES: mips
 
 # Check PLT entries generation in case of using N32 ABI.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
 # RUN:         -target-abi n32 %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
 # RUN:         -target-abi n32 %S/Inputs/mips-dynamic.s -o %t2.o
 # RUN: ld.lld %t2.o -shared -o %t.so
 # RUN: ld.lld %t1.o %t.so -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefixes=DEFAULT,CHECK
 # RUN: ld.lld %t2.o -shared -o %t.so -z hazardplt
 # RUN: ld.lld %t1.o %t.so -o %t.exe -z hazardplt
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefixes=HAZARDPLT,CHECK
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:   20000:       0c 00 80 0c     jal     131120
 #                                                    ^-- 0x20030 gotplt[foo0]
 # CHECK-NEXT:   20004:       00 00 00 00     nop
 #
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .plt:
 # CHECK-NEXT:   20010:       3c 0e 00 03     lui     $14, 3
 # CHECK-NEXT:   20014:       8d d9 00 04     lw      $25, 4($14)
 # CHECK-NEXT:   20018:       25 ce 00 04     addiu   $14, $14, 4
 # CHECK-NEXT:   2001c:       03 0e c0 23     subu    $24, $24, $14
 # CHECK-NEXT:   20020:       03 e0 78 25     move    $15, $ra
 # CHECK-NEXT:   20024:       00 18 c0 82     srl     $24, $24, 2
 # DEFAULT:      20028:       03 20 f8 09     jalr    $25

test/ELF/mips-plt-r6.s

 # REQUIRES: mips
 # Check PLT entries generation in case of R6 ABI version.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mcpu=mips32r6 %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         -mcpu=mips32r6 %S/Inputs/mips-dynamic.s -o %t2.o
 # RUN: ld.lld %t2.o -shared -o %t.so
 # RUN: ld.lld %t1.o %t.so -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefixes=DEFAULT,CHECK
 # RUN: ld.lld %t2.o -shared -o %t.so -z hazardplt
 # RUN: ld.lld %t1.o %t.so -o %t.exe -z hazardplt
 # RUN: llvm-objdump -d %t.exe | FileCheck %s --check-prefixes=HAZARDPLT,CHECK
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:   20000:       0c 00 80 0c     jal     131120
 #                                                    ^-- 0x20030 gotplt[foo0]
 # CHECK-NEXT:   20004:       00 00 00 00     nop
 #
+# CHECK-EMPTY:
 # CHECK-NEXT: Disassembly of section .plt:
+# CHECK-EMPTY:
 # CHECK-NEXT: .plt:
 # CHECK-NEXT:   20010:       3c 1c 00 03     aui     $gp, $zero, 3
 # CHECK-NEXT:   20014:       8f 99 00 04     lw      $25, 4($gp)
 # CHECK-NEXT:   20018:       27 9c 00 04     addiu   $gp, $gp, 4
 # CHECK-NEXT:   2001c:       03 1c c0 23     subu    $24, $24, $gp
 # CHECK-NEXT:   20020:       03 e0 78 25     move    $15, $ra
 # CHECK-NEXT:   20024:       00 18 c0 82     srl     $24, $24, 2
 # DEFAULT:      20028:       03 20 f8 09     jalr    $25

test/ELF/mips-xgot-order.s

 # REQUIRES: mips
 # Check that GOT entries accessed via 16-bit indexing are allocated
 # in the beginning of the GOT.
 
 # 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 -s -t %t.exe | FileCheck %s
 
 # CHECK:      Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    20004:       8c 42 80 24     lw      $2, -32732($2)
 # CHECK-NEXT:    20008:       3c 02 00 00     lui     $2, 0
 # CHECK-NEXT:    2000c:       8c 42 80 28     lw      $2, -32728($2)
 #
 # CHECK:      bar:
 # CHECK-NEXT:    20010:       8c 42 80 20     lw      $2, -32736($2)

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 %t2.o %t1.o
 ; RUN: llvm-objdump -s -d %t.exe | FileCheck %s
 
 ;; Check handling of basic msp430 relocation types.
 
   .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
 

test/ELF/no-inhibit-exec.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o %t2
 # RUN: ld.lld %t --noinhibit-exec -o %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s
 # RUN: llvm-readobj -r %t2 | FileCheck %s --check-prefix=RELOC
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: _start
 # CHECK-NEXT: 201000: {{.*}} callq -2101253
 
 # RELOC:      Relocations [
 # RELOC-NEXT: ]
 
 # next code will not link without noinhibit-exec flag
 # because of undefined symbol _bar
 .globl _start
 _start:
   call _bar

test/ELF/non-abs-reloc.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t 2>&1 | FileCheck %s
 // CHECK: (.nonalloc+0x1): has non-ABS relocation R_X86_64_PC32 against symbol '_start'
 // CHECK: (.nonalloc+0x6): has non-ABS relocation R_X86_64_PC32 against symbol '_start'
 
 // RUN: llvm-objdump -D %t | FileCheck --check-prefix=DISASM %s
 // DISASM:      Disassembly of section .nonalloc:
+// DISASM-EMPTY:
 // DISASM-NEXT: .nonalloc:
 // DISASM-NEXT: 0: {{.*}}  callq {{.*}} <_start>
 // DISASM-NEXT: 5: {{.*}}  callq {{.*}} <_start>
 
 .globl _start
 _start:
   nop
 
 .section .nonalloc
   .byte 0xe8
   .long _start - . - 4
   .byte 0xe8
   .long _start - . - 4

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:      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

test/ELF/plt-aarch64.s

 // DISASMDSO-NEXT:     10004: 0f 00 00 14   b #60
 // 0x10050 - 0x10008 = 0x48 = 72
 // DISASMDSO-NEXT:     10008: 12 00 00 14   b #72
 
 // DISASMDSO: foo:
 // DISASMDSO-NEXT:     1000c: 1f 20 03 d5   nop
 
 // DISASMDSO: Disassembly of section .plt:
+// DISASMDSO-EMPTY:
 // DISASMDSO-NEXT: .plt:
 // DISASMDSO-NEXT:     10010: f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x3000 + 2 * 8 = 0x3010
 // Page(0x30010) - Page(0x10014) = 0x30000 - 0x10000 = 0x20000 = 131072
 // DISASMDSO-NEXT:     10014: 10 01 00 90   adrp  x16, #131072
 // 0x3010 & 0xFFF = 0x10 = 16
 // DISASMDSO-NEXT:     10018: 11 0a 40 f9 ldr x17, [x16, #16]
 // DISASMDSO-NEXT:     1001c: 10 42 00 91   add x16, x16, #16

 // DISASMEXE-NEXT:    210004: 0b 00 00 14   b #44
 // 0x210040 - 0x210008 = 0x38 = 56
 // DISASMEXE-NEXT:    210008: 0e 00 00 14   b #56
 
 // DISASMEXE: foo:
 // DISASMEXE-NEXT:    21000c: 1f 20 03 d5   nop
 
 // DISASMEXE: Disassembly of section .plt:
+// DISASMEXE-EMPTY:
 // DISASMEXE-NEXT: .plt:
 // DISASMEXE-NEXT:    210010: f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x2200B0 + 2 * 8 = 0x2200C0
 // Page(0x230010) - Page(0x210014) = 0x230000 - 0x210000 = 0x20000 = 131072
 // DISASMEXE-NEXT:    210014: 10 01 00 90   adrp  x16, #131072
 // 0x120c0 & 0xFFF = 0xC0 = 192
 // DISASMEXE-NEXT:    210018: 11 0a 40 f9   ldr x17, [x16, #16]
 // DISASMEXE-NEXT:    21001c: 10 42 00 91   add x16, x16, #16

test/ELF/plt-i686.s

 
 // 0x401010 - 0x40102b - 5 = -32
 // 0x401010 - 0x40103b - 5 = -48
 // 4206596 = 0x403004 = .got.plt (0x403000) + 4
 // 4206600 = 0x403008 = .got.plt (0x403000) + 8
 // 4206604 = 0x40300C = .got.plt (0x403000) + got.plt.reserved(12)
 // 4206608 = 0x403010 = .got.plt (0x403000) + got.plt.reserved(12) + 4
 // DISASM:      Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:    401020: ff 35 04 30 40 00 pushl 4206596
 // DISASM-NEXT:    401026: ff 25 08 30 40 00 jmpl *4206600
 // DISASM-NEXT:    40102c: 90 nop
 // DISASM-NEXT:    40102d: 90 nop
 // DISASM-NEXT:    40102e: 90 nop
 // DISASM-NEXT:    40102f: 90 nop
 // DISASM-EMPTY:

 // DISASMSHARED-NEXT:  1000: {{.*}}
 // DISASMSHARED-NEXT:  1002: {{.*}}
 // DISASMSHARED:       _start:
 // 0x1013 + 5 - 24 = 0x1000
 // DISASMSHARED-NEXT:  1004: e9 27 00 00 00 jmp 39
 // DISASMSHARED-NEXT:  1009: e9 22 00 00 00 jmp 34
 // DISASMSHARED-NEXT:  100e: e9 2d 00 00 00 jmp 45
 // DISASMSHARED-NEXT:  1013: e9 e8 ff ff ff jmp -24
+// DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT:  Disassembly of section .plt:
+// DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT:  .plt:
 // DISASMSHARED-NEXT:  1020: ff b3 04 00 00 00 pushl 4(%ebx)
 // DISASMSHARED-NEXT:  1026: ff a3 08 00 00 00 jmpl *8(%ebx)
 // DISASMSHARED-NEXT:  102c: 90 nop
 // DISASMSHARED-NEXT:  102d: 90 nop
 // DISASMSHARED-NEXT:  102e: 90 nop
 // DISASMSHARED-NEXT:  102f: 90 nop
 // DISASMSHARED:       bar@plt:
 // DISASMSHARED-NEXT:  1030: ff a3 0c 00 00 00 jmpl *12(%ebx)
 // DISASMSHARED-NEXT:  1036: 68 00 00 00 00     pushl $0
 // DISASMSHARED-NEXT:  103b: e9 e0 ff ff ff     jmp -32 <.plt>
 // DISASMSHARED:       zed@plt:
 // DISASMSHARED-NEXT:  1040: ff a3 10 00 00 00 jmpl *16(%ebx)
 // DISASMSHARED-NEXT:  1046: 68 08 00 00 00     pushl $8
 // DISASMSHARED-NEXT:  104b: e9 d0 ff ff ff     jmp -48 <.plt>
 
 // DISASMPIE:      Disassembly of section .plt:
+// DISASMPIE-EMPTY:
 // DISASMPIE-NEXT: .plt:
 // DISASMPIE-NEXT:   1020:  ff b3 04 00 00 00 pushl 4(%ebx)
 // DISASMPIE-NEXT:   1026:  ff a3 08 00 00 00 jmpl *8(%ebx)
 // DISASMPIE-NEXT:   102c:  90 nop
 // DISASMPIE-NEXT:   102d:  90 nop
 // DISASMPIE-NEXT:   102e:  90 nop
 // DISASMPIE-NEXT:   102f:  90 nop
 // DISASMPIE:        bar@plt:

test/ELF/plt.s

 // DISASM-NEXT:   100a:  e9 {{.*}}       jmp  49
 // DISASM-NEXT:   100f:  e9 {{.*}}       jmp  60
 
 // 0x3018 - 0x1036  = 8162
 // 0x3020 - 0x1046  = 8154
 // 0x3028 - 0x1056  = 8146
 
 // DISASM:      Disassembly of section .plt:
+// DISASM-EMPTY:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:   1020:  ff 35 e2 1f 00 00  pushq 8162(%rip)
 // DISASM-NEXT:   1026:  ff 25 e4 1f 00 00  jmpq *8164(%rip)
 // DISASM-NEXT:   102c:  0f 1f 40 00        nopl (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar@plt:
 // DISASM-NEXT:   1030:  ff 25 e2 1f 00 00  jmpq *8162(%rip)
 // DISASM-NEXT:   1036:  68 00 00 00 00     pushq $0

 // DISASM2-NEXT:   201005:  e9 {{.*}}     jmp  38
 // DISASM2-NEXT:   20100a:  e9 {{.*}}     jmp  49
 // DISASM2-NEXT:   20100f:  e9 {{.*}}     jmp  -20
 
 // 0x202018 - 0x201036  = 4066
 // 0x202020 - 0x201046  = 4058
 
 // DISASM2:      Disassembly of section .plt:
+// DISASM2-EMPTY:
 // DISASM2-NEXT: .plt:
 // DISASM2-NEXT:  201020:  ff 35 e2 1f 00 00   pushq 8162(%rip)
 // DISASM2-NEXT:  201026:  ff 25 e4 1f 00 00   jmpq *8164(%rip)
 // DISASM2-NEXT:  20102c:  0f 1f 40 00         nopl  (%rax)
 // DISASM2-EMPTY:
 // DISASM2-NEXT:   bar@plt:
 // DISASM2-NEXT:  201030:  ff 25 e2 1f 00 00   jmpq *8162(%rip)
 // DISASM2-NEXT:  201036:  68 00 00 00 00      pushq $0

test/ELF/ppc-relocs.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-freebsd %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 # RUN: llvm-objdump -s --no-show-raw-insn %t | FileCheck --check-prefix=HEX %s
 
 .section .R_PPC_ADDR16_HA,"ax",@progbits
 .globl _start
 _start:
   lis 4, msg@ha
 msg:
   .string "foo"
   len = . - msg
 
 # CHECK: Disassembly of section .R_PPC_ADDR16_HA:
+# CHECK-EMPTY:
 # CHECK: _start:
 # CHECK:    11000:       lis 4, 1
 # CHECK: msg:
 # CHECK:    11004:       oris 15, 19, 28416
 
 .section .R_PPC_ADDR16_HI,"ax",@progbits
 .globl _starti
 _starti:
   lis 4,msgi@h
 msgi:
   .string "foo"
   leni = . - msgi
 
 # CHECK: Disassembly of section .R_PPC_ADDR16_HI:
+# CHECK-EMPTY:
 # CHECK: _starti:
 # CHECK:    11008:       lis 4, 1
 # CHECK: msgi:
 # CHECK:    1100c:       oris 15, 19, 28416
 
 .section .R_PPC_ADDR16_LO,"ax",@progbits
   addi 4, 4, msg@l
 mystr:
   .asciz "blah"
   len = . - mystr
 
 # CHECK: Disassembly of section .R_PPC_ADDR16_LO:
+# CHECK-EMPTY:
 # CHECK: .R_PPC_ADDR16_LO:
 # CHECK:    11010:       addi 4, 4, 4100
 # CHECK: mystr:
 # CHECK:    11014:       ori 12, 19, 24936
 
 .align  2
 .section .R_PPC_REL24,"ax",@progbits
 .globl .FR_PPC_REL24
 .FR_PPC_REL24:
   b .Lfoox
 .section .R_PPC_REL24_2,"ax",@progbits
 .Lfoox:
 
 # CHECK: Disassembly of section .R_PPC_REL24:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC_REL24:
 # CHECK:    1101c:       b .+4
 
 .section .R_PPC_REL14,"ax",@progbits
 .globl .FR_PPC_REL14
 .FR_PPC_REL14:
   beq .Lfooy
 .section .R_PPC_REL14_2,"ax",@progbits
 .Lfooy:
 
 # CHECK: Disassembly of section .R_PPC_REL14:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC_REL14:
 # CHECK:    11020:       bt 2, .+4
 
 .section .R_PPC_REL32,"ax",@progbits
 .globl .FR_PPC_REL32
 .FR_PPC_REL32:
   .long .Lfoox3 - .
 .section .R_PPC_REL32_2,"ax",@progbits

 .section .R_PPC_PLTREL24,"ax",@progbits
 .globl .R_PPC_PLTREL24
 .FR_PPC_PLTREL24:
   b .Lfoox4@PLT
 .section .R_PPC_PLTREL24_2,"ax",@progbits
 .Lfoox4:
 
 # CHECK: Disassembly of section .R_PPC_PLTREL24:
+# CHECK-EMPTY:
 # CHECK: .R_PPC_PLTREL24:
 # CHECK:    1102c:       b .+4

test/ELF/ppc64-got-indirect.s

 # CHECK: _start:
 # CHECK-NEXT: 10010000:  {{.*}}   addis 2, 12, 2
 # CHECK-NEXT: 10010004:  {{.*}}   addi 2, 2, -32768
 # CHECK-NEXT: 10010008:  {{.*}}   nop
 # CHECK-NEXT: 1001000c:  {{.*}}   ld 3, -32760(2)
 # CHECK: 1001001c:  {{.*}}   lwa 3, 0(3)
 
 # CHECK-LE: Disassembly of section .got:
+# CHECK-LE-EMPTY:
 # CHECK-LE-NEXT: .got:
 # CHECK-LE-NEXT: 10020000:       00 80 02 10
 # CHECK-LE-NEXT: 10020004:       00 00 00 00
 
 # Verify that .toc comes right after .got
 # CHECK-LE: Disassembly of section .toc:
+# CHECK-LE-EMPTY:
 # CHECK-LE: 10020008:       00 00 03 10
 
 # CHECK-LE: Disassembly of section .data:
+# CHECK-LE-EMPTY:
 # CHECK-LE-NEXT: glob:
 # CHECK-LE-NEXT: 10030000:       37 00 00 00
 
 # CHECK-BE: Disassembly of section .got:
+# CHECK-BE-EMPTY:
 # CHECK-BE-NEXT: .got:
 # CHECK-BE-NEXT: 10020000:       00 00 00 00
 # CHECK-BE-NEXT: 10020004:       10 02 80 00
 
 # Verify that .toc comes right after .got
 # CHECK-BE: Disassembly of section .toc:
+# CHECK-BE-EMPTY:
 # CHECK-BE: 10020008:       00 00 00 00
 # CHECK-BE: 1002000c:       10 03 00 00
 
 # CHECK-BE: Disassembly of section .data:
+# CHECK-BE-EMPTY:
 # CHECK-BE-NEXT: glob:
 # CHECK-BE-NEXT: 10030000:       00 00 00 37

test/ELF/ppc64-plt-stub.s

 // REQUIRES: ppc
 
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/shared-ppc64.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld %t.o %t2.so -o %t
 // RUN: llvm-objdump -d %t | FileCheck %s
 
 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/shared-ppc64.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld %t.o %t2.so -o %t
 // RUN: llvm-objdump -d %t | FileCheck %s
 
 // CHECK:      Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: __plt_foo:
 // CHECK-NEXT:      std 2, 24(1)
 // CHECK-NEXT:      addis 12, 2, 0
 // CHECK-NEXT:      ld 12, 32560(12)
 // CHECK-NEXT:      mtctr 12
 // CHECK-NEXT:      bctr
 
 

test/ELF/ppc64-rel-calls.s

 # REQUIRES: ppc
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 
 .text
 .global _start
 _start:
 .Lfoo:
   li      0,1
   li      3,42
   sc

test/ELF/ppc64-relocs.s

.LC0:
         .tc .LJTI0_0[TC],.LJTI0_0
 
 .section .R_PPC64_TOC16_LO_DS,"ax",@progbits
 .globl .FR_PPC64_TOC16_LO_DS
 .FR_PPC64_TOC16_LO_DS:
   ld 1, .L1@toc@l(2)
 
 # CHECK: Disassembly of section .R_PPC64_TOC16_LO_DS:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_TOC16_LO_DS:
 # CHECK: 1001000c:       ld 1, -32768(2)
 
 .section .R_PPC64_TOC16_LO,"ax",@progbits
 .globl .FR_PPC64_TOC16_LO
 .FR_PPC64_TOC16_LO:
   addi  1, 2, .L1@toc@l
 
 # CHECK: Disassembly of section .R_PPC64_TOC16_LO:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_TOC16_LO:
 # CHECK: 10010010:       addi 1, 2, -32768
 
 .section .R_PPC64_TOC16_HI,"ax",@progbits
 .globl .FR_PPC64_TOC16_HI
 .FR_PPC64_TOC16_HI:
   addis 1, 2, .L1@toc@h
 
 # CHECK: Disassembly of section .R_PPC64_TOC16_HI:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_TOC16_HI:
 # CHECK: 10010014:       addis 1, 2, -1
 
 .section .R_PPC64_TOC16_HA,"ax",@progbits
 .globl .FR_PPC64_TOC16_HA
 .FR_PPC64_TOC16_HA:
   addis 1, 2, .L1@toc@ha
 
 # CHECK: Disassembly of section .R_PPC64_TOC16_HA:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_TOC16_HA:
 # CHECK: 10010018:       nop
 
 .section .R_PPC64_REL24,"ax",@progbits
 .globl .FR_PPC64_REL24
 .FR_PPC64_REL24:
   b .Lfoox
 .section .R_PPC64_REL24_2,"ax",@progbits
 .Lfoox:
 
 # CHECK: Disassembly of section .R_PPC64_REL24:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_REL24:
 # CHECK: 1001001c:       b .+4
 
 .section .R_PPC64_REL14,"ax",@progbits
 .globl .FR_PPC64_REL14
 .FR_PPC64_REL14:
   beq .Lfooy
 .section .R_PPC64_REL14_2,"ax",@progbits
 .Lfooy:
 
 # CHECK: Disassembly of section .R_PPC64_REL14:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_REL14:
 # CHECK: 10010020:       bt 2, .+4
 
 .section .R_PPC64_ADDR16_LO,"ax",@progbits
 .globl .FR_PPC64_ADDR16_LO
 .FR_PPC64_ADDR16_LO:
   li 1, .Lfoo@l
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_LO:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_LO:
 # CHECK: 10010024:       li 1, 0
 
 .section .R_PPC64_ADDR16_HI,"ax",@progbits
 .globl .FR_PPC64_ADDR16_HI
 .FR_PPC64_ADDR16_HI:
   li 1, .Lfoo@h
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_HI:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_HI:
 # CHECK: 10010028:       li 1, 4097
 
 .section .R_PPC64_ADDR16_HA,"ax",@progbits
 .globl .FR_PPC64_ADDR16_HA
 .FR_PPC64_ADDR16_HA:
   li 1, .Lfoo@ha
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_HA:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_HA:
 # CHECK: 1001002c:       li 1, 4097
 
 .section .R_PPC64_ADDR16_HIGHER,"ax",@progbits
 .globl .FR_PPC64_ADDR16_HIGHER
 .FR_PPC64_ADDR16_HIGHER:
   li 1, .Lfoo@higher
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_HIGHER:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_HIGHER:
 # CHECK: 10010030:       li 1, 0
 
 .section .R_PPC64_ADDR16_HIGHERA,"ax",@progbits
 .globl .FR_PPC64_ADDR16_HIGHERA
 .FR_PPC64_ADDR16_HIGHERA:
   li 1, .Lfoo@highera
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_HIGHERA:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_HIGHERA:
 # CHECK: 10010034:       li 1, 0
 
 .section .R_PPC64_ADDR16_HIGHEST,"ax",@progbits
 .globl .FR_PPC64_ADDR16_HIGHEST
 .FR_PPC64_ADDR16_HIGHEST:
   li 1, .Lfoo@highest
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_HIGHEST:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_HIGHEST:
 # CHECK: 10010038:       li 1, 0
 
 .section .R_PPC64_ADDR16_HIGHESTA,"ax",@progbits
 .globl .FR_PPC64_ADDR16_HIGHESTA
 .FR_PPC64_ADDR16_HIGHESTA:
   li 1, .Lfoo@highesta
 
 # CHECK: Disassembly of section .R_PPC64_ADDR16_HIGHESTA:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_ADDR16_HIGHESTA:
 # CHECK: 1001003c:       li 1, 0
 
 .section  .R_PPC64_REL32, "ax",@progbits
 .globl .FR_PPC64_REL32
 .FR_PPC64_REL32:
   addis 5, 2, .LC0@toc@ha
   ld 5, .LC0@toc@l(5)
 .LBB0_2:
   add 3, 3, 4
 
 # DATALE: '.rodata':
 # DATALE: 0x100001c8 80fe0000
 
 # DATABE: '.rodata':
 # DATABE: 0x100001c8 0000fe80
 
 # Address of rodata + value stored at rodata entry
 # should equal address of LBB0_2.
 # 0x10000190 + 0xfeb4 = 0x10010044
 # CHECK: Disassembly of section .R_PPC64_REL32:
+# CHECK-EMPTY:
 # CHECK: .FR_PPC64_REL32:
 # CHECK: 10010040:       nop
 # CHECK: 10010044:       ld 5, -32736(2)
 # CHECK: 10010048:       add 3, 3, 4
 
 .section .R_PPC64_REL64, "ax",@progbits
 .globl  .FR_PPC64_REL64
 .FR_PPC64_REL64:

test/ELF/ppc64-toc-restore.s

 .global _start
 _start:
   bl foo
   nop
   bl bar_local
 
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK: _start:
 // CHECK:     1001001c:       bl .-28
 // CHECK-NOT: 10010020:       nop
 // CHECK:     10010020:       ld 2, 24(1)
 // CHECK:     10010024:       bl .-16
 // CHECK-NOT: 10010028:       nop
 // CHECK-NOT: 10010028:       ld 2, 24(1)
 

test/ELF/ppc64-weak-undef-call.s

 # REQUIRES: ppc
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-objdump -d --no-show-raw-insn %t2 | FileCheck %s
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-objdump -d --no-show-raw-insn %t2 | FileCheck %s
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 
 .text
 .global _start
 _start:
   bl weakfunc
   nop
   blr
 

test/ELF/pr34660.s

 # REQUIRES: aarch64
 
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-none %s -o %t.o
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t
 # RUN: llvm-objdump %t -d | FileCheck %s --check-prefix=DISASM
 # RUN: llvm-readelf %t --symbols | FileCheck %s --check-prefix=SYM
 
 # It would be much easier to understand/read this test if llvm-objdump would print
 # the immediates in hex.
 # IMM = hex(65540) = 0x10004
 # PC = 0x10000
 # As the relocation is PC-relative, IMM + PC = 0x20004 which is the VA of the
 # correct symbol.
 
 # DISASM: Disassembly of section .text:
+# DISASM-EMPTY:
 # DISASM-NEXT: $x.0:
 # DISASM-NEXT:   10000:       28 00 10 58     ldr     x8, #131076
 
 # SYM: Symbol table '.symtab'
 # SYM:  0000000000030004     0 NOTYPE  LOCAL  DEFAULT    6 patatino
 
   ldr x8, patatino
   .data
   .zero 4
 patatino:

test/ELF/pre_init_fini_array_missing.s

_start:
   call __fini_array_end
 
 // With no .init_array section the symbols resolve to .text.
 // 0x201000 - (0x201000 + 5) = -5
 // 0x201000 - (0x201005 + 5) = -10
 // ...
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT:  _start:
 // CHECK-NEXT:   201000:    e8 fb ff ff ff     callq    -5
 // CHECK-NEXT:   201005:    e8 f6 ff ff ff     callq    -10
 // CHECK-NEXT:   20100a:    e8 f1 ff ff ff     callq    -15
 // CHECK-NEXT:   20100f:    e8 ec ff ff ff     callq    -20
 // CHECK-NEXT:   201014:    e8 e7 ff ff ff     callq    -25
 // CHECK-NEXT:   201019:    e8 e2 ff ff ff     callq    -30
 
 // In position-independent binaries, they resolve to .text too.
 
 // PIE:      Disassembly of section .text:
+// PIE-EMPTY:
 // PIE-NEXT: _start:
 // PIE-NEXT:     1000:  e8 fb ff ff ff  callq   -5
 // PIE-NEXT:     1005:  e8 f6 ff ff ff  callq   -10
 // PIE-NEXT:     100a:  e8 f1 ff ff ff  callq   -15
 // PIE-NEXT:     100f:  e8 ec ff ff ff  callq   -20
 // PIE-NEXT:     1014:  e8 e7 ff ff ff  callq   -25
 // PIE-NEXT:     1019:  e8 e2 ff ff ff  callq   -30

test/ELF/relocatable-symbols.s

 # DISASM-NEXT:  14: {{.*}} callq 0
 # DISASM-NEXT:  19: {{.*}} callq 0
 # DISASM-NEXT:  1e: {{.*}} callq 0
 # DISASM-NEXT:  23: {{.*}} callq 0
 # DISASM-NEXT:  28: {{.*}} callq 0
 # DISASM-NEXT:  2d: {{.*}} callq 0
 # DISASM-NEXT:  32: {{.*}} callq 0
 # DISASM-NEXT:  37: {{.*}} callq 0
+# DISASM-EMPTY:
 # DISASM-NEXT: Disassembly of section foo:
+# DISASM-EMPTY:
 # DISASM-NEXT: foo:
 # DISASM-NEXT:  0: 90 nop
 # DISASM-NEXT:  1: 90 nop
 # DISASM-NEXT:  2: 90 nop
+# DISASM-EMPTY:
 # DISASM-NEXT: Disassembly of section bar:
+# DISASM-EMPTY:
 # DISASM-NEXT: bar:
 # DISASM-NEXT:  0: 90 nop
 # DISASM-NEXT:  1: 90 nop
 # DISASM-NEXT:  2: 90 nop
 
 # RELOC:      Relocations [
 # RELOC-NEXT:   Section ({{.*}}) .rela.text {
 # RELOC-NEXT:     0x1 R_X86_64_PC32 __start_foo 0xFFFFFFFFFFFFFFFC

test/ELF/relocatable.s

 # SECTION:   2 .rela.text    00000090 0000000000000000
 # SECTION:   3 .bss          00000018 0000000000000000 BSS
 # SECTION:   4 .note.GNU-stack 00000000 0000000000000000
 # SECTION:   5 .symtab       00000168 0000000000000000
 # SECTION:   6 .shstrtab     00000041 0000000000000000
 # SECTION:   7 .strtab       0000002d 0000000000000000
 
 # CHECKTEXT:      Disassembly of section .text:
+# CHECKTEXT-EMPTY:
 # CHECKTEXT-NEXT: main:
 # CHECKTEXT-NEXT: 0: c7 04 25 00 00 00 00 05 00 00 00 movl $5, 0
 # CHECKTEXT-NEXT: b: c7 04 25 00 00 00 00 07 00 00 00 movl $7, 0
 # CHECKTEXT:      foo:
 # CHECKTEXT-NEXT: 20: c7 04 25 00 00 00 00 01 00 00 00 movl $1, 0
 # CHECKTEXT-NEXT: 2b: c7 04 25 00 00 00 00 02 00 00 00 movl $2, 0
 # CHECKTEXT:      bar:
 # CHECKTEXT-NEXT: 40: c7 04 25 00 00 00 00 08 00 00 00 movl $8, 0

test/ELF/relocation-b-aarch64.test

 # REQUIRES: aarch64
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: ld.lld %t.o -o %t.out
 # RUN: llvm-objdump -d -triple=aarch64-none-linux %t.out | FileCheck %s
 
 # Check that the R_AARCH64_JUMP26 writes the branch opcode as well as the
 # immediate. We use this property to overwrite instructions with a branch.
 
 # CHECK: Disassembly of section .text:
+# CHECK-EMPTY:
 # CHECK-NEXT: foo:
 # CHECK-NEXT:    210000:        01 00 00 14     b       #4
 # CHECK: bar:
 # CHECK-NEXT:    210004:        ff ff ff 17     b       #-4
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64

test/ELF/relocation-copy-i686.s

 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // 4206592 =  0x403000
 // 16 is alignment here
 // 4206608 =  0x403000 + 16
 // 4206612 =  0x403000 + 16 + 4
 // CODE: Disassembly of section .text:
+// CODE-EMPTY:
 // CODE-NEXT: main:
 // CODE-NEXT: 401000: c7 05 00 30 40 00 05 00 00 00 movl $5, 4206592
 // CODE-NEXT: 40100a: c7 05 10 30 40 00 07 00 00 00 movl $7, 4206608
 // CODE-NEXT: 401014: c7 05 14 30 40 00 09 00 00 00 movl $9, 4206612

test/ELF/relocation-copy.s

 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // 2109440 = 0x203000
 // 16 is alignment here
 // 2109456 = 0x203000 + 16
 // 2109460 = 0x203000 + 16 + 4
 // CODE: Disassembly of section .text:
+// CODE-EMPTY:
 // CODE-NEXT: _start:
 // CODE-NEXT: 201000: {{.*}} movl $5, 2109440
 // CODE-NEXT: 20100b: {{.*}} movl $7, 2109456
 // CODE-NEXT: 201016: {{.*}} movl $9, 2109460
 // CODE-NEXT: 201021: {{.*}} movl $2109440, %edx
 // CODE-NEXT: 201026: {{.*}} movl $2109456, %edx
 // CODE-NEXT: 20102b: {{.*}} movl $2109460, %edx

test/ELF/relocation-i686.s

R_386_PC32:
   call R_386_PC32_2
 
 .section       .R_386_PC32,"ax",@progbits,unique,2
 .zero 4
 R_386_PC32_2:
   nop
 
 // CHECK: Disassembly of section .R_386_32:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_386_32:
 // CHECK-NEXT:  401000: {{.*}} movl $4198401, %edx
 
 // CHECK: Disassembly of section .R_386_PC32:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_386_PC32:
 // CHECK-NEXT:   401005:  e8 04 00 00 00  calll 4
 
 // CHECK:      R_386_PC32_2:
 // CHECK-NEXT:   40100e:  90  nop
 
 // Create a .got
 movl bar@GOT, %eax

 
 .section .R_386_GOTPC,"ax",@progbits
 R_386_GOTPC:
  movl $_GLOBAL_OFFSET_TABLE_, %eax
 
 // 0x403000 (.got.plt) - 0x401014 = 8300
 
 // CHECK:      Disassembly of section .R_386_GOTPC:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_386_GOTPC:
 // CHECK-NEXT:   401014:  {{.*}} movl  $8172, %eax
 
 .section .dynamic_reloc, "ax",@progbits
  call bar
 // addr(.plt) + 16 - (0x401019 + 5) = 50
 // CHECK:      Disassembly of section .dynamic_reloc:
+// CHECK-EMPTY:
 // CHECK-NEXT: .dynamic_reloc:
 // CHECK-NEXT:   401019:  e8 32 00 00 00 calll 50
 
 .section .R_386_GOT32,"ax",@progbits
 .global R_386_GOT32
 R_386_GOT32:
  movl bar@GOT, %eax
  movl zed@GOT, %eax
  movl bar+8@GOT, %eax
  movl zed+4@GOT, %eax
 
 // 4294963320 = 0xfffff078 = got[0](0x402078) - .got.plt(0x403000)
 // 4294963324 = 0xfffff07c = got[1](0x40207c) - .got(0x403000)
 // CHECK:      Disassembly of section .R_386_GOT32:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_386_GOT32:
 // CHECK-NEXT: 40101e: a1 78 f0 ff ff movl 4294963320, %eax
 // CHECK-NEXT: 401023: a1 7c f0 ff ff movl 4294963324, %eax
 // CHECK-NEXT: 401028: a1 80 f0 ff ff movl 4294963328, %eax
 // CHECK-NEXT: 40102d: a1 80 f0 ff ff movl 4294963328, %eax

test/ELF/relocation-local.s

 
 .section       .text2,"ax",@progbits
 R_X86_64_32:
   movl $R_X86_64_32, %edx
 
 // FIXME: this would be far more self evident if llvm-objdump printed
 // constants in hex.
 // CHECK: Disassembly of section .text2:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_32:
 // CHECK-NEXT:  201009: {{.*}} movl $2101257, %edx
 
 .section .R_X86_64_32S,"ax",@progbits
 R_X86_64_32S:
   movq lulz - 0x100000, %rdx
 
 // CHECK: Disassembly of section .R_X86_64_32S:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_32S:
 // CHECK-NEXT:  {{.*}}: {{.*}} movq 1052681, %rdx
 
 .section .R_X86_64_64,"a",@progbits
 R_X86_64_64:
  .quad R_X86_64_64
 
 // CHECK:      Contents of section .R_X86_64_64:
 // CHECK-NEXT:   200120 20012000 00000000

test/ELF/relocation-size-shared.s

 // RELOCSHARED-NEXT:    0x201028 R_X86_64_SIZE64 fooshared 0x1
 // RELOCSHARED-NEXT:    0x201048 R_X86_64_SIZE32 fooshared 0xFFFFFFFFFFFFFFFF
 // RELOCSHARED-NEXT:    0x20104F R_X86_64_SIZE32 fooshared 0x0
 // RELOCSHARED-NEXT:    0x201056 R_X86_64_SIZE32 fooshared 0x1
 // RELOCSHARED-NEXT:  }
 // RELOCSHARED-NEXT:]
 
 // DISASM:      Disassembly of section test
+// DISASM-EMPTY:
 // DISASM:      _data:
 // DISASM-NEXT: 201000: 19 00
 // DISASM-NEXT: 201002: 00 00
 // DISASM-NEXT: 201004: 00 00
 // DISASM-NEXT: 201006: 00 00
 // DISASM-NEXT: 201008: 1a 00
 // DISASM-NEXT: 20100a: 00 00
 // DISASM-NEXT: 20100c: 00 00

test/ELF/relocation-size.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=NORELOC %s
 // RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
 // RUN: ld.lld -shared %t.o -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=RELOCSHARED %s
 // RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASMSHARED %s
 
 // NORELOC:      Relocations [
 // NORELOC-NEXT: ]
 
 // DISASM:      Disassembly of section test:
+// DISASM-EMPTY:
 // DISASM-NEXT: _data:
 // DISASM-NEXT: 201000: 19 00
 // DISASM-NEXT: 201002: 00 00
 // DISASM-NEXT: 201004: 00 00
 // DISASM-NEXT: 201006: 00 00
 // DISASM-NEXT: 201008: 1a 00
 // DISASM-NEXT: 20100a: 00 00
 // DISASM-NEXT: 20100c: 00 00

 // RELOCSHARED-NEXT:    0x1010 R_X86_64_SIZE64 foo 0x1
 // RELOCSHARED-NEXT:    0x1033 R_X86_64_SIZE32 foo 0xFFFFFFFFFFFFFFFF
 // RELOCSHARED-NEXT:    0x103A R_X86_64_SIZE32 foo 0x0
 // RELOCSHARED-NEXT:    0x1041 R_X86_64_SIZE32 foo 0x1
 // RELOCSHARED-NEXT:  }
 // RELOCSHARED-NEXT: ]
 
 // DISASMSHARED:      Disassembly of section test:
+// DISASMSHARED-EMPTY:
 // DISASMSHARED-NEXT: _data:
 // DISASMSHARED-NEXT: ...
 // DISASMSHARED-NEXT: 1018: 19 00
 // DISASMSHARED-NEXT: 101a: 00 00
 // DISASMSHARED-NEXT: 101c: 00 00
 // DISASMSHARED-NEXT: 101e: 00 00
 // DISASMSHARED-NEXT: 1020: 1a 00
 // DISASMSHARED-NEXT: 1022: 00 00

test/ELF/relocation.s

 
 .section       .text,"ax",@progbits,unique,2
 .zero 4
 .global lulz
 lulz:
   nop
 
 // CHECK: Disassembly of section .text:
+// CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:   201000:  e8 04 00 00 00   callq 4
 // CHECK-NEXT:   201005:
 
 // CHECK:      lulz:
 // CHECK-NEXT:   201009:  90  nop
 
 
 .section       .text2,"ax",@progbits
 .global R_X86_64_32
 R_X86_64_32:
   movl $R_X86_64_32, %edx
 
 // FIXME: this would be far more self evident if llvm-objdump printed
 // constants in hex.
 // CHECK: Disassembly of section .text2:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_32:
 // CHECK-NEXT:  20100a: {{.*}} movl $2101258, %edx
 
 .section .R_X86_64_32S,"ax",@progbits
 .global R_X86_64_32S
 R_X86_64_32S:
   movq lulz - 0x100000, %rdx
 
 // CHECK: Disassembly of section .R_X86_64_32S:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_32S:
 // CHECK-NEXT:  {{.*}}: {{.*}} movq 1052681, %rdx
 
 .section .R_X86_64_PC32,"ax",@progbits
 .global R_X86_64_PC32
 R_X86_64_PC32:
  call bar
  movl $bar, %eax
 //16 is a size of PLT[0]
 // 0x201030 + 16 - (0x201017 + 5) = 20
 // CHECK:      Disassembly of section .R_X86_64_PC32:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_PC32:
 // CHECK-NEXT:  201017:   {{.*}}  callq  36
 // CHECK-NEXT:  20101c:   {{.*}}  movl $2101312, %eax
 
 .section .R_X86_64_32S_2,"ax",@progbits
 .global R_X86_64_32S_2
 R_X86_64_32S_2:
   mov bar2, %eax
 // plt is  at 0x201030. The second plt entry is at 0x201050 == 69712
 // CHECK:      Disassembly of section .R_X86_64_32S_2:
+// CHECK-EMPTY:
 // CHECK-NEXT: R_X86_64_32S_2:
 // CHECK-NEXT: 201021: {{.*}}  movl    2101328, %eax
 
 .section .R_X86_64_64,"a",@progbits
 .global R_X86_64_64
 R_X86_64_64:
  .quad R_X86_64_64
 

test/ELF/startstop-gccollect.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t2.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t2.so
 # RUN: ld.lld %t --gc-sections -o %tout %t2.so
 # RUN: llvm-objdump -d %tout | FileCheck -check-prefix=DISASM %s
 
 # DISASM:      _start:
 # DISASM-NEXT: 201000:        e8 05 00 00 00  callq   5 <__start_foo>
 # DISASM-NEXT: 201005:        e8 02 00 00 00  callq   2 <__stop_bar>
+# DISASM-EMPTY:
 # DISASM-NEXT: Disassembly of section foo:
+# DISASM-EMPTY:
 # DISASM-NEXT: __start_foo:
 # DISASM-NEXT: 20100a:        90      nop
+# DISASM-EMPTY:
 # DISASM-NEXT: Disassembly of section bar:
+# DISASM-EMPTY:
 # DISASM-NEXT: bar:
 # DISASM-NEXT: 20100b:        90      nop
 
 .global _start
 .text
 _start:
  callq __start_foo
  callq __stop_bar
 
 .section foo,"ax"
  nop
 
 .section bar,"ax"
  nop

test/ELF/startstop.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: ld.lld --hash-style=sysv %t -o %tout -shared
 // RUN: llvm-objdump -d %tout | FileCheck -check-prefix=DISASM %s
 // RUN: llvm-readobj --symbols -r %tout | FileCheck -check-prefix=SYMBOL %s
 
 // DISASM: _start:
 // DISASM:    1000:       {{.*}}  callq   10
 // DISASM:    1005:       {{.*}}  callq   8
 // DISASM:    100a:       {{.*}}  callq   3
 // DISASM: Disassembly of section foo:
+// DISASM-EMPTY:
 // DISASM: __start_foo:
 // DISASM:    100f:       90      nop
 // DISASM:    1010:       90      nop
 // DISASM:    1011:       90      nop
 // DISASM: Disassembly of section bar:
+// DISASM-EMPTY:
 // DISASM: __start_bar:
 // DISASM:    1012:       90      nop
 // DISASM:    1013:       90      nop
 // DISASM:    1014:       90      nop
 
 // SYMBOL:      Relocations [
 // SYMBOL-NEXT:   Section ({{.*}}) .rela.dyn {
 // SYMBOL-NEXT:     R_X86_64_RELATIVE

test/ELF/tls-dynamic-i686.s

 // CHECK-NEXT: 0x2074 R_386_TLS_DTPOFF32 tls0 0x0
 // CHECK-NEXT: 0x2088 R_386_TLS_TPOFF tls0 0x0
 // CHECK-NEXT: 0x2078 R_386_TLS_DTPMOD32 tls1 0x0
 // CHECK-NEXT: 0x207C R_386_TLS_DTPOFF32 tls1 0x0
 // CHECK-NEXT: 0x208C R_386_TLS_TPOFF tls1 0x0
 // CHECK-NEXT: }
 
 // DIS:      Disassembly of section .text:
+// DIS-EMPTY:
 // DIS-NEXT: _start:
 // General dynamic model:
 // -32 and -24 are first and second GOT entries offsets.
 // Each one is a pair of records.
 // DIS-NEXT: 1000: {{.*}} leal -32(,%ebx), %eax
 // DIS-NEXT: 1007: {{.*}} calll 100
 // DIS-NEXT: 100c: {{.*}} leal -24(,%ebx), %eax
 // DIS-NEXT: 1013: {{.*}} calll 88

test/ELF/tls-dynamic.s

 // CHECK-NEXT:   }
 
 // 4313 = (0x20E0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
 // 4301 = (0x20F0 + -4) - (0x100c + 3) // PC relative offset to got entry.
 // 4283 = (0x20F8 + -4) - (0x102e + 3) // PC relative offset to got entry.
 // 4279 = (0x2100 + -4) - (0x1042 + 3) // PC relative offset to got entry.
 
 // DIS:      Disassembly of section .text:
+// DIS-EMPTY:
 // DIS-NEXT: .text:
 // DIS-NEXT:     1000: {{.+}} leaq    4313(%rip), %rdi
 // DIS-NEXT:     1007: {{.+}} callq
 // DIS-NEXT:     100c: {{.+}} leaq    4301(%rip), %rdi
 // DIS-NEXT:     1013: {{.+}} callq
 // DIS-NEXT:     1018: {{.+}} leaq    (%rax), %rcx
 // DIS-NEXT:     101f: {{.+}} leaq    4(%rax), %rcx
 // DIS-NEXT:     1026: 04 00

test/ELF/tls-got.s

 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rela.dyn {
 // CHECK-NEXT:     0x2020C8 R_X86_64_TPOFF64 tls0 0x0
 // CHECK-NEXT:     [[ADDR]] R_X86_64_TPOFF64 tls1 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
-//0x201000 + 4281 + 7 = 0x2020C0
-//0x20100A + 4279 + 7 = 0x2020C8
-//0x201014 + 4269 + 7 = 0x2020C8
-//DISASM:      Disassembly of section .text:
-//DISASM-NEXT: main:
-//DISASM-NEXT: 201000: {{.*}} movq 4281(%rip), %rax
-//DISASM-NEXT: 201007: {{.*}} movl %fs:(%rax), %eax
-//DISASM-NEXT: 20100a: {{.*}} movq 4279(%rip), %rax
-//DISASM-NEXT: 201011: {{.*}} movl %fs:(%rax), %eax
-//DISASM-NEXT: 201014: {{.*}} movq 4269(%rip), %rax
-//DISASM-NEXT: 20101b: {{.*}} movl %fs:(%rax), %eax
-//DISASM-NEXT: 20101e: {{.*}} retq
+// 0x201000 + 4281 + 7 = 0x2020C0
+// 0x20100A + 4279 + 7 = 0x2020C8
+// 0x201014 + 4269 + 7 = 0x2020C8
+// DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
+// DISASM-NEXT: main:
+// DISASM-NEXT: 201000: {{.*}} movq 4281(%rip), %rax
+// DISASM-NEXT: 201007: {{.*}} movl %fs:(%rax), %eax
+// DISASM-NEXT: 20100a: {{.*}} movq 4279(%rip), %rax
+// DISASM-NEXT: 201011: {{.*}} movl %fs:(%rax), %eax
+// DISASM-NEXT: 201014: {{.*}} movq 4269(%rip), %rax
+// DISASM-NEXT: 20101b: {{.*}} movl %fs:(%rax), %eax
+// DISASM-NEXT: 20101e: {{.*}} retq
 
 .section .tdata,"awT",@progbits
 
 .text
  .globl main
  .align 16, 0x90
  .type main,@function
 main:
  movq tls1@GOTTPOFF(%rip), %rax
  movl %fs:0(%rax), %eax
  movq tls0@GOTTPOFF(%rip), %rax
  movl %fs:0(%rax), %eax
  movq tls0@GOTTPOFF(%rip), %rax
  movl %fs:0(%rax), %eax
  ret

test/ELF/tls-i686.s

  subl %edx, %eax
 
  movl %gs:0, %ecx
  leal var@ntpoff(%ecx), %eax
  movl %gs:0, %ecx
  leal var1@ntpoff+123(%ecx), %eax
 
 // DIS:      Disassembly of section test:
+// DIS-EMPTY:
 // DIS-NEXT: _start:
 // DIS-NEXT: 401000: ba 08 00 00 00       movl $8, %edx
 // DIS-NEXT: 401005: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
 // DIS-NEXT: 40100c: 29 d0                subl %edx, %eax
 // DIS-NEXT: 40100e: ba 04 00 00 00       movl $4, %edx
 // DIS-NEXT: 401013: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
 // DIS-NEXT: 40101a: 29 d0                subl %edx, %eax
 // DIS-NEXT: 40101c: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
 // DIS-NEXT: 401023: 8d 81 f8 ff ff ff    leal -8(%ecx), %eax
 // DIS-NEXT: 401029: 65 8b 0d 00 00 00 00 movl %gs:0, %ecx
 // DIS-NEXT: 401030: 8d 81 77 00 00 00    leal 119(%ecx), %eax
 
 // RELOC: Relocations [
 // RELOC-NEXT: ]
 
 // DISSHARED: Disassembly of section test:
+// DISSHARED-EMPTY:
 // DISSHARED-NEXT: _start:
 // DISSHARED-NEXT: 1000: ba 00 00 00 00 movl   $0, %edx
 // DISSHARED-NEXT: 1005: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx
 // DISSHARED-NEXT: 100c: 29 d0 subl            %edx, %eax
 // DISSHARED-NEXT: 100e: ba 00 00 00 00        movl $0, %edx
 // DISSHARED-NEXT: 1013: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx
 // DISSHARED-NEXT: 101a: 29 d0 subl            %edx, %eax
 // DISSHARED-NEXT: 101c: 65 8b 0d 00 00 00 00  movl %gs:0, %ecx

test/ELF/tls-initial-exec-local.s

 // CHECK-NEXT:     0x20A0 R_X86_64_TPOFF64 - 0x0
 // CHECK-NEXT:     0x20A8 R_X86_64_TPOFF64 - 0x4
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // 0x1007 + 4249 = 0x20A0
 // 0x100e + 4250 = 0x20A8
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: .text:
 // DISASM-NEXT:  1000: {{.*}} addq 4249(%rip), %rax
 // DISASM-NEXT:  1007: {{.*}} addq 4250(%rip), %rax
 
         addq    foo@GOTTPOFF(%rip), %rax
         addq    bar@GOTTPOFF(%rip), %rax
 
         .section        .tbss,"awT",@nobits
 foo:
         .long 0
 bar:
         .long 0

test/ELF/tls-opt-gdie.s

 //RELOC-NEXT:     0x2020B0 R_X86_64_TPOFF64 tlsshared0 0x0
 //RELOC-NEXT:     0x2020B8 R_X86_64_TPOFF64 tlsshared1 0x0
 //RELOC-NEXT:   }
 //RELOC-NEXT: ]
 
 //0x201009 + (4256 + 7) = 0x2020B0
 //0x201019 + (4248 + 7) = 0x2020B8
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT: 201000: {{.*}} movq %fs:0, %rax
 // DISASM-NEXT: 201009: {{.*}} addq 4256(%rip), %rax
 // DISASM-NEXT: 201010: {{.*}} movq %fs:0, %rax
 // DISASM-NEXT: 201019: {{.*}} addq 4248(%rip), %rax
 
 .section .text
 .globl _start

test/ELF/tls-opt-gdiele-i686.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %p/Inputs/tls-opt-gdiele-i686.s -o %tso.o
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld -shared %tso.o -o %tso
 // RUN: ld.lld --hash-style=sysv %t.o %tso -o %tout
 // RUN: llvm-readobj -r %tout | FileCheck --check-prefix=NORELOC %s
 // RUN: llvm-objdump -d %tout | FileCheck --check-prefix=DISASM %s
 
 // NORELOC:      Relocations [
 // NORELOC-NEXT: Section ({{.*}}) .rel.dyn {
 // NORELOC-NEXT:   0x402058 R_386_TLS_TPOFF tlsshared0 0x0
 // NORELOC-NEXT:   0x40205C R_386_TLS_TPOFF tlsshared1 0x0
 // NORELOC-NEXT:   }
 // NORELOC-NEXT: ]
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT: 401000: 65 a1 00 00 00 00 movl %gs:0, %eax
 // DISASM-NEXT: 401006: 03 83 58 f0 ff ff addl -4008(%ebx), %eax
 // DISASM-NEXT: 40100c: 65 a1 00 00 00 00 movl %gs:0, %eax
 // DISASM-NEXT: 401012: 03 83 5c f0 ff ff addl -4004(%ebx), %eax
 // DISASM-NEXT: 401018: 65 a1 00 00 00 00 movl %gs:0, %eax
 // DISASM-NEXT: 40101e: 81 e8 08 00 00 00 subl $8, %eax
 // DISASM-NEXT: 401024: 65 a1 00 00 00 00 movl %gs:0, %eax

test/ELF/tls-opt-i686.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=NORELOC %s
 // RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
 
 // NORELOC:      Relocations [
 // NORELOC-NEXT: ]
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // LD -> LE:
 // DISASM-NEXT: 401000: 65 a1 00 00 00 00 movl %gs:0, %eax
 // DISASM-NEXT: 401006: 90                nop
 // DISASM-NEXT: 401007: 8d 74 26 00       leal (%esi,%eiz), %esi
 // DISASM-NEXT: 40100b: 8d 90 f8 ff ff ff leal -8(%eax), %edx
 // DISASM-NEXT: 401011: 65 a1 00 00 00 00 movl %gs:0, %eax
 // DISASM-NEXT: 401017: 90                nop

test/ELF/tls-opt-iele-i686-nopic.s

 // GOTREL:      Relocations [
 // GOTREL-NEXT: Section ({{.*}}) .rel.dyn {
 // GOTREL-NEXT:   0x402060 R_386_TLS_TPOFF tlsshared0 0x0
 // GOTREL-NEXT:   0x402064 R_386_TLS_TPOFF tlsshared1 0x0
 // GOTREL-NEXT:  }
 // GOTREL-NEXT: ]
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // 4294967288 = 0xFFFFFFF8
 // 4294967292 = 0xFFFFFFFC
 // 4202592 = (.got)[0] = 0x402060
 // 4202596 = (.got)[1] = 0x402064
 // DISASM-NEXT: 401000: {{.*}} movl $4294967288, %ecx
 // DISASM-NEXT: 401006: {{.*}} movl %gs:(%ecx), %eax
 // DISASM-NEXT: 401009: {{.*}} movl $4294967288, %eax

test/ELF/tls-opt-local.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t1
 // RUN: llvm-readobj -r %t1 | FileCheck --check-prefix=NORELOC %s
 // RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
 
 // NORELOC:      Relocations [
 // NORELOC-NEXT: ]
 
 // DISASM:      Disassembly of section .text:
+// DISASM-EMPTY:
 // DISASM-NEXT: _start:
 // DISASM-NEXT: 201000: 48 c7 c0 f8 ff ff ff movq $-8, %rax
 // DISASM-NEXT: 201007: 49 c7 c7 f8 ff ff ff movq $-8, %r15
 // DISASM-NEXT: 20100e: 48 8d 80 f8 ff ff ff leaq -8(%rax), %rax
 // DISASM-NEXT: 201015: 4d 8d bf f8 ff ff ff leaq -8(%r15), %r15
 // DISASM-NEXT: 20101c: 48 81 c4 f8 ff ff ff addq $-8, %rsp
 // DISASM-NEXT: 201023: 49 81 c4 f8 ff ff ff addq $-8, %r12
 // DISASM-NEXT: 20102a: 48 c7 c0 fc ff ff ff movq $-4, %rax

test/ELF/tls.s

 // CHECK-NEXT:     MemSize: 16
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       PF_R
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Alignment:
 // CHECK-NEXT:   }
 
 // DIS:      Disassembly of section .text:
+// DIS-EMPTY:
 // DIS-NEXT: _start:
 // DIS-NEXT:    201000: {{.+}} movl    %fs:-8, %eax
 // DIS-NEXT:    201008: {{.+}} movl    %fs:-16, %eax
 // DIS-NEXT:    201010: {{.+}} movl    %fs:-4, %eax
 // DIS-NEXT:    201018: {{.+}} movl    %fs:-12, %eax

test/ELF/x86-64-retpoline-linkerscript.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 -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 10:       ff 35 32 01 00 00       pushq   306(%rip)
 // CHECK-NEXT: 16:       4c 8b 1d 33 01 00 00    movq    307(%rip), %r11
 // CHECK-NEXT: 1d:       e8 0e 00 00 00  callq   14 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
 // CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3

test/ELF/x86-64-retpoline-znow-linkerscript.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 -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt -z now --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 10:  e8 0b 00 00 00  callq 11 <.plt+0x10>
 // CHECK-NEXT: 15:  f3 90   pause
 // CHECK-NEXT: 17:  0f ae e8  lfence
 // CHECK-NEXT: 1a:  eb f9   jmp -7 <.plt+0x5>
 // CHECK-NEXT: 1c:  cc  int3
 // CHECK-NEXT: 1d:  cc  int3
 // CHECK-NEXT: 1e:  cc  int3

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 -o %t2.so
 
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt -z now
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 1010:  e8 0b 00 00 00  callq 11 <.plt+0x10>
 // CHECK-NEXT: 1015:  f3 90   pause
 // CHECK-NEXT: 1017:  0f ae e8  lfence
 // CHECK-NEXT: 101a:  eb f9   jmp -7 <.plt+0x5>
 // CHECK-NEXT: 101c:  cc  int3
 // CHECK-NEXT: 101d:  cc  int3
 // CHECK-NEXT: 101e:  cc  int3

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 -o %t2.so
 
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
+// CHECK-EMPTY:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 1010:       ff 35 f2 1f 00 00       pushq   8178(%rip)
 // CHECK-NEXT: 1016:       4c 8b 1d f3 1f 00 00    movq    8179(%rip), %r11
 // CHECK-NEXT: 101d:       e8 0e 00 00 00  callq   14 <.plt+0x20>
 // CHECK-NEXT: 1022:       f3 90   pause
 // CHECK-NEXT: 1024:       0f ae e8        lfence
 // CHECK-NEXT: 1027:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 1029:       cc      int3