wasmtime 12.0.1 → 13.0.0

data/ext/cargo-vendor/winch-codegen-0.11.0/src/abi/mod.rs

@@ -0,0 +1,269 @@
+//! This module provides all the necessary building blocks for
+//! implementing ISA specific ABIs.
+//!
+//! # Default ABI
+//!
+//! Winch uses a default internal ABI, for all internal functions.
+//! This allows us to push the complexity of system ABI compliance to
+//! the trampolines (not yet implemented).  The default ABI treats all
+//! allocatable registers as caller saved, which means that (i) all
+//! register values in the Wasm value stack (which are normally
+//! referred to as "live"), must be saved onto the machine stack (ii)
+//! function prologues and epilogues don't store/restore other
+//! registers more than the non-allocatable ones (e.g. rsp/rbp in
+//! x86_64).
+//!
+//! The calling convention in the default ABI, uses registers to a
+//! certain fixed count for arguments and return values, and then the
+//! stack is used for all additional arguments.
+//!
+//! Generally the stack layout looks like:
+//! +-------------------------------+
+//! |                               |
+//! |                               |
+//! |         Stack Args            |
+//! |                               |
+//! |                               |
+//! +-------------------------------+----> SP @ function entry
+//! |         Ret addr              |
+//! +-------------------------------+
+//! |            SP                 |
+//! +-------------------------------+----> SP @ Function prologue
+//! |                               |
+//! |                               |
+//! |                               |
+//! |        Stack slots            |
+//! |        + `VMContext` slot     |
+//! |        + dynamic space        |
+//! |                               |
+//! |                               |
+//! |                               |
+//! +-------------------------------+----> SP @ callsite (after)
+//! |        alignment              |
+//! |        + arguments            |
+//! |                               | ----> Space allocated for calls
+//! |                               |
+use crate::isa::{reg::Reg, CallingConvention};
+use crate::masm::OperandSize;
+use smallvec::SmallVec;
+use std::ops::{Add, BitAnd, Not, Sub};
+use wasmtime_environ::{WasmFuncType, WasmType};
+
+pub(crate) mod local;
+pub(crate) use local::*;
+
+/// Trait implemented by a specific ISA and used to provide
+/// information about alignment, parameter passing, usage of
+/// specific registers, etc.
+pub(crate) trait ABI {
+    /// The required stack alignment.
+    fn stack_align() -> u8;
+
+    /// The required stack alignment for calls.
+    fn call_stack_align() -> u8;
+
+    /// The offset to the argument base, relative to the frame pointer.
+    fn arg_base_offset() -> u8;
+
+    /// The offset to the return address, relative to the frame pointer.
+    fn ret_addr_offset() -> u8;
+
+    /// Construct the ABI-specific signature from a WebAssembly
+    /// function type.
+    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig;
+
+    /// Construct the ABI-specific result from a slice of
+    /// [`wasmtime_environ::WasmtType`].
+    fn result(returns: &[WasmType], call_conv: &CallingConvention) -> ABIResult;
+
+    /// Returns the number of bits in a word.
+    fn word_bits() -> u32;
+
+    /// Returns the number of bytes in a word.
+    fn word_bytes() -> u32 {
+        Self::word_bits() / 8
+    }
+
+    /// Returns the designated scratch register.
+    fn scratch_reg() -> Reg;
+
+    /// Returns the frame pointer register.
+    fn fp_reg() -> Reg;
+
+    /// Returns the stack pointer register.
+    fn sp_reg() -> Reg;
+
+    /// Returns the pinned register used to hold
+    /// the `VMContext`.
+    fn vmctx_reg() -> Reg;
+
+    /// Returns the callee-saved registers for the given
+    /// calling convention.
+    fn callee_saved_regs(call_conv: &CallingConvention) -> SmallVec<[(Reg, OperandSize); 18]>;
+
+    /// Returns the size of each argument stack slot per argument type.
+    fn stack_arg_slot_size_for_type(ty: WasmType) -> u32;
+}
+
+/// ABI-specific representation of a function argument.
+#[derive(Debug)]
+pub(crate) enum ABIArg {
+    /// A register argument.
+    Reg {
+        /// Type of the argument.
+        ty: WasmType,
+        /// Register holding the argument.
+        reg: Reg,
+    },
+    /// A stack argument.
+    Stack {
+        /// The type of the argument.
+        ty: WasmType,
+        /// Offset of the argument relative to the frame pointer.
+        offset: u32,
+    },
+}
+
+impl ABIArg {
+    /// Allocate a new register abi arg.
+    pub fn reg(reg: Reg, ty: WasmType) -> Self {
+        Self::Reg { reg, ty }
+    }
+
+    /// Allocate a new stack abi arg.
+    pub fn stack_offset(offset: u32, ty: WasmType) -> Self {
+        Self::Stack { ty, offset }
+    }
+
+    /// Is this abi arg in a register.
+    pub fn is_reg(&self) -> bool {
+        match *self {
+            ABIArg::Reg { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Get the register associated to this arg.
+    pub fn get_reg(&self) -> Option<Reg> {
+        match *self {
+            ABIArg::Reg { reg, .. } => Some(reg),
+            _ => None,
+        }
+    }
+
+    /// Get the type associated to this arg.
+    pub fn ty(&self) -> WasmType {
+        match *self {
+            ABIArg::Reg { ty, .. } | ABIArg::Stack { ty, .. } => ty,
+        }
+    }
+}
+
+/// ABI-specific representation of the function result.
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum ABIResult {
+    Void,
+    Reg {
+        /// Type of the result.
+        ty: WasmType,
+        /// Register to hold the result.
+        reg: Reg,
+    },
+}
+
+impl Default for ABIResult {
+    fn default() -> Self {
+        Self::Void
+    }
+}
+
+impl ABIResult {
+    /// Create a register ABI result.
+    pub fn reg(ty: WasmType, reg: Reg) -> Self {
+        Self::Reg { ty, reg }
+    }
+
+    /// Createa void ABI result.
+    pub fn void() -> Self {
+        Self::Void
+    }
+
+    /// Get the result reg.
+    pub fn result_reg(&self) -> Option<Reg> {
+        match self {
+            Self::Reg { reg, .. } => Some(*reg),
+            _ => None,
+        }
+    }
+
+    /// Checks if the result is void.
+    pub fn is_void(&self) -> bool {
+        match self {
+            Self::Void => true,
+            _ => false,
+        }
+    }
+
+    /// Returns the length of the result.
+    pub fn len(&self) -> usize {
+        if self.is_void() {
+            0
+        } else {
+            1
+        }
+    }
+}
+
+pub(crate) type ABIParams = SmallVec<[ABIArg; 6]>;
+
+/// An ABI-specific representation of a function signature.
+pub(crate) struct ABISig {
+    /// Function parameters.
+    pub params: ABIParams,
+    /// Function result.
+    pub result: ABIResult,
+    /// Stack space needed for stack arguments.
+    pub stack_bytes: u32,
+}
+
+impl ABISig {
+    /// Create a new ABI signature.
+    pub fn new(params: ABIParams, result: ABIResult, stack_bytes: u32) -> Self {
+        Self {
+            params,
+            result,
+            stack_bytes,
+        }
+    }
+}
+
+/// Returns the size in bytes of a given WebAssembly type.
+pub(crate) fn ty_size(ty: &WasmType) -> u32 {
+    match *ty {
+        WasmType::I32 | WasmType::F32 => 4,
+        WasmType::I64 | WasmType::F64 => 8,
+        _ => panic!(),
+    }
+}
+
+/// Align a value up to the given power-of-two-alignment.
+// See https://sites.google.com/site/theoryofoperatingsystems/labs/malloc/align8
+pub(crate) fn align_to<N>(value: N, alignment: N) -> N
+where
+    N: Not<Output = N>
+        + BitAnd<N, Output = N>
+        + Add<N, Output = N>
+        + Sub<N, Output = N>
+        + From<u8>
+        + Copy,
+{
+    let alignment_mask = alignment - 1.into();
+    (value + alignment_mask) & !alignment_mask
+}
+
+/// Calculates the delta needed to adjust a function's frame plus some
+/// addend to a given alignment.
+pub(crate) fn calculate_frame_adjustment(frame_size: u32, addend: u32, alignment: u32) -> u32 {
+    let total = frame_size + addend;
+    (alignment - (total % alignment)) % alignment
+}

data/ext/cargo-vendor/winch-codegen-0.11.0/src/codegen/call.rs

@@ -0,0 +1,219 @@
+//! Function call emission.  For more details around the ABI and
+//! calling convention, see [ABI].
+use crate::{
+    abi::{ABIArg, ABISig, ABI},
+    codegen::CodeGenContext,
+    masm::{CalleeKind, MacroAssembler, OperandSize},
+    reg::Reg,
+};
+use wasmtime_environ::FuncIndex;
+
+/// All the information needed to emit a function call.
+pub(crate) struct FnCall<'a> {
+    /// The stack space consumed by the function call; that is,
+    /// the sum of:
+    ///
+    /// 1. The amount of stack space created by saving any live
+    ///    registers at the callsite.
+    /// 2. The amount of space used by any memory entries in the value
+    ///    stack present at the callsite, that will be used as
+    ///    arguments for the function call. Any memory values in the
+    ///    value stack that are needed as part of the function
+    ///    arguments, will be consumed by the function call (either by
+    ///    assigning those values to a register or by storing those
+    ///    values to a memory location if the callee argument is on
+    ///    the stack), so we track that stack space to reclaim it once
+    ///    the function call has ended. This could also be done in
+    ///    `assign_args` everytime a memory entry needs to be assigned
+    ///    to a particular location, but doing so, will incur in more
+    ///    instructions (e.g. a pop per argument that needs to be
+    ///    assigned); it's more efficient to track the space needed by
+    ///    those memory values and reclaim it at once.
+    ///
+    /// The machine stack throghout the function call is as follows:
+    /// ┌──────────────────────────────────────────────────┐
+    /// │                                                  │
+    /// │                  1                               │
+    /// │  Stack space created by any previous spills      │
+    /// │  from the value stack; and which memory values   │
+    /// │  are used as function arguments.                 │
+    /// │                                                  │
+    /// ├──────────────────────────────────────────────────┤ ---> The Wasm value stack at this point in time would look like:
+    /// │                                                  │      [ Reg | Reg | Mem(offset) | Mem(offset) ]
+    /// │                   2                              │
+    /// │   Stack space created by saving                  │
+    /// │   any live registers at the callsite.            │
+    /// │                                                  │
+    /// │                                                  │
+    /// ├─────────────────────────────────────────────────┬┤ ---> The Wasm value stack at this point in time would look like:
+    /// │                                                  │      [ Mem(offset) | Mem(offset) | Mem(offset) | Mem(offset) ]
+    /// │                                                  │      Assuming that the callee takes 4 arguments, we calculate
+    /// │                                                  │      2 spilled registers + 2 memory values; all of which will be used
+    /// │   Stack space allocated for                      │      as arguments to the call via `assign_args`, thus the memory they represent is
+    /// │   the callee function arguments in the stack;    │      is considered to be consumed by the call.
+    /// │   represented by `arg_stack_space`               │
+    /// │                                                  │
+    /// │                                                  │
+    /// │                                                  │
+    /// └──────────────────────────────────────────────────┘ ------> Stack pointer when emitting the call
+    ///
+    call_stack_space: u32,
+    /// The total stack space needed for the callee arguments on the
+    /// stack, including any adjustments to the function's frame and
+    /// aligned to to the required ABI alignment.
+    arg_stack_space: u32,
+    /// The ABI-specific signature of the callee.
+    abi_sig: &'a ABISig,
+}
+
+impl<'a> FnCall<'a> {
+    /// Allocate and setup a new function call.
+    ///
+    /// The setup process, will first save all the live registers in
+    /// the value stack, tracking down those spilled for the function
+    /// arguments(see comment below for more details) it will also
+    /// track all the memory entries consumed by the function
+    /// call. Then, it will calculate any adjustments needed to ensure
+    /// the alignment of the caller's frame.  It's important to note
+    /// that the order of operations in the setup is important, as we
+    /// want to calculate any adjustments to the caller's frame, after
+    /// having saved any live registers, so that we can account for
+    /// any pushes generated by register spilling.
+    pub fn new<M: MacroAssembler>(
+        callee_sig: &'a ABISig,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+    ) -> Self {
+        let stack = &context.stack;
+        let arg_stack_space = callee_sig.stack_bytes;
+        let callee_params = &callee_sig.params;
+
+        let call_stack_space = match callee_params.len() {
+            0 => {
+                let _ = context.save_live_registers_and_calculate_sizeof(masm, ..);
+                0u32
+            }
+            _ => {
+                // Here we perform a "spill" of the register entries
+                // in the Wasm value stack, we also count any memory
+                // values that will be used used as part of the callee
+                // arguments.  Saving the live registers is done by
+                // emitting push operations for every `Reg` entry in
+                // the Wasm value stack. We do this to be compliant
+                // with Winch's internal ABI, in which all registers
+                // are treated as caller-saved. For more details, see
+                // [ABI].
+                //
+                // The next few lines, partition the value stack into
+                // two sections:
+                // +------------------+--+--- (Stack top)
+                // |                  |  |
+                // |                  |  | 1. The top `n` elements, which are used for
+                // |                  |  |    function arguments; for which we save any
+                // |                  |  |    live registers, keeping track of the amount of registers
+                // +------------------+  |    saved plus the amount of memory values consumed by the function call;
+                // |                  |  |    with this information we can later reclaim the space used by the function call.
+                // |                  |  |
+                // +------------------+--+---
+                // |                  |  | 2. The rest of the items in the stack, for which
+                // |                  |  |    we only save any live registers.
+                // |                  |  |
+                // +------------------+  |
+                assert!(stack.len() >= callee_params.len());
+                let partition = stack.len() - callee_params.len();
+                let _ = context.save_live_registers_and_calculate_sizeof(masm, 0..partition);
+                context.save_live_registers_and_calculate_sizeof(masm, partition..)
+            }
+        };
+
+        Self {
+            abi_sig: &callee_sig,
+            arg_stack_space,
+            call_stack_space,
+        }
+    }
+
+    /// Emit a direct function call, to a locally defined function.
+    pub fn direct<M: MacroAssembler>(
+        &self,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+        callee: FuncIndex,
+    ) {
+        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
+            self.assign_args(context, masm, <M::ABI as ABI>::scratch_reg());
+            CalleeKind::Direct(callee.as_u32())
+        });
+        self.post_call::<M>(masm, context, reserved_stack);
+    }
+
+    /// Emit an indirect function call, using a raw address.
+    pub fn indirect<M: MacroAssembler>(
+        &self,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+        addr: M::Address,
+    ) {
+        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
+            let scratch = <M::ABI as ABI>::scratch_reg();
+            self.assign_args(context, masm, scratch);
+            masm.load(addr, scratch, OperandSize::S64);
+            CalleeKind::Indirect(scratch)
+        });
+        self.post_call::<M>(masm, context, reserved_stack);
+    }
+
+    fn post_call<M: MacroAssembler>(&self, masm: &mut M, context: &mut CodeGenContext, size: u32) {
+        masm.free_stack(self.call_stack_space + size);
+        // Only account for registers given that any memory entries
+        // consumed by the call (assigned to a register or to a stack
+        // slot) were freed by the previous call to
+        // `masm.free_stack`, so we only care about dropping them
+        // here.
+        //
+        // NOTE / TODO there's probably a path to getting rid of
+        // `save_live_registers_and_calculate_sizeof` and
+        // `call_stack_space`, making it a bit more obvious what's
+        // happening here. We could:
+        //
+        // * Modify the `spill` implementation so that it takes a
+        // filtering callback, to control which values the caller is
+        // interested in saving (e.g. save all if no function is provided)
+        // * Rely on the new implementation of `drop_last` to calcuate
+        // the stack memory entries consumed by the call and then free
+        // the calculated stack space.
+        context.drop_last(self.abi_sig.params.len(), |regalloc, v| {
+            if v.is_reg() {
+                regalloc.free(v.get_reg().into());
+            }
+        });
+        context.push_abi_results(&self.abi_sig.result, masm);
+    }
+
+    fn assign_args<M: MacroAssembler>(
+        &self,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+        scratch: Reg,
+    ) {
+        let arg_count = self.abi_sig.params.len();
+        let stack = &context.stack;
+        let mut stack_values = stack.peekn(arg_count);
+        for arg in &self.abi_sig.params {
+            let val = stack_values
+                .next()
+                .unwrap_or_else(|| panic!("expected stack value for function argument"));
+            match &arg {
+                &ABIArg::Reg { ty: _, reg } => {
+                    context.move_val_to_reg(&val, *reg, masm);
+                }
+                &ABIArg::Stack { ty, offset } => {
+                    let addr = masm.address_at_sp(*offset);
+                    let size: OperandSize = (*ty).into();
+                    context.move_val_to_reg(val, scratch, masm);
+                    masm.store(scratch.into(), addr, size);
+                }
+            }
+        }
+    }
+}