# REQUIRES: x86
# RUN: rm -rf %t && split-file %s %t && cd %t
# RUN: llvm-mc -n -filetype=obj -triple=x86_64 spill.s -o spill.o
## An input section spills to a later match when the region of its first match
## would overflow. The spill uses the alignment of the later match.
# RUN: ld.lld -T spill.ld spill.o -o spill --enable-non-contiguous-regions
# RUN: llvm-readelf -S spill | FileCheck %s --check-prefix=SPILL
# SPILL: Name Type Address Off Size
# SPILL: .first_chance PROGBITS 0000000000000000 001000 000001
# SPILL-NEXT: .last_chance PROGBITS 0000000000000008 001008 000002
## A spill off the end still fails the link.
# RUN: not ld.lld -T spill-fail.ld spill.o --enable-non-contiguous-regions 2>&1 |\
# RUN: FileCheck %s --check-prefix=SPILL-FAIL --implicit-check-not=error:
# SPILL-FAIL: error: section '.last_chance' will not fit in region 'b': overflowed by 2 bytes
## The above spill still occurs when the LMA would overflow, even though the
## VMA would fit.
# RUN: ld.lld -T spill-lma.ld spill.o -o spill-lma --enable-non-contiguous-regions
# RUN: llvm-readelf -S spill-lma | FileCheck %s --check-prefix=SPILL-LMA
# SPILL-LMA: Name Type Address Off Size
# SPILL-LMA: .first_chance PROGBITS 0000000000000000 001000 000001
# SPILL-LMA-NEXT: .last_chance PROGBITS 0000000000000003 001003 000002
## A spill occurs to an additional match after the first.
# RUN: ld.lld -T spill-later.ld spill.o -o spill-later --enable-non-contiguous-regions
# RUN: llvm-readelf -S spill-later | FileCheck %s --check-prefix=SPILL-LATER
# SPILL-LATER: Name Type Address Off Size
# SPILL-LATER: .first_chance PROGBITS 0000000000000000 001000 000001
# SPILL-LATER-NEXT: .second_chance PROGBITS 0000000000000002 001001 000000
# SPILL-LATER-NEXT: .last_chance PROGBITS 0000000000000003 001003 000002
## A later overflow causes an earlier section to spill.
# RUN: ld.lld -T spill-earlier.ld spill.o -o spill-earlier --enable-non-contiguous-regions
# RUN: llvm-readelf -S spill-earlier | FileCheck %s --check-prefix=SPILL-EARLIER
# SPILL-EARLIER: Name Type Address Off Size
# SPILL-EARLIER: .first_chance PROGBITS 0000000000000000 001000 000002
# SPILL-EARLIER-NEXT: .last_chance PROGBITS 0000000000000002 001002 000001
## An additional match in /DISCARD/ has no effect.
# RUN: not ld.lld -T no-spill-into-discard.ld spill.o --enable-non-contiguous-regions 2>&1 |\
# RUN: FileCheck %s --check-prefix=NO-SPILL-INTO-DISCARD --implicit-check-not=error:
# NO-SPILL-INTO-DISCARD: error: section '.osec' will not fit in region 'a': overflowed by 1 bytes
## An additional match after /DISCARD/ has no effect.
# RUN: ld.lld -T no-spill-from-discard.ld spill.o -o no-spill-from-discard --enable-non-contiguous-regions
# RUN: llvm-readelf -S no-spill-from-discard | FileCheck %s --check-prefix=NO-SPILL-FROM-DISCARD
# NO-SPILL-FROM-DISCARD: Name Type Address Off Size
# NO-SPILL-FROM-DISCARD-NOT: .osec
## SHF_MERGEd sections are spilled according to the matches of the first merged
## input section (the one giving the resulting section its name).
# RUN: llvm-mc -n -filetype=obj -triple=x86_64 merge.s -o merge.o
# RUN: ld.lld -T spill-merge.ld merge.o -o spill-merge --enable-non-contiguous-regions
# RUN: llvm-readelf -S spill-merge | FileCheck %s --check-prefix=SPILL-MERGE
# SPILL-MERGE: Name Type Address Off Size
# SPILL-MERGE: .first PROGBITS 0000000000000000 000190 000000
# SPILL-MERGE-NEXT: .second PROGBITS 0000000000000001 001001 000002
# SPILL-MERGE-NEXT: .third PROGBITS 0000000000000003 001003 000000
## An error is reported for INSERT.
# RUN: not ld.lld -T insert.ld spill.o --enable-non-contiguous-regions 2>&1 |\
# RUN: FileCheck %s --check-prefix=INSERT
# INSERT: error: INSERT cannot be used with --enable-non-contiguous-regions
## An error is reported for OVERWRITE_SECTIONS.
# RUN: not ld.lld -T overwrite-sections.ld spill.o --enable-non-contiguous-regions 2>&1 |\
# RUN: FileCheck %s --check-prefix=OVERWRITE_SECTIONS
# OVERWRITE_SECTIONS: error: OVERWRITE_SECTIONS cannot be used with --enable-non-contiguous-regions
## SHF_LINK_ORDER is reordered when spilling changes relative section order.
# RUN: llvm-mc -n -filetype=obj -triple=x86_64 link-order.s -o link-order.o
# RUN: ld.lld -T link-order.ld link-order.o -o link-order --enable-non-contiguous-regions
# RUN: llvm-readobj -x .order link-order | FileCheck %s --check-prefix=LINK-ORDER
# LINK-ORDER: 020301
#--- spill.s
.section .one_byte_section,"a",@progbits
.fill 1
.section .two_byte_section,"a",@progbits
.fill 2
#--- spill.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 2
b : ORIGIN = 2, LENGTH = 16
}
SECTIONS {
.first_chance : SUBALIGN(1) { *(.one_byte_section) *(.two_byte_section) } >a
.last_chance : SUBALIGN(8) { *(.two_byte_section) } >b
}
#--- spill-fail.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 1
b : ORIGIN = 2, LENGTH = 0
}
SECTIONS {
.first_chance : { *(.one_byte_section) *(.two_byte_section) } >a
.last_chance : { *(.two_byte_section) } >b
}
#--- spill-lma.ld
MEMORY {
vma_a : ORIGIN = 0, LENGTH = 3
vma_b : ORIGIN = 3, LENGTH = 3
lma_a : ORIGIN = 6, LENGTH = 2
lma_b : ORIGIN = 8, LENGTH = 2
}
SECTIONS {
.first_chance : { *(.one_byte_section) *(.two_byte_section) } >vma_a AT>lma_a
.last_chance : { *(.two_byte_section) } >vma_b AT>lma_b
}
#--- spill-later.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 2
b : ORIGIN = 2, LENGTH = 1
c : ORIGIN = 3, LENGTH = 2
}
SECTIONS {
.first_chance : { *(.one_byte_section) *(.two_byte_section) } >a
.second_chance : { *(.two_byte_section) } >b
.last_chance : { *(.two_byte_section) } >c
}
#--- spill-earlier.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 2
b : ORIGIN = 2, LENGTH = 1
}
SECTIONS {
.first_chance : { *(.one_byte_section) *(.two_byte_section) } >a
.last_chance : { *(.one_byte_section) } >b
}
#--- no-spill-into-discard.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 1
}
SECTIONS {
.osec : { *(.two_byte_section) } >a
/DISCARD/ : { *(.one_byte_section) *(.two_byte_section) }
}
#--- no-spill-from-discard.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 2
}
SECTIONS {
/DISCARD/ : { *(.one_byte_section) *(.two_byte_section) }
.osec : { *(.two_byte_section) } >a
}
#--- merge.s
.section .a,"aM",@progbits,1
.byte 0x12, 0x34
.section .b,"aM",@progbits,1
.byte 0x12
#--- spill-merge.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 1
b : ORIGIN = 1, LENGTH = 2
c : ORIGIN = 3, LENGTH = 2
}
SECTIONS {
.first : { *(.a) *(.b) } >a
.second : { *(.a) } >b
.third : { *(.b) } >c
}
#--- insert.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 1
}
SECTIONS {
.a : { *(.two_byte_section) } >a
}
SECTIONS {
.b : { *(.one_byte_section) } >a
} INSERT AFTER .a;
#--- overwrite-sections.ld
MEMORY {
a : ORIGIN = 0, LENGTH = 1
}
SECTIONS {
.a : { *(.two_byte_section) } >a
}
OVERWRITE_SECTIONS {
.b : { *(.one_byte_section) } >a
}
#--- link-order.s
.section .a,"a",@progbits
.fill 1
.section .b,"a",@progbits
.fill 1
.section .c,"a",@progbits
.fill 1
.section .link_order.a,"ao",@progbits,.a
.byte 1
.section .link_order.b,"ao",@progbits,.b
.byte 2
.section .link_order.c,"ao",@progbits,.c
.byte 3
#--- link-order.ld
MEMORY {
order : ORIGIN = 0, LENGTH = 3
potential_a : ORIGIN = 3, LENGTH = 0
bc : ORIGIN = 3, LENGTH = 2
actual_a : ORIGIN = 5, LENGTH = 1
}
SECTIONS {
.order : { *(.link_order.*) } > order
.potential_a : { *(.a) } >potential_a
.bc : { *(.b) *(.c) } >bc
.actual_a : { *(.a) } >actual_a
}
Codebase Browser
llvm