685cde98a4
Mark loads from globals generated by cton_wasm or by legalization as `aligned` and `notrap`, since memory for these globals should be allocated by the runtime environment for that purpose. This reduces the number of potentially trapping instructions, which can reduce the amount of metadata required by embedding environments.
126 lines
3.4 KiB
Plaintext
126 lines
3.4 KiB
Plaintext
; Test the legalization of memory objects.
|
|
test legalizer
|
|
set is_64bit
|
|
isa intel
|
|
|
|
; 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 spiderwasm {
|
|
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 spiderwasm {
|
|
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 spiderwasm {
|
|
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) spiderwasm {
|
|
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
|
|
}
|