10dcfcacdb
Now that the parser doesn't renumber indices, there's no need for entity variables like $v0.
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 $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 $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 $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
|
|
}
|