This is an archive of the discontinued LLVM Phabricator instance.

Differential D47513

[ELF] Remove redundant use of -m/-triple in test files. NFC.
ClosedPublic

Authored by sbc100 on May 29 2018, 10:02 PM.

Details

Reviewers
• espindola
pcc
Commits
rG3d63a409a00d: [ELF] Remove -m argument to lld in test files. NFC.
rLLD333567: [ELF] Remove -m argument to lld in test files. NFC.
rL333567: [ELF] Remove -m argument to lld in test files. NFC.
Summary

This makes the tests slightly easier to maintain and compare
with the equivalent tests under for other platforms.

Diff Detail

Repository
rL LLVM

Event Timeline

sbc100 created this revision.May 29 2018, 10:02 PM
Herald added a reviewer: • espindola. · View Herald TranscriptMay 29 2018, 10:02 PM
Herald added subscribers: llvm-commits, aheejin, eraman and 2 others. · View Herald Transcript
sbc100 added a reviewer: pcc.May 29 2018, 10:03 PM
pcc added a comment.May 29 2018, 10:06 PM

I don't think you can drop use of -triple because that would cause llvm-mc to default to the host triple, which would mean that the tests would start failing on non-ELF platforms.

Dropping the -m seems reasonable to me though.

sbc100 updated this revision to Diff 149157.May 30 2018, 10:28 AM
  • feedback
Harbormaster completed remote builds in B18750: Diff 149157.May 30 2018, 10:28 AM
pcc accepted this revision.May 30 2018, 10:39 AM

LGTM

This revision is now accepted and ready to land.May 30 2018, 10:39 AM
Closed by commit rL333567: [ELF] Remove -m argument to lld in test files. NFC. (authored by sbc). · Explain WhyMay 30 2018, 11:01 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lld/
trunk/
test/
ELF/
lto/
Inputs/
1 line
1 line
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
20 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
4 lines
2 lines
8 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
5 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines

Diff 149164

lld/trunk/test/ELF/lto/Inputs/archive-3.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
ret void ret void
} }

lld/trunk/test/ELF/lto/Inputs/common3.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@a = common hidden global i64 0, align 4 @a = common hidden global i64 0, align 4

lld/trunk/test/ELF/lto/archive-2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %S/Inputs/archive-2.ll -o %t1.o ; RUN: llvm-as %S/Inputs/archive-2.ll -o %t1.o
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t1.o ; RUN: llvm-ar rcs %t.a %t1.o
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t2.o %t.a -o %t3 ; RUN: ld.lld %t2.o %t.a -o %t3
; RUN: llvm-readobj -t %t3 | FileCheck %s ; RUN: llvm-readobj -t %t3 | FileCheck %s
; RUN: ld.lld -m elf_x86_64 %t2.o --whole-archive %t.a -o %t3 -shared ; RUN: ld.lld %t2.o --whole-archive %t.a -o %t3 -shared
; RUN: llvm-readobj -t %t3 | FileCheck %s ; RUN: llvm-readobj -t %t3 | FileCheck %s
; CHECK: Name: _start ( ; CHECK: Name: _start (
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
Show All 12 Lines

lld/trunk/test/ELF/lto/archive-3.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %S/Inputs/archive-3.ll -o %t1.o ; RUN: llvm-as %S/Inputs/archive-3.ll -o %t1.o
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t3 -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t3 -save-temps
; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t1.o ; RUN: llvm-ar rcs %t.a %t1.o
; RUN: ld.lld -m elf_x86_64 %t.a %t1.o %t2.o -o %t3 -save-temps ; RUN: ld.lld %t.a %t1.o %t2.o -o %t3 -save-temps
; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t3.0.2.internalize.bc -o - | FileCheck %s
; CHECK: define internal void @foo() { ; CHECK: define internal void @foo() {
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
ret void ret void
} }

lld/trunk/test/ELF/lto/archive-no-index.ll

; REQUIRES: x86 ; REQUIRES: x86
; Tests that we suggest that LTO symbols missing from an archive index ; Tests that we suggest that LTO symbols missing from an archive index
; may be the cause of undefined references, but only if we both ; may be the cause of undefined references, but only if we both
; encountered an empty archive index and undefined references (to prevent ; encountered an empty archive index and undefined references (to prevent
; noisy false alarms). ; noisy false alarms).
; RUN: llvm-as -o %t1.o %s ; RUN: llvm-as -o %t1.o %s
; RUN: llvm-as -o %t2.o %S/Inputs/archive.ll ; RUN: llvm-as -o %t2.o %S/Inputs/archive.ll
; RUN: rm -f %t1.a %t2.a ; RUN: rm -f %t1.a %t2.a
; RUN: llvm-ar crS %t1.a %t2.o ; RUN: llvm-ar crS %t1.a %t2.o
; RUN: llvm-ar crs %t2.a %t2.o ; RUN: llvm-ar crs %t2.a %t2.o
; RUN: ld.lld -o %t -emain -m elf_x86_64 %t1.o %t1.a ; RUN: ld.lld -o %t -emain %t1.o %t1.a
; RUN: ld.lld -o %t -emain -m elf_x86_64 %t1.o %t2.a ; RUN: ld.lld -o %t -emain %t1.o %t2.a
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @f() declare void @f()
define i32 @main() { define i32 @main() {
call void @f() call void @f()
ret i32 0 ret i32 0
} }

lld/trunk/test/ELF/lto/archive.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o ; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t1.o ; RUN: llvm-ar rcs %t.a %t1.o
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t2.o %t.a -o %t3 -shared ; RUN: ld.lld %t2.o %t.a -o %t3 -shared
; RUN: llvm-readobj -t %t3 | FileCheck %s ; RUN: llvm-readobj -t %t3 | FileCheck %s
; RUN: ld.lld -m elf_x86_64 %t2.o --whole-archive %t.a -o %t3 -shared ; RUN: ld.lld %t2.o --whole-archive %t.a -o %t3 -shared
; RUN: llvm-readobj -t %t3 | FileCheck %s ; RUN: llvm-readobj -t %t3 | FileCheck %s
; CHECK: Name: g ( ; CHECK: Name: g (
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
Show All 20 Lines

lld/trunk/test/ELF/lto/asmundef.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %S/Inputs/asmundef.ll -o %t2.o ; RUN: llvm-as %S/Inputs/asmundef.ll -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t -save-temps ; RUN: ld.lld %t.o %t2.o -o %t -save-temps
; RUN: llvm-dis %t.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.0.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
module asm ".weak patatino" module asm ".weak patatino"
module asm ".equ patatino, foo" module asm ".equ patatino, foo"
Show All 13 Lines

lld/trunk/test/ELF/lto/available-externally.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %p/Inputs/available-externally.ll -o %t2.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: ld.lld %t1.o %t2.o -o %t.so -shared -save-temps
; RUN: llvm-dis < %t.so.0.2.internalize.bc | FileCheck %s ; 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 datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void @bar() call void @bar()
call void @zed() call void @zed()
Show All 11 Lines

lld/trunk/test/ELF/lto/bitcode-nodatalayout.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: not ld.lld -m elf_x86_64 %t.o -o %t 2>&1 | FileCheck %s ; RUN: not ld.lld %t.o -o %t 2>&1 | FileCheck %s
; CHECK: input module has no datalayout ; CHECK: input module has no datalayout
; This bitcode file has no datalayout. ; This bitcode file has no datalayout.
; Check that we error out producing a reasonable diagnostic. ; Check that we error out producing a reasonable diagnostic.
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
ret void ret void
} }

lld/trunk/test/ELF/lto/codemodel.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %ts -mllvm -code-model=small ; RUN: ld.lld %t.o -o %ts -mllvm -code-model=small
; RUN: ld.lld -m elf_x86_64 %t.o -o %tl -mllvm -code-model=large ; RUN: ld.lld %t.o -o %tl -mllvm -code-model=large
; RUN: llvm-objdump -d %ts | FileCheck %s --check-prefix=CHECK-SMALL ; RUN: llvm-objdump -d %ts | FileCheck %s --check-prefix=CHECK-SMALL
; RUN: llvm-objdump -d %tl | FileCheck %s --check-prefix=CHECK-LARGE ; RUN: llvm-objdump -d %tl | FileCheck %s --check-prefix=CHECK-LARGE
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@data = internal constant [0 x i32] [] @data = internal constant [0 x i32] []
define i32* @_start() nounwind readonly { define i32* @_start() nounwind readonly {
entry: entry:
; CHECK-SMALL-LABEL: _start: ; CHECK-SMALL-LABEL: _start:
; CHECK-SMALL: movl $2097440, %eax ; CHECK-SMALL: movl $2097440, %eax
; CHECK-LARGE-LABEL: _start: ; CHECK-LARGE-LABEL: _start:
; CHECK-LARGE: movabsq $2097440, %rax ; CHECK-LARGE: movabsq $2097440, %rax
ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0) ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
} }

lld/trunk/test/ELF/lto/combined-lto-object-name.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: not ld.lld -m elf_x86_64 %t.o -o %t2 2>&1 | FileCheck %s ; RUN: not ld.lld %t.o -o %t2 2>&1 | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
declare void @foo() declare void @foo()
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }
; CHECK: error: undefined symbol: foo ; CHECK: error: undefined symbol: foo
; CHECK: >>> referenced by ld-temp.o ; CHECK: >>> referenced by ld-temp.o
; CHECK: {{.*}}:(_start) ; CHECK: {{.*}}:(_start)

lld/trunk/test/ELF/lto/comdat.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o %t.o -o %t.so -shared ; RUN: ld.lld %t.o %t.o -o %t.so -shared
; RUN: llvm-readobj -t %t.so | FileCheck %s ; RUN: llvm-readobj -t %t.so | FileCheck %s
; CHECK: Name: foo ; CHECK: Name: foo
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
Show All 10 Lines

lld/trunk/test/ELF/lto/comdat2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; 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: 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: ld.lld %t.o %t2.o -o %t.so -shared
; RUN: llvm-readobj -t %t.so | FileCheck %s ; RUN: llvm-readobj -t %t.so | FileCheck %s
; RUN: ld.lld -m elf_x86_64 %t2.o %t.o -o %t2.so -shared ; RUN: ld.lld %t2.o %t.o -o %t2.so -shared
; RUN: llvm-readobj -t %t2.so | FileCheck %s --check-prefix=OTHER ; RUN: llvm-readobj -t %t2.so | FileCheck %s --check-prefix=OTHER
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
$c = comdat any $c = comdat any
Show All 27 Lines

lld/trunk/test/ELF/lto/common2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld -m elf_x86_64 %t1.o -o %t -shared -save-temps ; RUN: ld.lld %t1.o -o %t -shared -save-temps
; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s
; RUN: llvm-readobj -t %t | FileCheck %s --check-prefix=SHARED ; 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 datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@a = common global i8 0, align 8 @a = common global i8 0, align 8
; CHECK-DAG: @a = common global i8 0, align 8 ; CHECK-DAG: @a = common global i8 0, align 8
Show All 17 Lines

lld/trunk/test/ELF/lto/common3.ll

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

lld/trunk/test/ELF/lto/ctors.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-readobj -sections %t.so | FileCheck %s ; RUN: llvm-readobj -sections %t.so | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
define void @ctor() { define void @ctor() {
call void asm "nop", ""() call void asm "nop", ""()
ret void ret void
} }
; The llvm.global_ctors should end up producing constructors. ; The llvm.global_ctors should end up producing constructors.
; On x86-64 (linux) we should always emit .init_array and never .ctors. ; On x86-64 (linux) we should always emit .init_array and never .ctors.
; CHECK: Name: .init_array ; CHECK: Name: .init_array
; CHECK-NOT: Name: .ctors ; CHECK-NOT: Name: .ctors

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

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 -shared -save-temps %t.o -o %t2.o ; RUN: ld.lld -shared -save-temps %t.o -o %t2.o
; RUN: llvm-dis < %t2.o.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis < %t2.o.0.0.preopt.bc | FileCheck %s
; CHECK: @GlobalValueName ; CHECK: @GlobalValueName
; CHECK: @foo(i32 %in) ; CHECK: @foo(i32 %in)
; CHECK: somelabel: ; CHECK: somelabel:
; CHECK: %GV = load i32, i32* @GlobalValueName ; CHECK: %GV = load i32, i32* @GlobalValueName
; CHECK: %add = add i32 %in, %GV ; CHECK: %add = add i32 %in, %GV
; CHECK: ret i32 %add ; CHECK: ret i32 %add
Show All 12 Lines

lld/trunk/test/ELF/lto/drop-debug-info.ll

; REQUIRES: x86 ; REQUIRES: x86
; ;
; drop-debug-info.bc was created from "void f(void) {}" with clang 3.5 and ; drop-debug-info.bc was created from "void f(void) {}" with clang 3.5 and
; -gline-tables-only, so it contains old debug info. ; -gline-tables-only, so it contains old debug info.
; ;
; RUN: ld.lld -m elf_x86_64 -shared %p/Inputs/drop-debug-info.bc \ ; RUN: ld.lld -shared %p/Inputs/drop-debug-info.bc \
; RUN: -disable-verify -o %t 2>&1 | FileCheck %s ; RUN: -disable-verify -o %t 2>&1 | FileCheck %s
; CHECK: ignoring debug info with an invalid version (1) in {{.*}}drop-debug-info.bc ; CHECK: ignoring debug info with an invalid version (1) in {{.*}}drop-debug-info.bc

lld/trunk/test/ELF/lto/drop-linkage.ll

target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; REQUIRES: x86 ; REQUIRES: x86
; RUN: llc %s -o %t.o -filetype=obj ; RUN: llc %s -o %t.o -filetype=obj
; RUN: llvm-as %p/Inputs/drop-linkage.ll -o %t2.o ; RUN: llvm-as %p/Inputs/drop-linkage.ll -o %t2.o
; RUN: ld.lld %t.o %t2.o -o %t.so -save-temps -shared ; RUN: ld.lld %t.o %t2.o -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; 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"
define void @foo() { define void @foo() {
ret void ret void
} }
; CHECK: declare void @foo() ; CHECK: declare void @foo()

lld/trunk/test/ELF/lto/duplicated.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: not ld.lld -m elf_x86_64 %t.o %t.o -o %t.so -shared 2>&1 | FileCheck %s ; RUN: not ld.lld %t.o %t.o -o %t.so -shared 2>&1 | FileCheck %s
; CHECK: duplicate symbol: f ; CHECK: duplicate symbol: f
; CHECK-NEXT: >>> defined in {{.*}}.o ; CHECK-NEXT: >>> defined in {{.*}}.o
; CHECK-NEXT: >>> defined in {{.*}}.o ; CHECK-NEXT: >>> defined in {{.*}}.o
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f() { define void @f() {
ret void ret void
} }

lld/trunk/test/ELF/lto/dynamic-list.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "{ foo; };" > %t.list ; RUN: echo "{ foo; };" > %t.list
; RUN: ld.lld -m elf_x86_64 -o %t --dynamic-list %t.list -pie %t.o ; RUN: ld.lld -o %t --dynamic-list %t.list -pie %t.o
; RUN: llvm-readobj -dyn-symbols %t | FileCheck %s ; RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
; CHECK: Name: foo@ ; CHECK: Name: foo@
; CHECK-NEXT: Value: 0x1010 ; CHECK-NEXT: Value: 0x1010
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Global (0x1) ; CHECK-NEXT: Binding: Global (0x1)
; CHECK-NEXT: Type: Function ; CHECK-NEXT: Type: Function
; CHECK-NEXT: Other: 0 ; CHECK-NEXT: Other: 0
Show All 13 Lines

lld/trunk/test/ELF/lto/dynsym.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -o %t.o %p/Inputs/dynsym.s ; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux -o %t.o %p/Inputs/dynsym.s
; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t2.o %t.so -o %t ; RUN: ld.lld %t2.o %t.so -o %t
; RUN: llvm-readobj -dyn-symbols %t | FileCheck %s ; RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
; Check that we don't crash when gc'ing sections and printing the result. ; Check that we don't crash when gc'ing sections and printing the result.
; RUN: ld.lld -m elf_x86_64 %t2.o %t.so --gc-sections --print-gc-sections \ ; RUN: ld.lld %t2.o %t.so --gc-sections --print-gc-sections \
; RUN: -o %t ; RUN: -o %t
; RUN: llvm-readobj -dyn-symbols %t | FileCheck %s ; RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
call void @foo() call void @foo()
Show All 13 Lines

lld/trunk/test/ELF/lto/inline-asm.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void asm "nop", ""() call void asm "nop", ""()
ret void ret void
} }

lld/trunk/test/ELF/lto/internalize-basic.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -save-temps ; RUN: ld.lld %t.o -o %t2 -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
Show All 10 Lines

lld/trunk/test/ELF/lto/internalize-exportdyn.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/internalize-exportdyn.ll -o %t2.o ; RUN: llvm-as %p/Inputs/internalize-exportdyn.ll -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t2 --export-dynamic -save-temps ; RUN: ld.lld %t.o %t2.o -o %t2 --export-dynamic -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
Show All 35 Lines

lld/trunk/test/ELF/lto/internalize-llvmused.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -save-temps ; RUN: ld.lld %t.o -o %t2 -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
Show All 9 Lines

lld/trunk/test/ELF/lto/internalize-undef.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/internalize-undef.ll -o %t2.o ; RUN: llvm-as %p/Inputs/internalize-undef.ll -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t -save-temps ; RUN: ld.lld %t.o %t2.o -o %t -save-temps
; RUN: llvm-dis < %t.0.2.internalize.bc | FileCheck %s ; 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 datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @f() declare void @f()
define void @_start() { define void @_start() {
call void @f() call void @f()
ret void ret void
} }
; CHECK: define internal void @f() ; CHECK: define internal void @f()

lld/trunk/test/ELF/lto/internalize-version-script.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "{ global: foo; local: *; };" > %t.script ; RUN: echo "{ global: foo; local: *; };" > %t.script
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -shared --version-script %t.script -save-temps ; RUN: ld.lld %t.o -o %t2 -shared --version-script %t.script -save-temps
; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.2.internalize.bc | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
Show All 10 Lines

lld/trunk/test/ELF/lto/irmover-error.ll

; RUN: llvm-as -o %t1.bc %s ; RUN: llvm-as -o %t1.bc %s
; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-error.ll ; RUN: llvm-as -o %t2.bc %S/Inputs/irmover-error.ll
; RUN: not ld.lld -m elf_x86_64 %t1.bc %t2.bc -o %t 2>&1 | FileCheck %s ; RUN: not ld.lld %t1.bc %t2.bc -o %t 2>&1 | FileCheck %s
; CHECK: linking module flags 'foo': IDs have conflicting values ; CHECK: linking module flags 'foo': IDs have conflicting values
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
!0 = !{ i32 1, !"foo", i32 1 } !0 = !{ i32 1, !"foo", i32 1 }
!llvm.module.flags = !{ !0 } !llvm.module.flags = !{ !0 }

lld/trunk/test/ELF/lto/keep-undefined.ll

; REQUIRES: x86 ; REQUIRES: x86
; This test checks that symbols which are specified in "-u" switches ; This test checks that symbols which are specified in "-u" switches
; are kept over LTO if we link an executable. ; are kept over LTO if we link an executable.
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %tout -u foo ; RUN: ld.lld %t.o -o %tout -u foo
; RUN: llvm-nm %tout | FileCheck %s ; RUN: llvm-nm %tout | FileCheck %s
; CHECK: T foo ; CHECK: T foo
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
} }
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }

lld/trunk/test/ELF/lto/linkage.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld -m elf_x86_64 %t1.o %t1.o -o %t.so -shared ; RUN: ld.lld %t1.o %t1.o -o %t.so -shared
; RUN: llvm-nm %t.so | FileCheck %s ; RUN: llvm-nm %t.so | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Should not encounter a duplicate symbol error for @.str ; Should not encounter a duplicate symbol error for @.str
@.str = private unnamed_addr constant [4 x i8] c"Hey\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"Hey\00", align 1
Show All 9 Lines

lld/trunk/test/ELF/lto/linker-script-symbols-assign.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "foo = 1;" > %t.script ; RUN: echo "foo = 1;" > %t.script
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 --script %t.script -save-temps ; RUN: ld.lld %t.o -o %t2 --script %t.script -save-temps
; RUN: llvm-readobj -symbols %t2.lto.o | FileCheck %s ; RUN: llvm-readobj -symbols %t2.lto.o | FileCheck %s
; CHECK-NOT: bar ; CHECK-NOT: bar
; CHECK-NOT: foo ; CHECK-NOT: foo
; RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=VAL ; RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=VAL
; VAL: Symbol { ; VAL: Symbol {
; VAL: Name: foo ; VAL: Name: foo
; VAL-NEXT: Value: 0x1 ; VAL-NEXT: Value: 0x1
; VAL-NEXT: Size: ; VAL-NEXT: Size:
; VAL-NEXT: Binding: Global ; VAL-NEXT: Binding: Global
; VAL-NEXT: Type: None ; VAL-NEXT: Type: None
; VAL-NEXT: Other: ; VAL-NEXT: Other:
; VAL-NEXT: Section: Absolute ; VAL-NEXT: Section: Absolute
; VAL-NEXT: } ; VAL-NEXT: }
; RUN: echo "zed = 1;" > %t2.script ; RUN: echo "zed = 1;" > %t2.script
; RUN: ld.lld -m elf_x86_64 %t.o -o %t3 --script %t2.script ; RUN: ld.lld %t.o -o %t3 --script %t2.script
; RUN: llvm-readobj -symbols %t3 | FileCheck %s --check-prefix=ABS ; RUN: llvm-readobj -symbols %t3 | FileCheck %s --check-prefix=ABS
; ABS: Symbol { ; ABS: Symbol {
; ABS: Name: zed ; ABS: Name: zed
; ABS-NEXT: Value: 0x1 ; ABS-NEXT: Value: 0x1
; ABS-NEXT: Size: 0 ; ABS-NEXT: Size: 0
; ABS-NEXT: Binding: Global ; ABS-NEXT: Binding: Global
; ABS-NEXT: Type: None ; ABS-NEXT: Type: None
; ABS-NEXT: Other: 0 ; ABS-NEXT: Other: 0
; ABS-NEXT: Section: Absolute ; ABS-NEXT: Section: Absolute
; ABS-NEXT: } ; ABS-NEXT: }
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@foo = global i32 0 @foo = global i32 0
@bar = global i32 0 @bar = global i32 0

lld/trunk/test/ELF/lto/linker-script-symbols-ipo.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %S/Inputs/linker-script-symbols-ipo.ll -o %t2.o ; RUN: llvm-as %S/Inputs/linker-script-symbols-ipo.ll -o %t2.o
; RUN: echo "bar = foo;" > %t.script ; RUN: echo "bar = foo;" > %t.script
;; Check that without linkerscript bar is inlined. ;; Check that without linkerscript bar is inlined.
; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t3 -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t3 -save-temps
; RUN: llvm-objdump -d %t3 | FileCheck %s --check-prefix=IPO ; RUN: llvm-objdump -d %t3 | FileCheck %s --check-prefix=IPO
; IPO: Disassembly of section .text: ; IPO: Disassembly of section .text:
; IPO: _start: ; IPO: _start:
; IPO-NEXT: 201000: {{.*}} movl $1, %eax ; IPO-NEXT: 201000: {{.*}} movl $1, %eax
; IPO-NEXT: 201005: {{.*}} retq ; IPO-NEXT: 201005: {{.*}} retq
;; Check that LTO does not do IPO for symbols assigned by script. ;; Check that LTO does not do IPO for symbols assigned by script.
; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t4 --script %t.script -save-temps ; RUN: ld.lld %t1.o %t2.o -o %t4 --script %t.script -save-temps
; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO ; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO
; NOIPO: Disassembly of section .text: ; NOIPO: Disassembly of section .text:
; NOIPO: foo: ; NOIPO: foo:
; NOIPO-NEXT: {{.*}} movl $2, %eax ; NOIPO-NEXT: {{.*}} movl $2, %eax
; NOIPO: _start: ; NOIPO: _start:
; NOIPO-NEXT: {{.*}} jmp -21 <foo> ; NOIPO-NEXT: {{.*}} jmp -21 <foo>
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 9 Lines

lld/trunk/test/ELF/lto/linker-script-symbols.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "foo = bar;" > %t.script ; RUN: echo "foo = bar;" > %t.script
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 --script %t.script -save-temps ; RUN: ld.lld %t.o -o %t2 --script %t.script -save-temps
; RUN: llvm-readobj -symbols %t2.lto.o | FileCheck %s ; RUN: llvm-readobj -symbols %t2.lto.o | FileCheck %s
; CHECK-NOT: zed ; CHECK-NOT: zed
; CHECK: Symbol { ; CHECK: Symbol {
; CHECK: Name: bar ; CHECK: Name: bar
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
; CHECK-NEXT: Size: ; CHECK-NEXT: Size:
; CHECK-NEXT: Binding: Global ; CHECK-NEXT: Binding: Global
Show All 16 Lines

lld/trunk/test/ELF/lto/lto-start.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 ; RUN: ld.lld %t.o -o %t2
; RUN: llvm-readobj -t %t2 | FileCheck %s ; RUN: llvm-readobj -t %t2 | FileCheck %s
; CHECK: Format: ELF64-x86-64 ; CHECK: Format: ELF64-x86-64
; CHECK-NEXT: Arch: x86_64 ; CHECK-NEXT: Arch: x86_64
; CHECK-NEXT: AddressSize: 64bit ; CHECK-NEXT: AddressSize: 64bit
; CHECK: Name: _start ; CHECK: Name: _start
; CHECK-NEXT: Value: ; CHECK-NEXT: Value:
Show All 12 Lines

lld/trunk/test/ELF/lto/ltopasses-basic.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps -mllvm -debug-pass=Arguments -shared 2>&1 | FileCheck %s --check-prefix=MLLVM ; RUN: ld.lld %t.o -o %t.so -save-temps -mllvm -debug-pass=Arguments -shared 2>&1 | FileCheck %s --check-prefix=MLLVM
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }] @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @ctor, i8* null }]
define void @ctor() { define void @ctor() {
ret void ret void
} }
; `@ctor` doesn't do anything and so the optimizer should kill it, leaving no ctors ; `@ctor` doesn't do anything and so the optimizer should kill it, leaving no ctors
; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer ; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer
; MLLVM: Pass Arguments: ; MLLVM: Pass Arguments:

lld/trunk/test/ELF/lto/ltopasses-custom.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -save-temps --lto-aa-pipeline=basic-aa \ ; RUN: ld.lld %t.o -o %t.so -save-temps --lto-aa-pipeline=basic-aa \
; RUN: --lto-newpm-passes=ipsccp -shared ; RUN: --lto-newpm-passes=ipsccp -shared
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2.so -save-temps --lto-newpm-passes=loweratomic -shared ; RUN: ld.lld %t.o -o %t2.so -save-temps --lto-newpm-passes=loweratomic -shared
; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.4.opt.bc -o - | FileCheck %s
; RUN: llvm-dis %t2.so.0.4.opt.bc -o - | FileCheck %s --check-prefix=ATOMIC ; RUN: llvm-dis %t2.so.0.4.opt.bc -o - | FileCheck %s --check-prefix=ATOMIC
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @barrier() { define void @barrier() {
fence seq_cst fence seq_cst
Show All 24 Lines

lld/trunk/test/ELF/lto/metadata.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld -m elf_x86_64 %t1.o %t1.o -o %t.so -shared ; RUN: ld.lld %t1.o %t1.o -o %t.so -shared
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define weak void @foo(i32* %p) { define weak void @foo(i32* %p) {
store i32 5, i32* %p, align 4, !tbaa !0 store i32 5, i32* %p, align 4, !tbaa !0
ret void ret void
} }
!0 = !{!1, !1, i64 0} !0 = !{!1, !1, i64 0}
!1 = !{!"int", !2} !1 = !{!"int", !2}
!2 = !{!"Simple C/C++ TBAA"} !2 = !{!"Simple C/C++ TBAA"}

lld/trunk/test/ELF/lto/module-asm.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t ; RUN: ld.lld %t.o -o %t
; RUN: llvm-nm %t | FileCheck %s ; RUN: llvm-nm %t | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
module asm ".text" module asm ".text"
module asm ".globl foo" module asm ".globl foo"
; CHECK: T foo ; CHECK: T foo
module asm "foo: ret" module asm "foo: ret"
declare void @foo() declare void @foo()
define void @_start() { define void @_start() {
call void @foo() call void @foo()
ret void ret void
} }

lld/trunk/test/ELF/lto/opt-level.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.o %s ; RUN: llvm-as -o %t.o %s
; RUN: ld.lld -o %t0 -m elf_x86_64 -e main --lto-O0 %t.o ; RUN: ld.lld -o %t0 -e main --lto-O0 %t.o
; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s ; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s
; RUN: ld.lld -o %t0 -m elf_x86_64 -e main --plugin-opt=O0 %t.o ; RUN: ld.lld -o %t0 -e main --plugin-opt=O0 %t.o
; RUN: llvm-nm %t0 | FileCheck --check-prefix=CHECK-O0 %s ; 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: ld.lld -o %t2 -e main --lto-O2 %t.o
; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
; RUN: ld.lld -o %t2a -m elf_x86_64 -e main %t.o ; RUN: ld.lld -o %t2a -e main %t.o
; RUN: llvm-nm %t2a | FileCheck --check-prefix=CHECK-O2 %s ; RUN: llvm-nm %t2a | FileCheck --check-prefix=CHECK-O2 %s
; RUN: ld.lld -o %t2 -m elf_x86_64 -e main %t.o --plugin-opt O2 ; RUN: ld.lld -o %t2 -e main %t.o --plugin-opt O2
; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s ; RUN: llvm-nm %t2 | FileCheck --check-prefix=CHECK-O2 %s
; Reject invalid optimization levels. ; Reject invalid optimization levels.
; RUN: not ld.lld -o %t3 -m elf_x86_64 -e main --lto-O6 %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --lto-O6 %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALID1 %s ; RUN: FileCheck --check-prefix=INVALID1 %s
; INVALID1: invalid optimization level for LTO: 6 ; INVALID1: invalid optimization level for LTO: 6
; RUN: not ld.lld -o %t3 -m elf_x86_64 -e main --plugin-opt=O6 %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --plugin-opt=O6 %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALID1 %s ; RUN: FileCheck --check-prefix=INVALID1 %s
; RUN: not ld.lld -o %t3 -m elf_x86_64 -e main --plugin-opt=Ofoo %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --plugin-opt=Ofoo %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALID2 %s ; RUN: FileCheck --check-prefix=INVALID2 %s
; INVALID2: --plugin-opt=Ofoo: number expected, but got 'foo' ; INVALID2: --plugin-opt=Ofoo: number expected, but got 'foo'
; RUN: not ld.lld -o %t3 -m elf_x86_64 -e main --lto-O-1 %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --lto-O-1 %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALIDNEGATIVE1 %s ; RUN: FileCheck --check-prefix=INVALIDNEGATIVE1 %s
; INVALIDNEGATIVE1: invalid optimization level for LTO: 4294967295 ; INVALIDNEGATIVE1: invalid optimization level for LTO: 4294967295
; RUN: not ld.lld -o %t3 -m elf_x86_64 -e main --plugin-opt=O-1 %t.o 2>&1 | \ ; RUN: not ld.lld -o %t3 -e main --plugin-opt=O-1 %t.o 2>&1 | \
; RUN: FileCheck --check-prefix=INVALIDNEGATIVE2 %s ; RUN: FileCheck --check-prefix=INVALIDNEGATIVE2 %s
; INVALIDNEGATIVE2: invalid optimization level for LTO: 4294967295 ; INVALIDNEGATIVE2: invalid optimization level for LTO: 4294967295
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-O0: foo ; CHECK-O0: foo
; CHECK-O2-NOT: foo ; CHECK-O2-NOT: foo
define internal void @foo() { define internal void @foo() {
ret void ret void
} }
define void @main() { define void @main() {
call void @foo() call void @foo()
ret void ret void
} }

lld/trunk/test/ELF/lto/parallel-internalize.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.bc %s ; RUN: llvm-as -o %t.bc %s
; RUN: rm -f %t.lto.o %t1.lto.o ; RUN: rm -f %t.lto.o %t1.lto.o
; RUN: ld.lld -m elf_x86_64 --lto-partitions=2 -save-temps -o %t %t.bc \ ; RUN: ld.lld --lto-partitions=2 -save-temps -o %t %t.bc \
; RUN: -e foo --lto-O0 ; RUN: -e foo --lto-O0
; RUN: llvm-readobj -t -dyn-symbols %t | FileCheck %s ; RUN: llvm-readobj -t -dyn-symbols %t | FileCheck %s
; RUN: llvm-nm %t.lto.o | FileCheck --check-prefix=CHECK0 %s ; RUN: llvm-nm %t.lto.o | FileCheck --check-prefix=CHECK0 %s
; RUN: llvm-nm %t1.lto.o | FileCheck --check-prefix=CHECK1 %s ; RUN: llvm-nm %t1.lto.o | FileCheck --check-prefix=CHECK1 %s
; CHECK: Symbols [ ; CHECK: Symbols [
; CHECK-NEXT: Symbol { ; CHECK-NEXT: Symbol {
; CHECK-NEXT: Name: (0) ; CHECK-NEXT: Name: (0)
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

lld/trunk/test/ELF/lto/parallel.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as -o %t.bc %s ; RUN: llvm-as -o %t.bc %s
; RUN: rm -f %t.lto.o %t1.lto.o ; RUN: rm -f %t.lto.o %t1.lto.o
; RUN: ld.lld -m elf_x86_64 --lto-partitions=2 -save-temps -o %t %t.bc -shared ; RUN: ld.lld --lto-partitions=2 -save-temps -o %t %t.bc -shared
; RUN: llvm-nm %t.lto.o | FileCheck --check-prefix=CHECK0 %s ; RUN: llvm-nm %t.lto.o | FileCheck --check-prefix=CHECK0 %s
; RUN: llvm-nm %t1.lto.o | FileCheck --check-prefix=CHECK1 %s ; RUN: llvm-nm %t1.lto.o | FileCheck --check-prefix=CHECK1 %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK0-NOT: bar ; CHECK0-NOT: bar
; CHECK0: T foo ; CHECK0: T foo
Show All 13 Lines

lld/trunk/test/ELF/lto/relax-relocs.ll

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

lld/trunk/test/ELF/lto/save-temps.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: cd %T ; RUN: cd %T
; RUN: rm -f a.out a.out.lto.bc a.out.lto.o ; RUN: rm -f a.out a.out.lto.bc a.out.lto.o
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/save-temps.ll -o %t2.o ; RUN: llvm-as %p/Inputs/save-temps.ll -o %t2.o
; RUN: ld.lld -shared -m elf_x86_64 %t.o %t2.o -save-temps ; RUN: ld.lld -shared %t.o %t2.o -save-temps
; RUN: llvm-nm a.out | FileCheck %s ; RUN: llvm-nm a.out | FileCheck %s
; RUN: llvm-nm a.out.0.0.preopt.bc | FileCheck %s ; RUN: llvm-nm a.out.0.0.preopt.bc | FileCheck %s
; RUN: llvm-nm a.out.lto.o | FileCheck %s ; RUN: llvm-nm a.out.lto.o | FileCheck %s
; RUN: llvm-dis a.out.0.0.preopt.bc ; RUN: llvm-dis a.out.0.0.preopt.bc
; RUN: rm -f a.out a.out.lto.bc a.out.lto.o ; RUN: rm -f a.out a.out.lto.bc a.out.lto.o
; RUN: ld.lld -shared -m elf_x86_64 %t.o %t2.o --plugin-opt=save-temps ; RUN: ld.lld -shared -m elf_x86_64 %t.o %t2.o --plugin-opt=save-temps
; RUN: llvm-nm a.out | FileCheck %s ; RUN: llvm-nm a.out | FileCheck %s
Show All 13 Lines

lld/trunk/test/ELF/lto/start-lib.ll

; REQUIRES: x86 ; REQUIRES: x86
; ;
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %p/Inputs/start-lib1.ll -o %t2.o ; RUN: llvm-as %p/Inputs/start-lib1.ll -o %t2.o
; RUN: llvm-as %p/Inputs/start-lib2.ll -o %t3.o ; RUN: llvm-as %p/Inputs/start-lib2.ll -o %t3.o
; ;
; RUN: ld.lld -m elf_x86_64 -shared -o %t3 %t1.o %t2.o %t3.o ; RUN: ld.lld -shared -o %t3 %t1.o %t2.o %t3.o
; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST1 %s ; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST1 %s
; TEST1: Name: bar ; TEST1: Name: bar
; TEST1: Name: foo ; TEST1: Name: foo
; ;
; RUN: ld.lld -m elf_x86_64 -shared -o %t3 -u bar %t1.o --start-lib %t2.o %t3.o ; RUN: ld.lld -shared -o %t3 -u bar %t1.o --start-lib %t2.o %t3.o
; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST2 %s ; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST2 %s
; TEST2: Name: bar ; TEST2: Name: bar
; TEST2-NOT: Name: foo ; TEST2-NOT: Name: foo
; ;
; RUN: ld.lld -m elf_x86_64 -shared -o %t3 %t1.o --start-lib %t2.o %t3.o ; RUN: ld.lld -shared -o %t3 %t1.o --start-lib %t2.o %t3.o
; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST3 %s ; RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=TEST3 %s
; TEST3-NOT: Name: bar ; TEST3-NOT: Name: bar
; TEST3-NOT: Name: foo ; TEST3-NOT: Name: foo
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @_start() { define void @_start() {
ret void ret void
} }

lld/trunk/test/ELF/lto/thinlto-cant-write-index.ll

; REQUIRES: x86 ; REQUIRES: x86
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; Ensure lld generates error if unable to write to index files ; Ensure lld generates error if unable to write to index files
; RUN: rm -f %t2.o.thinlto.bc ; RUN: rm -f %t2.o.thinlto.bc
; RUN: touch %t2.o.thinlto.bc ; RUN: touch %t2.o.thinlto.bc
; RUN: chmod 400 %t2.o.thinlto.bc ; RUN: chmod 400 %t2.o.thinlto.bc
; RUN: not ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t3 2>&1 | FileCheck %s ; RUN: not ld.lld --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t3 2>&1 | FileCheck %s
; CHECK: cannot open {{.*}}2.o.thinlto.bc: {{P|p}}ermission denied ; CHECK: cannot open {{.*}}2.o.thinlto.bc: {{P|p}}ermission denied
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/trunk/test/ELF/lto/thinlto-emit-imports.ll

Show All 25 Lines
; The index file should be created even for the input with an empty summary. ; The index file should be created even for the input with an empty summary.
; RUN: ls %t3.o.thinlto.bc ; RUN: ls %t3.o.thinlto.bc
; Ensure lld generates error if unable to write to imports file. ; Ensure lld generates error if unable to write to imports file.
; RUN: rm -f %t3.o.imports ; RUN: rm -f %t3.o.imports
; RUN: touch %t3.o.imports ; RUN: touch %t3.o.imports
; RUN: chmod 400 %t3.o.imports ; RUN: chmod 400 %t3.o.imports
; RUN: not ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only --plugin-opt=thinlto-emit-imports-files -shared %t1.o %t2.o %t3.o -o %t4 2>&1 | FileCheck %s --check-prefix=ERR ; RUN: not ld.lld --plugin-opt=thinlto-index-only --plugin-opt=thinlto-emit-imports-files -shared %t1.o %t2.o %t3.o -o %t4 2>&1 | FileCheck %s --check-prefix=ERR
; ERR: cannot open {{.*}}3.o.imports: {{P|p}}ermission denied ; ERR: cannot open {{.*}}3.o.imports: {{P|p}}ermission denied
; Ensure lld doesn't generate import files when thinlto-index-only is not enabled ; Ensure lld doesn't generate import files when thinlto-index-only is not enabled
; RUN: rm -f %t1.o.imports ; RUN: rm -f %t1.o.imports
; RUN: rm -f %t2.o.imports ; RUN: rm -f %t2.o.imports
; RUN: rm -f %t3.o.imports ; RUN: rm -f %t3.o.imports
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-emit-imports-files -shared %t1.o %t2.o %t3.o -o %t4 ; RUN: ld.lld --plugin-opt=thinlto-emit-imports-files -shared %t1.o %t2.o %t3.o -o %t4
; RUN: not ls %t1.o.imports ; RUN: not ls %t1.o.imports
; RUN: not ls %t2.o.imports ; RUN: not ls %t2.o.imports
; RUN: not ls %t3.o.imports ; RUN: not ls %t3.o.imports
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/trunk/test/ELF/lto/thinlto-index-file.ll

; REQUIRES: x86 ; REQUIRES: x86
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o ; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o
; Ensure lld writes linked files to linked objects file ; Ensure lld writes linked files to linked objects file
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only=%t.idx -shared %t1.o %t2.o %t3.o -o %t4 ; RUN: ld.lld --plugin-opt=thinlto-index-only=%t.idx -shared %t1.o %t2.o %t3.o -o %t4
; RUN: FileCheck %s < %t.idx ; RUN: FileCheck %s < %t.idx
; CHECK: {{.*}}thinlto-index-file.ll.tmp1.o ; CHECK: {{.*}}thinlto-index-file.ll.tmp1.o
; CHECK: {{.*}}thinlto-index-file.ll.tmp2.o ; CHECK: {{.*}}thinlto-index-file.ll.tmp2.o
; CHECK: {{.*}}thinlto-index-file.ll.tmp3.o ; CHECK: {{.*}}thinlto-index-file.ll.tmp3.o
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/trunk/test/ELF/lto/thinlto-index-only.ll

; REQUIRES: x86 ; REQUIRES: x86
; First ensure that the ThinLTO handling in lld handles ; First ensure that the ThinLTO handling in lld handles
; bitcode without summary sections gracefully and generates index file. ; bitcode without summary sections gracefully and generates index file.
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-as %p/Inputs/thinlto.ll -o %t2.o ; RUN: llvm-as %p/Inputs/thinlto.ll -o %t2.o
; RUN: rm -f %t3 ; RUN: rm -f %t3
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t3 ; RUN: ld.lld --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t3
; RUN: ls %t2.o.thinlto.bc ; RUN: ls %t2.o.thinlto.bc
; RUN: not test -e %t3 ; RUN: not test -e %t3
; RUN: ld.lld -m elf_x86_64 -shared %t1.o %t2.o -o %t3 ; RUN: ld.lld -shared %t1.o %t2.o -o %t3
; RUN: llvm-nm %t3 | FileCheck %s --check-prefix=NM ; RUN: llvm-nm %t3 | FileCheck %s --check-prefix=NM
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o ; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o
; Ensure lld generates an index and not a binary if requested. ; Ensure lld generates an index and not a binary if requested.
; RUN: rm -f %t4 ; RUN: rm -f %t4
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t4 ; RUN: ld.lld --plugin-opt=thinlto-index-only -shared %t1.o %t2.o -o %t4
; RUN: llvm-bcanalyzer -dump %t1.o.thinlto.bc | FileCheck %s --check-prefix=BACKEND1 ; RUN: llvm-bcanalyzer -dump %t1.o.thinlto.bc | FileCheck %s --check-prefix=BACKEND1
; RUN: llvm-bcanalyzer -dump %t2.o.thinlto.bc | FileCheck %s --check-prefix=BACKEND2 ; RUN: llvm-bcanalyzer -dump %t2.o.thinlto.bc | FileCheck %s --check-prefix=BACKEND2
; RUN: not test -e %t4 ; RUN: not test -e %t4
; Ensure lld generates an index even if the file is wrapped in --start-lib/--end-lib ; Ensure lld generates an index even if the file is wrapped in --start-lib/--end-lib
; RUN: rm -f %t2.o.thinlto.bc %t4 ; RUN: rm -f %t2.o.thinlto.bc %t4
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only -shared %t1.o %t3.o --start-lib %t2.o --end-lib -o %t4 ; RUN: ld.lld --plugin-opt=thinlto-index-only -shared %t1.o %t3.o --start-lib %t2.o --end-lib -o %t4
; RUN: ls %t2.o.thinlto.bc ; RUN: ls %t2.o.thinlto.bc
; RUN: not test -e %t4 ; RUN: not test -e %t4
; NM: T f ; NM: T f
; The backend index for this module contains summaries from itself and ; The backend index for this module contains summaries from itself and
; Inputs/thinlto.ll, as it imports from the latter. ; Inputs/thinlto.ll, as it imports from the latter.
; BACKEND1: <MODULE_STRTAB_BLOCK ; BACKEND1: <MODULE_STRTAB_BLOCK
Show All 34 Lines

lld/trunk/test/ELF/lto/thinlto-no-index.ll

; REQUIRES: x86 ; REQUIRES: x86
; Basic ThinLTO tests. ; Basic ThinLTO tests.
; RUN: opt -module-summary %s -o %t1.o ; RUN: opt -module-summary %s -o %t1.o
; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o ; RUN: opt -module-summary %p/Inputs/thinlto_empty.ll -o %t3.o
; Ensure lld doesn't generates index files when thinlto-index-only is not enabled ; Ensure lld doesn't generates index files when thinlto-index-only is not enabled
; RUN: rm -f %t1.o.thinlto.bc %t2.o.thinlto.bc %t3.o.thinlto.bc ; RUN: rm -f %t1.o.thinlto.bc %t2.o.thinlto.bc %t3.o.thinlto.bc
; RUN: ld.lld -m elf_x86_64 -shared %t1.o %t2.o %t3.o -o %t4 ; RUN: ld.lld -shared %t1.o %t2.o %t3.o -o %t4
; RUN: not ls %t1.o.thinlto.bc ; RUN: not ls %t1.o.thinlto.bc
; RUN: not ls %t2.o.thinlto.bc ; RUN: not ls %t2.o.thinlto.bc
; RUN: not ls %t3.o.thinlto.bc ; RUN: not ls %t3.o.thinlto.bc
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @g(...) declare void @g(...)
define void @f() { define void @f() {
entry: entry:
call void (...) @g() call void (...) @g()
ret void ret void
} }

lld/trunk/test/ELF/lto/thinlto-object-suffix-replace.ll

; REQUIRES: x86 ; REQUIRES: x86
; Test to make sure the thinlto-object-suffix-replace option is handled ; Test to make sure the thinlto-object-suffix-replace option is handled
; correctly. ; correctly.
; Generate bitcode file with summary, as well as a minimized bitcode without ; Generate bitcode file with summary, as well as a minimized bitcode without
; the debug metadata for the thin link. ; the debug metadata for the thin link.
; RUN: opt -thinlto-bc %s -thin-link-bitcode-file=%t1.thinlink.bc -o %t1.o ; RUN: opt -thinlto-bc %s -thin-link-bitcode-file=%t1.thinlink.bc -o %t1.o
; First perform the thin link on the normal bitcode file, and save the ; First perform the thin link on the normal bitcode file, and save the
; resulting index. ; resulting index.
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only -shared %t1.o -o %t3 ; RUN: ld.lld --plugin-opt=thinlto-index-only -shared %t1.o -o %t3
; RUN: cp %t1.o.thinlto.bc %t1.o.thinlto.bc.orig ; RUN: cp %t1.o.thinlto.bc %t1.o.thinlto.bc.orig
; Next perform the thin link on the minimized bitcode file, and compare dump ; Next perform the thin link on the minimized bitcode file, and compare dump
; of the resulting index to the above dump to ensure they are identical. ; of the resulting index to the above dump to ensure they are identical.
; RUN: rm -f %t1.o.thinlto.bc ; RUN: rm -f %t1.o.thinlto.bc
; Make sure it isn't inadvertently using the regular bitcode file. ; Make sure it isn't inadvertently using the regular bitcode file.
; RUN: rm -f %t1.o ; RUN: rm -f %t1.o
; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only \ ; RUN: ld.lld --plugin-opt=thinlto-index-only \
; RUN: --plugin-opt=thinlto-object-suffix-replace=".thinlink.bc;.o" \ ; RUN: --plugin-opt=thinlto-object-suffix-replace=".thinlink.bc;.o" \
; RUN: -shared %t1.thinlink.bc -o %t3 ; RUN: -shared %t1.thinlink.bc -o %t3
; RUN: diff %t1.o.thinlto.bc.orig %t1.o.thinlto.bc ; RUN: diff %t1.o.thinlto.bc.orig %t1.o.thinlto.bc
; Ensure lld generates error if object suffix replace option does not have 'old;new' format ; Ensure lld generates error if object suffix replace option does not have 'old;new' format
; RUN: rm -f %t1.o.thinlto.bc ; RUN: rm -f %t1.o.thinlto.bc
; RUN: not ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only \ ; RUN: not ld.lld --plugin-opt=thinlto-index-only \
; RUN: --plugin-opt=thinlto-object-suffix-replace="abc:def" -shared %t1.thinlink.bc \ ; RUN: --plugin-opt=thinlto-object-suffix-replace="abc:def" -shared %t1.thinlink.bc \
; RUN: -o %t3 2>&1 | FileCheck %s --check-prefix=ERR1 ; RUN: -o %t3 2>&1 | FileCheck %s --check-prefix=ERR1
; ERR1: --plugin-opt=thinlto-object-suffix-replace= expects 'old;new' format, but got abc:def ; ERR1: --plugin-opt=thinlto-object-suffix-replace= expects 'old;new' format, but got abc:def
; Ensure lld generates error if old suffix doesn't exist in file name ; Ensure lld generates error if old suffix doesn't exist in file name
; RUN: rm -f %t1.o ; RUN: rm -f %t1.o
; RUN: not ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only \ ; RUN: not ld.lld --plugin-opt=thinlto-index-only \
; RUN: --plugin-opt=thinlto-object-suffix-replace=".abc;.o" -shared %t1.thinlink.bc \ ; RUN: --plugin-opt=thinlto-object-suffix-replace=".abc;.o" -shared %t1.thinlink.bc \
; RUN: -o %t3 2>&1 | FileCheck %s --check-prefix=ERR2 ; RUN: -o %t3 2>&1 | FileCheck %s --check-prefix=ERR2
; ERR2: error: -thinlto-object-suffix-replace=.abc;.o was given, but {{.*}} does not end with the suffix ; ERR2: error: -thinlto-object-suffix-replace=.abc;.o was given, but {{.*}} does not end with the suffix
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f() { define void @f() {
entry: entry:
ret void ret void
} }
!llvm.dbg.cu = !{} !llvm.dbg.cu = !{}
!1 = !{i32 2, !"Debug Info Version", i32 3} !1 = !{i32 2, !"Debug Info Version", i32 3}
!llvm.module.flags = !{!1} !llvm.module.flags = !{!1}

lld/trunk/test/ELF/lto/tls-mixed.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: llvm-mc %p/Inputs/tls-mixed.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux ; RUN: llvm-mc %p/Inputs/tls-mixed.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux
; RUN: ld.lld -m elf_x86_64 %t1.o %t2.o -o %t.so -shared ; RUN: ld.lld %t1.o %t2.o -o %t.so -shared
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Should not encounter TLS-ness mismatch for @foo ; Should not encounter TLS-ness mismatch for @foo
@foo = external thread_local global i32, align 4 @foo = external thread_local global i32, align 4

lld/trunk/test/ELF/lto/tls-preserve.ll

; TLS attribute needs to be preserved. ; TLS attribute needs to be preserved.
; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t1.o ; RUN: llvm-as %s -o %t1.o
; RUN: ld.lld -shared %t1.o -m elf_x86_64 -o %t1 ; RUN: ld.lld -shared %t1.o -o %t1
; RUN: llvm-readobj -t %t1 | FileCheck %s ; RUN: llvm-readobj -t %t1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@tsp_int = thread_local global i32 1 @tsp_int = thread_local global i32 1
define void @_start() { define void @_start() {
Show All 13 Lines

lld/trunk/test/ELF/lto/type-merge.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/type-merge.ll -o %t2.o ; RUN: llvm-as %p/Inputs/type-merge.ll -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t.o %t2.o -o %t -shared -save-temps ; RUN: ld.lld %t.o %t2.o -o %t -shared -save-temps
; RUN: llvm-dis < %t.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis < %t.0.0.preopt.bc | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo() { define void @foo() {
call void @bar(i8* null) call void @bar(i8* null)
ret void ret void
Show All 14 Lines

lld/trunk/test/ELF/lto/type-merge2.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-as %p/Inputs/type-merge2.ll -o %t2.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: ld.lld %t.o %t2.o -o %t.so -shared -save-temps
; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.0.preopt.bc -o - | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%zed = type { i8 } %zed = type { i8 }
define void @foo() { define void @foo() {
call void @bar(%zed* null) call void @bar(%zed* null)
Show All 16 Lines

lld/trunk/test/ELF/lto/undef-weak.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o ; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
; RUN: rm -f %t.a ; RUN: rm -f %t.a
; RUN: llvm-ar rcs %t.a %t1.o ; RUN: llvm-ar rcs %t.a %t1.o
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld -m elf_x86_64 %t2.o -o %t2.so %t.a -shared ; RUN: ld.lld %t2.o -o %t2.so %t.a -shared
; RUN: llvm-readobj -t %t2.so | FileCheck %s ; RUN: llvm-readobj -t %t2.so | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
declare extern_weak void @f() declare extern_weak void @f()
define void @foo() { define void @foo() {
call void @f() call void @f()
ret void ret void
} }
Show All 11 Lines

lld/trunk/test/ELF/lto/undef.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t.so -shared ; RUN: ld.lld %t.o -o %t.so -shared
; RUN: llvm-readobj -t %t.so | FileCheck %s ; RUN: llvm-readobj -t %t.so | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
declare void @bar() declare void @bar()
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
Show All 9 Lines

lld/trunk/test/ELF/lto/undefined-puts.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-mc %p/Inputs/shared.s -o %t1.o -filetype=obj -triple=x86_64-unknown-linux ; RUN: llvm-mc %p/Inputs/shared.s -o %t1.o -filetype=obj -triple=x86_64-unknown-linux
; RUN: ld.lld %t1.o -o %t1.so -shared ; RUN: ld.lld %t1.o -o %t1.so -shared
; RUN: llvm-as %s -o %t2.o ; RUN: llvm-as %s -o %t2.o
; RUN: ld.lld %t1.so %t2.o -m elf_x86_64 -o %t ; RUN: ld.lld %t1.so %t2.o -o %t
; RUN: llvm-readobj -dyn-symbols -dyn-relocations %t | FileCheck %s ; RUN: llvm-readobj -dyn-symbols -dyn-relocations %t | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@.str = private unnamed_addr constant [6 x i8] c"blah\0A\00", align 1 @.str = private unnamed_addr constant [6 x i8] c"blah\0A\00", align 1
define i32 @_start() { define i32 @_start() {
Show All 15 Lines

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

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

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

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

lld/trunk/test/ELF/lto/unnamed-addr-lib.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: llvm-mc %p/Inputs/unnamed-addr-lib.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux ; RUN: llvm-mc %p/Inputs/unnamed-addr-lib.s -o %t2.o -filetype=obj -triple=x86_64-pc-linux
; RUN: ld.lld %t2.o -shared -o %t2.so ; RUN: ld.lld %t2.o -shared -o %t2.so
; RUN: ld.lld -m elf_x86_64 %t.o %t2.so -o %t.so -save-temps -shared ; RUN: ld.lld %t.o %t2.so -o %t.so -save-temps -shared
; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s ; RUN: llvm-dis %t.so.0.2.internalize.bc -o - | FileCheck %s
; This documents a small limitation of lld's internalization logic. We decide ; This documents a small limitation of lld's internalization logic. We decide
; that bar should be in the symbol table because if it is it will preempt the ; that bar should be in the symbol table because if it is it will preempt the
; one in the shared library. ; one in the shared library.
; We could add one extra bit for ODR so that we know that preemption is not ; We could add one extra bit for ODR so that we know that preemption is not
; necessary, but that is probably not worth it. ; necessary, but that is probably not worth it.
; CHECK: @foo = internal unnamed_addr constant i8 42 ; CHECK: @foo = internal unnamed_addr constant i8 42
; CHECK: @bar = weak_odr unnamed_addr constant i8 42 ; CHECK: @bar = weak_odr unnamed_addr constant i8 42
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@foo = linkonce_odr unnamed_addr constant i8 42 @foo = linkonce_odr unnamed_addr constant i8 42
@bar = linkonce_odr unnamed_addr constant i8 42 @bar = linkonce_odr unnamed_addr constant i8 42

lld/trunk/test/ELF/lto/unnamed-addr.ll

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

lld/trunk/test/ELF/lto/verify-invalid.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -mllvm -debug-pass=Arguments \ ; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \
; RUN: 2>&1 | FileCheck -check-prefix=DEFAULT %s ; RUN: 2>&1 | FileCheck -check-prefix=DEFAULT %s
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -mllvm -debug-pass=Arguments \ ; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \
; RUN: -disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s ; RUN: -disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -mllvm -debug-pass=Arguments \ ; RUN: ld.lld %t.o -o %t2 -mllvm -debug-pass=Arguments \
; RUN: --plugin-opt=disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s ; RUN: --plugin-opt=disable-verify 2>&1 | FileCheck -check-prefix=DISABLE %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @_start() { define void @_start() {
ret void ret void
} }
; -disable-verify should disable the verification of bitcode. ; -disable-verify should disable the verification of bitcode.
; DEFAULT: Pass Arguments: {{.*}} -verify {{.*}} -verify ; DEFAULT: Pass Arguments: {{.*}} -verify {{.*}} -verify
; DISABLE-NOT: Pass Arguments: {{.*}} -verify {{.*}} -verify ; DISABLE-NOT: Pass Arguments: {{.*}} -verify {{.*}} -verify

lld/trunk/test/ELF/lto/version-script.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: echo "VERSION_1.0{ global: foo; local: *; }; VERSION_2.0{ global: bar; local: *; };" > %t.script ; RUN: echo "VERSION_1.0{ global: foo; local: *; }; VERSION_2.0{ global: bar; local: *; };" > %t.script
; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -shared --version-script %t.script -save-temps ; RUN: ld.lld %t.o -o %t2 -shared --version-script %t.script -save-temps
; RUN: llvm-dis < %t2.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis < %t2.0.0.preopt.bc | FileCheck %s
; RUN: llvm-readobj -V -dyn-symbols %t2 | FileCheck --check-prefix=DSO %s ; RUN: llvm-readobj -V -dyn-symbols %t2 | FileCheck --check-prefix=DSO %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo() { define void @foo() {
ret void ret void
Show All 38 Lines

lld/trunk/test/ELF/lto/weak.ll

; REQUIRES: x86 ; REQUIRES: x86
; RUN: llvm-as %s -o %t.o ; RUN: llvm-as %s -o %t.o
; RUN: ld.lld -m elf_x86_64 %t.o %t.o -o %t.so -shared ; RUN: ld.lld %t.o %t.o -o %t.so -shared
; RUN: llvm-readobj -t %t.so | FileCheck %s ; RUN: llvm-readobj -t %t.so | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define weak void @f() { define weak void @f() {
ret void ret void
} }
; CHECK: Name: f ; CHECK: Name: f
; CHECK-NEXT: Value: 0x1000 ; CHECK-NEXT: Value: 0x1000
; CHECK-NEXT: Size: 1 ; CHECK-NEXT: Size: 1
; CHECK-NEXT: Binding: Weak ; CHECK-NEXT: Binding: Weak