c5b15c2396
Add a calling-convention setting to the `Flags` used as part of the `TargetIsa`. This allows Cretonne code that generates calls to use the correct convention, such as when emitting libcalls during legalization or when the wasm frontend is decoding functions. This setting can be overridden per-function. This also adds "fast", "cold", and "fastcall" conventions, with "fast" as the new default. Note that "fast" and "cold" are not intended to be ABI-compatible across Cretonne versions. This will also ensure Windows users will get an `unimplemented!` rather than silent calling-convention mismatches, which reflects the fact that Windows calling conventions are not yet implemented. This also renames SpiderWASM, which isn't camel-case, to Baldrdash, which is, and which is also a more relevant name.
126 lines
3.4 KiB
Plaintext
126 lines
3.4 KiB
Plaintext
; Test the legalization of memory objects.
|
|
test legalizer
|
|
set is_64bit
|
|
isa x86
|
|
|
|
; regex: V=v\d+
|
|
; regex: EBB=ebb\d+
|
|
|
|
function %vmctx(i64 vmctx) -> i64 {
|
|
gv1 = vmctx-16
|
|
|
|
ebb1(v1: i64):
|
|
v2 = global_addr.i64 gv1
|
|
; check: v2 = iadd_imm v1, -16
|
|
return v2
|
|
; check: return v2
|
|
}
|
|
|
|
function %deref(i64 vmctx) -> i64 {
|
|
gv1 = vmctx-16
|
|
gv2 = deref(gv1)+32
|
|
|
|
ebb1(v1: i64):
|
|
v2 = global_addr.i64 gv2
|
|
; check: $(a1=$V) = iadd_imm v1, -16
|
|
; check: $(p1=$V) = load.i64 notrap aligned $a1
|
|
; check: v2 = iadd_imm $p1, 32
|
|
return v2
|
|
; check: return v2
|
|
}
|
|
|
|
function %sym() -> i64 {
|
|
gv0 = globalsym %something
|
|
gv1 = globalsym u123:456
|
|
|
|
ebb1:
|
|
v0 = global_addr.i64 gv0
|
|
; check: v0 = globalsym_addr.i64 gv0
|
|
v1 = global_addr.i64 gv1
|
|
; check: v1 = globalsym_addr.i64 gv1
|
|
v2 = bxor v0, v1
|
|
return v2
|
|
}
|
|
|
|
; SpiderMonkey VM-style static 4+2 GB heap.
|
|
; This eliminates bounds checks completely for offsets < 2GB.
|
|
function %staticheap_sm64(i32, i64 vmctx) -> f32 baldrdash {
|
|
gv0 = vmctx+64
|
|
heap0 = static gv0, min 0x1000, bound 0x1_0000_0000, guard 0x8000_0000
|
|
|
|
ebb0(v0: i32, v999: i64):
|
|
; check: ebb0(
|
|
v1 = heap_addr.i64 heap0, v0, 1
|
|
; Boundscheck should be eliminated.
|
|
; Checks here are assuming that no pipehole opts fold the load offsets.
|
|
; nextln: $(xoff=$V) = uextend.i64 v0
|
|
; nextln: $(haddr=$V) = iadd_imm v999, 64
|
|
; nextln: $(hbase=$V) = load.i64 notrap aligned $haddr
|
|
; nextln: v1 = iadd $hbase, $xoff
|
|
v2 = load.f32 v1+16
|
|
; nextln: v2 = load.f32 v1+16
|
|
v3 = load.f32 v1+20
|
|
; nextln: v3 = load.f32 v1+20
|
|
v4 = fadd v2, v3
|
|
return v4
|
|
}
|
|
|
|
function %staticheap_static_oob_sm64(i32, i64 vmctx) -> f32 baldrdash {
|
|
gv0 = vmctx+64
|
|
heap0 = static gv0, min 0x1000, bound 0x1000_0000, guard 0x8000_0000
|
|
|
|
ebb0(v0: i32, v999: i64):
|
|
; Everything after the obviously OOB access should be eliminated, leaving
|
|
; the `trap heap_oob` instruction as the terminator of the Ebb and moving
|
|
; the remainder of the instructions into an inaccessible Ebb.
|
|
; check: ebb0(
|
|
; nextln: trap heap_oob
|
|
; check: ebb1:
|
|
; nextln: v1 = iconst.i64 0
|
|
; nextln: v2 = load.f32 v1+16
|
|
; nextln: return v2
|
|
; nextln: }
|
|
v1 = heap_addr.i64 heap0, v0, 0x1000_0001
|
|
v2 = load.f32 v1+16
|
|
return v2
|
|
}
|
|
|
|
|
|
; SpiderMonkey VM-style static 4+2 GB heap.
|
|
; Offsets >= 2 GB do require a boundscheck.
|
|
function %staticheap_sm64(i32, i64 vmctx) -> f32 baldrdash {
|
|
gv0 = vmctx+64
|
|
heap0 = static gv0, min 0x1000, bound 0x1_0000_0000, guard 0x8000_0000
|
|
|
|
ebb0(v0: i32, v999: i64):
|
|
; check: ebb0(
|
|
v1 = heap_addr.i64 heap0, v0, 0x8000_0000
|
|
; Boundscheck code
|
|
; check: $(oob=$V) = icmp
|
|
; nextln: brz $oob, $(ok=$EBB)
|
|
; nextln: trap heap_oob
|
|
; check: $ok:
|
|
; Checks here are assuming that no pipehole opts fold the load offsets.
|
|
; nextln: $(xoff=$V) = uextend.i64 v0
|
|
; nextln: $(haddr=$V) = iadd_imm.i64 v999, 64
|
|
; nextln: $(hbase=$V) = load.i64 notrap aligned $haddr
|
|
; nextln: v1 = iadd $hbase, $xoff
|
|
v2 = load.f32 v1+0x7fff_ffff
|
|
; nextln: v2 = load.f32 v1+0x7fff_ffff
|
|
return v2
|
|
}
|
|
|
|
; Stack overflow check.
|
|
; The stack limit is stored in a pointer-sized global variable.
|
|
function %stkchk(i64 vmctx) baldrdash {
|
|
gv0 = vmctx+64
|
|
|
|
ebb0(v0: i64):
|
|
; check: ebb0(
|
|
stack_check gv0
|
|
; check: $(limit=$V) = load.i64 notrap aligned
|
|
; check: $(flags=$V) = ifcmp_sp $limit
|
|
; check: trapif uge $flags, stk_ovf
|
|
return
|
|
}
|