radiance · commit

lib/std/arch/rv64/emit.rad +6 -3

    let adj = adjustOffset(e, base, offset);
    match typ {
        case il::Type::W8 => emit(e, encode::lbu(rd, adj.base, adj.offset)),
        case il::Type::W16 => emit(e, encode::lhu(rd, adj.base, adj.offset)),
        case il::Type::W32 => emit(e, encode::lwu(rd, adj.base, adj.offset)),
        case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
        case il::Type::W64,
             il::Type::Ptr => emit(e, encode::ld(rd, adj.base, adj.offset)),
    }
}

/// Emit signed load with automatic offset adjustment.
pub fn emitSload(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
    let adj = adjustOffset(e, base, offset);
    match typ {
        case il::Type::W8 => emit(e, encode::lb(rd, adj.base, adj.offset)),
        case il::Type::W16 => emit(e, encode::lh(rd, adj.base, adj.offset)),
        case il::Type::W32 => emit(e, encode::lw(rd, adj.base, adj.offset)),
        case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
        case il::Type::W64,
             il::Type::Ptr => emit(e, encode::ld(rd, adj.base, adj.offset)),
    }
}

/// Emit store with automatic offset adjustment.
pub fn emitStore(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
    let adj = adjustOffset(e, base, offset);
    match typ {
        case il::Type::W8 => emit(e, encode::sb(rs, adj.base, adj.offset)),
        case il::Type::W16 => emit(e, encode::sh(rs, adj.base, adj.offset)),
        case il::Type::W32 => emit(e, encode::sw(rs, adj.base, adj.offset)),
        case il::Type::W64 => emit(e, encode::sd(rs, adj.base, adj.offset)),
        case il::Type::W64,
             il::Type::Ptr => emit(e, encode::sd(rs, adj.base, adj.offset)),
    }
}

/// Emit 64-bit load with automatic offset adjustment.
pub fn emitLd(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {

lib/std/arch/rv64/isel.rad +8 -4

        },
        case il::Type::W32 => {
            emit::emit(e, encode::slli(rd, rs, SHIFT_W32));
            emit::emit(e, encode::srli(rd, rd, SHIFT_W32));
        },
        case il::Type::W64 => {}
        case il::Type::W64,
             il::Type::Ptr => {}
    }
}

/// Emit sign-extension from a sub-word type to the full register width.
fn emitSext(e: *mut emit::Emitter, rd: gen::Reg, rs: gen::Reg, typ: il::Type) {

            emit::emit(e, encode::srai(rd, rd, SHIFT_W16));
        },
        case il::Type::W32 => {
            emit::emit(e, encode::addiw(rd, rs, 0));
        },
        case il::Type::W64 => {}
        case il::Type::W64,
             il::Type::Ptr => {}
    }
}

/// Resolve a value, trap if zero (unless known non-zero), and return the register.
fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> gen::Reg {

            // fits in the signed range of the target type.
            match typ {
                case il::Type::W8 => return imm >= I8_MIN and imm <= I8_MAX,
                case il::Type::W16 => return imm >= I16_MIN and imm <= I16_MAX,
                case il::Type::W32 => return imm >= I32_MIN and imm <= I32_MAX,
                case il::Type::W64 => return true,
                case il::Type::W64,
                     il::Type::Ptr => return true,
            }
        } else {
            // Zero-extension: value must be non-negative and within unsigned range.
            match typ {
                case il::Type::W8 => return imm >= 0 and imm <= U8_MAX,
                case il::Type::W16 => return imm >= 0 and imm <= U16_MAX,
                case il::Type::W32 => return imm >= 0 and imm <= U32_MAX,
                case il::Type::W64 => return true,
                case il::Type::W64,
                     il::Type::Ptr => return true,
            }
        }
    }
    return false;
}

lib/std/lang/il.rad +7 -2

    W8,
    /// 16-bit value.
    W16,
    /// 32-bit value.
    W32,
    /// 64-bit value (used for pointers on RV64).
    /// 64-bit value.
    W64,
    /// Pointer-width value with provenance.
    /// Same physical width as W64 on RV64, but semantically distinct:
    /// a verifier treats Ptr and W64 as incompatible types.
    Ptr,
}

/// Get the size of a type in bytes.
pub fn typeSize(t: Type) -> u32 {
    match t {
        case Type::W8 => return 1,
        case Type::W16 => return 2,
        case Type::W32 => return 4,
        case Type::W64 => return 8,
        case Type::W64,
             Type::Ptr => return 8,
    }
}

/// SSA register reference.
pub record Reg { n: u32 }

lib/std/lang/il/printer.rad +1 -0

    match typ {
        case super::Type::W8 => return "w8",
        case super::Type::W16 => return "w16",
        case super::Type::W32 => return "w32",
        case super::Type::W64 => return "w64",
        case super::Type::Ptr => return "ptr",
    }
}

/// Write a type.
fn writeType(out: *mut sexpr::Output, typ: super::Type) {

lib/std/lang/lower.rad +23 -23

        returnType: undefined,
        isExtern,
        isLeaf: true,
        blocks: &[],
    };
    // Throwing functions return a result aggregate (word-sized pointer).
    // Throwing functions return a result aggregate (pointer to stack slot).
    // TODO: The resolver should set an appropriate type that takes into account
    //       the throws list. It shouldn't set the return type to the "success"
    //       value only.
    if fnType.throwList.len > 0 {
        func.returnType = il::Type::W64;
        func.returnType = il::Type::Ptr;
    } else {
        func.returnType = ilType(self, *fnType.returnType);
    }
    let body = decl.body else {
        // Extern functions have no body.

        isExtern: false,
        isLeaf: true,
        blocks: &[],
    };
    if fnType.throwList.len > 0 {
        func.returnType = il::Type::W64;
        func.returnType = il::Type::Ptr;
    }
    func.blocks = try lowerFnBody(&mut fnLow, body);
    func.isLeaf = fnLow.isLeaf;

    return func;


    match subject.kind {
        case MatchSubjectKind::OptionalPtr if isNil => {
            // Null pointer optimization: branch on the data pointer being null.
            let nilReg = try optionalNilReg(self, subject.val, subject.type);
            try emitBrCmp(self, il::CmpOp::Eq, il::Type::W64, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);
            try emitBrCmp(self, il::CmpOp::Eq, il::Type::Ptr, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);
        }
        case MatchSubjectKind::OptionalAggregate => {
            let base = emitValToReg(self, subject.val);

            if isNil { // Optional aggregate: `nil` means tag is zero.

    let params = try! alloc::allocSlice(
        self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
    ) as *mut [il::Param];

    if let reg = self.returnReg {
        params[0] = il::Param { value: reg, type: il::Type::W64 };
        params[0] = il::Param { value: reg, type: il::Type::Ptr };
    }
    for i in 0..fnType.paramTypes.len as u32 {
        let type = ilType(self.low, *fnType.paramTypes[i]);
        let reg = nextReg(self);


    let val = try lowerExpr(self, opt);
    let cmpReg = try optionalNilReg(self, val, optTy);

    // Null-pointer-optimized types compare a 64-bit pointer against zero.
    // Aggregate optionals compare an 8-bit tag byte against zero.
    let cmpType = il::Type::W64 if resolver::isOptionalPointer(optTy) else il::Type::W8;
    let cmpType = il::Type::Ptr if resolver::isOptionalPointer(optTy) else il::Type::W8;

    let op = il::BinOp::Eq if isEq else il::BinOp::Ne;
    return emitTypedBinOp(self, op, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));
}


        alignment: resolver::PTR_SIZE,
    });

    // Store data pointer.
    emit(self, il::Instr::Store {
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        src: dataVal,
        dst: slot,
        offset: TRAIT_OBJ_DATA_OFFSET,
    });

    // Store v-table address.
    emit(self, il::Instr::Store {
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        src: il::Val::DataSym(vName),
        dst: slot,
        offset: TRAIT_OBJ_VTABLE_OFFSET,
    });
    return il::Val::Reg(slot);

    }
    let dst = nextReg(self);

    emit(self, il::Instr::BinOp {
        op: il::BinOp::Add,
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        dst,
        a: il::Val::Reg(base),
        b: il::Val::Imm(offset as i64),
    });
    return dst;

    if stride == 1 {
        let dst = nextReg(self);

        emit(self, il::Instr::BinOp {
            op: il::BinOp::Add,
            typ: il::Type::W64,
            typ: il::Type::Ptr,
            dst,
            a: il::Val::Reg(base),
            b: idx
        });
        return dst;

    });
    // Compute `dst = base + offset`.
    let dst = nextReg(self);
    emit(self, il::Instr::BinOp {
        op: il::BinOp::Add,
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        dst,
        a: il::Val::Reg(base),
        b: il::Val::Reg(offset)
    });
    return dst;

    args[1] = byteSize;
    args[2] = il::Val::Imm(alignment as i64);

    let newPtrReg = nextReg(self);
    emit(self, il::Instr::Call {
        retTy: il::Type::W64,
        retTy: il::Type::Ptr,
        dst: newPtrReg,
        func: il::Val::Reg(allocFnReg),
        args,
    });


    let traitObjReg = emitValToReg(self, traitObjVal);

    // Load data pointer from trait object.
    let dataReg = nextReg(self);
    emit(self, il::Instr::Load {
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        dst: dataReg,
        src: traitObjReg,
        offset: TRAIT_OBJ_DATA_OFFSET,
    });

    // Load v-table pointer from trait object.
    let vtableReg = nextReg(self);
    emit(self, il::Instr::Load {
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        dst: vtableReg,
        src: traitObjReg,
        offset: TRAIT_OBJ_VTABLE_OFFSET,
    });

    // Load function pointer from v-table at the method's slot offset.
    let fnPtrReg = nextReg(self);
    let slotOffset = (methodIndex * resolver::PTR_SIZE) as i32;

    emit(self, il::Instr::Load {
        typ: il::Type::W64,
        typ: il::Type::Ptr,
        dst: fnPtrReg,
        src: vtableReg,
        offset: slotOffset,
    });
    let methodFnType = traitInfo.methods[methodIndex].fnType;

            args[0] = il::Val::Reg(try emitReserve(self, retTy));
        }
        let dst = nextReg(self);

        emit(self, il::Instr::Call {
            retTy: il::Type::W64,
            retTy: il::Type::Ptr,
            dst,
            func: callee,
            args,
        });
        return il::Val::Reg(dst);

        case resolver::Type::I16,
             resolver::Type::U16 => return il::Type::W16,
        case resolver::Type::I32,
             resolver::Type::U32 => return il::Type::W32,
        case resolver::Type::I64,
             resolver::Type::U64,
             resolver::Type::Pointer { .. },
             resolver::Type::Slice { .. },
             resolver::Type::Array(_),
             resolver::Type::Optional(_),
             resolver::Type::U64 => return il::Type::W64,
        case resolver::Type::Pointer { .. },
             resolver::Type::Fn(_),
             resolver::Type::TraitObject { .. } => return il::Type::W64,
             resolver::Type::TraitObject { .. } => return il::Type::Ptr,
        case resolver::Type::Slice { .. },
             resolver::Type::Array(_),
             resolver::Type::Optional(_) => return il::Type::Ptr,
        case resolver::Type::Nominal(_) => {
            if resolver::isVoidUnion(typ) {
                return il::Type::W8;
            }
            return il::Type::W64;
            return il::Type::Ptr;
        }
        case resolver::Type::Void => return il::Type::W64,
        // [`Type::Int`] is the type of unsuffixed integer literals and their
        // compound expressions (e.g. `1 + 2`). It defaults to W64 (i64) here,
        // matching the native word size on RV64. It cannot be resolved earlier

test/tests/arith.subword.ril +0 -1

  @assert.fail29
    unreachable;
  @assert.ok30
    ret 0;
}


test/tests/arith.w64.ril +0 -1

  @assert.fail35
    unreachable;
  @assert.ok36
    ret 0;
}


test/tests/array.aggregate.stride.ril +9 -9

fn w32 $arrayOfRecords(w64 %0, w32 %1) {
fn w32 $arrayOfRecords(ptr %0, w32 %1) {
  @entry0
    br.ult w32 %1 3 @guard#pass1 @guard#trap2;
  @guard#pass1
    mul w64 %2 %1 8;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    sload w32 %4 %3 0;
    ret %4;
  @guard#trap2
    ebreak;
    unreachable;
}

fn w64 $addressOfRecord(w64 %0, w32 %1) {
fn ptr $addressOfRecord(ptr %0, w32 %1) {
  @entry0
    br.ult w32 %1 3 @guard#pass1 @guard#trap2;
  @guard#pass1
    mul w64 %2 %1 8;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    ret %3;
  @guard#trap2
    ebreak;
    unreachable;
}

fn w32 $arrayOfArrays(w64 %0, w32 %1) {
fn w32 $arrayOfArrays(ptr %0, w32 %1) {
  @entry0
    br.ult w32 %1 3 @guard#pass1 @guard#trap2;
  @guard#pass1
    mul w64 %2 %1 16;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    sload w32 %4 %3 0;
    ret %4;
  @guard#trap2
    ebreak;
    unreachable;
}

fn w32 $nestedLargeStride(w64 %0, w32 %1, w32 %2) {
fn w32 $nestedLargeStride(ptr %0, w32 %1, w32 %2) {
  @entry0
    br.ult w32 %1 3 @guard#pass1 @guard#trap2;
  @guard#pass1
    mul w64 %3 %1 16;
    add w64 %4 %0 %3;
    add ptr %4 %0 %3;
    br.ult w32 %2 2 @guard#pass3 @guard#trap4;
  @guard#trap2
    ebreak;
    unreachable;
  @guard#pass3
    mul w64 %5 %2 8;
    add w64 %6 %4 %5;
    add ptr %6 %4 %5;
    sload w32 %7 %6 4;
    ret %7;
  @guard#trap4
    ebreak;
    unreachable;

test/tests/array.assign.ril +2 -3

    store w32 6 %1 12;
    store w32 0 %1 16;
    blit %1 %0 20;
    sload w32 %2 %1 0;
    mul w64 %3 3 4;
    add w64 %4 %1 %3;
    add ptr %4 %1 %3;
    sload w32 %5 %4 0;
    add w32 %6 %2 %5;
    mul w64 %7 2 4;
    add w64 %8 %1 %7;
    add ptr %8 %1 %7;
    sload w32 %9 %8 0;
    sub w32 %10 %6 %9;
    ret %10;
}


test/tests/array.index.ril +3 -4

6	6		store w32 30 %0 8;
7	7		store w32 40 %0 12;
8	8		sload w32 %1 %0 0;
9	9		add w32 %2 0 %1;
10	10		mul w64 %3 1 4;
11		-	add w64 %4 %0 %3;
	11	+	add ptr %4 %0 %3;
12	12		sload w32 %5 %4 0;
13	13		add w32 %6 %2 %5;
14	14		mul w64 %7 2 4;
15		-	add w64 %8 %0 %7;
	15	+	add ptr %8 %0 %7;
16	16		sload w32 %9 %8 0;
17	17		add w32 %10 %6 %9;
18	18		mul w64 %11 3 4;
19		-	add w64 %12 %0 %11;
	19	+	add ptr %12 %0 %11;
20	20		sload w32 %13 %12 0;
21	21		add w32 %14 %10 %13;
22	22		sub w32 %15 %14 100;
23	23		ret %15;
24	24		}
25		-

test/tests/array.len.const.ril +3 -3

fn w32 $arrayLen(w64 %0) {
fn w32 $arrayLen(ptr %0) {
  @entry0
    ret 5;
}

fn w32 $arrayLenExpr(w64 %0) {
fn w32 $arrayLenExpr(ptr %0) {
  @entry0
    add w32 %1 3 10;
    ret %1;
}

fn w8 $arrayLenCmp(w64 %0) {
fn w8 $arrayLenCmp(ptr %0) {
  @entry0
    eq w32 %1 4 4;
    ret %1;
}

test/tests/array.literal.ril +2 -2

    store w32 1 %0 0;
    store w32 2 %0 4;
    store w32 3 %0 8;
    sload w32 %1 %0 0;
    mul w64 %2 1 4;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    sload w32 %4 %3 0;
    add w32 %5 %1 %4;
    mul w64 %6 2 4;
    add w64 %7 %0 %6;
    add ptr %7 %0 %6;
    sload w32 %8 %7 0;
    add w32 %9 %5 %8;
    ret %9;
}

test/tests/array.nested.ril +8 -9

8	8		blit %0 %1 12;
9	9		reserve %2 12 4;
10	10		store w32 4 %2 0;
11	11		store w32 5 %2 4;
12	12		store w32 6 %2 8;
13		-	add w64 %3 %0 12;
	13	+	add ptr %3 %0 12;
14	14		blit %3 %2 12;
15	15		reserve %4 24 4;
16	16		blit %4 %0 24;
17	17		sload w32 %5 %0 0;
18	18		mul w64 %6 1 4;
19		-	add w64 %7 %4 %6;
	19	+	add ptr %7 %4 %6;
20	20		sload w32 %8 %7 0;
21	21		add w32 %9 %5 %8;
22	22		mul w64 %10 2 4;
23		-	add w64 %11 %0 %10;
	23	+	add ptr %11 %0 %10;
24	24		sload w32 %12 %11 0;
25	25		add w32 %13 %9 %12;
26	26		mul w64 %14 1 12;
27		-	add w64 %15 %4 %14;
	27	+	add ptr %15 %4 %14;
28	28		sload w32 %16 %15 0;
29	29		add w32 %17 %13 %16;
30	30		mul w64 %18 1 12;
31		-	add w64 %19 %0 %18;
	31	+	add ptr %19 %0 %18;
32	32		mul w64 %20 1 4;
33		-	add w64 %21 %19 %20;
	33	+	add ptr %21 %19 %20;
34	34		sload w32 %22 %21 0;
35	35		add w32 %23 %17 %22;
36	36		mul w64 %24 1 12;
37		-	add w64 %25 %4 %24;
	37	+	add ptr %25 %4 %24;
38	38		mul w64 %26 2 4;
39		-	add w64 %27 %25 %26;
	39	+	add ptr %27 %25 %26;
40	40		sload w32 %28 %27 0;
41	41		add w32 %29 %23 %28;
42	42		ret %29;
43	43		}
44		-

test/tests/array.repeat.ril +9 -10

    store w32 42 %0 8;
    sload w32 %3 %0 0;
    br.eq w32 %3 42 @and#then4 @and#else5;
  @and#then1
    mul w64 %9 2 4;
    add w64 %10 %0 %9;
    add ptr %10 %0 %9;
    sload w32 %11 %10 0;
    eq w32 %12 %11 42;
    jmp @and#end3(%12);
  @and#else2
    jmp @and#end3(0);
  @and#end3(w8 %1)
    ret %1;
  @and#then4
    mul w64 %4 1 4;
    add w64 %5 %0 %4;
    add ptr %5 %0 %4;
    sload w32 %6 %5 0;
    eq w32 %7 %6 42;
    jmp @and#end6(%7);
  @and#else5
    jmp @and#end6(0);

    store w32 0 %0 16;
    sload w32 %5 %0 0;
    br.eq w32 %5 0 @and#then10 @and#else11;
  @and#then1
    mul w64 %21 4 4;
    add w64 %22 %0 %21;
    add ptr %22 %0 %21;
    sload w32 %23 %22 0;
    eq w32 %24 %23 0;
    jmp @and#end3(%24);
  @and#else2
    jmp @and#end3(0);
  @and#end3(w8 %1)
    ret %1;
  @and#then4
    mul w64 %16 3 4;
    add w64 %17 %0 %16;
    add ptr %17 %0 %16;
    sload w32 %18 %17 0;
    eq w32 %19 %18 0;
    jmp @and#end6(%19);
  @and#else5
    jmp @and#end6(0);
  @and#end6(w8 %2)
    br.ne w32 %2 0 @and#then1 @and#else2;
  @and#then7
    mul w64 %11 2 4;
    add w64 %12 %0 %11;
    add ptr %12 %0 %11;
    sload w32 %13 %12 0;
    eq w32 %14 %13 0;
    jmp @and#end9(%14);
  @and#else8
    jmp @and#end9(0);
  @and#end9(w8 %3)
    br.ne w32 %3 0 @and#then4 @and#else5;
  @and#then10
    mul w64 %6 1 4;
    add w64 %7 %0 %6;
    add ptr %7 %0 %6;
    sload w32 %8 %7 0;
    eq w32 %9 %8 0;
    jmp @and#end12(%9);
  @and#else11
    jmp @and#end12(0);

    store w8 1 %0 2;
    store w8 1 %0 3;
    load w8 %4 %0 0;
    br.ne w32 %4 0 @and#then7 @and#else8;
  @and#then1
    add w64 %11 %0 3;
    add ptr %11 %0 3;
    load w8 %12 %11 0;
    jmp @and#end3(%12);
  @and#else2
    jmp @and#end3(0);
  @and#end3(w8 %1)
    ret %1;
  @and#then4
    add w64 %8 %0 2;
    add ptr %8 %0 2;
    load w8 %9 %8 0;
    jmp @and#end6(%9);
  @and#else5
    jmp @and#end6(0);
  @and#end6(w8 %2)
    br.ne w32 %2 0 @and#then1 @and#else2;
  @and#then7
    add w64 %5 %0 1;
    add ptr %5 %0 1;
    load w8 %6 %5 0;
    jmp @and#end9(%6);
  @and#else8
    jmp @and#end9(0);
  @and#end9(w8 %3)

  @and#else8
    jmp @and#end9(0);
  @and#end9(w8 %2)
    br.ne w32 %2 0 @and#then4 @and#else5;
}


test/tests/array.slice.full.ril +2 -2

fn w64 $sliceFull(w64 %0, w64 %1) {
fn ptr $sliceFull(ptr %0, ptr %1) {
  @entry0
    reserve %2 16 8;
    store w64 %1 %2 0;
    store ptr %1 %2 0;
    store w32 4 %2 8;
    store w32 4 %2 12;
    blit %0 %2 16;
    ret %0;
}

test/tests/array.slice.openend.ril +3 -3

fn w64 $sliceOpenEnd(w64 %0, w64 %1, w32 %2) {
fn ptr $sliceOpenEnd(ptr %0, ptr %1, w32 %2) {
  @entry0
    mul w64 %3 %2 4;
    add w64 %4 %1 %3;
    add ptr %4 %1 %3;
    sub w32 %5 4 %2;
    reserve %6 16 8;
    store w64 %4 %6 0;
    store ptr %4 %6 0;
    store w32 %5 %6 8;
    store w32 %5 %6 12;
    blit %0 %6 16;
    ret %0;
}

test/tests/array.slice.openstart.ril +2 -2

fn w64 $sliceOpenStart(w64 %0, w64 %1, w32 %2) {
fn ptr $sliceOpenStart(ptr %0, ptr %1, w32 %2) {
  @entry0
    reserve %3 16 8;
    store w64 %1 %3 0;
    store ptr %1 %3 0;
    store w32 %2 %3 8;
    store w32 %2 %3 12;
    blit %0 %3 16;
    ret %0;
}

test/tests/assert.basic.ril +0 -1

  @assert.fail11
    unreachable;
  @assert.ok12
    ret 0;
}


test/tests/average.ril +2 -2

fn w32 $average(w64 %0) {
fn w32 $average(ptr %0) {
  @entry0
    load w32 %1 %0 8;
    load w64 %2 %0 0;
    jmp @loop1(0, 0);
  @loop1(w32 %3, w32 %7)
    br.slt w32 %3 %1 @body2 @merge3;
  @body2
    mul w64 %4 %3 4;
    add w64 %5 %2 %4;
    add ptr %5 %2 %4;
    load w32 %6 %5 0;
    add w32 %8 %7 %6;
    add w32 %9 %3 1;
    jmp @loop1(%9, %8);
  @merge3

test/tests/byte.load.store.ril +7 -7

fn w8 $loadByte(w64 %0) {
fn w8 $loadByte(ptr %0) {
  @entry0
    load w8 %1 %0 0;
    ret %1;
}

fn w64 $storeByte(w64 %0, w8 %1) {
fn w64 $storeByte(ptr %0, w8 %1) {
  @entry0
    store w8 %1 %0 0;
    ret;
}

fn w64 $loadStoreByte(w64 %0, w64 %1) {
fn w64 $loadStoreByte(ptr %0, ptr %1) {
  @entry0
    load w8 %2 %0 0;
    store w8 %2 %1 0;
    ret;
}

fn w8 $byteArrayAccess(w64 %0, w32 %1) {
fn w8 $byteArrayAccess(ptr %0, w32 %1) {
  @entry0
    br.ult w32 %1 4 @guard#pass1 @guard#trap2;
  @guard#pass1
    add w64 %2 %0 %1;
    add ptr %2 %0 %1;
    load w8 %3 %2 0;
    ret %3;
  @guard#trap2
    ebreak;
    unreachable;
}

fn w8 $byteSliceAccess(w64 %0, w32 %1) {
fn w8 $byteSliceAccess(ptr %0, w32 %1) {
  @entry0
    load w32 %2 %0 8;
    br.ult w32 %1 %2 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %3 %0 0;
    add w64 %4 %3 %1;
    add ptr %4 %3 %1;
    load w8 %5 %4 0;
    ret %5;
  @guard#trap2
    ebreak;
    unreachable;

test/tests/cast.basic.ril +1 -1

  @entry0
    sext w16 %1 %0;
    ret %1;
}

fn w64 $ptrCast(w64 %0) {
fn ptr $ptrCast(ptr %0) {
  @entry0
    ret %0;
}

test/tests/cast.same.size.ril +0 -1

  @assert.fail19
    unreachable;
  @assert.ok20
    ret 0;
}


test/tests/coercion.implicit.ril +1 -1

    ret %5;
  @else2
    ret 0;
}

fn w64 $optionalLiftReturn(w64 %0, w32 %1) {
fn ptr $optionalLiftReturn(ptr %0, w32 %1) {
  @entry0
    reserve %2 8 4;
    store w8 1 %2 0;
    store w32 %1 %2 4;
    blit %0 %2 8;

test/tests/compound.assign.ril +3 -4

    reserve %10 12 4;
    store w32 10 %10 0;
    store w32 20 %10 4;
    store w32 30 %10 8;
    mul w64 %11 1 4;
    add w64 %12 %10 %11;
    add ptr %12 %10 %11;
    sload w32 %13 %12 0;
    add w32 %14 %13 5;
    mul w64 %15 1 4;
    add w64 %16 %10 %15;
    add ptr %16 %10 %15;
    store w32 %14 %16 0;
    mul w64 %17 1 4;
    add w64 %18 %10 %17;
    add ptr %18 %10 %17;
    sload w32 %19 %18 0;
    br.eq w32 %19 25 @assert.ok22 @assert.fail21;
  @assert.fail21
    unreachable;
  @assert.ok22

  @assert.fail25
    unreachable;
  @assert.ok26
    ret 0;
}


test/tests/cond.iflet.mut.ril +1 -1

fn w32 $ifLetMut(w64 %0) {
fn w32 $ifLetMut(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    load w8 %2 %1 0;
    br.ne w32 %2 0 @then1 @else2;

test/tests/cond.iflet.noelse.ril +1 -1

fn w32 $ifLetNoElse(w64 %0) {
fn w32 $ifLetNoElse(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    load w8 %2 %1 0;
    br.ne w32 %2 0 @then1 @else2;

test/tests/cond.iflet.optional.ril +1 -1

fn w32 $ifLetOptional(w64 %0) {
fn w32 $ifLetOptional(ptr %0) {
  @entry0
    br.ne w32 %0 0 @then1 @else2;
  @then1
    ret 1;
  @else2

test/tests/cond.iflet.optional.value.ril +1 -1

fn w32 $ifLetOptionalValue(w64 %0) {
fn w32 $ifLetOptionalValue(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    load w8 %2 %1 0;
    br.ne w32 %2 0 @then1 @else2;

test/tests/cond.letelse.mut.ril +1 -1

fn w32 $letMutElse(w64 %0) {
fn w32 $letMutElse(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    load w8 %2 %1 0;
    br.ne w32 %2 0 @merge1 @else2;

test/tests/cond.letelse.optional.ril +1 -1

fn w32 $letElseOptional(w64 %0) {
fn w32 $letElseOptional(ptr %0) {
  @entry0
    br.ne w32 %0 0 @merge1 @else2;
  @merge1
    ret 1;
  @else2

test/tests/const.array.record.ident.ril +1 -1

  @entry0
    copy %0 $POINTS;
    sload w32 %1 %0 0;
    copy %2 $POINTS;
    mul w64 %3 1 8;
    add w64 %4 %2 %3;
    add ptr %4 %2 %3;
    sload w32 %5 %4 4;
    add w32 %6 %1 %5;
    ret %6;
}

test/tests/const.array.repeat.record.ril +2 -2

  @entry0
    copy %0 $POINTS;
    sload w32 %1 %0 0;
    copy %2 $POINTS;
    mul w64 %3 1 8;
    add w64 %4 %2 %3;
    add ptr %4 %2 %3;
    sload w32 %5 %4 4;
    add w32 %6 %1 %5;
    copy %7 $POINTS;
    mul w64 %8 2 8;
    add w64 %9 %7 %8;
    add ptr %9 %7 %8;
    sload w32 %10 %9 0;
    add w32 %11 %6 %10;
    ret %11;
}

test/tests/const.array.ril +1 -2

    jmp @loop1(0, 0);
  @loop1(w32 %1, w32 %5)
    br.slt w32 %1 4 @body2 @merge3;
  @body2
    mul w64 %2 %1 4;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    sload w32 %4 %3 0;
    add w32 %6 %5 %4;
    add w32 %7 %1 1;
    jmp @loop1(%7, %6);
  @merge3
    sub w32 %8 %5 10;
    ret %8;
}


test/tests/const.array.strings.slice.ril +2 -2

  @entry0
    copy %0 $WORDS;
    load w32 %1 %0 8;
    copy %2 $WORDS;
    mul w64 %3 1 16;
    add w64 %4 %2 %3;
    add ptr %4 %2 %3;
    load w32 %5 %4 8;
    add w32 %6 %1 %5;
    copy %7 $WORDS;
    mul w64 %8 2 16;
    add w64 %9 %7 %8;
    add ptr %9 %7 %8;
    load w32 %10 %9 8;
    add w32 %11 %6 %10;
    ret %11;
}

test/tests/const.record.ctor.ril +0 -1

  @assert.fail1
    unreachable;
  @assert.ok2
    ret 0;
}


test/tests/const.record.mutcopy.ril +1 -1


data $SCRATCH2 align 1 {
    w8 31;
}

fn w64 $test(w64 %0) {
fn ptr $test(ptr %0) {
  @entry0
    copy %1 $SCRATCH1;
    reserve %2 1 1;
    blit %2 %1 1;
    load w8 %3 %0 0;

test/tests/const.record.nested.ril +2 -2

}

fn w8 $getInnerA() {
  @entry0
    copy %0 $O;
    add w64 %1 %0 4;
    add ptr %1 %0 4;
    load w8 %2 %1 0;
    ret %2;
}

fn w32 $getInnerB() {
  @entry0
    copy %0 $O;
    add w64 %1 %0 4;
    add ptr %1 %0 4;
    sload w32 %2 %1 4;
    ret %2;
}

fn w8 $getY() {

test/tests/const.record.ril +0 -1

    sload w32 %3 %2 4;
    add w32 %4 %1 %3;
    sub w32 %5 %4 7;
    ret %5;
}


test/tests/const.slice.of.slices.ril +2 -2

  @entry0
    copy %0 $GROUPS;
    load w32 %1 %0 8;
    copy %2 $GROUPS;
    mul w64 %3 1 16;
    add w64 %4 %2 %3;
    add ptr %4 %2 %3;
    load w32 %5 %4 8;
    add w32 %6 %1 %5;
    copy %7 $GROUPS;
    load w32 %8 %7 8;
    br.ult w32 1 %8 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %9 %7 0;
    mul w64 %10 1 16;
    add w64 %11 %9 %10;
    add ptr %11 %9 %10;
    load w32 %12 %11 8;
    add w32 %13 %6 %12;
    ret %13;
  @guard#trap2
    ebreak;

test/tests/const.string.ril +1 -1


fn w32 $getLen() {
  @entry0
    copy %0 $HELLO$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/const.string.scoped.names.ril +3 -3


fn w32 $totalLen() {
  @entry0
    copy %0 $HELLO1$0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    copy %3 $HELLO1$0;
    reserve %4 16 8;
    store w64 %3 %4 0;
    store ptr %3 %4 0;
    store w32 5 %4 8;
    store w32 5 %4 12;
    load w32 %5 %4 8;
    add w32 %6 %2 %5;
    copy %7 $MSGS;
    load w32 %8 %7 8;
    add w32 %9 %6 %8;
    copy %10 $MSGS;
    mul w64 %11 1 16;
    add w64 %12 %10 %11;
    add ptr %12 %10 %11;
    load w32 %13 %12 8;
    add w32 %14 %9 %13;
    ret %14;
}

test/tests/const.union.payload.ctor.ril +0 -1

  @arm8
    jmp @case9;
  @case9
    ret 3;
}


test/tests/const.union.record.literal.ril +1 -2

  @case2
    ret 1;
  @arm3
    jmp @case4;
  @case4
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    add w32 %6 %4 %5;
    br.eq w32 %6 42 @assert.ok7 @assert.fail6;
  @assert.fail6

  @assert.ok7
    jmp @merge8;
  @merge8
    ret 0;
}


test/tests/error.catch.return.ril +2 -2

fn w64 $fallible(w64 %0, w8 %1) {
fn ptr $fallible(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

}

fn w32 $caller(w8 %0) {
  @entry0
    reserve %1 12 8;
    call w64 %2 $fallible(%1, %0);
    call ptr %2 $fallible(%1, %0);
    load w64 %3 %2 0;
    reserve %4 4 4;
    br.ne w32 %3 0 @err2 @ok1;
  @ok1
    sload w32 %5 %2 8;

test/tests/field.aggregate.ril +3 -3

    store w32 30 %0 8;
    sload w32 %2 %0 4;
    ret %2;
}

fn w64 $accessUnionField() {
fn ptr $accessUnionField() {
  @entry0
    reserve %0 12 4;
    reserve %1 4 4;
    store w32 42 %1 0;
    reserve %2 8 4;
    store w8 1 %2 0;
    add w64 %3 %2 4;
    add ptr %3 %2 4;
    blit %3 %1 4;
    blit %0 %2 8;
    store w32 99 %0 8;
    load w64 %4 %0 0;
    ret %4;

    store w32 1 %0 0;
    store w32 2 %0 4;
    store w32 3 %0 8;
    reserve %1 24 8;
    reserve %2 16 8;
    store w64 %0 %2 0;
    store ptr %0 %2 0;
    store w32 3 %2 8;
    store w32 3 %2 12;
    blit %1 %2 16;
    store w32 77 %1 16;
    load w32 %3 %1 8;

test/tests/fn.ptr.assign.ril +1 -1

  @entry0
    add w32 %2 %0 %1;
    ret %2;
}

fn w64 $assignFnPtr() {
fn ptr $assignFnPtr() {
  @entry0
    copy %0 $add;
    ret %0;
}

test/tests/fn.ptr.param.ril +1 -1

  @entry0
    add w32 %2 %0 %1;
    ret %2;
}

fn w32 $apply(w64 %0, w32 %1, w32 %2) {
fn w32 $apply(ptr %0, w32 %1, w32 %2) {
  @entry0
    call w32 %3 %0(%1, %2);
    ret %3;
}


test/tests/let.copy.semantics.ril +4 -4

fn w64 $makePoint() {
fn ptr $makePoint() {
  @entry0
    reserve %0 8 4;
    store w32 1 %0 0;
    store w32 2 %0 4;
    load w64 %1 %0 0;
    ret %1;
}

fn w32 $letFromCall() {
  @entry0
    call w64 %0 $makePoint();
    call ptr %0 $makePoint();
    reserve %1 8 8;
    store w64 %0 %1 0;
    sload w32 %2 %1 0;
    ret %2;
}

    store w32 2 %1 4;
    blit %0 %1 8;
    reserve %2 8 4;
    store w32 3 %2 0;
    store w32 4 %2 4;
    add w64 %3 %0 8;
    add ptr %3 %0 8;
    blit %3 %2 8;
    mul w64 %4 1 8;
    add w64 %5 %0 %4;
    add ptr %5 %0 %4;
    reserve %6 8 4;
    blit %6 %5 8;
    sload w32 %7 %6 0;
    ret %7;
}

test/tests/let.placeholder.ril +1 -1

fn w32 $placeholder() {
  @entry0
    ret 1;
}

fn w32 $placeholderWithSideEffect(w64 %0) {
fn w32 $placeholderWithSideEffect(ptr %0) {
  @entry0
    sload w32 %1 %0 0;
    ret 0;
}


test/tests/literal.slice.bytes.ril +1 -1


fn w32 $byteSlice() {
  @entry0
    copy %0 $byteSlice0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.slice.dedup.ril +2 -2


fn w32 $dedupSlice() {
  @entry0
    copy %0 $dedupSlice0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    copy %2 $dedupSlice0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 3 %3 8;
    store w32 3 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;

test/tests/literal.slice.empty.ril +1 -1

fn w32 $emptySlice() {
  @entry0
    reserve %0 16 8;
    store w64 0 %0 0;
    store ptr 0 %0 0;
    store w32 0 %0 8;
    store w32 0 %0 12;
    load w32 %1 %0 8;
    ret %1;
}

test/tests/literal.slice.multi.ril +2 -2


fn w32 $multiSlice() {
  @entry0
    copy %0 $multiSlice0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 2 %1 8;
    store w32 2 %1 12;
    copy %2 $multiSlice1;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 3 %3 8;
    store w32 3 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;

test/tests/literal.slice.record.ril +2 -2


fn w32 $localSliceOfRecords() {
  @entry0
    copy %0 $localSliceOfRecords0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 2 %1 8;
    store w32 2 %1 12;
    load w32 %2 %1 8;
    br.ult w32 0 %2 @guard#pass1 @guard#trap2;
  @guard#pass1

    ebreak;
    unreachable;
  @guard#pass3
    load w64 %6 %1 0;
    mul w64 %7 1 8;
    add w64 %8 %6 %7;
    add ptr %8 %6 %7;
    sload w32 %9 %8 4;
    add w32 %10 %4 %9;
    ret %10;
  @guard#trap4
    ebreak;

test/tests/literal.slice.ril +1 -1


fn w32 $sliceLiteral() {
  @entry0
    copy %0 $sliceLiteral0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.string.dedup.ril +2 -2


fn w32 $dedupString() {
  @entry0
    copy %0 $dedupString0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    copy %2 $dedupString0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 5 %3 8;
    store w32 5 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;

test/tests/literal.string.empty.ril +1 -1


fn w32 $emptyString() {
  @entry0
    copy %0 $emptyString0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 0 %1 8;
    store w32 0 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.string.fns.ril +2 -2


fn w32 $first() {
  @entry0
    copy %0 $first0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

fn w32 $second() {
  @entry0
    copy %0 $second0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/literal.string.multi.ril +2 -2


fn w32 $multiString() {
  @entry0
    copy %0 $multiString0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    copy %2 $multiString1;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 5 %3 8;
    store w32 5 %3 12;
    load w32 %4 %1 8;
    load w32 %5 %3 8;
    add w32 %6 %4 %5;

test/tests/literal.string.ril +1 -1


fn w32 $stringLen() {
  @entry0
    copy %0 $stringLen0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    ret %2;
}

test/tests/loop.for.array.ril +2 -2

fn w32 $forArrayIndexed(w64 %0) {
fn w32 $forArrayIndexed(ptr %0) {
  @entry0
    jmp @loop1(0, 0);
  @loop1(w32 %1, w32 %5)
    br.slt w32 %1 3 @body2 @merge3;
  @body2
    mul w64 %2 %1 4;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    sload w32 %4 %3 0;
    add w32 %6 %4 %1;
    add w32 %7 %5 %6;
    add w32 %8 %1 1;
    jmp @loop1(%8, %7);

test/tests/loop.for.continue.ril +2 -2

  @step6(w32 %6)
    add w32 %5 %1 1;
    jmp @loop1(%5, %6);
}

fn w32 $forContinueArray(w64 %0) {
fn w32 $forContinueArray(ptr %0) {
  @entry0
    jmp @loop1(0, 0);
  @loop1(w32 %1, w32 %5)
    br.slt w32 %1 4 @body2 @merge3;
  @body2
    mul w64 %2 %1 4;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    sload w32 %4 %3 0;
    br.eq w32 %4 0 @then4 @merge5;
  @merge3
    ret %5;
  @then4

test/tests/loop.for.placeholder.ril +1 -1

    jmp @loop1(%4, %3);
  @merge3
    ret %2;
}

fn w32 $forPlaceholderArray(w64 %0) {
fn w32 $forPlaceholderArray(ptr %0) {
  @entry0
    jmp @loop1(0, 0);
  @loop1(w32 %1, w32 %2)
    br.slt w32 %1 4 @body2 @merge3;
  @body2

test/tests/loop.for.slice.ril +2 -2

fn w32 $forSliceIndexed(w64 %0) {
fn w32 $forSliceIndexed(ptr %0) {
  @entry0
    load w32 %1 %0 8;
    load w64 %2 %0 0;
    jmp @loop1(0, 0);
  @loop1(w32 %3, w32 %7)
    br.slt w32 %3 %1 @body2 @merge3;
  @body2
    mul w64 %4 %3 4;
    add w64 %5 %2 %4;
    add ptr %5 %2 %4;
    sload w32 %6 %5 0;
    add w32 %8 %6 %3;
    add w32 %9 %7 %8;
    add w32 %10 %3 1;
    jmp @loop1(%10, %9);

test/tests/loop.mutable.ril +3 -3

    ret %0;
  @merge2
    ret %1;
}

fn w32 $computeMaxAlign(w64 %0) {
fn w32 $computeMaxAlign(ptr %0) {
  @entry0
    load w32 %1 %0 8;
    jmp @loop1(0, 1, %0);
  @loop1(w32 %2, w32 %3, w64 %4)
  @loop1(w32 %2, w32 %3, ptr %4)
    br.ult w32 %2 %1 @body2 @merge3;
  @body2
    load w32 %5 %4 8;
    br.ult w32 %2 %5 @guard#pass4 @guard#trap5;
  @merge3
    ret %3;
  @guard#pass4
    load w64 %6 %4 0;
    mul w64 %7 %2 4;
    add w64 %8 %6 %7;
    add ptr %8 %6 %7;
    load w32 %9 %8 0;
    call w32 %10 $max(%3, %9);
    add w32 %11 %2 1;
    jmp @loop1(%11, %10, %4);
  @guard#trap5

test/tests/loop.whilelet.optional.ril +2 -2

fn w32 $whileLetOptional(w64 %0) {
fn w32 $whileLetOptional(ptr %0) {
  @entry0
    jmp @while1(%0, 0);
  @while1(w64 %1, w32 %2)
  @while1(ptr %1, w32 %2)
    br.ne w32 %1 0 @body2 @merge3(%2);
  @body2
    add w32 %3 %2 1;
    jmp @merge3(%3);
  @merge3(w32 %4)

test/tests/loop.whilelet.union.ril +2 -2

fn w32 $sumWhileLet(w64 %0) {
fn w32 $sumWhileLet(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    jmp @while1(%1, 0);
  @while1(w64 %2, w32 %6)
  @while1(ptr %2, w32 %6)
    reserve %3 8 4;
    blit %3 %2 8;
    load w8 %4 %3 0;
    br.eq w8 %4 1 @body2 @merge3;
  @body2

test/tests/match.multi.seal.ril +0 -1

  @assert.fail7
    unreachable;
  @assert.ok8
    ret 0;
}


test/tests/match.nested.iflet.ril +7 -8

fn w32 $ifLetNested(w64 %0) {
fn w32 $ifLetNested(ptr %0) {
  @entry0
    reserve %1 16 4;
    blit %1 %0 16;
    load w8 %2 %1 0;
    br.eq w8 %2 0 @then1 @else2;
  @then1
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    sload w32 %6 %3 8;
    add w32 %7 %4 %5;
    add w32 %8 %7 %6;

    jmp @merge3;
  @merge3
    ret -1;
}

fn w32 $ifLetNestedUnion(w64 %0) {
fn w32 $ifLetNestedUnion(ptr %0) {
  @entry0
    reserve %1 12 4;
    blit %1 %0 12;
    load w8 %2 %1 0;
    br.eq w8 %2 0 @then1 @else2;
  @then1
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    load w8 %4 %3 0;
    br.eq w8 %4 0 @nest3 @else2;
  @else2
    jmp @merge5;
  @nest3

    ret %5;
  @merge5
    ret 0;
}

fn w32 $ifLetPlaceholder(w64 %0) {
fn w32 $ifLetPlaceholder(ptr %0) {
  @entry0
    reserve %1 16 4;
    blit %1 %0 16;
    load w8 %2 %1 0;
    br.eq w8 %2 0 @then1 @else2;
  @then1
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    ret %4;
  @else2
    jmp @merge3;
  @merge3

    reserve %0 16 4;
    store w8 0 %0 0;
    reserve %1 8 4;
    store w32 10 %1 0;
    store w32 20 %1 4;
    add w64 %2 %0 4;
    add ptr %2 %0 4;
    blit %2 %1 8;
    store w32 30 %0 12;
    call w32 %3 $ifLetNested(%0);
    br.eq w32 %3 60 @assert.ok2 @assert.fail1;
  @assert.fail1

  @assert.fail13
    unreachable;
  @assert.ok14
    ret 0;
}


test/tests/match.nested.pattern.ril +30 -31

fn w32 $testNestedMatch(w64 %0) {
fn w32 $testNestedMatch(ptr %0) {
  @entry0
    reserve %1 16 4;
    blit %1 %0 16;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    sload w32 %6 %3 8;
    add w32 %7 %4 %5;
    add w32 %8 %7 %6;

    jmp @case4;
  @case4
    ret 0;
}

fn w32 $testNestedIfLetCase(w64 %0) {
fn w32 $testNestedIfLetCase(ptr %0) {
  @entry0
    reserve %1 16 4;
    blit %1 %0 16;
    load w8 %2 %1 0;
    br.eq w8 %2 0 @then1 @else2;
  @then1
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    sload w32 %6 %3 8;
    add w32 %7 %4 %5;
    add w32 %8 %7 %6;

    jmp @merge3;
  @merge3
    ret 0;
}

fn w32 $testNestedPlaceholder(w64 %0) {
fn w32 $testNestedPlaceholder(ptr %0) {
  @entry0
    reserve %1 16 4;
    blit %1 %0 16;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 8;
    add w32 %6 %4 %5;
    ret %6;
  @arm3
    jmp @case4;
  @case4
    ret 0;
}

fn w32 $testDeepNesting(w64 %0) {
fn w32 $testDeepNesting(ptr %0) {
  @entry0
    reserve %1 16 4;
    blit %1 %0 16;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    sload w32 %6 %3 8;
    add w32 %7 %4 %5;
    add w32 %8 %7 %6;

    jmp @case4;
  @case4
    ret 0;
}

fn w32 $testNestedUnionLiteral(w64 %0) {
fn w32 $testNestedUnionLiteral(ptr %0) {
  @entry0
    reserve %1 12 4;
    blit %1 %0 12;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    load w8 %4 %3 0;
    br.eq w8 %4 0 @nest4 @arm3;
  @arm3
    load w8 %6 %1 0;
    br.eq w8 %6 0 @case6 @arm7;

    sload w32 %5 %3 4;
    jmp @case5;
  @case5
    ret %5;
  @case6
    add w64 %7 %1 4;
    add ptr %7 %1 4;
    load w8 %8 %7 0;
    br.eq w8 %8 1 @nest8 @arm7;
  @arm7
    jmp @else10;
  @nest8

    ret %10;
  @else10
    ret 0;
}

fn w32 $testMixedNesting(w64 %0) {
fn w32 $testMixedNesting(ptr %0) {
  @entry0
    reserve %1 20 4;
    blit %1 %0 20;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    sload w32 %6 %3 8;
    add w32 %7 %4 %5;
    add w32 %8 %7 %6;
    ret %8;
  @arm3
    load w8 %9 %1 0;
    br.eq w8 %9 1 @case4 @arm5;
  @case4
    add w64 %10 %1 4;
    add ptr %10 %1 4;
    sload w32 %11 %10 0;
    sload w32 %12 %10 4;
    add w64 %13 %10 8;
    add ptr %13 %10 8;
    sload w32 %14 %13 0;
    sload w32 %15 %13 4;
    add w32 %16 %11 %12;
    add w32 %17 %16 %14;
    add w32 %18 %17 %15;

    jmp @case6;
  @case6
    ret 0;
}

fn w32 $testNestedUnionInRecord(w64 %0) {
fn w32 $testNestedUnionInRecord(ptr %0) {
  @entry0
    reserve %1 20 4;
    blit %1 %0 20;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    load w8 %4 %3 0;
    br.eq w8 %4 0 @nest4 @arm3;
  @arm3
    load w8 %11 %1 0;
    br.eq w8 %11 0 @case6 @arm7;
  @nest4
    add w64 %5 %3 4;
    add ptr %5 %3 4;
    sload w32 %6 %5 0;
    sload w32 %7 %5 4;
    sload w32 %8 %3 12;
    jmp @case5;
  @case5
    add w32 %9 %6 %7;
    add w32 %10 %9 %8;
    ret %10;
  @case6
    add w64 %12 %1 4;
    add ptr %12 %1 4;
    load w8 %13 %12 0;
    br.eq w8 %13 1 @nest8 @arm7;
  @arm7
    jmp @else10;
  @nest8

    ret -1;
  @else10
    ret 0;
}

fn w32 $testPartialNesting(w64 %0) {
fn w32 $testPartialNesting(ptr %0) {
  @entry0
    reserve %1 20 4;
    blit %1 %0 20;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 8;
    sload w32 %5 %3 0;
    sload w32 %6 %3 4;
    add w32 %7 %5 %6;
    add w32 %8 %7 %4;
    ret %8;
  @arm3
    load w8 %9 %1 0;
    br.eq w8 %9 1 @case4 @arm5;
  @case4
    add w64 %10 %1 4;
    add w64 %11 %10 8;
    add ptr %10 %1 4;
    add ptr %11 %10 8;
    sload w32 %12 %11 0;
    sload w32 %13 %11 4;
    sload w32 %14 %10 0;
    sload w32 %15 %10 4;
    add w32 %16 %14 %15;

    reserve %0 16 4;
    store w8 0 %0 0;
    reserve %1 8 4;
    store w32 10 %1 0;
    store w32 20 %1 4;
    add w64 %2 %0 4;
    add ptr %2 %0 4;
    blit %2 %1 8;
    store w32 30 %0 12;
    call w32 %3 $testNestedMatch(%0);
    br.eq w32 %3 60 @assert.ok2 @assert.fail1;
  @assert.fail1

    reserve %11 8 4;
    reserve %12 4 4;
    store w32 100 %12 0;
    blit %11 %12 4;
    store w32 200 %11 4;
    add w64 %13 %10 4;
    add ptr %13 %10 4;
    blit %13 %11 8;
    store w32 300 %10 12;
    call w32 %14 $testDeepNesting(%10);
    br.eq w32 %14 600 @assert.ok12 @assert.fail11;
  @assert.fail11

    reserve %23 20 4;
    store w8 0 %23 0;
    reserve %24 8 4;
    store w32 1 %24 0;
    store w32 2 %24 4;
    add w64 %25 %23 4;
    add ptr %25 %23 4;
    blit %25 %24 8;
    store w32 10 %23 12;
    call w32 %26 $testMixedNesting(%23);
    br.eq w32 %26 13 @assert.ok22 @assert.fail21;
  @assert.fail21

    reserve %27 20 4;
    store w8 1 %27 0;
    reserve %28 8 4;
    store w32 3 %28 0;
    store w32 4 %28 4;
    add w64 %29 %27 4;
    add ptr %29 %27 4;
    blit %29 %28 8;
    reserve %30 8 4;
    store w32 5 %30 0;
    store w32 6 %30 4;
    add w64 %31 %27 12;
    add ptr %31 %27 12;
    blit %31 %30 8;
    call w32 %32 $testMixedNesting(%27);
    br.eq w32 %32 18 @assert.ok24 @assert.fail23;
  @assert.fail23
    unreachable;

    store w8 0 %37 0;
    store w32 7 %37 4;
    store w32 8 %37 8;
    blit %36 %37 12;
    store w32 100 %36 12;
    add w64 %38 %35 4;
    add ptr %38 %35 4;
    blit %38 %36 16;
    call w32 %39 $testNestedUnionInRecord(%35);
    br.eq w32 %39 115 @assert.ok28 @assert.fail27;
  @assert.fail27
    unreachable;

    reserve %41 16 4;
    reserve %42 12 4;
    store w8 1 %42 0;
    blit %41 %42 12;
    store w32 99 %41 12;
    add w64 %43 %40 4;
    add ptr %43 %40 4;
    blit %43 %41 16;
    call w32 %44 $testNestedUnionInRecord(%40);
    br.eq w32 %44 -1 @assert.ok30 @assert.fail29;
  @assert.fail29
    unreachable;

  @assert.fail37
    unreachable;
  @assert.ok38
    ret 0;
}


test/tests/match.nested.record.ril +16 -17

1		-	fn w32 $area(w64 %0) {
	1	+	fn w32 $area(ptr %0) {
2	2		@entry0
3	3		reserve %1 20 4;
4	4		blit %1 %0 20;
5	5		jmp @arm1;
6	6		@arm1
7	7		load w8 %2 %1 0;
8	8		br.eq w8 %2 0 @case2 @arm3;
9	9		@case2
10		-	add w64 %3 %1 4;
	10	+	add ptr %3 %1 4;
11	11		sload w32 %4 %3 0;
12	12		sload w32 %5 %3 4;
13	13		sload w32 %6 %3 8;
14	14		add w32 %7 %4 %5;
15	15		add w32 %8 %7 %6;
16	16		ret %8;
17	17		@arm3
18	18		load w8 %9 %1 0;
19	19		br.eq w8 %9 1 @case4 @arm5;
20	20		@case4
21		-	add w64 %10 %1 4;
	21	+	add ptr %10 %1 4;
22	22		sload w32 %11 %10 0;
23	23		sload w32 %12 %10 4;
24		-	add w64 %13 %10 8;
	24	+	add ptr %13 %10 8;
25	25		sload w32 %14 %13 0;
26	26		sload w32 %15 %13 4;
27	27		add w32 %16 %11 %12;
28	28		mul w32 %17 %14 %15;
29	29		add w32 %18 %16 %17;

    jmp @case6;
  @case6
    ret 0;
}

fn w32 $partial(w64 %0) {
fn w32 $partial(ptr %0) {
  @entry0
    reserve %1 20 4;
    blit %1 %0 20;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 8;
    sload w32 %5 %3 0;
    sload w32 %6 %3 4;
    add w32 %7 %5 %6;
    add w32 %8 %7 %4;
    ret %8;
  @arm3
    load w8 %9 %1 0;
    br.eq w8 %9 1 @case4 @arm5;
  @case4
    add w64 %10 %1 4;
    add ptr %10 %1 4;
    sload w32 %11 %10 0;
    add w64 %12 %10 8;
    add ptr %12 %10 8;
    sload w32 %13 %12 0;
    add w64 %14 %10 8;
    add ptr %14 %10 8;
    sload w32 %15 %14 4;
    mul w32 %16 %13 %15;
    add w32 %17 %11 %16;
    ret %17;
  @arm5
    jmp @case6;
  @case6
    ret -1;
}

fn w32 $withPlaceholder(w64 %0) {
fn w32 $withPlaceholder(ptr %0) {
  @entry0
    reserve %1 20 4;
    blit %1 %0 20;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 8;
    add w32 %6 %4 %5;
    ret %6;
  @arm3
    load w8 %7 %1 0;
    br.eq w8 %7 1 @case4 @arm5;
  @case4
    add w64 %8 %1 4;
    add w64 %9 %8 8;
    add ptr %8 %1 4;
    add ptr %9 %8 8;
    sload w32 %10 %9 0;
    sload w32 %11 %9 4;
    mul w32 %12 %10 %11;
    ret %12;
  @arm5

    reserve %0 20 4;
    store w8 0 %0 0;
    reserve %1 8 4;
    store w32 3 %1 0;
    store w32 4 %1 4;
    add w64 %2 %0 4;
    add ptr %2 %0 4;
    blit %2 %1 8;
    store w32 5 %0 12;
    reserve %3 20 4;
    store w8 1 %3 0;
    reserve %4 16 4;

    store w32 2 %5 4;
    blit %4 %5 8;
    reserve %6 8 4;
    store w32 10 %6 0;
    store w32 20 %6 4;
    add w64 %7 %4 8;
    add ptr %7 %4 8;
    blit %7 %6 8;
    add w64 %8 %3 4;
    add ptr %8 %3 4;
    blit %8 %4 16;
    call w32 %9 $area(%0);
    br.eq w32 %9 12 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;

  @assert.fail17
    unreachable;
  @assert.ok18
    ret 0;
}


test/tests/match.nested.union.ril +10 -11

fn w32 $dispatch(w64 %0) {
fn w32 $dispatch(ptr %0) {
  @entry0
    reserve %1 12 4;
    blit %1 %0 12;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    load w8 %4 %3 0;
    br.eq w8 %4 0 @nest4 @arm3;
  @arm3
    load w8 %6 %1 0;
    br.eq w8 %6 0 @case6 @arm7;

    sload w32 %5 %3 4;
    jmp @case5;
  @case5
    ret %5;
  @case6
    add w64 %7 %1 4;
    add ptr %7 %1 4;
    load w8 %8 %7 0;
    br.eq w8 %8 1 @nest8 @arm7;
  @arm7
    load w8 %11 %1 0;
    br.eq w8 %11 0 @case10 @arm11;

30	30		jmp @case9;
31	31		@case9
32	32		sub w32 %10 0 %9;
33	33		ret %10;
34	34		@case10
35		-	add w64 %12 %1 4;
	35	+	add ptr %12 %1 4;
36	36		load w8 %13 %12 0;
37	37		br.eq w8 %13 2 @nest12 @arm11;
38	38		@arm11
39	39		load w8 %16 %1 0;
40	40		br.eq w8 %16 0 @case14 @arm15;

43	43		jmp @case13;
44	44		@case13
45	45		mul w32 %15 %14 2;
46	46		ret %15;
47	47		@case14
48		-	add w64 %17 %1 4;
	48	+	add ptr %17 %1 4;
49	49		load w8 %18 %17 0;
50	50		br.eq w8 %18 3 @nest16 @arm15;
51	51		@arm15
52	52		load w8 %21 %1 0;
53	53		br.eq w8 %21 1 @case18 @arm19;

    jmp @case17;
  @case17
    mul w32 %20 %19 3;
    ret %20;
  @case18
    add w64 %22 %1 4;
    add ptr %22 %1 4;
    load w8 %23 %22 0;
    br.eq w8 %23 0 @nest20 @arm19;
  @arm19
    load w8 %24 %1 0;
    br.eq w8 %24 1 @case22 @arm23;
  @nest20
    jmp @case21;
  @case21
    ret 100;
  @case22
    add w64 %25 %1 4;
    add ptr %25 %1 4;
    load w8 %26 %25 0;
    br.eq w8 %26 1 @nest24 @arm23;
  @arm23
    jmp @else26;
  @nest24

    ret 200;
  @else26
    ret 0;
}

fn w32 $moveOnly(w64 %0) {
fn w32 $moveOnly(ptr %0) {
  @entry0
    reserve %1 12 4;
    blit %1 %0 12;
    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    load w8 %4 %3 0;
    br.eq w8 %4 0 @nest4 @arm3;
  @arm3
    load w8 %7 %1 0;
    br.eq w8 %7 0 @case6 @arm7;

    jmp @case5;
  @case5
    add w32 %6 %5 10;
    ret %6;
  @case6
    add w64 %8 %1 4;
    add ptr %8 %1 4;
    load w8 %9 %8 0;
    br.eq w8 %9 1 @nest8 @arm7;
  @arm7
    jmp @else10;
  @nest8

  @assert.fail23
    unreachable;
  @assert.ok24
    ret 0;
}


test/tests/match.optional.aggregate.ril +1 -1

fn w32 $matchOptionalAggregate(w64 %0) {
fn w32 $matchOptionalAggregate(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    jmp @arm1;
  @arm1

test/tests/match.optional.ril +2 -2

fn w32 $matchOptional(w64 %0) {
fn w32 $matchOptional(ptr %0) {
  @entry0
    jmp @arm1;
  @arm1
    br.eq w64 %0 0 @case2 @arm3;
    br.eq ptr %0 0 @case2 @arm3;
  @case2
    ret 0;
  @arm3
    jmp @case4;
  @case4

test/tests/match.record.pattern.ril +2 -2

fn w32 $getFirst(w64 %0) {
fn w32 $getFirst(ptr %0) {
  @entry0
    reserve %1 12 4;
    blit %1 %0 12;
    jmp @arm1;
  @arm1

  @case2
    ret 0;
  @arm3
    jmp @case4;
  @case4
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 0;
    sload w32 %5 %3 4;
    ret %4;
}

test/tests/multi.throw.basic.ril +1 -1

fn w64 $fallible(w64 %0, w32 %1) {
fn ptr $fallible(ptr %0, w32 %1) {
  @entry0
    br.eq w32 %1 1 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

test/tests/multi.throw.catch.typed.ril +2 -2

fn w64 $fallible(w64 %0, w32 %1) {
fn ptr $fallible(ptr %0, w32 %1) {
  @entry0
    br.eq w32 %1 1 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

}

fn w32 $caller(w32 %0) {
  @entry0
    reserve %1 12 8;
    call w64 %2 $fallible(%1, %0);
    call ptr %2 $fallible(%1, %0);
    load w64 %3 %2 0;
    reserve %4 4 4;
    br.ne w32 %3 0 @err2 @ok1;
  @ok1
    sload w32 %5 %2 8;

test/tests/multi.throw.propagate.ril +5 -5

fn w64 $inner(w64 %0, w8 %1) {
fn ptr $inner(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

    store w32 10 %4 8;
    blit %0 %4 12;
    ret %0;
}

fn w64 $outer(w64 %0, w8 %1) {
fn ptr $outer(ptr %0, w8 %1) {
  @entry0
    reserve %2 12 8;
    call w64 %3 $inner(%2, %1);
    call ptr %3 $inner(%2, %1);
    load w64 %4 %3 0;
    reserve %5 4 4;
    br.ne w32 %4 0 @err2 @ok1;
  @ok1
    sload w32 %6 %3 8;
    store w32 %6 %5 0;
    jmp @merge3;
  @err2
    reserve %7 12 8;
    store w64 %4 %7 0;
    add w64 %8 %3 8;
    add w64 %9 %7 8;
    add ptr %8 %3 8;
    add ptr %9 %7 8;
    blit %9 %8 1;
    blit %0 %7 12;
    ret %0;
  @merge3
    sload w32 %10 %5 0;

test/tests/mutref.loop.ril +1 -1

fn w64 $callback(w32 %0, w64 %1) {
fn w64 $callback(w32 %0, ptr %1) {
  @entry0
    store w32 %0 %1 0;
    ret;
}


test/tests/mutref.scalar.ril +1 -1

1		-	fn w8 $modify(w64 %0, w8 %1) {
	1	+	fn w8 $modify(ptr %0, w8 %1) {
2	2		@entry0
3	3		sload w32 %2 %0 0;
4	4		add w32 %3 %2 1;
5	5		store w32 %3 %0 0;
6	6		ret %1;

test/tests/nil.cmp.ril +6 -6

fn w8 $nilNeNil() {
  @entry0
    ret 0;
}

fn w8 $nilEqOptPtr(w64 %0) {
fn w8 $nilEqOptPtr(ptr %0) {
  @entry0
    eq w64 %1 %0 0;
    eq ptr %1 %0 0;
    ret %1;
}

fn w8 $nilNeOptPtr(w64 %0) {
fn w8 $nilNeOptPtr(ptr %0) {
  @entry0
    ne w64 %1 %0 0;
    ne ptr %1 %0 0;
    ret %1;
}

fn w8 $nilEqOptAgg(w64 %0) {
fn w8 $nilEqOptAgg(ptr %0) {
  @entry0
    load w8 %1 %0 0;
    eq w8 %2 %1 0;
    ret %2;
}

fn w8 $nilNeOptAgg(w64 %0) {
fn w8 $nilNeOptAgg(ptr %0) {
  @entry0
    load w8 %1 %0 0;
    ne w8 %2 %1 0;
    ret %2;
}

test/tests/opt.ptr.return.nil.ril +1 -1

1		-	fn w64 $optPtrReturnNil() {
	1	+	fn ptr $optPtrReturnNil() {
2	2		@entry0
3	3		ret 0;
4	4		}

test/tests/opt.record.eq.rev.ril +4 -4

1		-	fn w64 $makeOpt(w64 %0, w64 %1) {
	1	+	fn ptr $makeOpt(ptr %0, ptr %1) {
2	2		@entry0
3	3		reserve %2 8 4;
4	4		store w8 1 %2 0;
5		-	add w64 %3 %2 4;
	5	+	add ptr %3 %2 4;
6	6		blit %3 %1 4;
7	7		blit %0 %2 8;
8	8		ret %0;
9	9		}
10	10
11	11		fn w32 $main() {
12	12		@entry0
13	13		reserve %0 4 4;
14	14		store w32 5 %0 0;
15	15		reserve %1 8 4;
16		-	call w64 %2 $makeOpt(%1, %0);
	16	+	call ptr %2 $makeOpt(%1, %0);
17	17		reserve %3 8 4;
18	18		store w8 1 %3 0;
19		-	add w64 %4 %3 4;
	19	+	add ptr %4 %3 4;
20	20		blit %4 %0 4;
21	21		load w8 %5 %2 0;
22	22		load w8 %6 %3 0;
23	23		eq w8 %7 %5 %6;
24	24		eq w8 %8 %5 0;

test/tests/opt.record.eq.ril +6 -7

4	4		reserve %1 8 4;
5	5		store w32 3 %1 0;
6	6		store w32 9 %1 4;
7	7		reserve %2 12 4;
8	8		store w8 1 %2 0;
9		-	add w64 %3 %2 4;
	9	+	add ptr %3 %2 4;
10	10		blit %3 %1 8;
11	11		blit %0 %2 12;
12	12		reserve %4 12 4;
13	13		reserve %5 8 4;
14	14		store w32 3 %5 0;
15	15		store w32 9 %5 4;
16	16		reserve %6 12 4;
17	17		store w8 1 %6 0;
18		-	add w64 %7 %6 4;
	18	+	add ptr %7 %6 4;
19	19		blit %7 %5 8;
20	20		blit %4 %6 12;
21	21		load w8 %8 %0 0;
22	22		load w8 %9 %4 0;
23	23		eq w8 %10 %8 %9;

40	40		reserve %23 8 4;
41	41		store w32 4 %23 0;
42	42		store w32 6 %23 4;
43	43		reserve %24 12 4;
44	44		store w8 1 %24 0;
45		-	add w64 %25 %24 4;
	45	+	add ptr %25 %24 4;
46	46		blit %25 %23 8;
47	47		blit %22 %24 12;
48	48		load w8 %26 %0 0;
49	49		load w8 %27 %22 0;
50	50		eq w8 %28 %26 %27;

70	70		store w8 0 %41 0;
71	71		reserve %42 16 4;
72	72		store w8 0 %42 0;
73	73		reserve %43 16 4;
74	74		store w8 1 %43 0;
75		-	add w64 %44 %43 4;
	75	+	add ptr %44 %43 4;
76	76		blit %44 %0 12;
77	77		blit %39 %43 16;
78	78		reserve %45 16 4;
79	79		store w8 1 %45 0;
80		-	add w64 %46 %45 4;
	80	+	add ptr %46 %45 4;
81	81		blit %46 %4 12;
82	82		blit %40 %45 16;
83	83		reserve %47 16 4;
84	84		store w8 1 %47 0;
85		-	add w64 %48 %47 4;
	85	+	add ptr %48 %47 4;
86	86		blit %48 %22 12;
87	87		blit %41 %47 16;
88	88		load w8 %49 %39 0;
89	89		load w8 %50 %40 0;
90	90		eq w8 %51 %49 %50;

  @then9
    ret 0;
  @merge10
    ret 1;
}


test/tests/opt.return.nil.ril +1 -1

fn w64 $optReturnNil(w64 %0) {
fn ptr $optReturnNil(ptr %0) {
  @entry0
    reserve %1 8 4;
    store w8 0 %1 0;
    blit %0 %1 8;
    ret %0;

test/tests/opt.return.value.ril +1 -1

fn w64 $optReturnValue(w64 %0) {
fn ptr $optReturnValue(ptr %0) {
  @entry0
    reserve %1 8 4;
    store w8 1 %1 0;
    store w32 7 %1 4;
    blit %0 %1 8;

test/tests/opt.slice.npo.ril +32 -33

}

fn w8 $checkNil() {
  @entry0
    reserve %0 16 8;
    store w64 0 %0 0;
    store ptr 0 %0 0;
    store w32 0 %0 8;
    store w32 0 %0 12;
    load w64 %1 %0 0;
    eq w64 %2 %1 0;
    eq ptr %2 %1 0;
    br.ne w32 %2 0 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;
  @assert.ok2
    ret 0;

    reserve %0 3 1;
    store w8 1 %0 0;
    store w8 2 %0 1;
    store w8 3 %0 2;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    reserve %2 16 8;
    blit %2 %1 16;
    load w64 %3 %2 0;
    ne w64 %4 %3 0;
    ne ptr %4 %3 0;
    br.ne w32 %4 0 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;
  @assert.ok2
    ret 0;

    reserve %0 3 1;
    store w8 10 %0 0;
    store w8 20 %0 1;
    store w8 30 %0 2;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    reserve %2 16 8;
    blit %2 %1 16;
    reserve %3 16 8;

    unreachable;
  @assert.ok10
    jmp @merge13;
  @guard#pass11
    load w64 %10 %3 0;
    add w64 %11 %10 1;
    add ptr %11 %10 1;
    load w8 %12 %11 0;
    br.eq w8 %12 20 @assert.ok10 @assert.fail9;
  @guard#trap12
    ebreak;
    unreachable;
  @merge13
    reserve %13 16 8;
    store w64 0 %13 0;
    store ptr 0 %13 0;
    store w32 0 %13 8;
    store w32 0 %13 12;
    reserve %14 16 8;
    blit %14 %13 16;
    load w64 %15 %14 0;

    reserve %0 3 1;
    store w8 10 %0 0;
    store w8 20 %0 1;
    store w8 30 %0 2;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 3 %1 8;
    store w32 3 %1 12;
    reserve %2 16 8;
    blit %2 %1 16;
    reserve %3 16 8;

    unreachable;
  @assert.ok4
    ret 0;
}

fn w64 $returnNil(w64 %0) {
fn ptr $returnNil(ptr %0) {
  @entry0
    reserve %1 16 8;
    store w64 0 %1 0;
    store ptr 0 %1 0;
    store w32 0 %1 8;
    store w32 0 %1 12;
    blit %0 %1 16;
    ret %0;
}

fn w64 $returnSome(w64 %0) {
fn ptr $returnSome(ptr %0) {
  @entry0
    reserve %1 2 1;
    store w8 42 %1 0;
    store w8 99 %1 1;
    reserve %2 16 8;
    store w64 %1 %2 0;
    store ptr %1 %2 0;
    store w32 2 %2 8;
    store w32 2 %2 12;
    blit %0 %2 16;
    ret %0;
}

fn w8 $checkReturn() {
  @entry0
    reserve %0 16 8;
    call w64 %1 $returnNil(%0);
    call ptr %1 $returnNil(%0);
    load w64 %2 %1 0;
    eq w64 %3 %2 0;
    eq ptr %3 %2 0;
    br.ne w32 %3 0 @assert.ok2 @assert.fail1;
  @assert.fail1
    unreachable;
  @assert.ok2
    reserve %4 16 8;
    call w64 %5 $returnSome(%4);
    call ptr %5 $returnSome(%4);
    load w64 %6 %5 0;
    ne w64 %7 %6 0;
    ne ptr %7 %6 0;
    br.ne w32 %7 0 @assert.ok4 @assert.fail3;
  @assert.fail3
    unreachable;
  @assert.ok4
    reserve %8 16 8;

  @entry0
    reserve %0 2 1;
    store w8 5 %0 0;
    store w8 6 %0 1;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 2 %1 8;
    store w32 2 %1 12;
    reserve %2 16 8;
    blit %2 %1 16;
    reserve %3 16 8;
    blit %3 %2 16;
    jmp @arm1;
  @arm1
    load w64 %4 %3 0;
    br.eq w64 %4 0 @case2 @arm3;
    br.eq ptr %4 0 @case2 @arm3;
  @case2
    ret 60;
  @arm3
    jmp @else4;
  @else4
    jmp @merge6;
  @merge6
    reserve %5 16 8;
    store w64 0 %5 0;
    store ptr 0 %5 0;
    store w32 0 %5 8;
    store w32 0 %5 12;
    reserve %6 16 8;
    blit %6 %5 16;
    jmp @arm7;
  @arm7
    load w64 %7 %6 0;
    br.eq w64 %7 0 @case8 @arm9;
    br.eq ptr %7 0 @case8 @arm9;
  @case8
    jmp @merge10;
  @arm9
    jmp @else11;
  @merge10

}

fn w8 $checkEq() {
  @entry0
    reserve %0 16 8;
    store w64 0 %0 0;
    store ptr 0 %0 0;
    store w32 0 %0 8;
    store w32 0 %0 12;
    reserve %1 16 8;
    store w64 0 %1 0;
    store ptr 0 %1 0;
    store w32 0 %1 8;
    store w32 0 %1 12;
    load w64 %2 %0 0;
    load w64 %3 %1 0;
    eq w64 %4 %2 %3;
    load ptr %2 %0 0;
    load ptr %3 %1 0;
    eq ptr %4 %2 %3;
    load w32 %5 %0 8;
    load w32 %6 %1 8;
    eq w32 %7 %5 %6;
    and w32 %8 %4 %7;
    br.ne w32 %8 0 @assert.ok2 @assert.fail1;

281	281		@assert.ok2
282	282		reserve %9 2 1;
283	283		store w8 1 %9 0;
284	284		store w8 2 %9 1;
285	285		reserve %10 16 8;
286		-	store w64 %9 %10 0;
	286	+	store ptr %9 %10 0;
287	287		store w32 2 %10 8;
288	288		store w32 2 %10 12;
289	289		reserve %11 16 8;
290	290		blit %11 %10 16;
291		-	load w64 %12 %11 0;
292		-	load w64 %13 %0 0;
293		-	eq w64 %14 %12 %13;
	291	+	load ptr %12 %11 0;
	292	+	load ptr %13 %0 0;
	293	+	eq ptr %14 %12 %13;
294	294		load w32 %15 %11 8;
295	295		load w32 %16 %0 8;
296	296		eq w32 %17 %15 %16;
297	297		and w32 %18 %14 %17;
298	298		eq w32 %19 %18 0;

300	300		@assert.fail3
301	301		unreachable;
302	302		@assert.ok4
303	303		reserve %20 16 8;
304	304		blit %20 %10 16;
305		-	load w64 %21 %11 0;
306		-	load w64 %22 %20 0;
307		-	eq w64 %23 %21 %22;
	305	+	load ptr %21 %11 0;
	306	+	load ptr %22 %20 0;
	307	+	eq ptr %23 %21 %22;
308	308		load w32 %24 %11 8;
309	309		load w32 %25 %20 8;
310	310		eq w32 %26 %24 %25;
311	311		and w32 %27 %23 %26;
312	312		br.ne w32 %27 0 @assert.ok6 @assert.fail5;

  @then15
    ret %7;
  @merge16
    ret 0;
}


test/tests/optional.aggregate.eq.ril +3 -3

1		-	fn w8 $optPairEq(w64 %0, w64 %1) {
	1	+	fn w8 $optPairEq(ptr %0, ptr %1) {
2	2		@entry0
3	3		load w8 %2 %0 0;
4	4		load w8 %3 %1 0;
5	5		eq w8 %4 %2 %3;
6	6		eq w8 %5 %2 0;

14	14		or w32 %13 %5 %12;
15	15		and w32 %14 %4 %13;
16	16		ret %14;
17	17		}
18	18
19		-	fn w8 $optI32Eq(w64 %0, w64 %1) {
	19	+	fn w8 $optI32Eq(ptr %0, ptr %1) {
20	20		@entry0
21	21		load w8 %2 %0 0;
22	22		load w8 %3 %1 0;
23	23		eq w8 %4 %2 %3;
24	24		eq w8 %5 %2 0;

28	28		or w32 %9 %5 %8;
29	29		and w32 %10 %4 %9;
30	30		ret %10;
31	31		}
32	32
33		-	fn w8 $optI32EqNil(w64 %0) {
	33	+	fn w8 $optI32EqNil(ptr %0) {
34	34		@entry0
35	35		load w8 %1 %0 0;
36	36		eq w8 %2 %1 0;
37	37		ret %2;
38	38		}

test/tests/optional.eq.ril +1 -1

1		-	fn w8 $optionalEq(w64 %0, w64 %1) {
	1	+	fn w8 $optionalEq(ptr %0, ptr %1) {
2	2		@entry0
3	3		load w8 %2 %0 0;
4	4		load w8 %3 %1 0;
5	5		eq w8 %4 %2 %3;
6	6		eq w8 %5 %2 0;

test/tests/optional.ptr.eq.ril +8 -8

1		-	fn w8 $optPtrEq(w64 %0, w64 %1) {
	1	+	fn w8 $optPtrEq(ptr %0, ptr %1) {
2	2		@entry0
3		-	eq w64 %2 %0 %1;
	3	+	eq ptr %2 %0 %1;
4	4		ret %2;
5	5		}
6	6
7		-	fn w8 $optPtrNeq(w64 %0, w64 %1) {
	7	+	fn w8 $optPtrNeq(ptr %0, ptr %1) {
8	8		@entry0
9		-	ne w64 %2 %0 %1;
	9	+	ne ptr %2 %0 %1;
10	10		ret %2;
11	11		}
12	12
13		-	fn w8 $optPtrEqNil(w64 %0) {
	13	+	fn w8 $optPtrEqNil(ptr %0) {
14	14		@entry0
15		-	eq w64 %1 %0 0;
	15	+	eq ptr %1 %0 0;
16	16		ret %1;
17	17		}
18	18
19		-	fn w8 $optPtrNeqNil(w64 %0) {
	19	+	fn w8 $optPtrNeqNil(ptr %0) {
20	20		@entry0
21		-	ne w64 %1 %0 0;
	21	+	ne ptr %1 %0 0;
22	22		ret %1;
23	23		}

test/tests/pointerfn.ril +1 -1

1		-	fn w64 $takePointer(w64 %0) {
	1	+	fn ptr $takePointer(ptr %0) {
2	2		@entry0
3	3		ret %0;
4	4		}

test/tests/ptr.addressof.field.ril +2 -2

fn w64 $addressOfField(w64 %0) {
fn ptr $addressOfField(ptr %0) {
  @entry0
    add w64 %1 %0 4;
    add ptr %1 %0 4;
    ret %1;
}

test/tests/ptr.addressof.local.ril +3 -3

fn w64 $addressOfRecordLocal() {
fn ptr $addressOfRecordLocal() {
  @entry0
    reserve %0 8 4;
    store w32 1 %0 0;
    store w32 2 %0 4;
    ret %0;
}

fn w64 $addressOfScalarLocal() {
fn ptr $addressOfScalarLocal() {
  @entry0
    reserve %0 4 4;
    store w32 42 %0 0;
    ret %0;
}

fn w64 $addressOfDeref(w64 %0) {
fn ptr $addressOfDeref(ptr %0) {
  @entry0
    ret %0;
}

test/tests/ptr.addressof.ril +2 -2

fn w64 $addressOfElem(w64 %0, w32 %1) {
fn ptr $addressOfElem(ptr %0, w32 %1) {
  @entry0
    br.ult w32 %1 4 @guard#pass1 @guard#trap2;
  @guard#pass1
    mul w64 %2 %1 4;
    add w64 %3 %0 %2;
    add ptr %3 %0 %2;
    ret %3;
  @guard#trap2
    ebreak;
    unreachable;
}

test/tests/ptr.assign.ril +0 -1

    store w32 1 %0 0;
    store w32 42 %0 0;
    sload w32 %1 %0 0;
    ret %1;
}


test/tests/ptr.deref.record.ril +2 -2

fn w32 $derefField(w64 %0) {
fn w32 $derefField(ptr %0) {
  @entry0
    sload w32 %1 %0 0;
    ret %1;
}

fn w32 $derefCopy(w64 %0) {
fn w32 $derefCopy(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    sload w32 %2 %1 4;
    ret %2;

test/tests/ptr.deref.ril +5 -6

    w32 2;
    w32 4;
    w32 6;
}

fn w32 $derefArrayIndex(w64 %0) {
fn w32 $derefArrayIndex(ptr %0) {
  @entry0
    mul w64 %1 1 4;
    add w64 %2 %0 %1;
    add ptr %2 %0 %1;
    sload w32 %3 %2 0;
    ret %3;
}

fn w32 $derefSliceIndex(w64 %0) {
fn w32 $derefSliceIndex(ptr %0) {
  @entry0
    load w32 %1 %0 8;
    br.ult w32 2 %1 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %2 %0 0;
    mul w64 %3 2 4;
    add w64 %4 %2 %3;
    add ptr %4 %2 %3;
    sload w32 %5 %4 0;
    ret %5;
  @guard#trap2
    ebreak;
    unreachable;

    store w32 8 %3 4;
    store w32 9 %3 8;
    call w32 %4 $derefArrayIndex(%3);
    copy %5 $main0;
    reserve %6 16 8;
    store w64 %5 %6 0;
    store ptr %5 %6 0;
    store w32 3 %6 8;
    store w32 3 %6 12;
    call w32 %7 $derefSliceIndex(%6);
    add w32 %8 %1 %2;
    add w32 %9 %8 %4;
    add w32 %10 %9 %7;
    ret %10;
}


test/tests/ptr.subscript.assign.ril +2 -2

fn w64 $subscriptAssign(w64 %0, w32 %1, w32 %2) {
fn w64 $subscriptAssign(ptr %0, w32 %1, w32 %2) {
  @entry0
    load w32 %3 %0 8;
    br.ult w32 %1 %3 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %4 %0 0;
    mul w64 %5 %1 4;
    add w64 %6 %4 %5;
    add ptr %6 %4 %5;
    store w32 %2 %6 0;
    ret;
  @guard#trap2
    ebreak;
    unreachable;

test/tests/record.ctor.tuple.ril +1 -1

fn w64 $make() {
fn ptr $make() {
  @entry0
    reserve %0 8 4;
    store w32 1 %0 0;
    store w32 2 %0 4;
    load w64 %1 %0 0;

test/tests/record.empty.eq.ril +2 -2

fn w8 $emptyEq(w64 %0, w64 %1) {
fn w8 $emptyEq(ptr %0, ptr %1) {
  @entry0
    ret 1;
}

fn w8 $emptyNeq(w64 %0, w64 %1) {
fn w8 $emptyNeq(ptr %0, ptr %1) {
  @entry0
    eq w32 %2 1 0;
    ret %2;
}


test/tests/record.eq.ril +1 -1

fn w8 $recordEq(w64 %0, w64 %1) {
fn w8 $recordEq(ptr %0, ptr %1) {
  @entry0
    sload w32 %2 %0 0;
    sload w32 %3 %1 0;
    eq w32 %4 %2 %3;
    sload w32 %5 %0 4;

test/tests/record.field.assign.ril +0 -1

12	12		sload w32 %4 %0 4;
13	13		add w32 %5 %3 %4;
14	14		sub w32 %6 %5 42;
15	15		ret %6;
16	16		}
17		-

test/tests/record.nested.eq.ril +2 -2

fn w8 $innerEq(w64 %0, w64 %1) {
fn w8 $innerEq(ptr %0, ptr %1) {
  @entry0
    sload w32 %2 %0 0;
    sload w32 %3 %1 0;
    eq w32 %4 %2 %3;
    sload w32 %5 %0 4;

8	8		eq w32 %7 %5 %6;
9	9		and w32 %8 %4 %7;
10	10		ret %8;
11	11		}
12	12
13		-	fn w8 $outerEq(w64 %0, w64 %1) {
	13	+	fn w8 $outerEq(ptr %0, ptr %1) {
14	14		@entry0
15	15		sload w32 %2 %0 0;
16	16		sload w32 %3 %1 0;
17	17		eq w32 %4 %2 %3;
18	18		sload w32 %5 %0 4;

test/tests/record.ptr.access.ril +0 -1

7	7		sload w32 %2 %0 4;
8	8		add w32 %3 %1 %2;
9	9		sub w32 %4 %3 42;
10	10		ret %4;
11	11		}
12		-

test/tests/reserve.loop.ril +0 -1

  @assert.fail4
    unreachable;
  @assert.ok5
    ret 0;
}


test/tests/slice.append.ril +76 -77

data mut $BUF align 1 {
    undef * 4096;
}

fn w64 $newArena(w64 %0, w64 %1) {
fn ptr $newArena(ptr %0, ptr %1) {
  @entry0
    reserve %2 24 8;
    blit %2 %1 16;
    store w32 0 %2 16;
    blit %0 %2 24;
    ret %0;
}

fn w64 $arenaAlloc(w64 %0, w32 %1, w32 %2) {
fn ptr $arenaAlloc(ptr %0, w32 %1, w32 %2) {
  @entry0
    load w32 %3 %0 16;
    add w32 %4 %3 %2;
    sub w32 %5 %4 1;
    udiv w32 %6 %5 %2;

  @assert.ok2
    load w32 %10 %0 8;
    br.ult w32 %7 %10 @guard#pass3 @guard#trap4;
  @guard#pass3
    load w64 %11 %0 0;
    add w64 %12 %11 %7;
    add ptr %12 %11 %7;
    store w32 %8 %0 16;
    ret %12;
  @guard#trap4
    ebreak;
    unreachable;
}

fn w64 $arenaAllocFn(w64 %0, w32 %1, w32 %2) {
fn ptr $arenaAllocFn(ptr %0, w32 %1, w32 %2) {
  @entry0
    call w64 %3 $arenaAlloc(%0, %1, %2);
    call ptr %3 $arenaAlloc(%0, %1, %2);
    ret %3;
}

fn w64 $arenaAllocator(w64 %0, w64 %1) {
fn ptr $arenaAllocator(ptr %0, ptr %1) {
  @entry0
    reserve %2 16 8;
    copy %3 $arenaAllocFn;
    store w64 %3 %2 0;
    store w64 %1 %2 8;
    store ptr %3 %2 0;
    store ptr %1 %2 8;
    blit %0 %2 16;
    ret %0;
}

fn w32 $main() {
  @entry0
    copy %0 $BUF;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 4096 %1 8;
    store w32 4096 %1 12;
    reserve %2 24 8;
    call w64 %3 $newArena(%2, %1);
    call ptr %3 $newArena(%2, %1);
    reserve %4 16 8;
    call w64 %5 $arenaAllocator(%4, %3);
    call ptr %5 $arenaAllocator(%4, %3);
    mul w32 %6 4 4;
    call w64 %7 $arenaAlloc(%3, %6, 4);
    call ptr %7 $arenaAlloc(%3, %6, 4);
    reserve %8 16 8;
    store w64 %7 %8 0;
    store ptr %7 %8 0;
    store w32 0 %8 8;
    store w32 4 %8 12;
    load w32 %9 %8 8;
    load w32 %10 %8 12;
    br.ult w32 %9 %10 @append.store1 @append.grow2;
  @append.store1
    load w64 %24 %8 0;
    mul w64 %25 %9 4;
    add w64 %26 %24 %25;
    add ptr %26 %24 %25;
    store w32 10 %26 0;
    add w32 %27 %9 1;
    store w32 %27 %8 8;
    load w32 %32 %8 8;
    load w32 %33 %8 12;

86	86		shl w32 %11 %10 1;
87	87		or w32 %12 %11 1;
88	88		load w64 %13 %5 0;
89	89		load w64 %14 %5 8;
90	90		mul w32 %15 %12 4;
91		-	call w64 %16 %13(%14, %15, 4);
	91	+	call ptr %16 %13(%14, %15, 4);
92	92		load w64 %17 %8 0;
93	93		mul w32 %18 %9 4;
94	94		jmp @append3(0);
95	95		@append3(w32 %19)
96	96		br.ult w32 %19 %18 @append4 @append5;
97	97		@append4
98		-	add w64 %20 %17 %19;
	98	+	add ptr %20 %17 %19;
99	99		load w8 %21 %20 0;
100		-	add w64 %22 %16 %19;
	100	+	add ptr %22 %16 %19;
101	101		store w8 %21 %22 0;
102	102		add w32 %23 %19 1;
103	103		jmp @append3(%23);
104	104		@append5
105	105		store w64 %16 %8 0;
106	106		store w32 %12 %8 12;
107	107		jmp @append.store1;
108	108		@append.store6
109	109		load w64 %47 %8 0;
110	110		mul w64 %48 %32 4;
111		-	add w64 %49 %47 %48;
	111	+	add ptr %49 %47 %48;
112	112		store w32 20 %49 0;
113	113		add w32 %50 %32 1;
114	114		store w32 %50 %8 8;
115	115		load w32 %55 %8 8;
116	116		load w32 %56 %8 12;

119	119		shl w32 %34 %33 1;
120	120		or w32 %35 %34 1;
121	121		load w64 %36 %5 0;
122	122		load w64 %37 %5 8;
123	123		mul w32 %38 %35 4;
124		-	call w64 %39 %36(%37, %38, 4);
	124	+	call ptr %39 %36(%37, %38, 4);
125	125		load w64 %40 %8 0;
126	126		mul w32 %41 %32 4;
127	127		jmp @append8(0);
128	128		@append8(w32 %42)
129	129		br.ult w32 %42 %41 @append9 @append10;
130	130		@append9
131		-	add w64 %43 %40 %42;
	131	+	add ptr %43 %40 %42;
132	132		load w8 %44 %43 0;
133		-	add w64 %45 %39 %42;
	133	+	add ptr %45 %39 %42;
134	134		store w8 %44 %45 0;
135	135		add w32 %46 %42 1;
136	136		jmp @append8(%46);
137	137		@append10
138	138		store w64 %39 %8 0;
139	139		store w32 %35 %8 12;
140	140		jmp @append.store6;
141	141		@append.store11
142	142		load w64 %70 %8 0;
143	143		mul w64 %71 %55 4;
144		-	add w64 %72 %70 %71;
	144	+	add ptr %72 %70 %71;
145	145		store w32 30 %72 0;
146	146		add w32 %73 %55 1;
147	147		store w32 %73 %8 8;
148	148		load w32 %76 %8 8;
149	149		br.ne w32 %76 3 @then16 @merge17;

151	151		shl w32 %57 %56 1;
152	152		or w32 %58 %57 1;
153	153		load w64 %59 %5 0;
154	154		load w64 %60 %5 8;
155	155		mul w32 %61 %58 4;
156		-	call w64 %62 %59(%60, %61, 4);
	156	+	call ptr %62 %59(%60, %61, 4);
157	157		load w64 %63 %8 0;
158	158		mul w32 %64 %55 4;
159	159		jmp @append13(0);
160	160		@append13(w32 %65)
161	161		br.ult w32 %65 %64 @append14 @append15;
162	162		@append14
163		-	add w64 %66 %63 %65;
	163	+	add ptr %66 %63 %65;
164	164		load w8 %67 %66 0;
165		-	add w64 %68 %62 %65;
	165	+	add ptr %68 %62 %65;
166	166		store w8 %67 %68 0;
167	167		add w32 %69 %65 1;
168	168		jmp @append13(%69);
169	169		@append15
170	170		store w64 %62 %8 0;

    load w32 %86 %8 8;
    br.ult w32 2 %86 @guard#pass30 @guard#trap31;
  @guard#pass26
    load w64 %82 %8 0;
    mul w64 %83 1 4;
    add w64 %84 %82 %83;
    add ptr %84 %82 %83;
    sload w32 %85 %84 0;
    br.ne w32 %85 20 @then24 @merge25;
  @guard#trap27
    ebreak;
    unreachable;

    load w32 %94 %8 12;
    br.ult w32 %93 %94 @append.store32 @append.grow33;
  @guard#pass30
    load w64 %87 %8 0;
    mul w64 %88 2 4;
    add w64 %89 %87 %88;
    add ptr %89 %87 %88;
    sload w32 %90 %89 0;
    br.ne w32 %90 30 @then28 @merge29;
  @guard#trap31
    ebreak;
    unreachable;
  @append.store32
    load w64 %108 %8 0;
    mul w64 %109 %93 4;
    add w64 %110 %108 %109;
    add ptr %110 %108 %109;
    store w32 40 %110 0;
    add w32 %111 %93 1;
    store w32 %111 %8 8;
    load w32 %114 %8 8;
    br.ne w32 %114 4 @then37 @merge38;

234	234		shl w32 %95 %94 1;
235	235		or w32 %96 %95 1;
236	236		load w64 %97 %5 0;
237	237		load w64 %98 %5 8;
238	238		mul w32 %99 %96 4;
239		-	call w64 %100 %97(%98, %99, 4);
	239	+	call ptr %100 %97(%98, %99, 4);
240	240		load w64 %101 %8 0;
241	241		mul w32 %102 %93 4;
242	242		jmp @append34(0);
243	243		@append34(w32 %103)
244	244		br.ult w32 %103 %102 @append35 @append36;
245	245		@append35
246		-	add w64 %104 %101 %103;
	246	+	add ptr %104 %101 %103;
247	247		load w8 %105 %104 0;
248		-	add w64 %106 %100 %103;
	248	+	add ptr %106 %100 %103;
249	249		store w8 %105 %106 0;
250	250		add w32 %107 %103 1;
251	251		jmp @append34(%107);
252	252		@append36
253	253		store w64 %100 %8 0;

    load w32 %119 %8 12;
    br.ult w32 %118 %119 @append.store41 @append.grow42;
  @append.store41
    load w64 %133 %8 0;
    mul w64 %134 %118 4;
    add w64 %135 %133 %134;
    add ptr %135 %133 %134;
    store w32 50 %135 0;
    add w32 %136 %118 1;
    store w32 %136 %8 8;
    load w32 %139 %8 8;
    br.ne w32 %139 5 @then46 @merge47;

277	277		shl w32 %120 %119 1;
278	278		or w32 %121 %120 1;
279	279		load w64 %122 %5 0;
280	280		load w64 %123 %5 8;
281	281		mul w32 %124 %121 4;
282		-	call w64 %125 %122(%123, %124, 4);
	282	+	call ptr %125 %122(%123, %124, 4);
283	283		load w64 %126 %8 0;
284	284		mul w32 %127 %118 4;
285	285		jmp @append43(0);
286	286		@append43(w32 %128)
287	287		br.ult w32 %128 %127 @append44 @append45;
288	288		@append44
289		-	add w64 %129 %126 %128;
	289	+	add ptr %129 %126 %128;
290	290		load w8 %130 %129 0;
291		-	add w64 %131 %125 %128;
	291	+	add ptr %131 %125 %128;
292	292		store w8 %130 %131 0;
293	293		add w32 %132 %128 1;
294	294		jmp @append43(%132);
295	295		@append45
296	296		store w64 %125 %8 0;

    load w32 %146 %8 8;
    br.ult w32 0 %146 @guard#pass56 @guard#trap57;
  @guard#pass52
    load w64 %142 %8 0;
    mul w64 %143 4 4;
    add w64 %144 %142 %143;
    add ptr %144 %142 %143;
    sload w32 %145 %144 0;
    br.ne w32 %145 50 @then50 @merge51;
  @guard#trap53
    ebreak;
    unreachable;

    unreachable;
  @then58
    ret 12;
  @merge59
    reserve %164 16 8;
    store w64 %7 %164 0;
    store ptr %7 %164 0;
    store w32 0 %164 8;
    store w32 0 %164 12;
    load w32 %167 %164 8;
    load w32 %168 %164 12;
    br.ult w32 %167 %168 @append.store62 @append.grow63;
  @guard#pass60
    load w64 %150 %8 0;
    mul w64 %151 3 4;
    add w64 %152 %150 %151;
    add ptr %152 %150 %151;
    sload w32 %153 %152 0;
    br.ne w32 %153 40 @then58 @merge59;
  @guard#trap61
    ebreak;
    unreachable;
  @append.store62
    load w64 %182 %164 0;
    mul w64 %183 %167 4;
    add w64 %184 %182 %183;
    add ptr %184 %182 %183;
    store w32 99 %184 0;
    add w32 %185 %167 1;
    store w32 %185 %164 8;
    load w32 %188 %164 8;
    br.ne w32 %188 1 @then67 @merge68;

364	364		shl w32 %169 %168 1;
365	365		or w32 %170 %169 1;
366	366		load w64 %171 %5 0;
367	367		load w64 %172 %5 8;
368	368		mul w32 %173 %170 4;
369		-	call w64 %174 %171(%172, %173, 4);
	369	+	call ptr %174 %171(%172, %173, 4);
370	370		load w64 %175 %164 0;
371	371		mul w32 %176 %167 4;
372	372		jmp @append64(0);
373	373		@append64(w32 %177)
374	374		br.ult w32 %177 %176 @append65 @append66;
375	375		@append65
376		-	add w64 %178 %175 %177;
	376	+	add ptr %178 %175 %177;
377	377		load w8 %179 %178 0;
378		-	add w64 %180 %174 %177;
	378	+	add ptr %180 %174 %177;
379	379		store w8 %179 %180 0;
380	380		add w32 %181 %177 1;
381	381		jmp @append64(%181);
382	382		@append66
383	383		store w64 %174 %164 0;

408	408		unreachable;
409	409		@loop75(w32 %197, w32 %201)
410	410		br.slt w32 %197 %195 @body76 @merge77;
411	411		@body76
412	412		mul w64 %198 %197 4;
413		-	add w64 %199 %196 %198;
	413	+	add ptr %199 %196 %198;
414	414		sload w32 %200 %199 0;
415	415		add w32 %202 %201 %200;
416	416		add w32 %203 %197 1;
417	417		jmp @loop75(%203, %202);
418	418		@merge77
419	419		br.ne w32 %201 150 @then78 @merge79;
420	420		@then78
421	421		ret 16;
422	422		@merge79
423		-	call w64 %217 $arenaAlloc(%3, 2, 1);
	423	+	call ptr %217 $arenaAlloc(%3, 2, 1);
424	424		reserve %218 16 8;
425		-	store w64 %217 %218 0;
	425	+	store ptr %217 %218 0;
426	426		store w32 0 %218 8;
427	427		store w32 2 %218 12;
428	428		load w32 %222 %218 8;
429	429		load w32 %223 %218 12;
430	430		br.ult w32 %222 %223 @append.store80 @append.grow81;
431	431		@append.store80
432	432		load w64 %237 %218 0;
433		-	add w64 %238 %237 %222;
	433	+	add ptr %238 %237 %222;
434	434		store w8 171 %238 0;
435	435		add w32 %239 %222 1;
436	436		store w32 %239 %218 8;
437	437		load w32 %244 %218 8;
438	438		load w32 %245 %218 12;

441	441		shl w32 %224 %223 1;
442	442		or w32 %225 %224 1;
443	443		load w64 %226 %5 0;
444	444		load w64 %227 %5 8;
445	445		mul w32 %228 %225 1;
446		-	call w64 %229 %226(%227, %228, 1);
	446	+	call ptr %229 %226(%227, %228, 1);
447	447		load w64 %230 %218 0;
448	448		mul w32 %231 %222 1;
449	449		jmp @append82(0);
450	450		@append82(w32 %232)
451	451		br.ult w32 %232 %231 @append83 @append84;
452	452		@append83
453		-	add w64 %233 %230 %232;
	453	+	add ptr %233 %230 %232;
454	454		load w8 %234 %233 0;
455		-	add w64 %235 %229 %232;
	455	+	add ptr %235 %229 %232;
456	456		store w8 %234 %235 0;
457	457		add w32 %236 %232 1;
458	458		jmp @append82(%236);
459	459		@append84
460	460		store w64 %229 %218 0;
461	461		store w32 %225 %218 12;
462	462		jmp @append.store80;
463	463		@append.store85
464	464		load w64 %259 %218 0;
465		-	add w64 %260 %259 %244;
	465	+	add ptr %260 %259 %244;
466	466		store w8 205 %260 0;
467	467		add w32 %261 %244 1;
468	468		store w32 %261 %218 8;
469	469		load w32 %264 %218 8;
470	470		br.ne w32 %264 2 @then90 @merge91;

472	472		shl w32 %246 %245 1;
473	473		or w32 %247 %246 1;
474	474		load w64 %248 %5 0;
475	475		load w64 %249 %5 8;
476	476		mul w32 %250 %247 1;
477		-	call w64 %251 %248(%249, %250, 1);
	477	+	call ptr %251 %248(%249, %250, 1);
478	478		load w64 %252 %218 0;
479	479		mul w32 %253 %244 1;
480	480		jmp @append87(0);
481	481		@append87(w32 %254)
482	482		br.ult w32 %254 %253 @append88 @append89;
483	483		@append88
484		-	add w64 %255 %252 %254;
	484	+	add ptr %255 %252 %254;
485	485		load w8 %256 %255 0;
486		-	add w64 %257 %251 %254;
	486	+	add ptr %257 %251 %254;
487	487		store w8 %256 %257 0;
488	488		add w32 %258 %254 1;
489	489		jmp @append87(%258);
490	490		@append89
491	491		store w64 %251 %218 0;

    load w32 %274 %218 8;
    load w32 %275 %218 12;
    br.ult w32 %274 %275 @append.store100 @append.grow101;
  @guard#pass98
    load w64 %269 %218 0;
    add w64 %270 %269 1;
    add ptr %270 %269 1;
    load w8 %271 %270 0;
    br.ne w8 %271 205 @then96 @merge97;
  @guard#trap99
    ebreak;
    unreachable;
  @append.store100
    load w64 %289 %218 0;
    add w64 %290 %289 %274;
    add ptr %290 %289 %274;
    store w8 239 %290 0;
    add w32 %291 %274 1;
    store w32 %291 %218 8;
    load w32 %294 %218 8;
    br.ne w32 %294 3 @then105 @merge106;

534	534		shl w32 %276 %275 1;
535	535		or w32 %277 %276 1;
536	536		load w64 %278 %5 0;
537	537		load w64 %279 %5 8;
538	538		mul w32 %280 %277 1;
539		-	call w64 %281 %278(%279, %280, 1);
	539	+	call ptr %281 %278(%279, %280, 1);
540	540		load w64 %282 %218 0;
541	541		mul w32 %283 %274 1;
542	542		jmp @append102(0);
543	543		@append102(w32 %284)
544	544		br.ult w32 %284 %283 @append103 @append104;
545	545		@append103
546		-	add w64 %285 %282 %284;
	546	+	add ptr %285 %282 %284;
547	547		load w8 %286 %285 0;
548		-	add w64 %287 %281 %284;
	548	+	add ptr %287 %281 %284;
549	549		store w8 %286 %287 0;
550	550		add w32 %288 %284 1;
551	551		jmp @append102(%288);
552	552		@append104
553	553		store w64 %281 %218 0;

  @merge110
    load w32 %300 %218 8;
    br.ult w32 0 %300 @guard#pass115 @guard#trap116;
  @guard#pass111
    load w64 %297 %218 0;
    add w64 %298 %297 2;
    add ptr %298 %297 2;
    load w8 %299 %298 0;
    br.ne w8 %299 239 @then109 @merge110;
  @guard#trap112
    ebreak;
    unreachable;
  @then113
    ret 23;
  @merge114
    mul w32 %309 4 2;
    call w64 %310 $arenaAlloc(%3, %309, 4);
    call ptr %310 $arenaAlloc(%3, %309, 4);
    reserve %311 16 8;
    store w64 %310 %311 0;
    store ptr %310 %311 0;
    store w32 0 %311 8;
    store w32 2 %311 12;
    load w32 %314 %311 8;
    load w32 %315 %311 12;
    br.ult w32 %314 %315 @append.store117 @append.grow118;

596	596		ebreak;
597	597		unreachable;
598	598		@append.store117
599	599		load w64 %329 %311 0;
600	600		mul w64 %330 %314 4;
601		-	add w64 %331 %329 %330;
	601	+	add ptr %331 %329 %330;
602	602		store w32 42 %331 0;
603	603		add w32 %332 %314 1;
604	604		store w32 %332 %311 8;
605	605		blit %311 %311 16;
606	606		load w32 %335 %311 8;

609	609		shl w32 %316 %315 1;
610	610		or w32 %317 %316 1;
611	611		load w64 %318 %5 0;
612	612		load w64 %319 %5 8;
613	613		mul w32 %320 %317 4;
614		-	call w64 %321 %318(%319, %320, 4);
	614	+	call ptr %321 %318(%319, %320, 4);
615	615		load w64 %322 %311 0;
616	616		mul w32 %323 %314 4;
617	617		jmp @append119(0);
618	618		@append119(w32 %324)
619	619		br.ult w32 %324 %323 @append120 @append121;
620	620		@append120
621		-	add w64 %325 %322 %324;
	621	+	add ptr %325 %322 %324;
622	622		load w8 %326 %325 0;
623		-	add w64 %327 %321 %324;
	623	+	add ptr %327 %321 %324;
624	624		store w8 %326 %327 0;
625	625		add w32 %328 %324 1;
626	626		jmp @append119(%328);
627	627		@append121
628	628		store w64 %321 %311 0;

647	647		ebreak;
648	648		unreachable;
649	649		@append.store128
650	650		load w64 %356 %311 0;
651	651		mul w64 %357 %341 4;
652		-	add w64 %358 %356 %357;
	652	+	add ptr %358 %356 %357;
653	653		store w32 43 %358 0;
654	654		add w32 %359 %341 1;
655	655		store w32 %359 %311 8;
656	656		blit %311 %311 16;
657	657		load w32 %362 %311 8;

660	660		shl w32 %343 %342 1;
661	661		or w32 %344 %343 1;
662	662		load w64 %345 %5 0;
663	663		load w64 %346 %5 8;
664	664		mul w32 %347 %344 4;
665		-	call w64 %348 %345(%346, %347, 4);
	665	+	call ptr %348 %345(%346, %347, 4);
666	666		load w64 %349 %311 0;
667	667		mul w32 %350 %341 4;
668	668		jmp @append130(0);
669	669		@append130(w32 %351)
670	670		br.ult w32 %351 %350 @append131 @append132;
671	671		@append131
672		-	add w64 %352 %349 %351;
	672	+	add ptr %352 %349 %351;
673	673		load w8 %353 %352 0;
674		-	add w64 %354 %348 %351;
	674	+	add ptr %354 %348 %351;
675	675		store w8 %353 %354 0;
676	676		add w32 %355 %351 1;
677	677		jmp @append130(%355);
678	678		@append132
679	679		store w64 %348 %311 0;

693	693		ebreak;
694	694		unreachable;
695	695		@append.store137
696	696		load w64 %382 %311 0;
697	697		mul w64 %383 %367 4;
698		-	add w64 %384 %382 %383;
	698	+	add ptr %384 %382 %383;
699	699		store w32 44 %384 0;
700	700		add w32 %385 %367 1;
701	701		store w32 %385 %311 8;
702	702		blit %311 %311 16;
703	703		load w32 %388 %311 8;

706	706		shl w32 %369 %368 1;
707	707		or w32 %370 %369 1;
708	708		load w64 %371 %5 0;
709	709		load w64 %372 %5 8;
710	710		mul w32 %373 %370 4;
711		-	call w64 %374 %371(%372, %373, 4);
	711	+	call ptr %374 %371(%372, %373, 4);
712	712		load w64 %375 %311 0;
713	713		mul w32 %376 %367 4;
714	714		jmp @append139(0);
715	715		@append139(w32 %377)
716	716		br.ult w32 %377 %376 @append140 @append141;
717	717		@append140
718		-	add w64 %378 %375 %377;
	718	+	add ptr %378 %375 %377;
719	719		load w8 %379 %378 0;
720		-	add w64 %380 %374 %377;
	720	+	add ptr %380 %374 %377;
721	721		store w8 %379 %380 0;
722	722		add w32 %381 %377 1;
723	723		jmp @append139(%381);
724	724		@append141
725	725		store w64 %374 %311 0;

  @assert.ok145
    load w32 %390 %311 8;
    br.ult w32 0 %390 @guard#pass146 @guard#trap147;
  @guard#pass146
    load w64 %391 %311 0;
    br.ne w64 %364 %391 @assert.ok149 @assert.fail148;
    br.ne ptr %364 %391 @assert.ok149 @assert.fail148;
  @guard#trap147
    ebreak;
    unreachable;
  @assert.fail148
    unreachable;

    load w32 %402 %311 8;
    br.ult w32 2 %402 @guard#pass160 @guard#trap161;
  @guard#pass156
    load w64 %398 %311 0;
    mul w64 %399 1 4;
    add w64 %400 %398 %399;
    add ptr %400 %398 %399;
    sload w32 %401 %400 0;
    br.eq w32 %401 43 @assert.ok155 @assert.fail154;
  @guard#trap157
    ebreak;
    unreachable;

  @assert.ok159
    ret 0;
  @guard#pass160
    load w64 %403 %311 0;
    mul w64 %404 2 4;
    add w64 %405 %403 %404;
    add ptr %405 %403 %404;
    sload w32 %406 %405 0;
    br.eq w32 %406 44 @assert.ok159 @assert.fail158;
  @guard#trap161
    ebreak;
    unreachable;
}


test/tests/slice.basic.ril +9 -9

fn w32 $sliceLen(w64 %0) {
fn w32 $sliceLen(ptr %0) {
  @entry0
    load w32 %1 %0 8;
    ret %1;
}

fn w32 $sliceCap(w64 %0) {
fn w32 $sliceCap(ptr %0) {
  @entry0
    load w32 %1 %0 12;
    ret %1;
}

fn w64 $slicePtr(w64 %0) {
fn ptr $slicePtr(ptr %0) {
  @entry0
    load w64 %1 %0 0;
    load ptr %1 %0 0;
    ret %1;
}

fn w64 $sliceCopy(w64 %0, w64 %1) {
fn ptr $sliceCopy(ptr %0, ptr %1) {
  @entry0
    reserve %2 16 8;
    blit %2 %1 16;
    blit %0 %2 16;
    ret %0;
}

fn w64 $sliceOf(w64 %0, w64 %1, w32 %2) {
fn ptr $sliceOf(ptr %0, ptr %1, w32 %2) {
  @entry0
    reserve %3 16 8;
    store w64 %1 %3 0;
    store ptr %1 %3 0;
    store w32 %2 %3 8;
    store w32 %2 %3 12;
    blit %0 %3 16;
    ret %0;
}

fn w64 $sliceOfWithCap(w64 %0, w64 %1, w32 %2, w32 %3) {
fn ptr $sliceOfWithCap(ptr %0, ptr %1, w32 %2, w32 %3) {
  @entry0
    reserve %4 16 8;
    store w64 %1 %4 0;
    store ptr %1 %4 0;
    store w32 %2 %4 8;
    store w32 %3 %4 12;
    blit %0 %4 16;
    ret %0;
}

test/tests/slice.delete.ril +18 -19

    store w32 20 %0 4;
    store w32 30 %0 8;
    store w32 40 %0 12;
    store w32 50 %0 16;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store ptr %0 %1 0;
    store w32 5 %1 8;
    store w32 5 %1 12;
    load w32 %2 %1 8;
    br.ult w32 2 %2 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %3 %1 0;
    mul w64 %4 2 4;
    add w64 %5 %3 %4;
    add w64 %6 %5 4;
    add ptr %5 %3 %4;
    add ptr %6 %5 4;
    sub w32 %7 %2 2;
    sub w32 %8 %7 1;
    mul w32 %9 %8 4;
    jmp @delete3(0);
  @guard#trap2
    ebreak;
    unreachable;
  @delete3(w32 %10)
    br.ult w32 %10 %9 @delete4 @delete5;
  @delete4
    add w64 %11 %6 %10;
    add ptr %11 %6 %10;
    load w8 %12 %11 0;
    add w64 %13 %5 %10;
    add ptr %13 %5 %10;
    store w8 %12 %13 0;
    add w32 %14 %10 1;
    jmp @delete3(%14);
  @delete5
    sub w32 %15 %2 1;

    load w32 %26 %1 8;
    br.ult w32 2 %26 @guard#pass18 @guard#trap19;
  @guard#pass14
    load w64 %22 %1 0;
    mul w64 %23 1 4;
    add w64 %24 %22 %23;
    add ptr %24 %22 %23;
    sload w32 %25 %24 0;
    br.ne w32 %25 20 @then12 @merge13;
  @guard#trap15
    ebreak;
    unreachable;

    load w32 %31 %1 8;
    br.ult w32 3 %31 @guard#pass22 @guard#trap23;
  @guard#pass18
    load w64 %27 %1 0;
    mul w64 %28 2 4;
    add w64 %29 %27 %28;
    add ptr %29 %27 %28;
    sload w32 %30 %29 0;
    br.ne w32 %30 40 @then16 @merge17;
  @guard#trap19
    ebreak;
    unreachable;

    load w32 %36 %1 8;
    br.ult w32 0 %36 @guard#pass24 @guard#trap25;
  @guard#pass22
    load w64 %32 %1 0;
    mul w64 %33 3 4;
    add w64 %34 %32 %33;
    add ptr %34 %32 %33;
    sload w32 %35 %34 0;
    br.ne w32 %35 50 @then20 @merge21;
  @guard#trap23
    ebreak;
    unreachable;
  @guard#pass24
    load w64 %37 %1 0;
    add w64 %38 %37 4;
    add ptr %38 %37 4;
    sub w32 %39 %36 0;
    sub w32 %40 %39 1;
    mul w32 %41 %40 4;
    jmp @delete26(0);
  @guard#trap25
    ebreak;
    unreachable;
  @delete26(w32 %42)
    br.ult w32 %42 %41 @delete27 @delete28;
  @delete27
    add w64 %43 %38 %42;
    add ptr %43 %38 %42;
    load w8 %44 %43 0;
    add w64 %45 %37 %42;
    add ptr %45 %37 %42;
    store w8 %44 %45 0;
    add w32 %46 %42 1;
    jmp @delete26(%46);
  @delete28
    sub w32 %47 %36 1;

    load w32 %58 %1 8;
    br.ult w32 2 %58 @guard#pass41 @guard#trap42;
  @guard#pass37
    load w64 %54 %1 0;
    mul w64 %55 1 4;
    add w64 %56 %54 %55;
    add ptr %56 %54 %55;
    sload w32 %57 %56 0;
    br.ne w32 %57 40 @then35 @merge36;
  @guard#trap38
    ebreak;
    unreachable;

    load w32 %63 %1 8;
    br.ult w32 2 %63 @guard#pass43 @guard#trap44;
  @guard#pass41
    load w64 %59 %1 0;
    mul w64 %60 2 4;
    add w64 %61 %59 %60;
    add ptr %61 %59 %60;
    sload w32 %62 %61 0;
    br.ne w32 %62 50 @then39 @merge40;
  @guard#trap42
    ebreak;
    unreachable;
  @guard#pass43
    load w64 %64 %1 0;
    mul w64 %65 2 4;
    add w64 %66 %64 %65;
    add w64 %67 %66 4;
    add ptr %66 %64 %65;
    add ptr %67 %66 4;
    sub w32 %68 %63 2;
    sub w32 %69 %68 1;
    mul w32 %70 %69 4;
    jmp @delete45(0);
  @guard#trap44
    ebreak;
    unreachable;
  @delete45(w32 %71)
    br.ult w32 %71 %70 @delete46 @delete47;
  @delete46
    add w64 %72 %67 %71;
    add ptr %72 %67 %71;
    load w8 %73 %72 0;
    add w64 %74 %66 %71;
    add ptr %74 %66 %71;
    store w8 %73 %74 0;
    add w32 %75 %71 1;
    jmp @delete45(%75);
  @delete47
    sub w32 %76 %63 1;

    load w32 %87 %1 12;
    br.ne w32 %87 5 @then58 @merge59;
  @guard#pass56
    load w64 %83 %1 0;
    mul w64 %84 1 4;
    add w64 %85 %83 %84;
    add ptr %85 %83 %84;
    sload w32 %86 %85 0;
    br.ne w32 %86 40 @then54 @merge55;
  @guard#trap57
    ebreak;
    unreachable;
  @then58
    ret 13;
  @merge59
    ret 0;
}


test/tests/slice.eq.ril +4 -4

1		-	fn w8 $sliceEq(w64 %0, w64 %1) {
	1	+	fn w8 $sliceEq(ptr %0, ptr %1) {
2	2		@entry0
3		-	load w64 %2 %0 0;
4		-	load w64 %3 %1 0;
5		-	eq w64 %4 %2 %3;
	3	+	load ptr %2 %0 0;
	4	+	load ptr %3 %1 0;
	5	+	eq ptr %4 %2 %3;
6	6		load w32 %5 %0 8;
7	7		load w32 %6 %1 8;
8	8		eq w32 %7 %5 %6;
9	9		and w32 %8 %4 %7;
10	10		ret %8;

test/tests/slice.index.ril +2 -2

fn w32 $sliceIndex(w64 %0, w32 %1) {
fn w32 $sliceIndex(ptr %0, w32 %1) {
  @entry0
    load w32 %2 %0 8;
    br.ult w32 %1 %2 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %3 %0 0;
    mul w64 %4 %1 4;
    add w64 %5 %3 %4;
    add ptr %5 %3 %4;
    sload w32 %6 %5 0;
    ret %6;
  @guard#trap2
    ebreak;
    unreachable;

test/tests/slice.mutable.ril +10 -10

fn w64 $mutSliceStore(w64 %0, w32 %1, w32 %2) {
fn w64 $mutSliceStore(ptr %0, w32 %1, w32 %2) {
  @entry0
    load w32 %3 %0 8;
    br.ult w32 %1 %3 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %4 %0 0;
    mul w64 %5 %1 4;
    add w64 %6 %4 %5;
    add ptr %6 %4 %5;
    store w32 %2 %6 0;
    ret;
  @guard#trap2
    ebreak;
    unreachable;
}

fn w64 $mutSliceIncrement(w64 %0, w32 %1) {
fn w64 $mutSliceIncrement(ptr %0, w32 %1) {
  @entry0
    load w32 %2 %0 8;
    br.ult w32 %1 %2 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %3 %0 0;
    mul w64 %4 %1 4;
    add w64 %5 %3 %4;
    add ptr %5 %3 %4;
    sload w32 %6 %5 0;
    add w32 %7 %6 1;
    load w32 %8 %0 8;
    br.ult w32 %1 %8 @guard#pass3 @guard#trap4;
  @guard#trap2
    ebreak;
    unreachable;
  @guard#pass3
    load w64 %9 %0 0;
    mul w64 %10 %1 4;
    add w64 %11 %9 %10;
    add ptr %11 %9 %10;
    store w32 %7 %11 0;
    ret;
  @guard#trap4
    ebreak;
    unreachable;
}

fn w64 $mutSliceSwap(w64 %0, w32 %1, w32 %2) {
fn w64 $mutSliceSwap(ptr %0, w32 %1, w32 %2) {
  @entry0
    load w32 %3 %0 8;
    br.ult w32 %1 %3 @guard#pass1 @guard#trap2;
  @guard#pass1
    load w64 %4 %0 0;
    mul w64 %5 %1 4;
    add w64 %6 %4 %5;
    add ptr %6 %4 %5;
    sload w32 %7 %6 0;
    load w32 %8 %0 8;
    br.ult w32 %2 %8 @guard#pass3 @guard#trap4;
  @guard#trap2
    ebreak;
    unreachable;
  @guard#pass3
    load w64 %9 %0 0;
    mul w64 %10 %2 4;
    add w64 %11 %9 %10;
    add ptr %11 %9 %10;
    sload w32 %12 %11 0;
    load w32 %13 %0 8;
    br.ult w32 %1 %13 @guard#pass5 @guard#trap6;
  @guard#trap4
    ebreak;
    unreachable;
  @guard#pass5
    load w64 %14 %0 0;
    mul w64 %15 %1 4;
    add w64 %16 %14 %15;
    add ptr %16 %14 %15;
    store w32 %12 %16 0;
    load w32 %17 %0 8;
    br.ult w32 %2 %17 @guard#pass7 @guard#trap8;
  @guard#trap6
    ebreak;
    unreachable;
  @guard#pass7
    load w64 %18 %0 0;
    mul w64 %19 %2 4;
    add w64 %20 %18 %19;
    add ptr %20 %18 %19;
    store w32 %7 %20 0;
    ret;
  @guard#trap8
    ebreak;
    unreachable;

test/tests/slice.range.ril +13 -13

fn w64 $sliceRange(w64 %0, w64 %1, w32 %2, w32 %3) {
fn ptr $sliceRange(ptr %0, ptr %1, w32 %2, w32 %3) {
  @entry0
    load w64 %4 %1 0;
    load w32 %5 %1 8;
    mul w64 %6 %2 4;
    add w64 %7 %4 %6;
    add ptr %7 %4 %6;
    sub w32 %8 %3 %2;
    reserve %9 16 8;
    store w64 %7 %9 0;
    store ptr %7 %9 0;
    store w32 %8 %9 8;
    store w32 %8 %9 12;
    blit %0 %9 16;
    ret %0;
}

fn w64 $sliceRangeOpenEnd(w64 %0, w64 %1, w32 %2) {
fn ptr $sliceRangeOpenEnd(ptr %0, ptr %1, w32 %2) {
  @entry0
    load w64 %3 %1 0;
    load w32 %4 %1 8;
    mul w64 %5 %2 4;
    add w64 %6 %3 %5;
    add ptr %6 %3 %5;
    sub w32 %7 %4 %2;
    reserve %8 16 8;
    store w64 %6 %8 0;
    store ptr %6 %8 0;
    store w32 %7 %8 8;
    store w32 %7 %8 12;
    blit %0 %8 16;
    ret %0;
}

fn w64 $sliceRangeOpenStart(w64 %0, w64 %1, w32 %2) {
fn ptr $sliceRangeOpenStart(ptr %0, ptr %1, w32 %2) {
  @entry0
    load w64 %3 %1 0;
    load w32 %4 %1 8;
    reserve %5 16 8;
    store w64 %3 %5 0;
    store ptr %3 %5 0;
    store w32 %2 %5 8;
    store w32 %2 %5 12;
    blit %0 %5 16;
    ret %0;
}

fn w64 $sliceRangeFull(w64 %0, w64 %1) {
fn ptr $sliceRangeFull(ptr %0, ptr %1) {
  @entry0
    load w64 %2 %1 0;
    load w32 %3 %1 8;
    reserve %4 16 8;
    store w64 %2 %4 0;
    store ptr %2 %4 0;
    store w32 %3 %4 8;
    store w32 %3 %4 12;
    blit %0 %4 16;
    ret %0;
}

fn w64 $sliceArray(w64 %0, w64 %1) {
fn ptr $sliceArray(ptr %0, ptr %1) {
  @entry0
    mul w64 %2 1 4;
    add w64 %3 %1 %2;
    add ptr %3 %1 %2;
    sub w32 %4 3 1;
    reserve %5 16 8;
    store w64 %3 %5 0;
    store ptr %3 %5 0;
    store w32 %4 %5 8;
    store w32 %4 %5 12;
    blit %0 %5 16;
    ret %0;
}

test/tests/slice.runtime.i32.ril +6 -6

fn w64 $sliceWithVar(w64 %0, w32 %1) {
fn ptr $sliceWithVar(ptr %0, w32 %1) {
  @entry0
    reserve %2 4 4;
    store w32 %1 %2 0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 1 %3 8;
    store w32 1 %3 12;
    blit %0 %3 16;
    ret %0;
}

fn w64 $sliceWithVars(w64 %0, w32 %1, w32 %2) {
fn ptr $sliceWithVars(ptr %0, w32 %1, w32 %2) {
  @entry0
    reserve %3 8 4;
    store w32 %1 %3 0;
    store w32 %2 %3 4;
    reserve %4 16 8;
    store w64 %3 %4 0;
    store ptr %3 %4 0;
    store w32 2 %4 8;
    store w32 2 %4 12;
    blit %0 %4 16;
    ret %0;
}

fn w64 $sliceWithMixed(w64 %0, w32 %1) {
fn ptr $sliceWithMixed(ptr %0, w32 %1) {
  @entry0
    reserve %2 12 4;
    store w32 %1 %2 0;
    store w32 42 %2 4;
    store w32 %1 %2 8;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 3 %3 8;
    store w32 3 %3 12;
    blit %0 %3 16;
    ret %0;
}

test/tests/slice.runtime.literal.ril +4 -4

fn w64 $sliceWithVar(w64 %0, w8 %1) {
fn ptr $sliceWithVar(ptr %0, w8 %1) {
  @entry0
    reserve %2 1 1;
    store w8 %1 %2 0;
    reserve %3 16 8;
    store w64 %2 %3 0;
    store ptr %2 %3 0;
    store w32 1 %3 8;
    store w32 1 %3 12;
    blit %0 %3 16;
    ret %0;
}

fn w64 $sliceWithVars(w64 %0, w8 %1, w8 %2) {
fn ptr $sliceWithVars(ptr %0, w8 %1, w8 %2) {
  @entry0
    reserve %3 2 1;
    store w8 %1 %3 0;
    store w8 %2 %3 1;
    reserve %4 16 8;
    store w64 %3 %4 0;
    store ptr %3 %4 0;
    store w32 2 %4 8;
    store w32 2 %4 12;
    blit %0 %4 16;
    ret %0;
}

test/tests/trait.dispatch.ril +9 -9

data $"vtable::Acc::Ops" align 8 {
    fn $"Acc::get";
    fn $"Acc::set";
}

fn w32 $"Acc::get"(w64 %0) {
fn w32 $"Acc::get"(ptr %0) {
  @entry0
    sload w32 %1 %0 0;
    ret %1;
}

fn w64 $"Acc::set"(w64 %0, w32 %1) {
fn w64 $"Acc::set"(ptr %0, w32 %1) {
  @entry0
    store w32 %1 %0 0;
    ret;
}

fn w32 $dispatch(w64 %0) {
fn w32 $dispatch(ptr %0) {
  @entry0
    load w64 %1 %0 0;
    load w64 %2 %0 8;
    load w64 %3 %2 8;
    load ptr %1 %0 0;
    load ptr %2 %0 8;
    load ptr %3 %2 8;
    call w64 %3(%1, 42);
    load w64 %4 %0 0;
    load w64 %5 %0 8;
    load w64 %6 %5 0;
    load ptr %4 %0 0;
    load ptr %5 %0 8;
    load ptr %6 %5 0;
    call w32 %7 %6(%4);
    ret %7;
}

test/tests/trait.object.ril +6 -6

data $"vtable::Counter::Adder" align 8 {
    fn $"Counter::add";
}

fn w32 $"Counter::add"(w64 %0, w32 %1) {
fn w32 $"Counter::add"(ptr %0, w32 %1) {
  @entry0
    sload w32 %2 %0 0;
    add w32 %3 %2 %1;
    store w32 %3 %0 0;
    sload w32 %4 %0 0;

fn w32 $use_adder() {
  @entry0
    reserve %0 4 4;
    store w32 0 %0 0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w64 $"vtable::Counter::Adder" %1 8;
    load w64 %2 %1 0;
    load w64 %3 %1 8;
    load w64 %4 %3 0;
    store ptr %0 %1 0;
    store ptr $"vtable::Counter::Adder" %1 8;
    load ptr %2 %1 0;
    load ptr %3 %1 8;
    load ptr %4 %3 0;
    call w32 %5 %4(%2, 1);
    ret %5;
}

test/tests/trait.supertrait.ril +28 -29


data $main0 align 1 {
    str "abc";
}

fn w32 $"Socket::read"(w64 %0, w64 %1) {
fn w32 $"Socket::read"(ptr %0, ptr %1) {
  @entry0
    jmp @while1(0, %1, %0);
  @while1(w32 %3, w64 %4, w64 %6)
  @while1(w32 %3, ptr %4, ptr %6)
    load w32 %5 %4 8;
    br.ult w32 %3 %5 @and#then4 @and#else5;
  @body2
    sload w32 %11 %6 32;
    br.ult w32 %11 32 @guard#pass7 @guard#trap8;

  @and#else5
    jmp @and#end6(0);
  @and#end6(w8 %2)
    br.ne w32 %2 0 @body2 @merge3;
  @guard#pass7
    add w64 %12 %6 %11;
    add ptr %12 %6 %11;
    load w8 %13 %12 0;
    load w32 %16 %4 8;
    br.ult w32 %3 %16 @guard#pass9 @guard#trap10;
  @guard#trap8
    ebreak;
    unreachable;
  @guard#pass9
    load w64 %17 %4 0;
    add w64 %18 %17 %3;
    add ptr %18 %17 %3;
    store w8 %13 %18 0;
    sload w32 %19 %6 32;
    add w32 %20 %19 1;
    store w32 %20 %6 32;
    add w32 %21 %3 1;

  @guard#trap10
    ebreak;
    unreachable;
}

fn w32 $"Socket::write"(w64 %0, w64 %1) {
fn w32 $"Socket::write"(ptr %0, ptr %1) {
  @entry0
    jmp @while1(0, %1, %0);
  @while1(w32 %2, w64 %3, w64 %5)
  @while1(w32 %2, ptr %3, ptr %5)
    load w32 %4 %3 8;
    br.ult w32 %2 %4 @body2 @merge3;
  @body2
    sload w32 %6 %5 72;
    br.slt w32 %6 32 @merge5 @then4;

  @merge5
    load w32 %8 %3 8;
    br.ult w32 %2 %8 @guard#pass6 @guard#trap7;
  @guard#pass6
    load w64 %9 %3 0;
    add w64 %10 %9 %2;
    add ptr %10 %9 %2;
    load w8 %11 %10 0;
    sload w32 %12 %5 72;
    add w64 %13 %5 40;
    add ptr %13 %5 40;
    br.ult w32 %12 32 @guard#pass8 @guard#trap9;
  @guard#trap7
    ebreak;
    unreachable;
  @guard#pass8
    add w64 %14 %13 %12;
    add ptr %14 %13 %12;
    store w8 %11 %14 0;
    sload w32 %15 %5 72;
    add w32 %16 %15 1;
    store w32 %16 %5 72;
    add w32 %17 %2 1;

  @guard#trap9
    ebreak;
    unreachable;
}

fn w32 $"Socket::flush"(w64 %0) {
fn w32 $"Socket::flush"(ptr %0) {
  @entry0
    sload w32 %1 %0 72;
    store w32 0 %0 72;
    ret %1;
}

    reserve %0 76 4;
    store w32 0 %0 32;
    store w32 5 %0 36;
    store w32 0 %0 72;
    store w8 104 %0 0;
    add w64 %1 %0 1;
    add ptr %1 %0 1;
    store w8 101 %1 0;
    add w64 %2 %0 2;
    add ptr %2 %0 2;
    store w8 108 %2 0;
    add w64 %3 %0 3;
    add ptr %3 %0 3;
    store w8 108 %3 0;
    add w64 %4 %0 4;
    add ptr %4 %0 4;
    store w8 111 %4 0;
    reserve %5 16 8;
    store w64 %0 %5 0;
    store w64 $"vtable::Socket::ReadWriter" %5 8;
    load w64 %6 %5 0;
    load w64 %7 %5 8;
    load w64 %8 %7 8;
    store ptr %0 %5 0;
    store ptr $"vtable::Socket::ReadWriter" %5 8;
    load ptr %6 %5 0;
    load ptr %7 %5 8;
    load ptr %8 %7 8;
    copy %9 $main0;
    reserve %10 16 8;
    store w64 %9 %10 0;
    store ptr %9 %10 0;
    store w32 3 %10 8;
    store w32 3 %10 12;
    call w32 %11 %8(%6, %10);
    br.eq w32 %11 3 @assert.ok2 @assert.fail1;
  @assert.fail1

    br.eq w32 %12 3 @assert.ok4 @assert.fail3;
  @assert.fail3
    unreachable;
  @assert.ok4
    reserve %13 8 1;
    load w64 %14 %5 0;
    load w64 %15 %5 8;
    load w64 %16 %15 0;
    load ptr %14 %5 0;
    load ptr %15 %5 8;
    load ptr %16 %15 0;
    reserve %17 16 8;
    store w64 %13 %17 0;
    store ptr %13 %17 0;
    store w32 8 %17 8;
    store w32 8 %17 12;
    call w32 %18 %16(%14, %17);
    br.eq w32 %18 5 @assert.ok6 @assert.fail5;
  @assert.fail5

    load w8 %19 %13 0;
    br.eq w8 %19 104 @assert.ok8 @assert.fail7;
  @assert.fail7
    unreachable;
  @assert.ok8
    add w64 %20 %13 4;
    add ptr %20 %13 4;
    load w8 %21 %20 0;
    br.eq w8 %21 111 @assert.ok10 @assert.fail9;
  @assert.fail9
    unreachable;
  @assert.ok10
    load w64 %22 %5 0;
    load w64 %23 %5 8;
    load w64 %24 %23 16;
    load ptr %22 %5 0;
    load ptr %23 %5 8;
    load ptr %24 %23 16;
    call w32 %25 %24(%22);
    br.eq w32 %25 3 @assert.ok12 @assert.fail11;
  @assert.fail11
    unreachable;
  @assert.ok12

  @assert.fail13
    unreachable;
  @assert.ok14
    ret 0;
}


test/tests/try.basic.ril +5 -5

fn w64 $fallible(w64 %0, w8 %1) {
fn ptr $fallible(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

    store w32 7 %4 8;
    blit %0 %4 12;
    ret %0;
}

fn w64 $caller(w64 %0, w8 %1) {
fn ptr $caller(ptr %0, w8 %1) {
  @entry0
    reserve %2 12 8;
    call w64 %3 $fallible(%2, %1);
    call ptr %3 $fallible(%2, %1);
    load w64 %4 %3 0;
    reserve %5 4 4;
    br.ne w32 %4 0 @err2 @ok1;
  @ok1
    sload w32 %6 %3 8;
    store w32 %6 %5 0;
    jmp @merge3;
  @err2
    reserve %7 12 8;
    store w64 %4 %7 0;
    add w64 %8 %3 8;
    add w64 %9 %7 8;
    add ptr %8 %3 8;
    add ptr %9 %7 8;
    blit %9 %8 1;
    blit %0 %7 12;
    ret %0;
  @merge3
    sload w32 %10 %5 0;

test/tests/try.catch.ril +3 -3

fn w64 $fallible(w64 %0, w8 %1) {
fn ptr $fallible(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

    store w32 42 %4 8;
    blit %0 %4 12;
    ret %0;
}

fn w64 $caller(w64 %0, w8 %1) {
fn ptr $caller(ptr %0, w8 %1) {
  @entry0
    reserve %2 12 8;
    call w64 %3 $fallible(%2, %1);
    call ptr %3 $fallible(%2, %1);
    load w64 %4 %3 0;
    reserve %5 4 4;
    br.ne w32 %4 0 @err2 @ok1;
  @ok1
    sload w32 %6 %3 8;

test/tests/try.optional.ril +3 -3

fn w64 $fallible(w64 %0, w8 %1) {
fn ptr $fallible(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

    store w32 3 %4 8;
    blit %0 %4 12;
    ret %0;
}

fn w64 $caller(w64 %0, w8 %1) {
fn ptr $caller(ptr %0, w8 %1) {
  @entry0
    reserve %2 12 8;
    call w64 %3 $fallible(%2, %1);
    call ptr %3 $fallible(%2, %1);
    load w64 %4 %3 0;
    reserve %5 8 4;
    br.ne w32 %4 0 @err2 @ok1;
  @ok1
    sload w32 %6 %3 8;

test/tests/try.panic.ril +2 -2

fn w64 $fallible(w64 %0, w8 %1) {
fn ptr $fallible(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

}

fn w32 $caller(w8 %0) {
  @entry0
    reserve %1 12 8;
    call w64 %2 $fallible(%1, %0);
    call ptr %2 $fallible(%1, %0);
    load w64 %3 %2 0;
    reserve %4 4 4;
    br.ne w32 %3 0 @err2 @ok1;
  @ok1
    sload w32 %5 %2 8;

test/tests/undefined.record.field.ril +1 -1

    jmp @arm1;
  @arm1
    load w8 %2 %1 0;
    br.eq w8 %2 0 @case2 @arm3;
  @case2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    sload w32 %4 %3 16;
    ret %4;
  @arm3
    jmp @else4;
  @else4

test/tests/union.ctor.ril +3 -3

fn w8 $makeBlue() {
  @entry0
    ret 2;
}

fn w64 $makeSome() {
fn ptr $makeSome() {
  @entry0
    reserve %0 4 4;
    store w32 7 %0 0;
    reserve %1 8 4;
    store w8 1 %1 0;
    add w64 %2 %1 4;
    add ptr %2 %1 4;
    blit %2 %0 4;
    load w64 %3 %1 0;
    ret %3;
}

fn w64 $makeNone() {
fn ptr $makeNone() {
  @entry0
    reserve %0 8 4;
    store w8 0 %0 0;
    load w64 %1 %0 0;
    ret %1;

test/tests/union.eq.ril +3 -3

2	2		@entry0
3	3		eq w8 %2 %0 %1;
4	4		ret %2;
5	5		}
6	6
7		-	fn w8 $maybeIntEq(w64 %0, w64 %1) {
	7	+	fn w8 $maybeIntEq(ptr %0, ptr %1) {
8	8		@entry0
9	9		load w8 %2 %0 0;
10	10		load w8 %3 %1 0;
11	11		br.eq w8 %2 %3 @eq#tag2 @eq#merge1(0);
12	12		@eq#merge1(w8 %4)

20	20		jmp @eq#merge1(%7);
21	21		@eq#unreachable4
22	22		unreachable;
23	23		}
24	24
25		-	fn w8 $valueEq(w64 %0, w64 %1) {
	25	+	fn w8 $valueEq(ptr %0, ptr %1) {
26	26		@entry0
27	27		load w8 %2 %0 0;
28	28		load w8 %3 %1 0;
29	29		br.eq w8 %2 %3 @eq#tag2 @eq#merge1(0);
30	30		@eq#merge1(w8 %4)

43	43		jmp @eq#merge1(%10);
44	44		@eq#unreachable5
45	45		unreachable;
46	46		}
47	47
48		-	fn w8 $shapeEq(w64 %0, w64 %1) {
	48	+	fn w8 $shapeEq(ptr %0, ptr %1) {
49	49		@entry0
50	50		load w8 %2 %0 0;
51	51		load w8 %3 %1 0;
52	52		br.eq w8 %2 %3 @eq#tag2 @eq#merge1(0);
53	53		@eq#merge1(w8 %4)

test/tests/union.match.bind.ril +1 -1

fn w32 $unwrap(w64 %0) {
fn w32 $unwrap(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    jmp @arm1;
  @arm1

test/tests/union.match.ref.ril +9 -9

fn w32 $matchColorRef(w64 %0) {
fn w32 $matchColorRef(ptr %0) {
  @entry0
    jmp @arm1;
  @arm1
    load w8 %1 %0 0;
    br.eq w8 %1 0 @case2 @arm3;

    jmp @case6;
  @case6
    ret 2;
}

fn w32 $matchRef(w64 %0) {
fn w32 $matchRef(ptr %0) {
  @entry0
    jmp @arm1;
  @arm1
    load w8 %1 %0 0;
    br.eq w8 %1 0 @case2 @arm3;
  @case2
    ret 0;
  @arm3
    jmp @case4;
  @case4
    add w64 %2 %0 4;
    add ptr %2 %0 4;
    load w32 %3 %2 0;
    ret %3;
}

fn w32 $ifLetRef(w64 %0) {
fn w32 $ifLetRef(ptr %0) {
  @entry0
    load w8 %1 %0 0;
    br.eq w8 %1 1 @then1 @else2;
  @then1
    add w64 %2 %0 4;
    add ptr %2 %0 4;
    load w32 %3 %2 0;
    ret %3;
  @else2
    jmp @merge3;
  @merge3
    ret 0;
}

fn w32 $whileLetRef(w64 %0) {
fn w32 $whileLetRef(ptr %0) {
  @entry0
    jmp @while1(%0, 0);
  @while1(w64 %1, w32 %4)
  @while1(ptr %1, w32 %4)
    load w8 %2 %1 0;
    br.eq w8 %2 1 @body2 @merge3;
  @body2
    add w64 %3 %1 4;
    add ptr %3 %1 4;
    load w32 %5 %3 0;
    add w32 %6 %4 %5;
    reserve %7 8 4;
    store w8 0 %7 0;
    blit %1 %7 8;
    jmp @while1(%1, %6);
  @merge3
    ret %4;
}

fn w32 $optionalRef(w64 %0) {
fn w32 $optionalRef(ptr %0) {
  @entry0
    br.ne w32 %0 0 @then1 @else2;
  @then1
    load w32 %1 %0 0;
    ret %1;

test/tests/union.match.tag.ril +2 -2

    jmp @else4;
  @else4
    ret 1;
}

fn w32 $matchTag(w64 %0) {
fn w32 $matchTag(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    jmp @arm1;
  @arm1

    jmp @case4;
  @case4
    ret 1;
}

fn w32 $matchElse(w64 %0) {
fn w32 $matchElse(ptr %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    jmp @arm1;
  @arm1

test/tests/union.payload.record.eq.ril +2 -2

1		-	fn w8 $maybePointEq(w64 %0, w64 %1) {
	1	+	fn w8 $maybePointEq(ptr %0, ptr %1) {
2	2		@entry0
3	3		load w8 %2 %0 0;
4	4		load w8 %3 %1 0;
5	5		br.eq w8 %2 %3 @eq#tag2 @eq#merge1(0);
6	6		@eq#merge1(w8 %4)

    jmp @eq#merge1(%11);
  @eq#unreachable4
    unreachable;
}

fn w8 $maybePointNeq(w64 %0, w64 %1) {
fn w8 $maybePointNeq(ptr %0, ptr %1) {
  @entry0
    load w8 %2 %0 0;
    load w8 %3 %1 0;
    br.eq w8 %2 %3 @eq#tag2 @eq#merge1(0);
  @eq#merge1(w8 %4)

test/tests/union.record.literal.ril +2 -2

fn w64 $makePair(w64 %0, w32 %1, w32 %2) {
fn ptr $makePair(ptr %0, w32 %1, w32 %2) {
  @entry0
    reserve %3 12 4;
    store w8 1 %3 0;
    store w32 %1 %3 4;
    store w32 %2 %3 8;
    blit %0 %3 12;
    ret %0;
}

fn w8 $isPair(w64 %0) {
fn w8 $isPair(ptr %0) {
  @entry0
    reserve %1 12 4;
    blit %1 %0 12;
    jmp @arm1;
  @arm1

test/tests/union.variant.access.ril +4 -4

fn w8 $assignGreen() {
  @entry0
    ret 1;
}

fn w64 $makeNone() {
fn ptr $makeNone() {
  @entry0
    reserve %0 8 4;
    store w8 0 %0 0;
    load w64 %1 %0 0;
    ret %1;
}

fn w64 $makeSome(w32 %0) {
fn ptr $makeSome(w32 %0) {
  @entry0
    reserve %1 4 4;
    store w32 %0 %1 0;
    reserve %2 8 4;
    store w8 1 %2 0;
    add w64 %3 %2 4;
    add ptr %3 %2 4;
    blit %3 %1 4;
    load w64 %4 %2 0;
    ret %4;
}

fn w64 $assignNone() {
fn ptr $assignNone() {
  @entry0
    reserve %0 8 4;
    store w8 0 %0 0;
    load w64 %1 %0 0;
    ret %1;

test/tests/void.throw.ril +5 -5

fn w64 $fallible(w64 %0, w8 %1) {
fn ptr $fallible(ptr %0, w8 %1) {
  @entry0
    br.ne w32 %1 0 @then1 @merge2;
  @then1
    reserve %2 1 1;
    store w8 0 %2 0;

    store w64 0 %4 0;
    blit %0 %4 9;
    ret %0;
}

fn w64 $caller(w64 %0, w8 %1) {
fn ptr $caller(ptr %0, w8 %1) {
  @entry0
    reserve %2 9 8;
    call w64 %3 $fallible(%2, %1);
    call ptr %3 $fallible(%2, %1);
    load w64 %4 %3 0;
    br.ne w32 %4 0 @err2 @ok1;
  @ok1
    jmp @merge3;
  @err2
    reserve %5 9 8;
    store w64 %4 %5 0;
    add w64 %6 %3 8;
    add w64 %7 %5 8;
    add ptr %6 %3 8;
    add ptr %7 %5 8;
    blit %7 %6 1;
    blit %0 %5 9;
    ret %0;
  @merge3
    reserve %8 9 8;

492	492		let adj = adjustOffset(e, base, offset);
493	493		match typ {
494	494		case il::Type::W8 => emit(e, encode::lbu(rd, adj.base, adj.offset)),
495	495		case il::Type::W16 => emit(e, encode::lhu(rd, adj.base, adj.offset)),
496	496		case il::Type::W32 => emit(e, encode::lwu(rd, adj.base, adj.offset)),
497		-	case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
	497	+	case il::Type::W64,
	498	+	il::Type::Ptr => emit(e, encode::ld(rd, adj.base, adj.offset)),
498	499		}
499	500		}
500	501
501	502		/// Emit signed load with automatic offset adjustment.
502	503		pub fn emitSload(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
503	504		let adj = adjustOffset(e, base, offset);
504	505		match typ {
505	506		case il::Type::W8 => emit(e, encode::lb(rd, adj.base, adj.offset)),
506	507		case il::Type::W16 => emit(e, encode::lh(rd, adj.base, adj.offset)),
507	508		case il::Type::W32 => emit(e, encode::lw(rd, adj.base, adj.offset)),
508		-	case il::Type::W64 => emit(e, encode::ld(rd, adj.base, adj.offset)),
	509	+	case il::Type::W64,
	510	+	il::Type::Ptr => emit(e, encode::ld(rd, adj.base, adj.offset)),
509	511		}
510	512		}
511	513
512	514		/// Emit store with automatic offset adjustment.
513	515		pub fn emitStore(e: *mut Emitter, rs: gen::Reg, base: gen::Reg, offset: i32, typ: il::Type) {
514	516		let adj = adjustOffset(e, base, offset);
515	517		match typ {
516	518		case il::Type::W8 => emit(e, encode::sb(rs, adj.base, adj.offset)),
517	519		case il::Type::W16 => emit(e, encode::sh(rs, adj.base, adj.offset)),
518	520		case il::Type::W32 => emit(e, encode::sw(rs, adj.base, adj.offset)),
519		-	case il::Type::W64 => emit(e, encode::sd(rs, adj.base, adj.offset)),
	521	+	case il::Type::W64,
	522	+	il::Type::Ptr => emit(e, encode::sd(rs, adj.base, adj.offset)),
520	523		}
521	524		}
522	525
523	526		/// Emit 64-bit load with automatic offset adjustment.
524	527		pub fn emitLd(e: *mut Emitter, rd: gen::Reg, base: gen::Reg, offset: i32) {

780	782		// fits in the signed range of the target type.
781	783		match typ {
782	784		case il::Type::W8 => return imm >= I8_MIN and imm <= I8_MAX,
783	785		case il::Type::W16 => return imm >= I16_MIN and imm <= I16_MAX,
784	786		case il::Type::W32 => return imm >= I32_MIN and imm <= I32_MAX,
785		-	case il::Type::W64 => return true,
	787	+	case il::Type::W64,
	788	+	il::Type::Ptr => return true,
786	789		}
787	790		} else {
788	791		// Zero-extension: value must be non-negative and within unsigned range.
789	792		match typ {
790	793		case il::Type::W8 => return imm >= 0 and imm <= U8_MAX,
791	794		case il::Type::W16 => return imm >= 0 and imm <= U16_MAX,
792	795		case il::Type::W32 => return imm >= 0 and imm <= U32_MAX,
793		-	case il::Type::W64 => return true,
	796	+	case il::Type::W64,
	797	+	il::Type::Ptr => return true,
794	798		}
795	799		}
796	800		}
797	801		return false;
798	802		}

936	936		returnType: undefined,
937	937		isExtern,
938	938		isLeaf: true,
939	939		blocks: &[],
940	940		};
941		-	// Throwing functions return a result aggregate (word-sized pointer).
	941	+	// Throwing functions return a result aggregate (pointer to stack slot).
942	942		// TODO: The resolver should set an appropriate type that takes into account
943	943		// the throws list. It shouldn't set the return type to the "success"
944	944		// value only.
945	945		if fnType.throwList.len > 0 {
946		-	func.returnType = il::Type::W64;
	946	+	func.returnType = il::Type::Ptr;
947	947		} else {
948	948		func.returnType = ilType(self, *fnType.returnType);
949	949		}
950	950		let body = decl.body else {
951	951		// Extern functions have no body.

1103	1103		isExtern: false,
1104	1104		isLeaf: true,
1105	1105		blocks: &[],
1106	1106		};
1107	1107		if fnType.throwList.len > 0 {
1108		-	func.returnType = il::Type::W64;
	1108	+	func.returnType = il::Type::Ptr;
1109	1109		}
1110	1110		func.blocks = try lowerFnBody(&mut fnLow, body);
1111	1111		func.isLeaf = fnLow.isLeaf;
1112	1112
1113	1113		return func;

2193	2193
2194	2194		match subject.kind {
2195	2195		case MatchSubjectKind::OptionalPtr if isNil => {
2196	2196		// Null pointer optimization: branch on the data pointer being null.
2197	2197		let nilReg = try optionalNilReg(self, subject.val, subject.type);
2198		-	try emitBrCmp(self, il::CmpOp::Eq, il::Type::W64, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);
	2198	+	try emitBrCmp(self, il::CmpOp::Eq, il::Type::Ptr, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);
2199	2199		}
2200	2200		case MatchSubjectKind::OptionalAggregate => {
2201	2201		let base = emitValToReg(self, subject.val);
2202	2202
2203	2203		if isNil { // Optional aggregate: `nil` means tag is zero.

228	228		},
229	229		case il::Type::W32 => {
230	230		emit::emit(e, encode::slli(rd, rs, SHIFT_W32));
231	231		emit::emit(e, encode::srli(rd, rd, SHIFT_W32));
232	232		},
233		-	case il::Type::W64 => {}
	233	+	case il::Type::W64,
	234	+	il::Type::Ptr => {}
234	235		}
235	236		}
236	237
237	238		/// Emit sign-extension from a sub-word type to the full register width.
238	239		fn emitSext(e: *mut emit::Emitter, rd: gen::Reg, rs: gen::Reg, typ: il::Type) {

246	247		emit::emit(e, encode::srai(rd, rd, SHIFT_W16));
247	248		},
248	249		case il::Type::W32 => {
249	250		emit::emit(e, encode::addiw(rd, rs, 0));
250	251		},
251		-	case il::Type::W64 => {}
	252	+	case il::Type::W64,
	253	+	il::Type::Ptr => {}
252	254		}
253	255		}
254	256
255	257		/// Resolve a value, trap if zero (unless known non-zero), and return the register.
256	258		fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> gen::Reg {

109	109		W8,
110	110		/// 16-bit value.
111	111		W16,
112	112		/// 32-bit value.
113	113		W32,
114		-	/// 64-bit value (used for pointers on RV64).
	114	+	/// 64-bit value.
115	115		W64,
	116	+	/// Pointer-width value with provenance.
	117	+	/// Same physical width as W64 on RV64, but semantically distinct:
	118	+	/// a verifier treats Ptr and W64 as incompatible types.
	119	+	Ptr,
116	120		}
117	121
118	122		/// Get the size of a type in bytes.
119	123		pub fn typeSize(t: Type) -> u32 {
120	124		match t {
121	125		case Type::W8 => return 1,
122	126		case Type::W16 => return 2,
123	127		case Type::W32 => return 4,
124		-	case Type::W64 => return 8,
	128	+	case Type::W64,
	129	+	Type::Ptr => return 8,
125	130		}
126	131		}
127	132
128	133		/// SSA register reference.
129	134		pub record Reg { n: u32 }

97	97		match typ {
98	98		case super::Type::W8 => return "w8",
99	99		case super::Type::W16 => return "w16",
100	100		case super::Type::W32 => return "w32",
101	101		case super::Type::W64 => return "w64",
	102	+	case super::Type::Ptr => return "ptr",
102	103		}
103	104		}
104	105
105	106		/// Write a type.
106	107		fn writeType(out: *mut sexpr::Output, typ: super::Type) {

2881	2881		let params = try! alloc::allocSlice(
2882	2882		self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
2883	2883		) as *mut [il::Param];
2884	2884
2885	2885		if let reg = self.returnReg {
2886		-	params[0] = il::Param { value: reg, type: il::Type::W64 };
	2886	+	params[0] = il::Param { value: reg, type: il::Type::Ptr };
2887	2887		}
2888	2888		for i in 0..fnType.paramTypes.len as u32 {
2889	2889		let type = ilType(self.low, *fnType.paramTypes[i]);
2890	2890		let reg = nextReg(self);
2891	2891

2996	2996		let val = try lowerExpr(self, opt);
2997	2997		let cmpReg = try optionalNilReg(self, val, optTy);
2998	2998
2999	2999		// Null-pointer-optimized types compare a 64-bit pointer against zero.
3000	3000		// Aggregate optionals compare an 8-bit tag byte against zero.
3001		-	let cmpType = il::Type::W64 if resolver::isOptionalPointer(optTy) else il::Type::W8;
	3001	+	let cmpType = il::Type::Ptr if resolver::isOptionalPointer(optTy) else il::Type::W8;
3002	3002
3003	3003		let op = il::BinOp::Eq if isEq else il::BinOp::Ne;
3004	3004		return emitTypedBinOp(self, op, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));
3005	3005		}
3006	3006

4068	4068		alignment: resolver::PTR_SIZE,
4069	4069		});
4070	4070
4071	4071		// Store data pointer.
4072	4072		emit(self, il::Instr::Store {
4073		-	typ: il::Type::W64,
	4073	+	typ: il::Type::Ptr,
4074	4074		src: dataVal,
4075	4075		dst: slot,
4076	4076		offset: TRAIT_OBJ_DATA_OFFSET,
4077	4077		});
4078	4078
4079	4079		// Store v-table address.
4080	4080		emit(self, il::Instr::Store {
4081		-	typ: il::Type::W64,
	4081	+	typ: il::Type::Ptr,
4082	4082		src: il::Val::DataSym(vName),
4083	4083		dst: slot,
4084	4084		offset: TRAIT_OBJ_VTABLE_OFFSET,
4085	4085		});
4086	4086		return il::Val::Reg(slot);

4093	4093		}
4094	4094		let dst = nextReg(self);
4095	4095
4096	4096		emit(self, il::Instr::BinOp {
4097	4097		op: il::BinOp::Add,
4098		-	typ: il::Type::W64,
	4098	+	typ: il::Type::Ptr,
4099	4099		dst,
4100	4100		a: il::Val::Reg(base),
4101	4101		b: il::Val::Imm(offset as i64),
4102	4102		});
4103	4103		return dst;

4114	4114		if stride == 1 {
4115	4115		let dst = nextReg(self);
4116	4116
4117	4117		emit(self, il::Instr::BinOp {
4118	4118		op: il::BinOp::Add,
4119		-	typ: il::Type::W64,
	4119	+	typ: il::Type::Ptr,
4120	4120		dst,
4121	4121		a: il::Val::Reg(base),
4122	4122		b: idx
4123	4123		});
4124	4124		return dst;

4135	4135		});
4136	4136		// Compute `dst = base + offset`.
4137	4137		let dst = nextReg(self);
4138	4138		emit(self, il::Instr::BinOp {
4139	4139		op: il::BinOp::Add,
4140		-	typ: il::Type::W64,
	4140	+	typ: il::Type::Ptr,
4141	4141		dst,
4142	4142		a: il::Val::Reg(base),
4143	4143		b: il::Val::Reg(offset)
4144	4144		});
4145	4145		return dst;

6271	6271		args[1] = byteSize;
6272	6272		args[2] = il::Val::Imm(alignment as i64);
6273	6273
6274	6274		let newPtrReg = nextReg(self);
6275	6275		emit(self, il::Instr::Call {
6276		-	retTy: il::Type::W64,
	6276	+	retTy: il::Type::Ptr,
6277	6277		dst: newPtrReg,
6278	6278		func: il::Val::Reg(allocFnReg),
6279	6279		args,
6280	6280		});
6281	6281

6469	6469		args[0] = il::Val::Reg(try emitReserve(self, retTy));
6470	6470		}
6471	6471		let dst = nextReg(self);
6472	6472
6473	6473		emit(self, il::Instr::Call {
6474		-	retTy: il::Type::W64,
	6474	+	retTy: il::Type::Ptr,
6475	6475		dst,
6476	6476		func: callee,
6477	6477		args,
6478	6478		});
6479	6479		return il::Val::Reg(dst);

6407	6407		let traitObjReg = emitValToReg(self, traitObjVal);
6408	6408
6409	6409		// Load data pointer from trait object.
6410	6410		let dataReg = nextReg(self);
6411	6411		emit(self, il::Instr::Load {
6412		-	typ: il::Type::W64,
	6412	+	typ: il::Type::Ptr,
6413	6413		dst: dataReg,
6414	6414		src: traitObjReg,
6415	6415		offset: TRAIT_OBJ_DATA_OFFSET,
6416	6416		});
6417	6417
6418	6418		// Load v-table pointer from trait object.
6419	6419		let vtableReg = nextReg(self);
6420	6420		emit(self, il::Instr::Load {
6421		-	typ: il::Type::W64,
	6421	+	typ: il::Type::Ptr,
6422	6422		dst: vtableReg,
6423	6423		src: traitObjReg,
6424	6424		offset: TRAIT_OBJ_VTABLE_OFFSET,
6425	6425		});
6426	6426
6427	6427		// Load function pointer from v-table at the method's slot offset.
6428	6428		let fnPtrReg = nextReg(self);
6429	6429		let slotOffset = (methodIndex * resolver::PTR_SIZE) as i32;
6430	6430
6431	6431		emit(self, il::Instr::Load {
6432		-	typ: il::Type::W64,
	6432	+	typ: il::Type::Ptr,
6433	6433		dst: fnPtrReg,
6434	6434		src: vtableReg,
6435	6435		offset: slotOffset,
6436	6436		});
6437	6437		let methodFnType = traitInfo.methods[methodIndex].fnType;

6979	6979		case resolver::Type::I16,
6980	6980		resolver::Type::U16 => return il::Type::W16,
6981	6981		case resolver::Type::I32,
6982	6982		resolver::Type::U32 => return il::Type::W32,
6983	6983		case resolver::Type::I64,
6984		-	resolver::Type::U64,
6985		-	resolver::Type::Pointer { .. },
6986		-	resolver::Type::Slice { .. },
6987		-	resolver::Type::Array(_),
6988		-	resolver::Type::Optional(_),
	6984	+	resolver::Type::U64 => return il::Type::W64,
	6985	+	case resolver::Type::Pointer { .. },
6989	6986		resolver::Type::Fn(_),
6990		-	resolver::Type::TraitObject { .. } => return il::Type::W64,
	6987	+	resolver::Type::TraitObject { .. } => return il::Type::Ptr,
	6988	+	case resolver::Type::Slice { .. },
	6989	+	resolver::Type::Array(_),
	6990	+	resolver::Type::Optional(_) => return il::Type::Ptr,
6991	6991		case resolver::Type::Nominal(_) => {
6992	6992		if resolver::isVoidUnion(typ) {
6993	6993		return il::Type::W8;
6994	6994		}
6995		-	return il::Type::W64;
	6995	+	return il::Type::Ptr;
6996	6996		}
6997	6997		case resolver::Type::Void => return il::Type::W64,
6998	6998		// [`Type::Int`] is the type of unsuffixed integer literals and their
6999	6999		// compound expressions (e.g. `1 + 2`). It defaults to W64 (i64) here,
7000	7000		// matching the native word size on RV64. It cannot be resolved earlier

242	242		@assert.fail29
243	243		unreachable;
244	244		@assert.ok30
245	245		ret 0;
246	246		}
247		-

293	293		@assert.fail35
294	294		unreachable;
295	295		@assert.ok36
296	296		ret 0;
297	297		}
298		-

1		-	fn w32 $arrayOfRecords(w64 %0, w32 %1) {
	1	+	fn w32 $arrayOfRecords(ptr %0, w32 %1) {
2	2		@entry0
3	3		br.ult w32 %1 3 @guard#pass1 @guard#trap2;
4	4		@guard#pass1
5	5		mul w64 %2 %1 8;
6		-	add w64 %3 %0 %2;
	6	+	add ptr %3 %0 %2;
7	7		sload w32 %4 %3 0;
8	8		ret %4;
9	9		@guard#trap2
10	10		ebreak;
11	11		unreachable;
12	12		}
13	13
14		-	fn w64 $addressOfRecord(w64 %0, w32 %1) {
	14	+	fn ptr $addressOfRecord(ptr %0, w32 %1) {
15	15		@entry0
16	16		br.ult w32 %1 3 @guard#pass1 @guard#trap2;
17	17		@guard#pass1
18	18		mul w64 %2 %1 8;
19		-	add w64 %3 %0 %2;
	19	+	add ptr %3 %0 %2;
20	20		ret %3;
21	21		@guard#trap2
22	22		ebreak;
23	23		unreachable;
24	24		}
25	25
26		-	fn w32 $arrayOfArrays(w64 %0, w32 %1) {
	26	+	fn w32 $arrayOfArrays(ptr %0, w32 %1) {
27	27		@entry0
28	28		br.ult w32 %1 3 @guard#pass1 @guard#trap2;
29	29		@guard#pass1
30	30		mul w64 %2 %1 16;
31		-	add w64 %3 %0 %2;
	31	+	add ptr %3 %0 %2;
32	32		sload w32 %4 %3 0;
33	33		ret %4;
34	34		@guard#trap2
35	35		ebreak;
36	36		unreachable;
37	37		}
38	38
39		-	fn w32 $nestedLargeStride(w64 %0, w32 %1, w32 %2) {
	39	+	fn w32 $nestedLargeStride(ptr %0, w32 %1, w32 %2) {
40	40		@entry0
41	41		br.ult w32 %1 3 @guard#pass1 @guard#trap2;
42	42		@guard#pass1
43	43		mul w64 %3 %1 16;
44		-	add w64 %4 %0 %3;
	44	+	add ptr %4 %0 %3;
45	45		br.ult w32 %2 2 @guard#pass3 @guard#trap4;
46	46		@guard#trap2
47	47		ebreak;
48	48		unreachable;
49	49		@guard#pass3
50	50		mul w64 %5 %2 8;
51		-	add w64 %6 %4 %5;
	51	+	add ptr %6 %4 %5;
52	52		sload w32 %7 %6 4;
53	53		ret %7;
54	54		@guard#trap4
55	55		ebreak;
56	56		unreachable;

13	13		store w32 6 %1 12;
14	14		store w32 0 %1 16;
15	15		blit %1 %0 20;
16	16		sload w32 %2 %1 0;
17	17		mul w64 %3 3 4;
18		-	add w64 %4 %1 %3;
	18	+	add ptr %4 %1 %3;
19	19		sload w32 %5 %4 0;
20	20		add w32 %6 %2 %5;
21	21		mul w64 %7 2 4;
22		-	add w64 %8 %1 %7;
	22	+	add ptr %8 %1 %7;
23	23		sload w32 %9 %8 0;
24	24		sub w32 %10 %6 %9;
25	25		ret %10;
26	26		}
27		-

1		-	fn w32 $arrayLen(w64 %0) {
	1	+	fn w32 $arrayLen(ptr %0) {
2	2		@entry0
3	3		ret 5;
4	4		}
5	5
6		-	fn w32 $arrayLenExpr(w64 %0) {
	6	+	fn w32 $arrayLenExpr(ptr %0) {
7	7		@entry0
8	8		add w32 %1 3 10;
9	9		ret %1;
10	10		}
11	11
12		-	fn w8 $arrayLenCmp(w64 %0) {
	12	+	fn w8 $arrayLenCmp(ptr %0) {
13	13		@entry0
14	14		eq w32 %1 4 4;
15	15		ret %1;
16	16		}

4	4		store w32 1 %0 0;
5	5		store w32 2 %0 4;
6	6		store w32 3 %0 8;
7	7		sload w32 %1 %0 0;
8	8		mul w64 %2 1 4;
9		-	add w64 %3 %0 %2;
	9	+	add ptr %3 %0 %2;
10	10		sload w32 %4 %3 0;
11	11		add w32 %5 %1 %4;
12	12		mul w64 %6 2 4;
13		-	add w64 %7 %0 %6;
	13	+	add ptr %7 %0 %6;
14	14		sload w32 %8 %7 0;
15	15		add w32 %9 %5 %8;
16	16		ret %9;
17	17		}

6	6		store w32 42 %0 8;
7	7		sload w32 %3 %0 0;
8	8		br.eq w32 %3 42 @and#then4 @and#else5;
9	9		@and#then1
10	10		mul w64 %9 2 4;
11		-	add w64 %10 %0 %9;
	11	+	add ptr %10 %0 %9;
12	12		sload w32 %11 %10 0;
13	13		eq w32 %12 %11 42;
14	14		jmp @and#end3(%12);
15	15		@and#else2
16	16		jmp @and#end3(0);
17	17		@and#end3(w8 %1)
18	18		ret %1;
19	19		@and#then4
20	20		mul w64 %4 1 4;
21		-	add w64 %5 %0 %4;
	21	+	add ptr %5 %0 %4;
22	22		sload w32 %6 %5 0;
23	23		eq w32 %7 %6 42;
24	24		jmp @and#end6(%7);
25	25		@and#else5
26	26		jmp @and#end6(0);

38	38		store w32 0 %0 16;
39	39		sload w32 %5 %0 0;
40	40		br.eq w32 %5 0 @and#then10 @and#else11;
41	41		@and#then1
42	42		mul w64 %21 4 4;
43		-	add w64 %22 %0 %21;
	43	+	add ptr %22 %0 %21;
44	44		sload w32 %23 %22 0;
45	45		eq w32 %24 %23 0;
46	46		jmp @and#end3(%24);
47	47		@and#else2
48	48		jmp @and#end3(0);
49	49		@and#end3(w8 %1)
50	50		ret %1;
51	51		@and#then4
52	52		mul w64 %16 3 4;
53		-	add w64 %17 %0 %16;
	53	+	add ptr %17 %0 %16;
54	54		sload w32 %18 %17 0;
55	55		eq w32 %19 %18 0;
56	56		jmp @and#end6(%19);
57	57		@and#else5
58	58		jmp @and#end6(0);
59	59		@and#end6(w8 %2)
60	60		br.ne w32 %2 0 @and#then1 @and#else2;
61	61		@and#then7
62	62		mul w64 %11 2 4;
63		-	add w64 %12 %0 %11;
	63	+	add ptr %12 %0 %11;
64	64		sload w32 %13 %12 0;
65	65		eq w32 %14 %13 0;
66	66		jmp @and#end9(%14);
67	67		@and#else8
68	68		jmp @and#end9(0);
69	69		@and#end9(w8 %3)
70	70		br.ne w32 %3 0 @and#then4 @and#else5;
71	71		@and#then10
72	72		mul w64 %6 1 4;
73		-	add w64 %7 %0 %6;
	73	+	add ptr %7 %0 %6;
74	74		sload w32 %8 %7 0;
75	75		eq w32 %9 %8 0;
76	76		jmp @and#end12(%9);
77	77		@and#else11
78	78		jmp @and#end12(0);

88	88		store w8 1 %0 2;
89	89		store w8 1 %0 3;
90	90		load w8 %4 %0 0;
91	91		br.ne w32 %4 0 @and#then7 @and#else8;
92	92		@and#then1
93		-	add w64 %11 %0 3;
	93	+	add ptr %11 %0 3;
94	94		load w8 %12 %11 0;
95	95		jmp @and#end3(%12);
96	96		@and#else2
97	97		jmp @and#end3(0);
98	98		@and#end3(w8 %1)
99	99		ret %1;
100	100		@and#then4
101		-	add w64 %8 %0 2;
	101	+	add ptr %8 %0 2;
102	102		load w8 %9 %8 0;
103	103		jmp @and#end6(%9);
104	104		@and#else5
105	105		jmp @and#end6(0);
106	106		@and#end6(w8 %2)
107	107		br.ne w32 %2 0 @and#then1 @and#else2;
108	108		@and#then7
109		-	add w64 %5 %0 1;
	109	+	add ptr %5 %0 1;
110	110		load w8 %6 %5 0;
111	111		jmp @and#end9(%6);
112	112		@and#else8
113	113		jmp @and#end9(0);
114	114		@and#end9(w8 %3)

148	148		@and#else8
149	149		jmp @and#end9(0);
150	150		@and#end9(w8 %2)
151	151		br.ne w32 %2 0 @and#then4 @and#else5;
152	152		}
153		-

1		-	fn w64 $sliceFull(w64 %0, w64 %1) {
	1	+	fn ptr $sliceFull(ptr %0, ptr %1) {
2	2		@entry0
3	3		reserve %2 16 8;
4		-	store w64 %1 %2 0;
	4	+	store ptr %1 %2 0;
5	5		store w32 4 %2 8;
6	6		store w32 4 %2 12;
7	7		blit %0 %2 16;
8	8		ret %0;
9	9		}

1		-	fn w64 $sliceOpenEnd(w64 %0, w64 %1, w32 %2) {
	1	+	fn ptr $sliceOpenEnd(ptr %0, ptr %1, w32 %2) {
2	2		@entry0
3	3		mul w64 %3 %2 4;
4		-	add w64 %4 %1 %3;
	4	+	add ptr %4 %1 %3;
5	5		sub w32 %5 4 %2;
6	6		reserve %6 16 8;
7		-	store w64 %4 %6 0;
	7	+	store ptr %4 %6 0;
8	8		store w32 %5 %6 8;
9	9		store w32 %5 %6 12;
10	10		blit %0 %6 16;
11	11		ret %0;
12	12		}

1		-	fn w64 $sliceOpenStart(w64 %0, w64 %1, w32 %2) {
	1	+	fn ptr $sliceOpenStart(ptr %0, ptr %1, w32 %2) {
2	2		@entry0
3	3		reserve %3 16 8;
4		-	store w64 %1 %3 0;
	4	+	store ptr %1 %3 0;
5	5		store w32 %2 %3 8;
6	6		store w32 %2 %3 12;
7	7		blit %0 %3 16;
8	8		ret %0;
9	9		}

25	25		@assert.fail11
26	26		unreachable;
27	27		@assert.ok12
28	28		ret 0;
29	29		}
30		-

1		-	fn w32 $average(w64 %0) {
	1	+	fn w32 $average(ptr %0) {
2	2		@entry0
3	3		load w32 %1 %0 8;
4	4		load w64 %2 %0 0;
5	5		jmp @loop1(0, 0);
6	6		@loop1(w32 %3, w32 %7)
7	7		br.slt w32 %3 %1 @body2 @merge3;
8	8		@body2
9	9		mul w64 %4 %3 4;
10		-	add w64 %5 %2 %4;
	10	+	add ptr %5 %2 %4;
11	11		load w32 %6 %5 0;
12	12		add w32 %8 %7 %6;
13	13		add w32 %9 %3 1;
14	14		jmp @loop1(%9, %8);
15	15		@merge3

1		-	fn w8 $loadByte(w64 %0) {
	1	+	fn w8 $loadByte(ptr %0) {
2	2		@entry0
3	3		load w8 %1 %0 0;
4	4		ret %1;
5	5		}
6	6
7		-	fn w64 $storeByte(w64 %0, w8 %1) {
	7	+	fn w64 $storeByte(ptr %0, w8 %1) {
8	8		@entry0
9	9		store w8 %1 %0 0;
10	10		ret;
11	11		}
12	12
13		-	fn w64 $loadStoreByte(w64 %0, w64 %1) {
	13	+	fn w64 $loadStoreByte(ptr %0, ptr %1) {
14	14		@entry0
15	15		load w8 %2 %0 0;
16	16		store w8 %2 %1 0;
17	17		ret;
18	18		}
19	19
20		-	fn w8 $byteArrayAccess(w64 %0, w32 %1) {
	20	+	fn w8 $byteArrayAccess(ptr %0, w32 %1) {
21	21		@entry0
22	22		br.ult w32 %1 4 @guard#pass1 @guard#trap2;
23	23		@guard#pass1
24		-	add w64 %2 %0 %1;
	24	+	add ptr %2 %0 %1;
25	25		load w8 %3 %2 0;
26	26		ret %3;
27	27		@guard#trap2
28	28		ebreak;
29	29		unreachable;
30	30		}
31	31
32		-	fn w8 $byteSliceAccess(w64 %0, w32 %1) {
	32	+	fn w8 $byteSliceAccess(ptr %0, w32 %1) {
33	33		@entry0
34	34		load w32 %2 %0 8;
35	35		br.ult w32 %1 %2 @guard#pass1 @guard#trap2;
36	36		@guard#pass1
37	37		load w64 %3 %0 0;
38		-	add w64 %4 %3 %1;
	38	+	add ptr %4 %3 %1;
39	39		load w8 %5 %4 0;
40	40		ret %5;
41	41		@guard#trap2
42	42		ebreak;
43	43		unreachable;

43	43		@entry0
44	44		sext w16 %1 %0;
45	45		ret %1;
46	46		}
47	47
48		-	fn w64 $ptrCast(w64 %0) {
	48	+	fn ptr $ptrCast(ptr %0) {
49	49		@entry0
50	50		ret %0;
51	51		}

46	46		@assert.fail19
47	47		unreachable;
48	48		@assert.ok20
49	49		ret 0;
50	50		}
51		-