[ELF] - Specify -section argument for objdump calls in testcases.

[grimar]

Summary

My motivation for doing that was to check if that can
speed up testcases execution time a little. For example running check-lld
under windows takes about 21 second for me.

Unfortunately this change had no effect on testcase execution time at all.
Though It still looks a reasonable cleanup for testcases output.

[davide]

I don't quite understand the rationale behind this patch. You tried something to speed up which didn't work, so maybe you want to try profiling llvm-objdump and see where the time is spent and try to optimize that instead of landing this patch? Also, did you profile the tests execution and actually found out objdump is the real bottleneck? Keep in mind running LLVM tests on Windows is notoriously slower than on *NIX.

[grimar]

In D28092#630613, @davide wrote:

I don't quite understand the rationale behind this patch. You tried something to speed up which didn't work, so maybe you want to try profiling llvm-objdump and see where the time is spent and try to optimize that instead of landing this patch? Also, did you profile the tests execution and actually found out objdump is the real bottleneck? Keep in mind running LLVM tests on Windows is notoriously slower than on *NIX.

I am mostly suggest this for consistency. We already use -section argument in many tests. That also has a positive effect when need to debug testcase for some reason. I mean reducing output of sections content is still usefull to have.

I did not try to profile the tests yet, just checked that idea as supposed that probably can change something.

[davide]

In D28092#630614, @grimar wrote:

In D28092#630613, @davide wrote:

I don't quite understand the rationale behind this patch. You tried something to speed up which didn't work, so maybe you want to try profiling llvm-objdump and see where the time is spent and try to optimize that instead of landing this patch? Also, did you profile the tests execution and actually found out objdump is the real bottleneck? Keep in mind running LLVM tests on Windows is notoriously slower than on *NIX.

I am mostly suggest this for consistency. We already use -section argument in many tests. That also has a positive effect when need to debug testcase for some reason. I mean reducing output of sections content is still usefull to have.

Why is reducing the output of objdump useful? If that would have an impact on performance, I'd agree with you, but you realized it hasn't, so, I don't understand what's the real motivation behind this change.
As a side note, this makes slightly more annoying updating tests. If you rename a section, you need to modify two places, and if you're adding a section which you need to dump, then you need to change the linker invocation. Not the end of the world, but why?

[ruiu]

I think I agree with Davide. This patch might not necessarily be a bad change, but to me it seems to be adding extraneous command line options to so many command invocations. As the tests work without these command line options, I wouldn't add that based on Occum's razor-ish principle. I want to keep it simple.

[grimar]

In D28092#631265, @davide wrote:

As a side note, this makes slightly more annoying updating tests. If you rename a section, you need to modify two places, and if you're adding a section which you need to dump, then you need to change the linker invocation. Not the end of the world, but why?

We probably usually do not rename or add sections when updating tests. That happens sometimes, but more often case is updating checked values when test fails, in that case reducing of printed data can be useful. It is IMO a bit more convinent to see data of single section on output to find the difference with test than have data from many sections both used and unused in checks. I was sure we used -section=xxx in other tests because of that reason (to keep output minimized to help debugging testcases a bit).
At least that was my motivation in other patches where I added -section=xxx intitially.

Now it is not clear for me why we have this parameter in other tests then. May be it worst to remove it then ?

Since you and Rui are not fond of this patch, I am abandoning this diff.

test/ELF/aarch64-data-relocs.s

 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-freebsd %S/Inputs/abs256.s -o %t256.o
 // RUN: ld.lld %t %t256.o -o %t2
-// RUN: llvm-objdump -s %t2 | FileCheck %s
+// RUN: llvm-objdump -s -section=.R_AARCH64_ABS64 -section=.R_AARCH64_PREL64 %t2 | FileCheck %s
 // REQUIRES: aarch64
 
 .globl _start
 _start:
 .section .R_AARCH64_ABS64, "ax",@progbits
   .xword foo + 0x24
 
 // S = 0x100, A = 0x24

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

 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %S/Inputs/shared2.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 // RUN: ld.lld %t.so %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
-// RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
+// RUN: llvm-objdump -s -section=.got.plt %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r -dynamic-table %tout | FileCheck %s
 // REQUIRES: aarch64
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rela.plt {
 // CHECK:     0x40018 R_AARCH64_JUMP_SLOT bar2 0x0
 // CHECK-NEXT:     0x40020 R_AARCH64_JUMP_SLOT zed2 0x0

test/ELF/amdgpu-relocs.s

 # RUN: llvm-mc -filetype=obj -triple=amdgcn--amdhsa -mcpu=fiji %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t.so
 # RUN: llvm-readobj -r %t.so | FileCheck %s
-# RUN: llvm-objdump -s %t.so | FileCheck %s --check-prefix=OBJDUMP
+# RUN: llvm-objdump -s --section=nonalloc %t.so | FileCheck %s --check-prefix=OBJDUMP
 
 # REQUIRES: amdgpu
 
 .text
 
 kernel0:
   s_mov_b32 s0, common_var0@GOTPCREL+4
   s_mov_b32 s0, common_var1@gotpcrel32@lo+4

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

 // RUN: llvm-mc -filetype=obj -triple=armv7a-linux-gnueabihf %S/Inputs/arm-shared.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=armv7a-linux-gnueabihf %s -o %t.o
 // RUN: ld.lld %t.so %t.o -o %tout
 // RUN: llvm-objdump -triple=armv7a-linux-gnueabihf -d %tout | FileCheck %s --check-prefix=DISASM
-// RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
+// RUN: llvm-objdump -s -section=.got -section=.got.plt %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r -dynamic-table %tout | FileCheck %s
 // REQUIRES: arm
 
 // Check that the IRELATIVE relocations are last in the .got
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rel.dyn {
 // CHECK-NEXT:     0x12078 R_ARM_GLOB_DAT bar2 0x0
 // CHECK-NEXT:     0x1207C R_ARM_GLOB_DAT zed2 0x0

test/ELF/arm-pie-relative.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: ld.lld %t --pie -o %t2
 // RUN: llvm-readobj -r %t2 | FileCheck %s
-// RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=GOT
+// RUN: llvm-objdump -s -section=.got %t2 | FileCheck %s --check-prefix=GOT
 // REQUIRES: arm
 
 // Test that a R_ARM_GOT_BREL relocation with PIE results in a R_ARM_RELATIVE
 // dynamic relocation
  .syntax unified
  .text
  .global _start
 _start:

test/ELF/arm-tls-norelax-gd-le.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-tls-get-addr.s -o %t1
 // RUN: ld.lld %t1 --shared -o %t1.so
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
 // RUN: ld.lld %t1.so %t.o -o %t
-// RUN: llvm-objdump -s %t | FileCheck %s
+// RUN: llvm-objdump -s -section=.got %t | FileCheck %s
 // REQUIRES: arm
 
 // This tls global-dynamic sequence is with respect to a non-preemptible
 // symbol in an application so a relaxation to Local Exec would normally be
 // possible. This would result in an assertion failure on ARM as the
 // relaxation functions can't be implemented on ARM. Check that the sequence
 // is handled as global dynamic
 

test/ELF/arm-tls-norelax-ld-le.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-tls-get-addr.s -o %t1
 // RUN: ld.lld %t1 --shared -o %t1.so
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
 // RUN: ld.lld %t1.so %t.o -o %t
-// RUN: llvm-objdump -s %t | FileCheck %s
+// RUN: llvm-objdump -s -section=.got %t | FileCheck %s
 // REQUIRES: arm
 
  .global __tls_get_addr
  .text
  .p2align  2
  .global _start
  .syntax unified
  .arm

test/ELF/comment-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/comment-gc.s -o %t2.o
 # RUN: ld.lld %t.o %t2.o -o %t1 --gc-sections -shared
-# RUN: llvm-objdump -s %t1 | FileCheck %s
+# RUN: llvm-objdump -s -section=.comment %t1 | FileCheck %s
 
 # CHECK:      Contents of section .comment:
 # CHECK-NEXT:  0000 00666f6f 00626172 004c4c44 20312e30 .foo.bar.LLD 1.0
 # CHECK-NEXT:  0010 00 .
 
 .ident "foo"
 
 .globl _start
 _start:
   nop

test/ELF/ctors_dtors_priority.s

 // 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/ctors_dtors_priority1.s -o %t-crtbegin.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/ctors_dtors_priority2.s -o %t2
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/ctors_dtors_priority3.s -o %t-crtend.o
 // RUN: ld.lld %t1 %t2 %t-crtend.o %t-crtbegin.o -o %t.exe
-// RUN: llvm-objdump -s %t.exe | FileCheck %s
+// RUN: llvm-objdump -s -section=.ctors -section=.dtors %t.exe | FileCheck %s
 // REQUIRES: x86
 
 .globl _start
 _start:
   nop
 
 .section .ctors, "aw", @progbits
   .byte 1

test/ELF/debug-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 -s %t1 | FileCheck %s
+# RUN: llvm-objdump -s -section=.debug_str -section=.foo -section=.debug_info %t1 | FileCheck %s
 
 # CHECK:      Contents of section .debug_str:
 # CHECK-NEXT:  0000 41414100 42424200 43434300           AAA.BBB.CCC.
 # CHECK:      Contents of section .foo:
 # CHECK-NEXT:  0000 2a000000
 # CHECK:      Contents of section .debug_info:
 # CHECK-NEXT:  0000 00000000 04000000
 

test/ELF/eh-frame-hdr-icf.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2 --icf=all --eh-frame-hdr
-# RUN: llvm-objdump -s %t2 | FileCheck %s
+# RUN: llvm-objdump -s -section=.eh_frame_hdr %t2 | FileCheck %s
 
 # CHECK: Contents of section .eh_frame_hdr:
 # CHECK-NEXT: 200158 011b033b 1c000000 01000000 a80e0000
 #                                      ^ FDE count
 # CHECK-NEXT: 200168 38000000 00000000 00000000
 #                    ^ FDE for f2
 
 .globl _start, f1, f2

test/ELF/init_fini_priority.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: ld.lld %t -o %t.exe
-// RUN: llvm-objdump -s %t.exe | FileCheck %s
+// RUN: llvm-objdump -s -section=.init_array -section=.fini_array %t.exe | FileCheck %s
 // REQUIRES: x86
 
 .globl _start
 _start:
   nop
 
 .section .init_array, "aw", @init_array
   .align 8

test/ELF/linkerscript/data-commands.s

 # RUN:      SHORT(b)                 \
 # RUN:      *(.bar.3)                \
 # RUN:      LONG(c + 2)              \
 # RUN:      *(.bar.4)                \
 # RUN:      QUAD(d)                  \
 # RUN:    }                          \
 # RUN:  }" > %t.script
 # RUN: ld.lld -o %t %t.o --script %t.script
-# RUN: llvm-objdump -s %t | FileCheck %s
+# RUN: llvm-objdump -s -section=.foo -section=.bar %t | FileCheck %s
 
 # CHECK:      Contents of section .foo:
 # CHECK-NEXT:   ff11ff22 11ff4433 2211ff88 77665544
 # CHECK-NEXT:   332211
 
 # CHECK:      Contents of section .bar:
 # CHECK-NEXT:   ff12ff22 11ff4633 2211ff88 77665544
 # CHECK-NEXT:   332211
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %tmips64be
 # RUN: ld.lld --script %t.script %tmips64be -o %t2
-# RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=BE
+# RUN: llvm-objdump -s -section=.foo -section=.bar %t2 | FileCheck %s --check-prefix=BE
 # BE:      Contents of section .foo:
 # BE-NEXT:   ff11ff11 22ff1122 3344ff11 22334455
 # BE-NEXT:   667788
 # BE-NEXT: Contents of section .bar:
 # BE-NEXT:   ff12ff11 22ff1122 3346ff11 22334455
 # BE-NEXT:   667788
 
 .global a

test/ELF/linkerscript/exclude-multiple.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %tfile1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/exclude-multiple1.s -o %tfile2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/exclude-multiple2.s -o %tfile3.o
 # RUN: echo "SECTIONS { \
 # RUN:   .foo : { *(.foo.1 EXCLUDE_FILE (*file1.o) .foo.2 EXCLUDE_FILE (*file2.o) .foo.3) } \
 # RUN:  }" > %t1.script
 # RUN: ld.lld -script %t1.script %tfile1.o %tfile2.o %tfile3.o -o %t1.o
-# RUN: llvm-objdump -s %t1.o | FileCheck %s
+# RUN: llvm-objdump -s -section=.foo -section=.foo.2 -section=.foo.3 %t1.o | FileCheck %s
 
 # CHECK:      Contents of section .foo:
 # CHECK-NEXT:  01000000 00000000 04000000 00000000
 # CHECK-NEXT:  07000000 00000000 05000000 00000000
 # CHECK-NEXT:  08000000 00000000 03000000 00000000
 # CHECK-NEXT:  09000000 00000000
 # CHECK-NEXT: Contents of section .foo.2:
 # CHECK-NEXT:  02000000 00000000

test/ELF/linkerscript/fill.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS {     \
 # RUN:  .out : {            \
 # RUN:   FILL(0x11111111);  \
 # RUN:   *(.aaa)            \
 # RUN:   . += 4;            \
 # RUN:   *(.bbb)            \
 # RUN:   . += 4;            \
 # RUN:   FILL(0x22222222);  \
 # RUN:   . += 4;            \
 # RUN:  }                   \
 # RUN: }; " > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
-# RUN: llvm-objdump -s %t | FileCheck %s
+# RUN: llvm-objdump -s -section=.out %t | FileCheck %s
 
 # CHECK:      Contents of section .out:
 # CHECK-NEXT: aa222222 22bb2222 22222222 2222
 
 .text
 .globl _start
 _start:
 
 .section .aaa, "a"
 .align 1
 .byte 0xAA
 
 .section .bbb, "a"
 .align 1
 .byte 0xBB

test/ELF/linkerscript/merge-sections-reloc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/merge-sections-reloc.s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t2.o
 # RUN: echo "SECTIONS {}" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t | FileCheck %s
+# RUN: llvm-objdump -s -section=.text %t | FileCheck %s
 
 ## Check that sections content is not corrupted.
 # CHECK:      Contents of section .text:
 # CHECK-NEXT:  44332211 00000000 44332211 00000000
 # CHECK-NEXT:  f0ffffff ffffffff
 
 .globl _start
 _foo:
  .quad 0x11223344
  .quad _start - .

test/ELF/linkerscript/sort-init.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: echo "SECTIONS { .init_array : { *(SORT_BY_INIT_PRIORITY(.init_array.*)) } }" > %t1.script
 # RUN: ld.lld --script %t1.script %t1.o -o %t2
-# RUN: llvm-objdump -s %t2 | FileCheck %s
+# RUN: llvm-objdump -s -section=.init_array %t2 | FileCheck %s
 
 # CHECK:      Contents of section .init_array:
 # CHECK-NEXT: 03020000 00000000 010405
 
 .globl _start
 _start:
   nop
 

test/ELF/linkerscript/sort-nested.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 \
 # RUN:   %p/Inputs/sort-nested.s -o %t2.o
 
 ## Check sorting first by alignment and then by name.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.aaa.*))) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t1 | FileCheck -check-prefix=SORTED_AN %s
+# RUN: llvm-objdump -section=.aaa -s %t1 | FileCheck -check-prefix=SORTED_AN %s
 # SORTED_AN:      Contents of section .aaa:
 # SORTED_AN-NEXT:   01000000 00000000 00000000 00000000
 # SORTED_AN-NEXT:   11000000 00000000 00000000 00000000
 # SORTED_AN-NEXT:   55000000 00000000 22000000 00000000
 # SORTED_AN-NEXT:   02000000 00000000
 
 ## Check sorting first by name and then by alignment.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(SORT_BY_ALIGNMENT(.aaa.*))) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SORTED_NA %s
+# RUN: llvm-objdump -section=.aaa -s %t2 | FileCheck -check-prefix=SORTED_NA %s
 # SORTED_NA: Contents of section .aaa:
 # SORTED_NA:   01000000 00000000 00000000 00000000
 # SORTED_NA:   11000000 00000000 22000000 00000000
 # SORTED_NA:   02000000 00000000 00000000 00000000
 # SORTED_NA:   55000000 00000000
 
 ## If the section sorting command in linker script isn't nested, the
 ## command line option will make the section sorting command to be treated
 ## as nested sorting command.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_ALIGNMENT(.aaa.*)) } }" > %t3.script
 # RUN: ld.lld --sort-section name -o %t3 --script %t3.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t3 | FileCheck -check-prefix=SORTED_AN %s
+# RUN: llvm-objdump -s -section=.aaa %t3 | FileCheck -check-prefix=SORTED_AN %s
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(.aaa.*)) } }" > %t4.script
 # RUN: ld.lld --sort-section alignment -o %t4 --script %t4.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t4 | FileCheck -check-prefix=SORTED_NA %s
+# RUN: llvm-objdump -s -section=.aaa %t4 | FileCheck -check-prefix=SORTED_NA %s
 
 .global _start
 _start:
  nop
 
 .section .aaa.1, "a"
 .align 32
 .quad 1
 
 .section .aaa.2, "a"
 .align 2
 .quad 2
 
 .section .aaa.5, "a"
 .align 16
 .quad 0x55

test/ELF/linkerscript/sort.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 \
 # RUN:   %p/Inputs/sort.s -o %t2.o
 
 # RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t1 | FileCheck -check-prefix=UNSORTED %s
+# RUN: llvm-objdump -s -section=.aaa %t1 | FileCheck -check-prefix=UNSORTED %s
 # UNSORTED:       Contents of section .aaa:
 # UNSORTED-NEXT:   55000000 00000000 00000000 00000000
 # UNSORTED-NEXT:   00000000 00000000 00000000 00000000
 # UNSORTED-NEXT:   11000000 00000000 33000000 00000000
 # UNSORTED-NEXT:   22000000 00000000 44000000 00000000
 # UNSORTED-NEXT:   05000000 00000000 01000000 00000000
 # UNSORTED-NEXT:   03000000 00000000 02000000 00000000
 # UNSORTED-NEXT:   04000000 00000000
 
 ## Check that SORT works (sorted by name of section).
 # RUN: echo "SECTIONS { .aaa : { *(SORT(.aaa.*)) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SORTED_A %s
+# RUN: llvm-objdump -s -section=.aaa %t2 | FileCheck -check-prefix=SORTED_A %s
 # SORTED_A:      Contents of section .aaa:
 # SORTED_A-NEXT:  11000000 00000000 01000000 00000000
 # SORTED_A-NEXT:  22000000 00000000 02000000 00000000
 # SORTED_A-NEXT:  33000000 00000000 03000000 00000000
 # SORTED_A-NEXT:  44000000 00000000 00000000 00000000
 # SORTED_A-NEXT:  04000000 00000000 55000000 00000000
 # SORTED_A-NEXT:  00000000 00000000 00000000 00000000
 # SORTED_A-NEXT:  05000000 00000000
 
 ## When we switch the order of files, check that sorting by
 ## section names is stable.
 # RUN: echo "SECTIONS { .aaa : { *(SORT(.aaa.*)) } }" > %t3.script
 # RUN: ld.lld -o %t3 --script %t3.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t3 | FileCheck -check-prefix=SORTED_B %s
+# RUN: llvm-objdump -s -section=.aaa %t3 | FileCheck -check-prefix=SORTED_B %s
 # SORTED_B:      Contents of section .aaa:
 # SORTED_B-NEXT:  01000000 00000000 00000000 00000000
 # SORTED_B-NEXT:  00000000 00000000 00000000 00000000
 # SORTED_B-NEXT:  11000000 00000000 02000000 00000000
 # SORTED_B-NEXT:  22000000 00000000 03000000 00000000
 # SORTED_B-NEXT:  33000000 00000000 00000000 00000000
 # SORTED_B-NEXT:  04000000 00000000 44000000 00000000
 # SORTED_B-NEXT:  05000000 00000000 55000000 00000000
 
 ## Check that SORT surrounded with KEEP also works.
 # RUN: echo "SECTIONS { .aaa : { KEEP (*(SORT(.aaa.*))) } }" > %t3.script
 # RUN: ld.lld -o %t3 --script %t3.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t3 | FileCheck -check-prefix=SORTED_A %s
+# RUN: llvm-objdump -s -section=.aaa %t3 | FileCheck -check-prefix=SORTED_A %s
 
 ## Check that SORT_BY_NAME works (SORT is alias).
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(.aaa.*)) } }" > %t4.script
 # RUN: ld.lld -o %t4 --script %t4.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t4 | FileCheck -check-prefix=SORTED_A %s
+# RUN: llvm-objdump -s -section=.aaa %t4 | FileCheck -check-prefix=SORTED_A %s
 
 ## Check that sections ordered by alignment.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_ALIGNMENT(.aaa.*)) } }" > %t5.script
 # RUN: ld.lld -o %t5 --script %t5.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t5 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
+# RUN: llvm-objdump -s -section=.aaa %t5 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
 # SORTED_ALIGNMENT:      Contents of section .aaa:
 # SORTED_ALIGNMENT-NEXT:  05000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  00000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  11000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  04000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  22000000 00000000 03000000 00000000
 # SORTED_ALIGNMENT-NEXT:  33000000 00000000 02000000 00000000
 # SORTED_ALIGNMENT-NEXT:  44000000 00000000 01000000 00000000
 # SORTED_ALIGNMENT-NEXT:  55000000 00000000
 
 ## SORT_NONE itself does not sort anything.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_NONE(.aaa.*)) } }" > %t6.script
 # RUN: ld.lld -o %t7 --script %t6.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t7 | FileCheck -check-prefix=UNSORTED %s
+# RUN: llvm-objdump -s -section=.aaa %t7 | FileCheck -check-prefix=UNSORTED %s
 
 ## Check --sort-section alignment option.
 # RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t7.script
 # RUN: ld.lld --sort-section alignment -o %t8 --script %t7.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t8 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
+# RUN: llvm-objdump -s -section=.aaa %t8 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
 
 ## Check --sort-section= form.
 # RUN: ld.lld --sort-section=alignment -o %t8_1 --script %t7.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t8_1 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
+# RUN: llvm-objdump -s -section=.aaa %t8_1 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
 
 ## Check --sort-section name option.
 # RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t8.script
 # RUN: ld.lld --sort-section name -o %t9 --script %t8.script %t1.o %t2.o
-# RUN: llvm-objdump -s %t9 | FileCheck -check-prefix=SORTED_B %s
+# RUN: llvm-objdump -s -section=.aaa %t9 | FileCheck -check-prefix=SORTED_B %s
 
 ## SORT_NONE disables the --sort-section.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_NONE(.aaa.*)) } }" > %t9.script
 # RUN: ld.lld --sort-section name -o %t10 --script %t9.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t10 | FileCheck -check-prefix=UNSORTED %s
+# RUN: llvm-objdump -s -section=.aaa %t10 | FileCheck -check-prefix=UNSORTED %s
 
 ## SORT_NONE as a inner sort directive.
 # RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(SORT_NONE(.aaa.*))) } }" > %t10.script
 # RUN: ld.lld -o %t11 --script %t10.script %t2.o %t1.o
-# RUN: llvm-objdump -s %t11 | FileCheck -check-prefix=SORTED_A %s
+# RUN: llvm-objdump -s -section=.aaa %t11 | FileCheck -check-prefix=SORTED_A %s
 
 .global _start
 _start:
  nop
 
 .section .aaa.5, "a"
 .align 32
 .quad 5

test/ELF/linkerscript/sort2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %tfile1.o
 
 # RUN: echo "SECTIONS { .abc : { *(SORT(.foo.*) .bar.*) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %tfile1.o
-# RUN: llvm-objdump -s %t1 | FileCheck %s
+# RUN: llvm-objdump -s -section=.abc %t1 | FileCheck %s
 
 # CHECK:  Contents of section .abc:
 # CHECK:   01000000 00000000 02000000 00000000
 # CHECK:   03000000 00000000 04000000 00000000
 # CHECK:   06000000 00000000 05000000 00000000
 
 # RUN: echo "SECTIONS { \
 # RUN:   .abc : { *(SORT(.foo.* EXCLUDE_FILE (*file1.o) .bar.*) .bar.*) } \
 # RUN:  }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %tfile1.o
-# RUN: llvm-objdump -s %t2 | FileCheck %s
+# RUN: llvm-objdump -s -section=.abc %t2 | FileCheck %s
 
 .text
 .globl _start
 _start:
 
 .section .foo.2,"a"
  .quad 2
 

test/ELF/linkerscript/subalign.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 
 # RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t1.script
 # RUN: ld.lld -o %t1 --script %t1.script %t1.o
-# RUN: llvm-objdump -s %t1 | FileCheck -check-prefix=NOALIGN %s
+# RUN: llvm-objdump -s -section=.aaa %t1 | FileCheck -check-prefix=NOALIGN %s
 # NOALIGN:      Contents of section .aaa:
 # NOALIGN-NEXT:   01000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   00000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   02000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   00000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   03000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   00000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   00000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   00000000 00000000 00000000 00000000
 # NOALIGN-NEXT:   04000000 00000000
 
 # RUN: echo "SECTIONS { .aaa : SUBALIGN(1) { *(.aaa.*) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t1.o
-# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SUBALIGN %s
+# RUN: llvm-objdump -s -section=.aaa %t2 | FileCheck -check-prefix=SUBALIGN %s
 # SUBALIGN: Contents of section .aaa:
 # SUBALIGN:   01000000 00000000 02000000 00000000
 # SUBALIGN:   03000000 00000000 04000000 00000000
 
 .global _start
 _start:
  nop
 

test/ELF/mips-nonalloc.s

 # Check reading addends for relocations in non-allocatable sections.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %S/Inputs/mips-nonalloc.s -o %t2.o
 # RUN: ld.lld %t1.o %t2.o -o %t.exe
-# RUN: llvm-objdump -s %t.exe | FileCheck %s
+# RUN: llvm-objdump -s -section=.debug_info %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Contents of section .debug_info:
 # CHECK-NEXT:  0000 ffffffff 00020000 00020000
 #                            ^--------^-- __start
 
   .global __start
 __start:
   nop
 
 .section .debug_info
   .word 0xffffffff
   .word __start

test/ELF/mips-relocatable.s

 # Check linking MIPS code in case of -r linker's option.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld -r -o %t-r.o %t.o
-# RUN: llvm-objdump -s -t %t-r.o | FileCheck %s
+# RUN: llvm-objdump -s -section=.rodata -t %t-r.o | FileCheck %s
 
 # REQUIRES: mips
 
   .text
   .global  __start
 __start:
   lw      $t0,%call16(__start)($gp)
 foo:
   nop
 
   .section .rodata, "a"
 v:
   .gpword foo
 
 # CHECK-NOT: Contents of section .got:
 # CHECK-NOT: {{.*}} _gp

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

 # Check handling TLS related relocations and symbols when linking
 # a 64-bit static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
-# RUN: llvm-objdump -s -t %t.exe | FileCheck %s
+# RUN: llvm-objdump -s -section=.data -t %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Contents of section .data:
 # CHECK-NEXT:  40000 00020004 ffffffff ffff8004 ffffffff
 # CHECK-NEXT:  40010 ffff9004
 #
 # CHECK: SYMBOL TABLE:

test/ELF/mips-tls-static.s

 # Check handling TLS related relocations and symbols when linking
 # a static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
-# RUN: llvm-objdump -s -t %t.exe | FileCheck %s
+# RUN: llvm-objdump -s -section=.got -section=.data -t %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Contents of section .got:
 # CHECK-NEXT:  30008 00000000 80000000 00000001 ffff8000
 # CHECK-NEXT:  30018 00000001 00000000 ffff9000
 # CHECK:      Contents of section .data:
 # CHECK-NEXT:  40000 0002000c ffff8004 ffff9004

test/ELF/no-merge.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .data : {*(.data.*)} }" > %t0.script
 # RUN: ld.lld %t.o -o %t0.out --script %t0.script
-# RUN: llvm-objdump -s %t0.out | FileCheck %s --check-prefix=OPT
+# RUN: llvm-objdump -s -section=.data %t0.out | FileCheck %s --check-prefix=OPT
 # OPT:      Contents of section .data:
 # OPT-NEXT:   0000 01
 # OPT-NEXT: Contents of section .data:
 # OPT-NEXT:   0001 6100
 # OPT-NEXT: Contents of section .data:
 # OPT-NEXT:   0003 03
 
 # RUN: ld.lld -O0 %t.o -o %t1.out --script %t0.script
-# RUN: llvm-objdump -s %t1.out | FileCheck %s --check-prefix=NOOPT
+# RUN: llvm-objdump -s -section=.data %t1.out | FileCheck %s --check-prefix=NOOPT
 # NOOPT:      Contents of section .data:
 # NOOPT-NEXT:   0000 01610003
 
 .section .data.aw,"aw",@progbits
 .byte 1
 
 .section .data.ams,"aMS",@progbits,1
 .asciz "a"
 
 .section .data.am,"aM",@progbits,1
 .byte 3

test/ELF/relocatable.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/relocatable.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocatable2.s -o %t3.o
 # RUN: ld.lld -r %t1.o %t2.o %t3.o -o %t
 # RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
-# RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
+# RUN: llvm-objdump -s -section=.text -d %t | FileCheck -check-prefix=CHECKTEXT %s
 
 ## Test --relocatable alias
 # RUN: ld.lld --relocatable %t1.o %t2.o %t3.o -o %t
 # RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
-# RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
+# RUN: llvm-objdump -s -section=.text -d %t | FileCheck -check-prefix=CHECKTEXT %s
 
 ## Verify that we can use our relocation output as input to produce executable
 # RUN: ld.lld -e main %t -o %texec
 # RUN: llvm-readobj -file-headers %texec | FileCheck -check-prefix=CHECKEXE %s
 
 # CHECK:       ElfHeader {
 # CHECK-NEXT:  Ident {
 # CHECK-NEXT:    Magic: (7F 45 4C 46)

test/ELF/relocation-local.s

 // Test that relocation of local symbols is working.
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: ld.lld %t -o %t2
-// RUN: llvm-objdump -s -d %t2 | FileCheck %s
+// RUN: llvm-objdump -s -section=.text2 -section=.R_X86_64_32S -section=.R_X86_64_64 -d %t2 | FileCheck %s
 // REQUIRES: x86
 
 
 .global _start
 _start:
   call lulz
 
 .zero 4

test/ELF/startstop-shared2.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/startstop-shared2.s -o %t.o
 // RUN: ld.lld -o %t.so %t.o -shared
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t2.o
 // RUN: ld.lld -o %t %t2.o %t.so
-// RUN: llvm-objdump -s -h %t | FileCheck %s
+// RUN: llvm-objdump -s -section=.text -section=foo -h %t | FileCheck %s
 
 // CHECK: foo           00000000 0000000000201008
 
 // CHECK: Contents of section .text:
 // CHECK-NEXT: 201000 08102000 00000000
 
 .quad __start_foo
 .section foo,"ax"

test/ELF/symbol-ordering-file.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.out
-# RUN: llvm-objdump -s %t.out| FileCheck %s --check-prefix=BEFORE
+# RUN: llvm-objdump -s -section=.foo %t.out| FileCheck %s --check-prefix=BEFORE
 
 # BEFORE:      Contents of section .foo:
 # BEFORE-NEXT:  201000 11223344 5566
 
 # RUN: echo "_foo4  " > %t_order.txt
 # RUN: echo "  _foo3" >> %t_order.txt
 # RUN: echo "_foo5" >> %t_order.txt
 # RUN: echo "_foo2" >> %t_order.txt
 # RUN: echo " " >> %t_order.txt
 # RUN: echo "_foo4" >> %t_order.txt
 # RUN: echo "_bar1" >> %t_order.txt
 # RUN: echo "_foo1" >> %t_order.txt
 
 # RUN: ld.lld --symbol-ordering-file %t_order.txt %t.o -o %t2.out
-# RUN: llvm-objdump -s %t2.out| FileCheck %s --check-prefix=AFTER
+# RUN: llvm-objdump -s -section=.foo %t2.out| FileCheck %s --check-prefix=AFTER
 
 # AFTER:      Contents of section .foo:
 # AFTER-NEXT:  201000 44335566 2211
 
 .section .foo,"ax",@progbits,unique,1
 _foo1:
  .byte 0x11