Mark a number of x86 only tests to require x86

[JonChesterfield]

Summary

Noticed while testing for an out of tree target. There are probably more tests that should be so marked.
I'm not sure who owns these tests so I've added a few names I recognise from the recent history.

[probinson]

According to the top-level CODE_OWNERS.TXT the overall LLD code owner is @ruiu so please add him as a reviewer.
Also all LLD patches should have llvm-commits as a subscriber.
Note that when you add the list as a subscriber after-the-fact, you should repeat the original patch description as a comment, otherwise it won't appear on the mailing list.

[JonChesterfield]

Thanks Paul. This is my first time looking at lld, the guidance is appreciated.

Mark a number of x86 only tests to require x86

Noticed while testing for an out of tree target. There are probably more tests that should be so marked.
I'm not sure who owns these tests so I've added a few names I recognise from the recent history.

[davidb]

A few more tests have been introduced like this. It may make more sense to restructure the tests so that they are separated by target.

[ruiu]

We are using x86 as a "generic" target to test features that don't depend on targets. Besides that, the number of tests that need target-specific treatment is not that many, so I don't think we want to restructure the test files per target. (Also, the fact that we are using "x86" to test generic feature means that you usually want to enable the LLVM x86 target to run these tests.)

[probinson]

In D34685#795468, @ruiu wrote:

(Also, the fact that we are using "x86" to test generic feature means that you usually want to enable the LLVM x86 target to run these tests.)

Are you saying, if you want to test LLD, you must enable the x86 target? That sounds backwards.

[ruiu]

Yes, that's what I meant. It's not ideal, but if you want to write tests that don't depend on target, what target would you choose?

[probinson]

In D34685#795512, @ruiu wrote:

Yes, that's what I meant. It's not ideal, but if you want to write tests that don't depend on target, what target would you choose?

LLVM also has lots of tests that are generic in principle, but end up depending on a particular target for practical reasons. However, the project does not require people to include the X86 target (or ARM target, another favorite for "generic" tests) before they can run tests at all. The project relies on the many people who *do* have those targets enabled, plus bots, to guarantee coverage. And, the ought-to-be-generic tests end up in target-specific directories, where they don't get in the way of people whose work either doesn't depend on that target or requires that they not have that target enabled. As one recent example, r295384 added a "generic" test that had to be moved to an X86 specific directory in r295389, for exactly this reason.

The people who are proposing this change do not, for whatever reason, want to include the x86 target. I don't think the LLD project should force them to include it. I know I don't personally contribute meaningfully to the LLD project, but others in my company do, and as a designated merge guru I need to keep them happy.

[ruiu]

I don't know if I understand what you said correctly. I do not want to force anyone to enable the x86 target. If you disable x86, tests that use x86 as a "generic" target won't run, but it shouldn't be more than that. I'm still waiting for you to update this patch to address Rafael's comment.

[davidb]

In D34685#796778, @ruiu wrote:

I don't know if I understand what you said correctly. I do not want to force anyone to enable the x86 target. If you disable x86, tests that use x86 as a "generic" target won't run, but it shouldn't be more than that. I'm still waiting for you to update this patch to address Rafael's comment.

I'll update the patch. But I'm still concerned that needing to add "REQUIRES: x86" is going to be an ongoing maintenance for us as new tests are added.

Also as it currently stands, I can't see an easy way to distinguish between generic tests and actual x86 tests.

[ruiu]

I'll update the patch. But I'm still concerned that needing to add "REQUIRES: x86" is going to be an ongoing maintenance for us as new tests are added.

We should start adding "REQUIRES: x86" to new tests from now on.

Also as it currently stands, I can't see an easy way to distinguish between generic tests and actual x86 tests.

You can distinguish by filename, as target-specific tests start with target name.

[JonChesterfield]

In D34685#796778, @ruiu wrote:

I'm still waiting for you to update this patch to address Rafael's comment.

I don't see any comment by Rafael. What are you referring to?

[JonChesterfield]

In D34685#796846, @ruiu wrote:

You can distinguish by filename, as target-specific tests start with target name.

Does this mean the patch for files in the ELF directory which do not start with a target name should not specify a triple?
For example, relocatable-tls.s and no-symtab.s should pass without the REQUIRES clause were the explicit triple removed.

[probinson]

In D34685#798776, @JonChesterfield wrote:

In D34685#796778, @ruiu wrote:

I'm still waiting for you to update this patch to address Rafael's comment.

I don't see any comment by Rafael. What are you referring to?

Rafael replied via email, not on phabricator, and email replies don't always propagate. He said:

davidb added a comment.

In https://reviews.llvm.org/D34685#796778, @ruiu wrote:

I don't know if I understand what you said correctly. I do not want to force anyone to enable the x86 target. If you disable x86, tests that use x86 as a "generic" target won't run, but it shouldn't be more than that. I'm still waiting for you to update this patch to address Rafael's comment.

I'll update the patch. But I'm still concerned that needing to add "REQUIRES: x86" is going to be an ongoing maintenance for us as new tests are added.

The normal way of avoiding that is setting up a bot. Can you setup one
that tests lld without the x86 backend?

Cheers,
Rafael

[ruiu]

Again, can you please update as per the Rafael's comment?

Does this mean the patch for files in the ELF directory which do not start with a target name should not specify a triple?
For example, relocatable-tls.s and no-symtab.s should pass without the REQUIRES clause were the explicit triple removed.

Here is the rule that I'm proposing.

• If a test is testing an architecture-specific feature, add the architecture name as a prefix. For example, if a test tests x86 relocation relaxation, name it x86-relocation-relaxation.s.
• If a test is testing an architecture-independent feature, use the x86 as a "generic" target, and don't add "x86" as a prefix.

[davidb]

Sorry, Jon and I have been out of office the past week.

I can't seem to update the diff again without creating a new revision? The update existing revision doesn't seem available to me...

[ruiu]

Make sure you have logged in to reviews.llvm.org. Looks like even I can upload a new revision to this review request, so I think anyone who have logged in can do that.

[davidb]

I can't seem to do it through the Phabricator UI, or archanist which has just created a new differential... https://reviews.llvm.org/D35565

[davidb]

Updating D34685: Mark a number of x86 only tests to require x86

[ruiu]

LGTM

test/ELF/relocatable-compressed-input.s

1–2

REQUIRES: x86, zlib

[JonChesterfield]

In D34685#813125, @ruiu wrote:

LGTM

Great. Thank you Dave for picking this up in my absence

test/COFF/common.test

+# REQUIRES: x86
 # RUN: yaml2obj %s > %t.obj
 # RUN: lld-link /out:%t.exe /entry:main %t.obj %t.obj
 # RUN: llvm-objdump -d %t.exe | FileCheck %s
 
 # Operands of B8 (MOV EAX) are common symbols
 # CHECK: 3000: b8 00 10 00 40
 # CHECK: 3005: b8 04 10 00 40
 # CHECK: 300a: b8 20 10 00 40

test/COFF/conflict.test

+# REQUIRES: x86
 # RUN: yaml2obj < %s > %t1.obj
 # RUN: yaml2obj < %s > %t2.obj
 # RUN: not lld-link /out:%t.exe %t1.obj %t2.obj >& %t.log
 # RUN: FileCheck %s < %t.log
 
 # RUN: llvm-as -o %t.lto1.obj %S/Inputs/conflict.ll
 # RUN: llvm-as -o %t.lto2.obj %S/Inputs/conflict.ll
 # RUN: not lld-link /out:%t.exe %t.lto1.obj %t.lto2.obj >& %t.log

test/COFF/constant.test

+REQUIRES: x86
 RUN: mkdir -p %t
 RUN: llvm-mc -triple i686-unknown-windows-msvc -filetype obj -o %t/import.o %S/Inputs/constant-import.s
 RUN: llc -mtriple i686-unknown-windows-msvc -filetype obj -o %t/export.o %S/Inputs/constant-export.ll
 RUN: lld-link -machine:x86 -dll -out:%t/export.dll %t/export.o -entry:__CFConstantStringClassReference
 RUN: lld-link -machine:x86 -dll -out:%t/import.dll %t/import.o %t/export.lib

test/COFF/def-export-stdcall.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i686-windows-msvc %s -o %t.obj
 # RUN: echo -e "LIBRARY foo\nEXPORTS\n  stdcall" > %t.def
 # RUN: lld-link -entry:dllmain -dll -def:%t.def %t.obj -out:%t.dll -implib:%t.lib
 # RUN: llvm-nm %t.lib | FileCheck %s
 # CHECK: __imp__stdcall@8
 # CHECK: _stdcall@8
 
         .def     _stdcall@8;

test/COFF/delayimports32.test

+# REQUIRES: x86
 # RUN: yaml2obj < %p/Inputs/hello32.yaml > %t.obj
 # RUN: lld-link %t.obj %p/Inputs/std32.lib /subsystem:console \
 # RUN:   /entry:main@0 /alternatename:___delayLoadHelper2@8=_main@0 \
 # RUN:   /debug /delayload:std32.dll /out:%t.exe
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORT %s
 # RUN: llvm-readobj -coff-basereloc %t.exe | FileCheck -check-prefix=BASEREL %s
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=DISASM %s
 

test/COFF/entry-mangled.test

+# REQUIRES: x86
 # RUN: yaml2obj < %s > %t.obj
 # RUN: lld-link /out:%t.exe /entry:main %t.obj
 # RUN: llvm-as -o %t.lto.obj %S/Inputs/entry-mangled.ll
 # RUN: lld-link /out:%t.exe /entry:main %t.lto.obj
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64

test/COFF/entrylib.ll

+; REQUIRES: x86
 ; RUN: llvm-as -o %t.obj %s
 ; RUN: rm -f %t.lib
 ; RUN: llvm-ar cru %t.lib %t.obj
 ; RUN: lld-link /out:%t.exe /entry:main %t.lib
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 define i32 @main() {
   ret i32 0
 }

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 \

test/COFF/include-lto.ll

+; REQUIRES: x86
 ; RUN: llvm-as -o %t.obj %s
 ; RUN: lld-link /dll /out:%t.dll %t.obj
 ; RUN: llvm-objdump -d %t.dll | FileCheck %s
 
 ; Checks that code for foo is emitted, as required by the /INCLUDE directive.
 ; CHECK: xorl %eax, %eax
 ; CHECK-NEXT: retq
 

test/COFF/msvclto-archive.ll

+; REQUIRES: x86
 ;; Make sure we re-create archive files to strip bitcode files.
 
 ;; Do not create empty archives because the MSVC linker
 ;; doesn't support them.
 ; RUN: llvm-as -o %t.obj %s
 ; RUN: rm -f %t-main1.a
 ; RUN: llvm-ar cru %t-main1.a %t.obj
 ; RUN: mkdir -p %t.dir

test/COFF/msvclto-order.ll

+; REQUIRES: x86
 ; RUN: opt -thinlto-bc %s -o %t.obj
 ; RUN: llc -filetype=obj %S/Inputs/msvclto-order-a.ll -o %T/msvclto-order-a.obj
 ; RUN: llvm-ar crs %T/msvclto-order-a.lib %T/msvclto-order-a.obj
 ; RUN: llc -filetype=obj %S/Inputs/msvclto-order-b.ll -o %T/msvclto-order-b.obj
 ; RUN: llvm-ar crs %T/msvclto-order-b.lib %T/msvclto-order-b.obj
 ; RUN: lld-link /verbose /msvclto /out:%t.exe /entry:main %t.obj \
 ; RUN:     %T/msvclto-order-a.lib %T/msvclto-order-b.lib > %t.log || true
 ; RUN: FileCheck %s < %t.log

test/COFF/msvclto.ll

+; REQUIRES: x86
 ; RUN: llvm-as -o %t.obj %s
 ; RUN: mkdir -p %t.dir
 ; RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %t.dir/bitcode.obj %p/Inputs/msvclto.s
 ; RUN: lld-link %t.obj %t.dir/bitcode.obj /msvclto /out:%t.exe /opt:lldlto=1 /opt:icf \
 ; RUN:   /entry:main /verbose > %t.log || true
 ; RUN: FileCheck %s < %t.log
 
 ; CHECK: /opt:icf /entry:main

test/COFF/pdb-lib.s

+# REQUIRES: x86
 # RUN: rm -rf %t && mkdir -p %t && cd %t
 # RUN: llvm-mc -filetype=obj -triple=i686-windows-msvc %s -o foo.obj
 # RUN: llc %S/Inputs/bar.ll -filetype=obj -mtriple=i686-windows-msvc -o bar.obj
 # RUN: llvm-lib bar.obj -out:bar.lib
 # RUN: lld-link -debug -pdb:foo.pdb foo.obj bar.lib -out:foo.exe -entry:main
 # RUN: llvm-pdbutil dump -modules %t/foo.pdb | FileCheck %s
 
 # Make sure that the PDB has module descriptors. foo.obj and bar.lib should be

test/COFF/savetemps.ll

+; REQUIRES: x86
 ; RUN: rm -fr %T/savetemps
 ; RUN: mkdir %T/savetemps
 ; RUN: llvm-as -o %T/savetemps/savetemps.obj %s
 ; RUN: lld-link /out:%T/savetemps/savetemps.exe /entry:main \
 ; RUN:     /subsystem:console %T/savetemps/savetemps.obj
 ; RUN: not llvm-dis -o - %T/savetemps/savetemps.exe.0.0.preopt.bc
 ; RUN: not llvm-dis -o - %T/savetemps/savetemps.exe.0.2.internalize.bc
 ; RUN: not llvm-dis -o - %T/savetemps/savetemps.exe.0.4.opt.bc

test/COFF/thinlto-archives.ll

+; REQUIRES: x86
 ; RUN: rm -fr %T/thinlto-archives
 ; RUN: mkdir %T/thinlto-archives %T/thinlto-archives/a %T/thinlto-archives/b
 ; RUN: opt -thinlto-bc -o %T/thinlto-archives/main.obj %s
 ; RUN: opt -thinlto-bc -o %T/thinlto-archives/a/bar.obj %S/Inputs/lto-dep.ll
 ; RUN: opt -thinlto-bc -o %T/thinlto-archives/b/bar.obj %S/Inputs/bar.ll
 ; RUN: llvm-ar crs %T/thinlto-archives/a.lib %T/thinlto-archives/a/bar.obj
 ; RUN: llvm-ar crs %T/thinlto-archives/b.lib %T/thinlto-archives/b/bar.obj
 ; RUN: lld-link /out:%T/thinlto-archives/main.exe -entry:main \

test/COFF/thinlto-mangled.ll

+; REQUIRES: x86
 ; RUN: opt -thinlto-bc %s -o %t.obj
 ; RUN: opt -thinlto-bc %S/Inputs/thinlto-mangled-qux.ll -o %T/thinlto-mangled-qux.obj
 ; RUN: lld-link -out:%t.exe -entry:main %t.obj %T/thinlto-mangled-qux.obj
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24215"
 
 %"class.bar" = type { i32 (...)**, i8*, i8*, i8*, i32 }
 
 define i32 @main() {
   ret i32 0
 }
 
 define available_externally zeroext i1 @"\01?x@bar@@UEBA_NXZ"(%"class.bar"* %this) unnamed_addr align 2 {
   ret i1 false
 }

test/COFF/thinlto.ll

+; REQUIRES: x86
 ; RUN: rm -fr %T/thinlto
 ; RUN: mkdir %T/thinlto
 ; RUN: opt -thinlto-bc -o %T/thinlto/main.obj %s
 ; RUN: opt -thinlto-bc -o %T/thinlto/foo.obj %S/Inputs/lto-dep.ll
 ; RUN: lld-link /lldsavetemps /out:%T/thinlto/main.exe /entry:main /subsystem:console %T/thinlto/main.obj %T/thinlto/foo.obj
 ; RUN: llvm-nm %T/thinlto/main.exe.lto.obj | FileCheck %s
 
 ; CHECK-NOT: U foo

test/ELF/allow-shlib-undefined.s

+# REQUIRES: x86
 # --allow-shlib-undefined and --no-allow-shlib-undefined are fully
 # ignored in linker implementation.
 # --allow-shlib-undefined is set by default
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN: %p/Inputs/allow-shlib-undefined.s -o %t
 # RUN: ld.lld -shared %t -o %t.so
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 

test/ELF/auxiliary.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -f aaa --auxiliary bbb -o %t
 # RUN: llvm-readobj --dynamic-table %t | FileCheck %s
 
 # CHECK:      DynamicSection [
 # CHECK-NEXT: Tag                Type          Name/Value
 # CHECK-NEXT: 0x000000007FFFFFFD AUXILIARY     Auxiliary library: [aaa]
 # CHECK-NEXT: 0x000000007FFFFFFD AUXILIARY     Auxiliary library: [bbb]
 
 # RUN: not ld.lld %t.o -f aaa --auxiliary bbb -o %t 2>&1 \
 # RUN:    | FileCheck -check-prefix=ERR %s
 # ERR: -f may not be used without -shared

test/ELF/gdb-index-empty.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux -o %t %s
 # RUN: ld.lld --gdb-index --gc-sections -o %t2 %t
 # RUN: llvm-dwarfdump -debug-dump=gdb_index %t2 | FileCheck %s
 
 # CHECK: Address area offset = 0x28, has 0 entries:
 
 # Generated with: (clang r302976)
 # echo "void _start() { __builtin_unreachable(); }" | \

test/ELF/gdb-index-gc-sections.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux -o %t %s
 # RUN: ld.lld --gdb-index --gc-sections -o %t2 %t
 # RUN: llvm-dwarfdump -debug-dump=gdb_index %t2 | FileCheck %s
 
 # CHECK: Address area offset = 0x28, has 1 entries:
 # CHECK-NEXT:    Low/High address = [0x201000, 0x201001) (Size: 0x1), CU id = 0
 
 # Generated with: (clang r302976)

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

test/ELF/linkerscript/output-too-large.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text : { . = 0xffffffff; *(.text*); } }" > %t.script
 # RUN: not ld.lld --script %t.script %t.o -o %t 2>&1 | FileCheck %s
 # CHECK: error: output file too large
 
 .global _start
 _start:
   nop

test/ELF/lto/available-externally.ll

+# REQUIRES: x86
 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %p/Inputs/available-externally.ll -o %t2.o
 ; RUN: ld.lld %t1.o %t2.o -m elf_x86_64 -o %t.so -shared -save-temps
 ; RUN: llvm-dis < %t.so.0.2.internalize.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 

test/ELF/lto/comdat2.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-mc -triple=x86_64-pc-linux %p/Inputs/comdat.s -o %t2.o -filetype=obj
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t.so -shared
 ; RUN: llvm-readobj -t %t.so | FileCheck %s
 ; RUN: ld.lld -m elf_x86_64 %t2.o %t.o -o %t2.so -shared
 ; RUN: llvm-readobj -t %t2.so | FileCheck %s --check-prefix=OTHER
 
 

test/ELF/lto/common2.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t1.o
 ; RUN: ld.lld -m elf_x86_64 %t1.o -o %t -shared -save-temps
 ; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
 ; RUN: llvm-readobj -t %t | FileCheck %s --check-prefix=SHARED
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 

test/ELF/lto/common3.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %S/Inputs/common3.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t -shared -save-temps
 ; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 @a = common hidden global i32 0, align 8
 define i32 @f() {
   %t = load i32, i32* @a, align 4
   ret i32 %t
 }
 
 ; CHECK: @a = internal global i64 0, align 8

test/ELF/lto/discard-value-names.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: ld.lld -m elf_x86_64 -shared -save-temps %t.o -o %t2.o
 ; RUN: llvm-dis < %t2.o.0.0.preopt.bc | FileCheck %s
 
 ; CHECK: @GlobalValueName
 ; CHECK: @foo(i32 %in)
 ; CHECK: somelabel:

test/ELF/lto/opt-level.ll

+; REQUIRES: x86
 ; RUN: llvm-as -o %t.o %s
 ; RUN: ld.lld -o %t0 -m elf_x86_64 -e main --lto-O0 %t.o
 ; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
 ; RUN: ld.lld -o %t2 -m elf_x86_64 -e main --lto-O2 %t.o
 ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
 ; RUN: ld.lld -o %t2a -m elf_x86_64 -e main %t.o
 ; RUN: llvm-nm %t2a | FileCheck --check-prefix=CHECK-O2 %s
 

test/ELF/lto/opt-remarks.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: rm -f %t.yaml
 ; RUN: ld.lld --opt-remarks-filename %t.yaml %t.o -o %t -shared -save-temps
 ; RUN: llvm-dis %t.0.4.opt.bc -o - | FileCheck %s
 ; RUN: ld.lld --opt-remarks-with-hotness --opt-remarks-filename %t.hot.yaml \
 ; RUN:  %t.o -o %t -shared
 ; RUN: cat %t.yaml | FileCheck %s -check-prefix=YAML

test/ELF/lto/relax-relocs.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 -save-temps -shared %t.o -o %t.so
 ; RUN: llvm-readobj -r %t.so.lto.o | FileCheck %s
 
 ; Test that we produce R_X86_64_REX_GOTPCRELX instead of R_X86_64_GOTPCREL
 ; CHECK: R_X86_64_REX_GOTPCRELX foo
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = external global i32
 define i32 @bar() {
   %t = load i32, i32* @foo
   ret i32 %t
 }

test/ELF/lto/thin-archivecollision.ll

+; REQUIRES: x86
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: mkdir -p %t1 %t2
 ; RUN: opt -module-summary %p/Inputs/thin1.ll -o %t1/t.coll.o
 ; RUN: opt -module-summary %p/Inputs/thin2.ll -o %t2/t.coll.o
 
 ; RUN: rm -f %t.a
 ; RUN: llvm-ar rcs %t.a %t1/t.coll.o %t2/t.coll.o
 ; RUN: ld.lld %t.o %t.a -o %t

test/ELF/lto/thinlto.ll

+; REQUIRES: x86
 ; Basic ThinLTO tests.
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
 
 ; First force single-threaded mode
 ; RUN: rm -f %t.lto.o %t1.lto.o
 ; RUN: ld.lld -save-temps --thinlto-jobs=1 -shared %t.o %t2.o -o %t
 ; RUN: llvm-nm %t.lto.o | FileCheck %s --check-prefix=NM1

test/ELF/lto/type-merge2.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %p/Inputs/type-merge2.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t.so -shared -save-temps
 ; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

test/ELF/lto/unnamed-addr-comdat.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o %t.o -o %t.so -save-temps -shared
 ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 $foo = comdat any
 @foo = linkonce_odr unnamed_addr constant i32 42, comdat
 
 ; CHECK: @foo = internal unnamed_addr constant i32 42, comdat

test/ELF/lto/unnamed-addr-drop.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t1.o
 ; RUN: llvm-as %S/Inputs/unnamed-addr-drop.ll -o %t2.o
 ; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t.so -save-temps -shared
 ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @foo = weak constant i32 41
 
 ; Check that unnamed_addr is dropped during the merge.
 ; CHECK: @foo = constant i32 42

test/ELF/lto/unnamed-addr.ll

+; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps -shared
 ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @a = internal unnamed_addr constant i8 42
 
 define i8* @f() {
   ret i8* @a
 }
 
 ; CHECK: @a = internal unnamed_addr constant i8 42

test/ELF/many-alloc-sections.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t.o
 // RUN: echo "SECTIONS { . = SIZEOF_HEADERS; .text : { *(.text) } }" > %t.script
 // FIXME: threads are disable because the test is too slow with them (PR32942).
 // RUN: ld.lld -T %t.script %t.o -o %t --no-threads
 // RUN: llvm-readobj -t %t | FileCheck %s
 
 // Test that _start is in the correct section.
 // CHECK:      Name: _start

test/ELF/many-sections.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t
 // RUN: llvm-readobj -t %t | FileCheck  %s
 
 // Verify that the symbol _start is in a section with an index >= SHN_LORESERVE.
 // CHECK:      Name: _start
 // CHECK-NEXT: Value: 0x0
 // CHECK-NEXT: Size: 0
 // CHECK-NEXT: Binding: Global

test/ELF/merge-section-types.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t
 // RUN: llvm-readobj -s %t | FileCheck %s
 
 // CHECK:      Name: .foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC

test/ELF/new-dtags.test

+# REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -rpath=/somepath -shared --disable-new-dtags -o %t
 // RUN: ld.lld %t.o -rpath=/somepath -shared --enable-new-dtags -o %t2
 // RUN: llvm-readobj --dynamic-table %t | FileCheck --check-prefix=DISABLE %s
 // RUN: llvm-readobj --dynamic-table %t2 | FileCheck --check-prefix=ENABLE %s
 
 // DISABLE: DynamicSection [
 // DISABLE:   0x000000000000000F RPATH                /somepath
 // DISABLE-NOT: RUNPATH
 // DISABLE: ]
 
 // ENABLE: DynamicSection [
 // ENABLE:   0x000000000000001D RUNPATH              /somepath
 // ENABLE-NOT: RPATH
 // ENABLE: ]

test/ELF/no-obj.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: llvm-ar rcs %t.a %t.o
 // RUN: not ld.lld -o %t2 -u _start %t.a 2>&1 | FileCheck %s
 
 // CHECK: target emulation unknown: -m or at least one .o file required
 
 .global _start
 _start:

test/ELF/no-soname.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: mkdir -p %T/no-soname
 // RUN: ld.lld %t.o -shared -o %T/no-soname/libfoo.so
 
 // RUN: ld.lld %t.o %T/no-soname/libfoo.so -o %t
 // RUN: llvm-readobj --dynamic-table %t | FileCheck %s
 
 // CHECK:  0x0000000000000001 NEEDED               Shared library: [{{.*}}/no-soname/libfoo.so]

test/ELF/no-symtab.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o %p/Inputs/no-symtab.o -o %t
 .global _start
 _start:

test/ELF/no-undefined.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld --no-undefined -shared %t -o %t.so
 # RUN: ld.lld -shared %t -o %t1.so
 
 .globl _shared
 _shared:
   callq _unresolved@PLT

test/ELF/pie-weak.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -relax-relocations=false -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -pie %t.o -o %t
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=RELOCS %s
 # RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
 
 # RELOCS:      Relocations [
 # RELOCS-NEXT: ]
 
 .weak foo
 
 .globl _start
 _start:
 # DISASM: _start:
 # DISASM-NEXT: 1000: 48 8b 05 69 10 00 00 movq 4201(%rip), %rax
 #                                              ^ .got - (.text + 7)
 mov foo@gotpcrel(%rip), %rax

test/ELF/progname.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: echo .global __progname > %t2.s
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t2.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld -o %t %t.o %t2.so
 // RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
 
 // RUN: echo "VER_1 { global: bar; };" > %t.script

test/ELF/relative-dynamic-reloc-pie.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -pie %t.o -o %t.pie
 # RUN: llvm-readobj -r -dyn-symbols %t.pie | FileCheck %s
 
 ## Test that we create R_X86_64_RELATIVE relocations with -pie.
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 # CHECK-NEXT:     0x2000 R_X86_64_RELATIVE - 0x2000

test/ELF/relative-dynamic-reloc.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 
 // Test that we create R_X86_64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [

test/ELF/relocatable-compressed-input.s

+# REQUIRES: x86
 # REQUIRES: zlib
 
 # RUN: llvm-mc -compress-debug-sections=zlib-gnu -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 # RUN: llvm-readobj -sections %t1 | FileCheck -check-prefix=GNU %s
 # GNU: Name: .zdebug_str
 
 # RUN: ld.lld %t1 -o %t2 -r
 # RUN: llvm-readobj -sections -section-data %t2 | FileCheck %s
 

test/ELF/relocatable-reloc.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj %s -o %t.o -triple=x86_64-pc-linux
 // RUN: ld.lld %t.o %t.o -r -o %t2.o
 // RUN: llvm-readobj -r %t2.o | FileCheck %s
 
 .weak foo
 foo:
 .quad foo
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.text {
 // CHECK-NEXT:     0x0 R_X86_64_64 foo 0x0
 // CHECK-NEXT:     0x8 R_X86_64_64 foo 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/relocatable-section-symbol.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -r -o %t %t.o %t.o
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=RELA %s
 
 # RELA:      Relocations [
 # RELA-NEXT:   Section ({{.*}}) .rela.data {
 # RELA-NEXT:     0x0 R_X86_64_32 .text 0x1
 # RELA-NEXT:     0x4 R_X86_64_32 .text 0x5

test/ELF/relocatable-sections.s

+# REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: ld.lld -r %t1.o -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 
 # CHECK:      .text
 # CHECK-NEXT: .rela.text
 # CHECK: .text._init
 # CHECK-NEXT: .rela.text._init

test/ELF/relocatable-tls.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:   %S/Inputs/relocatable-tls.s -o %t2.o
 
 # RUN: ld.lld -r %t2.o -o %t3.r
 # RUN: llvm-objdump -t %t3.r | FileCheck --check-prefix=RELOCATABLE %s
 # RELOCATABLE: SYMBOL TABLE:
 # RELOCATABLE: 0000000000000000 *UND* 00000000 __tls_get_addr
 
 # RUN: ld.lld -shared %t2.o %t3.r -o %t4.out
 # RUN: llvm-objdump -t %t4.out | FileCheck --check-prefix=DSO %s
 # DSO: SYMBOL TABLE:
 # DSO: 0000000000000000 *UND* 00000000 __tls_get_addr
 
 callq __tls_get_addr@PLT

test/ELF/relocation-shared.s

+// REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -shared -o %t.so
 // RUN: llvm-readobj -r -s -section-data %t.so | FileCheck %s
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC