477 changes: 186 additions & 291 deletions lld/test/MachO/icf.s
View file
Original file line number Diff line number Diff line change
@@ -1,60 +1,79 @@
# REQUIRES: x86
# RUN: rm -rf %t; split-file %s %t

## Check that we fold identical function bodies correctly. Note: This test
## has many different functions; each group of similarly-named functions aim
## to test one aspect of ICF's logic. To prevent accidental folding across
## groups, we use `mov` instructions with a variety of immediates, with
## different immediate values for each group.

# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/main.s -o %t/main.o
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/abs.s -o %t/abs.o
# RUN: %lld -lSystem --icf=all -o %t/main %t/main.o %t/abs.o
# RUN: llvm-objdump -d --syms %t/main | FileCheck %s

# CHECK-LABEL: SYMBOL TABLE:
# CHECK: [[#%x,MAIN:]] g F __TEXT,__text _main
# CHECK: [[#%x,A:]] g F __TEXT,__text _a1
# CHECK: [[#%x,H:]] g F __TEXT,__text _h
# CHECK: [[#%x,A]] g F __TEXT,__text _a2
# CHECK: [[#%x,A]] g F __TEXT,__text _a3
# CHECK: [[#%x,B:]] g F __TEXT,__text _b
# CHECK: [[#%x,B2:]] g F __TEXT,__text _b2
# CHECK: [[#%x,C:]] g F __TEXT,__text _c
# CHECK: [[#%x,D:]] g F __TEXT,__text _d
# CHECK: [[#%x,E:]] g F __TEXT,__text _e
# CHECK: [[#%x,F:]] g F __TEXT,__text _f
# CHECK: [[#%x,G:]] g F __TEXT,__text _g
# CHECK: [[#%x,I:]] g F __TEXT,__text _i
# CHECK: [[#%x,J:]] g F __TEXT,__text _j
# CHECK: [[#%x,SR:]] g F __TEXT,__text _sr1
# CHECK: [[#%x,SR]] g F __TEXT,__text _sr2
# CHECK: [[#%x,MR:]] g F __TEXT,__text _mr1
# CHECK: [[#%x,MR]] g F __TEXT,__text _mr2
# CHECK: [[#%x,K1:]] g O __TEXT,__foo _k1
# CHECK: [[#%x,A:]] g F __TEXT,__text _k2
# CHECK: [[#%x,ABS1B_REF:]] l F __TEXT,__text _abs1a_ref
# CHECK: [[#%x,ABS1B_REF:]] l F __TEXT,__text _abs1b_ref
# CHECK: [[#%x,ABS1B_REF_WITH_ADDEND:]] l F __TEXT,__text _abs1a_ref_with_addend
# CHECK: [[#%x,ABS1B_REF_WITH_ADDEND:]] l F __TEXT,__text _abs1b_ref_with_addend
# CHECK: [[#%x,ABS2_REF:]] l F __TEXT,__text _abs2_ref
# CHECK: [[#%x,NOT_ABS_REF:]] l F __TEXT,__text _not_abs_ref
# CHECK: [[#%x,DYLIB_REF_2:]] l F __TEXT,__text _dylib_ref_1
# CHECK: [[#%x,DYLIB_REF_2:]] l F __TEXT,__text _dylib_ref_2
# CHECK: [[#%x,DYLIB_REF_3:]] l F __TEXT,__text _dylib_ref_3
# CHECK: [[#%x,ALT:]] l F __TEXT,__text _alt
# CHECK: [[#%x,WITH_ALT_ENTRY:]] l F __TEXT,__text _with_alt_entry
# CHECK: [[#%x,WITH_ALT_ENTRY:]] l F __TEXT,__text _no_alt_entry
# CHECK: [[#%x,DEFINED_REF_WITH_ADDEND_2:]] l F __TEXT,__text _defined_ref_with_addend_1
# CHECK: [[#%x,DEFINED_REF_WITH_ADDEND_2:]] l F __TEXT,__text _defined_ref_with_addend_2
# CHECK: [[#%x,RECURSIVE:]] l F __TEXT,__text _recursive
# CHECK: [[#%x,CALL_RECURSIVE_2:]] l F __TEXT,__text _call_recursive_1
# CHECK: [[#%x,CALL_RECURSIVE_2:]] l F __TEXT,__text _call_recursive_2
# CHECK: [[#%x,CHECK_LENGTH_1:]] l F __TEXT,__text _check_length_1
# CHECK: [[#%x,CHECK_LENGTH_2:]] l F __TEXT,__text _check_length_2
# CHECK: [[#%x,HAS_UNWIND_1:]] l F __TEXT,__text _has_unwind_1
# CHECK: [[#%x,HAS_UNWIND_2:]] l F __TEXT,__text _has_unwind_2
# CHECK: [[#%x,MUTALLY_RECURSIVE_2:]] l F __TEXT,__text _mutually_recursive_1
# CHECK: [[#%x,MUTALLY_RECURSIVE_2:]] l F __TEXT,__text _mutually_recursive_2
# CHECK: [[#%x,INIT_2:]] l F __TEXT,__text _init_1
# CHECK: [[#%x,INIT_2:]] l F __TEXT,__text _init_2
# CHECK: [[#%x,INIT_3:]] l O __TEXT,__foo _init_3
### FIXME: Mutually-recursive functions with identical bodies (see below)
# COM: [[#%x,XR:]] g F __TEXT,__text _xr1
# COM: [[#%x,XR]] g F __TEXT,__text _xr2
# COM: [[#%x,ASYMMETRIC_RECURSIVE_2:]] l F __TEXT,__text _asymmetric_recursive_1
# COM: [[#%x,ASYMMETRIC_RECURSIVE_2]] l F __TEXT,__text _asymmetric_recursive_2

# CHECK-LABEL: Disassembly of section __TEXT,__text:
# CHECK: [[#%x,MAIN]] <_main>:
# CHECK-NEXT: callq 0x[[#%x,A]] <_k2>
# CHECK-NEXT: callq 0x[[#%x,A]] <_k2>
# CHECK-NEXT: callq 0x[[#%x,A]] <_k2>
# CHECK-NEXT: callq 0x[[#%x,B]] <_b>
# CHECK-NEXT: callq 0x[[#%x,B2]] <_b2>
# CHECK-NEXT: callq 0x[[#%x,C]] <_c>
# CHECK-NEXT: callq 0x[[#%x,D]] <_d>
# CHECK-NEXT: callq 0x[[#%x,E]] <_e>
# CHECK-NEXT: callq 0x[[#%x,F]] <_f>
# CHECK-NEXT: callq 0x[[#%x,G]] <_g>
# CHECK-NEXT: callq 0x[[#%x,H]] <_h>
# CHECK-NEXT: callq 0x[[#%x,I]] <_i>
# CHECK-NEXT: callq 0x[[#%x,J]] <_j>
# CHECK-NEXT: callq 0x[[#%x,K1]] <_k1>
# CHECK-NEXT: callq 0x[[#%x,A]] <_k2>
# CHECK-NEXT: callq 0x[[#%x,SR]] <_sr2>
# CHECK-NEXT: callq 0x[[#%x,SR]] <_sr2>
# CHECK-NEXT: callq 0x[[#%x,MR]] <_mr2>
# CHECK-NEXT: callq 0x[[#%x,MR]] <_mr2>
### FIXME: Mutually-recursive functions with identical bodies (see below)
# COM-NEXT: callq 0x[[#%x,XR]] <_xr2>
# COM-NEXT: callq 0x[[#%x,XR]] <_xr2>
# CHECK: <_main>:
# CHECK: callq 0x[[#%x,ABS1B_REF:]] <_abs1b_ref>
# CHECK: callq 0x[[#%x,ABS1B_REF:]] <_abs1b_ref>
# CHECK: callq 0x[[#%x,ABS1B_REF_WITH_ADDEND:]] <_abs1b_ref_with_addend>
# CHECK: callq 0x[[#%x,ABS1B_REF_WITH_ADDEND:]] <_abs1b_ref_with_addend>
# CHECK: callq 0x[[#%x,ABS2_REF:]] <_abs2_ref>
# CHECK: callq 0x[[#%x,NOT_ABS_REF:]] <_not_abs_ref>
# CHECK: callq 0x[[#%x,DYLIB_REF_2:]] <_dylib_ref_2>
# CHECK: callq 0x[[#%x,DYLIB_REF_2:]] <_dylib_ref_2>
# CHECK: callq 0x[[#%x,DYLIB_REF_3:]] <_dylib_ref_3>
# CHECK: callq 0x[[#%x,ALT:]] <_alt>
# CHECK: callq 0x[[#%x,WITH_ALT_ENTRY:]] <_with_alt_entry>
# CHECK: callq 0x[[#%x,WITH_ALT_ENTRY:]] <_with_alt_entry>
# CHECK: callq 0x[[#%x,DEFINED_REF_WITH_ADDEND_2:]] <_defined_ref_with_addend_2>
# CHECK: callq 0x[[#%x,DEFINED_REF_WITH_ADDEND_2:]] <_defined_ref_with_addend_2>
# CHECK: callq 0x[[#%x,RECURSIVE:]] <_recursive>
# CHECK: callq 0x[[#%x,CALL_RECURSIVE_2:]] <_call_recursive_2>
# CHECK: callq 0x[[#%x,CALL_RECURSIVE_2:]] <_call_recursive_2>
# CHECK: callq 0x[[#%x,CHECK_LENGTH_1:]] <_check_length_1>
# CHECK: callq 0x[[#%x,CHECK_LENGTH_2:]] <_check_length_2>
# CHECK: callq 0x[[#%x,HAS_UNWIND_1:]] <_has_unwind_1>
# CHECK: callq 0x[[#%x,HAS_UNWIND_2:]] <_has_unwind_2>
# CHECK: callq 0x[[#%x,MUTALLY_RECURSIVE_2:]] <_mutually_recursive_2>
# CHECK: callq 0x[[#%x,MUTALLY_RECURSIVE_2:]] <_mutually_recursive_2>
## FIXME: Mutually-recursive functions with identical bodies (see below)
# COM: callq 0x[[#%x,ASYMMETRIC_RECURSIVE_2]] <_asymmetric_recursive_2>
# COM: callq 0x[[#%x,ASYMMETRIC_RECURSIVE_2]] <_asymmetric_recursive_2>
# CHECK: callq 0x[[#%x,INIT_2:]] <_init_2>
# CHECK: callq 0x[[#%x,INIT_2:]] <_init_2>
# CHECK: callq 0x[[#%x,INIT_3:]] <_init_3>

### TODO:
### * Fold: funcs only differ in alignment
Expand All @@ -77,291 +96,167 @@ _not_abs:
#--- main.s
.subsections_via_symbols
.text
.globl _h
.alt_entry _h

### Fold: _a1 & _a2 have identical bodies, flags, relocs

.globl _a1
.p2align 2
_a1:
callq _d
### No fold: _h is an alt entry past _a1
_h:
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
_abs1a_ref:
movabs $_abs1a, %rdx
movl $0, %eax
ret

.globl _a2
.p2align 2
_a2:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret

### Fold: reference to absolute symbol with different name but identical value

.globl _a3
.p2align 2
_a3:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
_abs1b_ref:
movabs $_abs1b, %rdx
movl $0, %eax
ret

### No fold: the absolute symbol value differs
_abs1a_ref_with_addend:
movabs $_abs1a + 3, %rdx

.globl _b
.p2align 2
_b:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
_abs1b_ref_with_addend:
movabs $_abs1b + 3, %rdx

## No fold: the absolute symbol value differs
_abs2_ref:
movabs $_abs2, %rdx
movl $0, %eax
ret

### No fold: _not_abs has the same value as _abs1{a,b}, but is not absolute.
## No fold: _not_abs has the same value as _abs1{a,b}, but is not absolute.
_not_abs_ref:
movabs $_not_abs, %rdx

.globl _b2
.p2align 2
_b2:
callq _d
_dylib_ref_1:
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_not_abs, %rdx
movl $0, %eax
ret

### No fold: _c has slightly different body from _a1 & _a2

.globl _c
.p2align 2
_c:
callq _d
_dylib_ref_2:
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $1, %eax
ret

### No fold: _d has the same body as _a1 & _a2, but _d is recursive!
## No fold: referent dylib symbol differs
_dylib_ref_3:
mov ___inf@GOTPCREL(%rip), %rax
callq ___inf

## We can merge two sections even if one of them has an alt entry. Just make
## sure we don't merge the alt entry symbol with a regular symbol.
.alt_entry _alt
_with_alt_entry:
movq $3132, %rax
_alt:
ret

.globl _d
.p2align 2
_d:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
_no_alt_entry:
movq $3132, %rax
ret

### No fold: the function body is longer
_defined_ref_with_addend_1:
callq _with_alt_entry + 4

.globl _e
.p2align 2
_e:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret
nop
_defined_ref_with_addend_2:
callq _with_alt_entry + 4

### No fold: GOT referent dylib symbol differs
## _recursive has the same body as its next two callers, but cannot be folded
## with them.
_recursive:
callq _recursive

.globl _f
.p2align 2
_f:
callq _d
mov ___inf@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret
_call_recursive_1:
callq _recursive

### No fold: call referent dylib symbol differs
_call_recursive_2:
callq _recursive

.globl _g
.p2align 2
_g:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isinf
movabs $_abs1a, %rdx
movl $0, %eax
ret
## Functions of different lengths should not be folded
_check_length_1:
movq $97, %rax

_check_length_2:
movq $97, %rax
.space 1

### No fold: functions have personality and/or LSDA
### Mere presence of personality and/or LSDA isolates a function into its own
### equivalence class. We don't care if two functions happen to have identical
### personality & LSDA.
_my_personality:
mov $1345, %rax

.globl _i
.p2align 2
_i:
## No fold: functions have unwind info.
## FIXME: Fold functions with identical unwind info.
_has_unwind_1:
.cfi_startproc
.cfi_personality 155, _my_personality0
.cfi_lsda 16, _exception0
.cfi_personality 155, _my_personality
.cfi_def_cfa_offset 16
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret
.cfi_endproc

.globl _j
.p2align 2
_j:
_has_unwind_2:
.cfi_startproc
.cfi_personality 155, _my_personality0
.cfi_lsda 16, _exception0
.cfi_personality 155, _my_personality
.cfi_def_cfa_offset 16
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret
.cfi_endproc

### No fold: _k1 is in a different section from _a1
.section __TEXT,__foo
.globl _k1
.p2align 2
_k1:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret
nopl (%rax)

### Fold: _k2 is in a section that gets renamed and output as __text
.section __TEXT,__StaticInit
.globl _k2
.p2align 2
_k2:
callq _d
mov ___nan@GOTPCREL(%rip), %rax
callq ___isnan
movabs $_abs1a, %rdx
movl $0, %eax
ret
## For some reason, llvm-mc generates different nop encodings when adding
## padding for __StaticInit vs __text functions. So we explicitly specify the
## nop here to make sure this function can be folded with _a1.
nopl (%rax)

### Fold: Simple recursion

.text
.globl _sr1
.p2align 2
_sr1:
callq _sr1
movl $0, %eax
ret

.globl _sr2
.p2align 2
_sr2:
callq _sr2
movl $0, %eax
ret

### Fold: Mutually-recursive functions with symmetric bodies

.globl _mr1
.p2align 2
_mr1:
callq _mr1 # call myself
callq _mr2 # call my twin
movl $0, %eax
ret

.globl _mr2
.p2align 2
_mr2:
callq _mr2 # call myself
callq _mr1 # call my twin
movl $0, %eax
ret

### Fold: Mutually-recursive functions with identical bodies
###
### FIXME: This test is currently broken. Recursive call sites have no relocs
### and the non-zero displacement field is already written to the section
### data, while non-recursive call sites use symbol relocs and section data
### contains zeros in the displacement field. Thus, ICF's equalsConstant()
### finds that the section data doesn't match.
###
### ELF folds this case properly because it emits symbol relocs for all calls,
### even recursive ones.

.globl _xr1
.p2align 2
_xr1:
callq _xr1 # call myself
callq _xr2 # call my twin
## Fold: Mutually-recursive functions with symmetric bodies
_mutually_recursive_1:
callq _mutually_recursive_1 # call myself
callq _mutually_recursive_2 # call my twin

_mutually_recursive_2:
callq _mutually_recursive_2 # call myself
callq _mutually_recursive_1 # call my twin

## Fold: Mutually-recursive functions with identical bodies
##
## FIXME: This test is currently broken. Recursive call sites have no relocs
## and the non-zero displacement field is already written to the section
## data, while non-recursive call sites use symbol relocs and section data
## contains zeros in the displacement field. Thus, ICF's equalsConstant()
## finds that the section data doesn't match.
##
## ELF folds this case properly because it emits symbol relocs for all calls,
## even recursive ones.

_asymmetric_recursive_1:
callq _asymmetric_recursive_1 # call myself
callq _asymmetric_recursive_2 # call my twin
movl $3, %eax
ret

.globl _xr2
.p2align 2
_xr2:
callq _xr1 # call my twin
callq _xr2 # call myself
_asymmetric_recursive_2:
callq _asymmetric_recursive_1 # call my twin
callq _asymmetric_recursive_2 # call myself
movl $3, %eax
ret

###
_init_1:
movq $12938, %rax

.globl _main
.p2align 2
_main:
callq _a1
callq _a2
callq _a3
callq _b
callq _b2
callq _c
callq _d
callq _e
callq _f
callq _g
callq _h
callq _i
callq _j
callq _k1
callq _k2
callq _sr1
callq _sr2
callq _mr1
callq _mr2
callq _xr1
callq _xr2
ret
## Fold: _init_2 is in a section that gets renamed and output as __text
.section __TEXT,__StaticInit
_init_2:
movq $12938, %rax

.globl _my_personality0
.p2align 2
_my_personality0:
movl $0, %eax
ret
## No fold: _init_3 is in a different output section from _init_{1,2}
.section __TEXT,__foo
_init_3:
movq $12938, %rax

.section __TEXT,__gcc_except_tab
.globl _exception0
_exception0:
.space 1
.text
.globl _main
_main:
callq _abs1a_ref
callq _abs1b_ref
callq _abs1a_ref_with_addend
callq _abs1b_ref_with_addend
callq _abs2_ref
callq _not_abs_ref
callq _dylib_ref_1
callq _dylib_ref_2
callq _dylib_ref_3
callq _alt
callq _with_alt_entry
callq _no_alt_entry
callq _defined_ref_with_addend_1
callq _defined_ref_with_addend_2
callq _recursive
callq _call_recursive_1
callq _call_recursive_2
callq _check_length_1
callq _check_length_2
callq _has_unwind_1
callq _has_unwind_2
callq _mutually_recursive_1
callq _mutually_recursive_2
callq _asymmetric_recursive_1
callq _asymmetric_recursive_2
callq _init_1
callq _init_2
callq _init_3
106 changes: 106 additions & 0 deletions lld/test/MachO/lto-symbol-resolution.ll
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,106 @@
; REQUIRES: x86

; RUN: rm -rf %t; split-file %s %t

; RUN: opt -module-summary %t/defined.ll -o %t/defined.o
; RUN: opt -module-summary %t/weak-defined.ll -o %t/weak-defined.o
; RUN: opt -module-summary %t/archive.ll -o %t/archive.o
; RUN: opt -module-summary %t/calls-foo.ll -o %t/calls-foo.o
; RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/weak-defined.s -o %t/weak-defined-asm.o

; RUN: %lld -lSystem -dylib %t/defined.o -o %t/libfoo.dylib
; RUN: %lld -lSystem -dylib %t/weak-defined.o -o %t/libweakfoo.dylib

; RUN: llvm-ar rcs %t/archive.a %t/archive.o

;; Regular defined symbols take precedence over weak ones.
; RUN: %lld -lSystem %t/defined.o %t/weak-defined.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=DEFINED
; RUN: %lld -lSystem %t/weak-defined.o %t/defined.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=DEFINED

;; Regular defined symbols take precedence over weak non-bitcode ones.
; RUN: %lld -lSystem %t/defined.o %t/weak-defined-asm.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=DEFINED
; RUN: %lld -lSystem %t/weak-defined-asm.o %t/defined.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=DEFINED

;; NOTE: we are deviating from ld64's behavior here.
;; ld64: Weak non-bitcode symbols take precedence over weak bitcode ones.
;; lld: Weak non-bitcode symbols have the same precedence as weak bitcode ones.
; RUN: %lld -lSystem %t/weak-defined.o %t/weak-defined-asm.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED
; COM (ld64): llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED-ASM
; RUN: %lld -lSystem %t/weak-defined-asm.o %t/weak-defined.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED-ASM

;; Weak defined symbols take precedence over dylib symbols.
; RUN: %lld -lSystem %t/weak-defined.o %t/libfoo.dylib %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED
; RUN: %lld -lSystem %t/libfoo.dylib %t/weak-defined.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED

;; Weak defined symbols take precedence over archive symbols.
; RUN: %lld -lSystem %t/archive.a %t/weak-defined.o %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED
; RUN: %lld -lSystem %t/weak-defined.o %t/archive.a %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=WEAK-DEFINED

;; Archive symbols have the same precedence as dylib symbols.
; RUN: %lld -lSystem %t/archive.a %t/libfoo.dylib %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=ARCHIVE
; RUN: %lld -lSystem %t/libfoo.dylib %t/archive.a %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=DYLIB

;; Archive symbols take precedence over weak dylib symbols.
; RUN: %lld -lSystem %t/archive.a %t/libweakfoo.dylib %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=ARCHIVE
; RUN: %lld -lSystem %t/libweakfoo.dylib %t/archive.a %t/calls-foo.o -o %t/test
; RUN: llvm-objdump --syms %t/test | FileCheck %s --check-prefix=ARCHIVE

; DEFINED: g O __TEXT,defined _foo
; WEAK-DEFINED: w O __TEXT,weak_defined _foo
; WEAK-DEFINED-ASM: w O __TEXT,weak_defined_asm _foo
; ARCHIVE: g O __TEXT,archive _foo
; DYLIB: *UND* _foo

;--- defined.ll
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"

define void @foo() section "__TEXT,defined" {
ret void
}

;--- weak-defined.ll
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"

define weak void @foo() section "__TEXT,weak_defined" {
ret void
}

;--- weak-defined.s
.globl _foo
.weak_definition _foo
.section __TEXT,weak_defined_asm
_foo:

;--- archive.ll
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"

define void @foo() section "__TEXT,archive" {
ret void
}

;--- calls-foo.ll
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"

declare void @foo()

define void @main() {
call void @foo()
ret void
}
5 changes: 5 additions & 0 deletions lld/test/MachO/weak-definition-direct-fetch.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,26 +57,31 @@

## The remaining lines test symbol pairs of different types.

## (Weak) archive symbols take precedence over weak dylib symbols.
# RUN: %lld -lSystem -o %t/weak-dylib-weak-ar -L%t -lweakfoo %t/weakfoo.a %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
# RUN: %lld -lSystem -o %t/weak-ar-weak-dylib -L%t %t/weakfoo.a -lweakfoo %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-weak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT

## (Weak) archive symbols have the same precedence as dylib symbols.
# RUN: %lld -lSystem -o %t/weak-ar-nonweak-dylib -L%t %t/weakfoo.a -lfoo %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-ar-nonweak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
# RUN: %lld -lSystem -o %t/nonweak-dylib-weak-ar -L%t -lfoo %t/weakfoo.a %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/nonweak-dylib-weak-ar | FileCheck %s --check-prefix=PREFER-NONWEAK-DYLIB

## Weak defined symbols take precedence over weak dylib symbols.
# RUN: %lld -lSystem -o %t/weak-dylib-weak-obj -L%t -lweakfoo %t/weakfoo.o %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-dylib-weak-obj | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
# RUN: %lld -lSystem -o %t/weak-obj-weak-dylib -L%t %t/weakfoo.o -lweakfoo %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-obj-weak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT

## Weak defined symbols take precedence over dylib symbols.
# RUN: %lld -lSystem -o %t/weak-obj-nonweak-dylib -L%t %t/weakfoo.o -lfoo %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-obj-nonweak-dylib | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
# RUN: %lld -lSystem -o %t/nonweak-dylib-weak-obj -L%t -lfoo %t/weakfoo.o %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/nonweak-dylib-weak-obj | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT

## Weak defined symbols take precedence over archive symbols.
# RUN: %lld -lSystem -o %t/weak-obj-nonweak-ar %t/weakfoo.o %t/foo.a %t/test.o
# RUN: llvm-objdump --macho --lazy-bind --syms %t/weak-obj-nonweak-ar | FileCheck %s --check-prefix=PREFER-WEAK-OBJECT
# RUN: %lld -lSystem -o %t/nonweak-ar-weak-obj %t/foo.a %t/weakfoo.o %t/test.o
Expand Down