; 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
}