Function load_heap_addr_unchecked

winch/codegen/src/codegen/bounds.rs:193–248

Load the requested heap address into the specified destination register. This function doesn't perform any bounds checks and assumes the caller performed the right checks.

(
    masm: &mut M,
    heap: &HeapData,
    index: Index,
    offset: ImmOffset,
    dst: Reg,
    ptr_size: OperandSize,
)

/// This function doesn't perform any bounds checks and assumes the caller
/// performed the right checks.
pub(crate) fn load_heap_addr_unchecked<M>(
    masm: &mut M,
    heap: &HeapData,
    index: Index,
    offset: ImmOffset,
    dst: Reg,
    ptr_size: OperandSize,
) -> Result<()>
where
    M: MacroAssembler,
{
    masm.with_scratch::<IntScratch, _>(|masm, scratch| {
        let base = if let Some(offset) = heap.import_from {
            // If the WebAssembly memory is imported, load the address into
            // the scratch register.
            masm.load_ptr(masm.address_at_vmctx(offset)?, scratch.writable())?;
            scratch.inner()
        } else {
            // Else if the WebAssembly memory is defined in the current module,
            // simply use the `VMContext` as the base for subsequent operations.
            vmctx!(M)
        };

        // Load the base of the memory into the `addr` register.
        masm.load_ptr(masm.address_at_reg(base, heap.offset)?, writable!(dst))
    })?;

    // Start by adding the index to the heap base addr.
    let index_typed = index.as_typed_reg();
    let heap_size: OperandSize = heap.index_type().try_into()?;

    // Emit a zero-extend add when dealing with 32-bit heaps to ensure
    // that the high bits of the 64-bit values are zeroed.
    if ptr_size == OperandSize::S64 && heap_size == OperandSize::S32 {
        masm.add_uextend(
            writable!(dst),
            dst,
            index_typed.reg,
            OperandSize::S32,
            ptr_size,
        )?;
    } else {
        assert!(index_typed.ty == WasmValType::I64);
        masm.add(writable!(dst), dst, index_typed.reg.into(), ptr_size)?;
    }

    if offset.as_u32() > 0 {
        masm.add(
            writable!(dst),
            dst,
            RegImm::i64(offset.as_u32() as i64),
            ptr_size,
        )?;
    }
    Ok(())
}