wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/winch-codegen-0.14.0/src/frame/mod.rs

@@ -0,0 +1,221 @@
+use crate::{
+    abi::{align_to, ABIOperand, ABISig, LocalSlot, ABI},
+    masm::MacroAssembler,
+};
+use anyhow::Result;
+use smallvec::SmallVec;
+use std::ops::Range;
+use wasmparser::{BinaryReader, FuncValidator, ValidatorResources};
+use wasmtime_environ::{TypeConvert, WasmType};
+
+// TODO:
+// SpiderMonkey's implementation uses 16;
+// (ref: https://searchfox.org/mozilla-central/source/js/src/wasm/WasmBCFrame.h#585)
+// during instrumentation we should measure to verify if this is a good default.
+pub(crate) type Locals = SmallVec<[LocalSlot; 16]>;
+
+/// Function defined locals start and end in the frame.
+pub(crate) struct DefinedLocalsRange(Range<u32>);
+
+impl DefinedLocalsRange {
+    /// Get a reference to the inner range.
+    pub fn as_range(&self) -> &Range<u32> {
+        &self.0
+    }
+}
+
+/// An abstraction to read the defined locals from the Wasm binary for a function.
+#[derive(Default)]
+pub(crate) struct DefinedLocals {
+    /// The defined locals for a function.
+    pub defined_locals: Locals,
+    /// The size of the defined locals.
+    pub stack_size: u32,
+}
+
+impl DefinedLocals {
+    /// Compute the local slots for a Wasm function.
+    pub fn new<A: ABI>(
+        types: &impl TypeConvert,
+        reader: &mut BinaryReader<'_>,
+        validator: &mut FuncValidator<ValidatorResources>,
+    ) -> Result<Self> {
+        let mut next_stack = 0;
+        // The first 32 bits of a Wasm binary function describe the number of locals.
+        let local_count = reader.read_var_u32()?;
+        let mut slots: Locals = Default::default();
+
+        for _ in 0..local_count {
+            let position = reader.original_position();
+            let count = reader.read_var_u32()?;
+            let ty = reader.read()?;
+            validator.define_locals(position, count, ty)?;
+
+            let ty = types.convert_valtype(ty);
+            for _ in 0..count {
+                let ty_size = <A as ABI>::sizeof(&ty);
+                next_stack = align_to(next_stack, ty_size) + ty_size;
+                slots.push(LocalSlot::new(ty, next_stack));
+            }
+        }
+
+        Ok(Self {
+            defined_locals: slots,
+            stack_size: next_stack,
+        })
+    }
+}
+
+/// Frame handler abstraction.
+pub(crate) struct Frame {
+    /// The size of the entire local area; the arguments plus the function defined locals.
+    pub locals_size: u32,
+
+    /// The range in the frame corresponding to the defined locals range.
+    pub defined_locals_range: DefinedLocalsRange,
+
+    /// The local slots for the current function.
+    ///
+    /// Locals get calculated when allocating a frame and are readonly
+    /// through the function compilation lifetime.
+    pub locals: Locals,
+
+    /// The offset to the slot containing the `VMContext`.
+    pub vmctx_slot: LocalSlot,
+
+    /// The slot holding the address of the results area.
+    pub results_base_slot: Option<LocalSlot>,
+}
+
+impl Frame {
+    /// Allocate a new [`Frame`].
+    pub fn new<A: ABI>(sig: &ABISig, defined_locals: &DefinedLocals) -> Result<Self> {
+        let (mut locals, defined_locals_start) = Self::compute_arg_slots::<A>(sig)?;
+
+        // The defined locals have a zero-based offset by default
+        // so we need to add the defined locals start to the offset.
+        locals.extend(
+            defined_locals
+                .defined_locals
+                .iter()
+                .map(|l| LocalSlot::new(l.ty, l.offset + defined_locals_start)),
+        );
+
+        // Align the locals to add a slot for the VMContext pointer.
+        let ptr_size = <A as ABI>::word_bytes();
+        let vmctx_offset =
+            align_to(defined_locals_start + defined_locals.stack_size, ptr_size) + ptr_size;
+
+        let (results_base_slot, locals_size) = if sig.params.has_retptr() {
+            match sig.params.unwrap_results_area_operand() {
+                ABIOperand::Stack { ty, offset, .. } => (
+                    Some(LocalSlot::stack_arg(
+                        *ty,
+                        *offset + (<A as ABI>::arg_base_offset() as u32),
+                    )),
+                    align_to(vmctx_offset, <A as ABI>::stack_align().into()),
+                ),
+                ABIOperand::Reg { ty, .. } => {
+                    let offs = align_to(vmctx_offset, ptr_size) + ptr_size;
+                    (
+                        Some(LocalSlot::new(*ty, offs)),
+                        align_to(offs, <A as ABI>::stack_align().into()),
+                    )
+                }
+            }
+        } else {
+            (
+                None,
+                align_to(vmctx_offset, <A as ABI>::stack_align().into()),
+            )
+        };
+
+        Ok(Self {
+            locals,
+            locals_size,
+            vmctx_slot: LocalSlot::i64(vmctx_offset),
+            defined_locals_range: DefinedLocalsRange(
+                defined_locals_start..(defined_locals_start + defined_locals.stack_size),
+            ),
+            results_base_slot,
+        })
+    }
+
+    /// Get a local slot.
+    pub fn get_local(&self, index: u32) -> Option<&LocalSlot> {
+        self.locals.get(index as usize)
+    }
+
+    /// Returns the address of the local at the given index.
+    ///
+    /// # Panics
+    /// This function panics if the the index is not associated to a local.
+    pub fn get_local_address<M: MacroAssembler>(
+        &self,
+        index: u32,
+        masm: &mut M,
+    ) -> (WasmType, M::Address) {
+        self.get_local(index)
+            .map(|slot| (slot.ty, masm.local_address(slot)))
+            .unwrap_or_else(|| panic!("Invalid local slot: {}", index))
+    }
+
+    fn compute_arg_slots<A: ABI>(sig: &ABISig) -> Result<(Locals, u32)> {
+        // Go over the function ABI-signature and
+        // calculate the stack slots.
+        //
+        //  for each parameter p; when p
+        //
+        //  Stack =>
+        //      The slot offset is calculated from the ABIOperand offset
+        //      relative the to the frame pointer (and its inclusions, e.g.
+        //      return address).
+        //
+        //  Register =>
+        //     The slot is calculated by accumulating into the `next_frame_size`
+        //     the size + alignment of the type that the register is holding.
+        //
+        //  NOTE
+        //      This implementation takes inspiration from SpiderMonkey's implementation
+        //      to calculate local slots for function arguments
+        //      (https://searchfox.org/mozilla-central/source/js/src/wasm/WasmBCFrame.cpp#83).
+        //      The main difference is that SpiderMonkey's implementation
+        //      doesn't append any sort of metadata to the locals regarding stack
+        //      addressing mode (stack pointer or frame pointer), the offset is
+        //      declared negative if the local belongs to a stack argument;
+        //      that's enough to later calculate address of the local later on.
+        //
+        //      Winch appends an addressing mode to each slot, in the end
+        //      we want positive addressing from the stack pointer
+        //      for both locals and stack arguments.
+
+        let arg_base_offset = <A as ABI>::arg_base_offset().into();
+        let mut next_stack = 0u32;
+
+        // Skip the results base param; if present, the [Frame] will create
+        // a dedicated slot for it.
+        let slots: Locals = sig
+            .params_without_retptr()
+            .into_iter()
+            .map(|arg| Self::abi_arg_slot(&arg, &mut next_stack, arg_base_offset))
+            .collect();
+
+        Ok((slots, next_stack))
+    }
+
+    fn abi_arg_slot(arg: &ABIOperand, next_stack: &mut u32, arg_base_offset: u32) -> LocalSlot {
+        match arg {
+            // Create a local slot, for input register spilling,
+            // with type-size aligned access.
+            ABIOperand::Reg { ty, size, .. } => {
+                *next_stack = align_to(*next_stack, *size) + *size;
+                LocalSlot::new(*ty, *next_stack)
+            }
+            // Create a local slot, with an offset from the arguments base in
+            // the stack; which is the frame pointer + return address.
+            ABIOperand::Stack { ty, offset, .. } => {
+                LocalSlot::stack_arg(*ty, offset + arg_base_offset)
+            }
+        }
+    }
+}

data/ext/cargo-vendor/winch-codegen-0.14.0/src/isa/aarch64/abi.rs

@@ -0,0 +1,313 @@
+use super::regs;
+use crate::abi::{align_to, ABIOperand, ABIParams, ABIResults, ABISig, ParamsOrReturns, ABI};
+use crate::isa::{reg::Reg, CallingConvention};
+use crate::masm::OperandSize;
+use smallvec::SmallVec;
+use wasmtime_environ::{WasmFuncType, WasmHeapType, WasmType};
+
+#[derive(Default)]
+pub(crate) struct Aarch64ABI;
+
+/// Helper environment to track argument-register
+/// assignment in aarch64.
+///
+/// The first element tracks the general purpose register index, capped at 7 (x0-x7).
+/// The second element tracks the floating point register index, capped at 7 (v0-v7).
+// Follows
+// https://github.com/ARM-software/abi-aa/blob/2021Q1/aapcs64/aapcs64.rst#64parameter-passing
+struct RegIndexEnv {
+    xregs: u8,
+    vregs: u8,
+    limit: u8,
+}
+
+impl Default for RegIndexEnv {
+    fn default() -> Self {
+        Self {
+            xregs: 0,
+            vregs: 0,
+            limit: 8,
+        }
+    }
+}
+
+impl RegIndexEnv {
+    fn with_limit(limit: u8) -> Self {
+        let mut default = Self::default();
+        default.limit = limit;
+        default
+    }
+
+    fn next_xreg(&mut self) -> Option<u8> {
+        if self.xregs < self.limit {
+            return Some(Self::increment(&mut self.xregs));
+        }
+
+        None
+    }
+
+    fn next_vreg(&mut self) -> Option<u8> {
+        if self.vregs < self.limit {
+            return Some(Self::increment(&mut self.vregs));
+        }
+
+        None
+    }
+
+    fn increment(index: &mut u8) -> u8 {
+        let current = *index;
+        *index += 1;
+        current
+    }
+}
+
+impl ABI for Aarch64ABI {
+    // TODO change to 16 once SIMD is supported
+    fn stack_align() -> u8 {
+        8
+    }
+
+    fn call_stack_align() -> u8 {
+        16
+    }
+
+    fn arg_base_offset() -> u8 {
+        16
+    }
+
+    fn ret_addr_offset() -> u8 {
+        8
+    }
+
+    fn word_bits() -> u32 {
+        64
+    }
+
+    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig {
+        Self::sig_from(wasm_sig.params(), wasm_sig.returns(), call_conv)
+    }
+
+    fn sig_from(
+        params: &[WasmType],
+        returns: &[WasmType],
+        call_conv: &CallingConvention,
+    ) -> ABISig {
+        assert!(call_conv.is_apple_aarch64() || call_conv.is_default());
+
+        let mut params_index_env = RegIndexEnv::default();
+        let results = Self::abi_results(returns, call_conv);
+        let params = ABIParams::from::<_, Self>(
+            params,
+            0,
+            results.has_stack_results(),
+            |ty, stack_offset| {
+                Self::to_abi_operand(
+                    ty,
+                    stack_offset,
+                    &mut params_index_env,
+                    ParamsOrReturns::Params,
+                )
+            },
+        );
+
+        ABISig::new(params, results)
+    }
+
+    fn abi_results(returns: &[WasmType], call_conv: &CallingConvention) -> ABIResults {
+        assert!(call_conv.is_apple_aarch64() || call_conv.is_default());
+
+        let mut returns_index_env = RegIndexEnv::with_limit(1);
+        ABIResults::from(returns, call_conv, |ty, stack_offset| {
+            Self::to_abi_operand(
+                ty,
+                stack_offset,
+                &mut returns_index_env,
+                ParamsOrReturns::Returns,
+            )
+        })
+    }
+
+    fn scratch_reg() -> Reg {
+        regs::scratch()
+    }
+
+    fn float_scratch_reg() -> Reg {
+        todo!()
+    }
+
+    fn sp_reg() -> Reg {
+        todo!()
+    }
+
+    fn fp_reg() -> Reg {
+        regs::fp()
+    }
+
+    fn vmctx_reg() -> Reg {
+        regs::xreg(9)
+    }
+
+    fn callee_saved_regs(_call_conv: &CallingConvention) -> SmallVec<[(Reg, OperandSize); 18]> {
+        regs::callee_saved()
+    }
+
+    fn stack_slot_size() -> u32 {
+        Self::word_bytes()
+    }
+
+    fn sizeof(ty: &WasmType) -> u32 {
+        match ty {
+            WasmType::Ref(rt) => match rt.heap_type {
+                WasmHeapType::Func => Self::word_bytes(),
+                ht => unimplemented!("Support for WasmHeapType: {ht}"),
+            },
+            WasmType::F64 | WasmType::I64 => Self::word_bytes(),
+            WasmType::F32 | WasmType::I32 => Self::word_bytes() / 2,
+            ty => unimplemented!("Support for WasmType: {ty}"),
+        }
+    }
+}
+
+impl Aarch64ABI {
+    fn to_abi_operand(
+        wasm_arg: &WasmType,
+        stack_offset: u32,
+        index_env: &mut RegIndexEnv,
+        params_or_returns: ParamsOrReturns,
+    ) -> (ABIOperand, u32) {
+        let (reg, ty) = match wasm_arg {
+            ty @ (WasmType::I32 | WasmType::I64) => (index_env.next_xreg().map(regs::xreg), ty),
+
+            ty @ (WasmType::F32 | WasmType::F64) => (index_env.next_vreg().map(regs::vreg), ty),
+
+            ty => unreachable!("Unsupported argument type {:?}", ty),
+        };
+
+        let ty_size = <Self as ABI>::sizeof(wasm_arg);
+        let default = || {
+            let arg = ABIOperand::stack_offset(stack_offset, *ty, ty_size);
+            let slot_size = Self::stack_slot_size();
+            // Stack slots for parameters are aligned to a fixed slot size,
+            // in the case of Aarch64, 8 bytes.
+            // Stack slots for returns are type-size aligned.
+            let next_stack = if params_or_returns == ParamsOrReturns::Params {
+                align_to(stack_offset, slot_size) + slot_size
+            } else {
+                align_to(stack_offset, ty_size) + ty_size
+            };
+            (arg, next_stack)
+        };
+        reg.map_or_else(default, |reg| {
+            (ABIOperand::reg(reg, *ty, ty_size), stack_offset)
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Aarch64ABI, RegIndexEnv};
+    use crate::{
+        abi::{ABIOperand, ABI},
+        isa::aarch64::regs,
+        isa::reg::Reg,
+        isa::CallingConvention,
+    };
+    use wasmtime_environ::{
+        WasmFuncType,
+        WasmType::{self, *},
+    };
+
+    #[test]
+    fn test_get_next_reg_index() {
+        let mut index_env = RegIndexEnv::default();
+        assert_eq!(index_env.next_xreg(), Some(0));
+        assert_eq!(index_env.next_vreg(), Some(0));
+        assert_eq!(index_env.next_xreg(), Some(1));
+        assert_eq!(index_env.next_vreg(), Some(1));
+        assert_eq!(index_env.next_xreg(), Some(2));
+        assert_eq!(index_env.next_vreg(), Some(2));
+    }
+
+    #[test]
+    fn xreg_abi_sig() {
+        let wasm_sig = WasmFuncType::new(
+            [I32, I64, I32, I64, I32, I32, I64, I32, I64].into(),
+            [].into(),
+        );
+
+        let sig = Aarch64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+
+        match_reg_arg(params.get(0).unwrap(), I32, regs::xreg(0));
+        match_reg_arg(params.get(1).unwrap(), I64, regs::xreg(1));
+        match_reg_arg(params.get(2).unwrap(), I32, regs::xreg(2));
+        match_reg_arg(params.get(3).unwrap(), I64, regs::xreg(3));
+        match_reg_arg(params.get(4).unwrap(), I32, regs::xreg(4));
+        match_reg_arg(params.get(5).unwrap(), I32, regs::xreg(5));
+        match_reg_arg(params.get(6).unwrap(), I64, regs::xreg(6));
+        match_reg_arg(params.get(7).unwrap(), I32, regs::xreg(7));
+        match_stack_arg(params.get(8).unwrap(), I64, 0);
+    }
+
+    #[test]
+    fn vreg_abi_sig() {
+        let wasm_sig = WasmFuncType::new(
+            [F32, F64, F32, F64, F32, F32, F64, F32, F64].into(),
+            [].into(),
+        );
+
+        let sig = Aarch64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+
+        match_reg_arg(params.get(0).unwrap(), F32, regs::vreg(0));
+        match_reg_arg(params.get(1).unwrap(), F64, regs::vreg(1));
+        match_reg_arg(params.get(2).unwrap(), F32, regs::vreg(2));
+        match_reg_arg(params.get(3).unwrap(), F64, regs::vreg(3));
+        match_reg_arg(params.get(4).unwrap(), F32, regs::vreg(4));
+        match_reg_arg(params.get(5).unwrap(), F32, regs::vreg(5));
+        match_reg_arg(params.get(6).unwrap(), F64, regs::vreg(6));
+        match_reg_arg(params.get(7).unwrap(), F32, regs::vreg(7));
+        match_stack_arg(params.get(8).unwrap(), F64, 0);
+    }
+
+    #[test]
+    fn mixed_abi_sig() {
+        let wasm_sig = WasmFuncType::new(
+            [F32, I32, I64, F64, I32, F32, F64, F32, F64].into(),
+            [].into(),
+        );
+
+        let sig = Aarch64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+
+        match_reg_arg(params.get(0).unwrap(), F32, regs::vreg(0));
+        match_reg_arg(params.get(1).unwrap(), I32, regs::xreg(0));
+        match_reg_arg(params.get(2).unwrap(), I64, regs::xreg(1));
+        match_reg_arg(params.get(3).unwrap(), F64, regs::vreg(1));
+        match_reg_arg(params.get(4).unwrap(), I32, regs::xreg(2));
+        match_reg_arg(params.get(5).unwrap(), F32, regs::vreg(2));
+        match_reg_arg(params.get(6).unwrap(), F64, regs::vreg(3));
+        match_reg_arg(params.get(7).unwrap(), F32, regs::vreg(4));
+        match_reg_arg(params.get(8).unwrap(), F64, regs::vreg(5));
+    }
+
+    fn match_reg_arg(abi_arg: &ABIOperand, expected_ty: WasmType, expected_reg: Reg) {
+        match abi_arg {
+            &ABIOperand::Reg { reg, ty, .. } => {
+                assert_eq!(reg, expected_reg);
+                assert_eq!(ty, expected_ty);
+            }
+            stack => panic!("Expected reg argument, got {:?}", stack),
+        }
+    }
+
+    fn match_stack_arg(abi_arg: &ABIOperand, expected_ty: WasmType, expected_offset: u32) {
+        match abi_arg {
+            &ABIOperand::Stack { offset, ty, .. } => {
+                assert_eq!(offset, expected_offset);
+                assert_eq!(ty, expected_ty);
+            }
+            reg => panic!("Expected stack argument, got {:?}", reg),
+        }
+    }
+}