wasmtime 15.0.1 → 16.0.0

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

@@ -1,436 +0,0 @@
-use crate::{
-    abi::{ABISig, ABI},
-    isa::reg::Reg,
-    masm::{IntCmpKind, MacroAssembler, OperandSize, RegImm, TrapCode},
-    stack::{TypedReg, Val},
-};
-use anyhow::Result;
-use smallvec::SmallVec;
-use wasmparser::{BinaryReader, FuncValidator, Operator, ValidatorResources, VisitOperator};
-use wasmtime_environ::{PtrSize, TableIndex, TypeIndex, WasmHeapType, WasmType, FUNCREF_MASK};
-
-mod context;
-pub(crate) use context::*;
-mod env;
-pub use env::*;
-mod call;
-pub(crate) use call::*;
-mod control;
-pub(crate) use control::*;
-mod builtin;
-pub use builtin::*;
-
-/// The code generation abstraction.
-pub(crate) struct CodeGen<'a, 'translation: 'a, 'data: 'translation, M>
-where
-    M: MacroAssembler,
-{
-    /// The ABI-specific representation of the function signature, excluding results.
-    sig: ABISig,
-
-    /// The code generation context.
-    pub context: CodeGenContext<'a, 'translation>,
-
-    /// A reference to the function compilation environment.
-    pub env: FuncEnv<'a, 'translation, 'data, M::Ptr>,
-
-    /// The MacroAssembler.
-    pub masm: &'a mut M,
-
-    /// Stack frames for control flow.
-    // NB The 64 is set arbitrarily, we can adjust it as
-    // we see fit.
-    pub control_frames: SmallVec<[ControlStackFrame; 64]>,
-}
-
-impl<'a, 'translation, 'data, M> CodeGen<'a, 'translation, 'data, M>
-where
-    M: MacroAssembler,
-{
-    pub fn new(
-        masm: &'a mut M,
-        context: CodeGenContext<'a, 'translation>,
-        env: FuncEnv<'a, 'translation, 'data, M::Ptr>,
-        sig: ABISig,
-    ) -> Self {
-        Self {
-            sig,
-            context,
-            masm,
-            env,
-            control_frames: Default::default(),
-        }
-    }
-
-    /// Emit the function body to machine code.
-    pub fn emit(
-        &mut self,
-        body: &mut BinaryReader<'a>,
-        validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<()> {
-        self.emit_start()
-            .and_then(|_| self.emit_body(body, validator))
-            .and_then(|_| self.emit_end())?;
-
-        Ok(())
-    }
-
-    // TODO stack checks
-    fn emit_start(&mut self) -> Result<()> {
-        self.masm.prologue();
-        self.masm.reserve_stack(self.context.frame.locals_size);
-
-        // Once we have emitted the epilogue and reserved stack space for the locals, we push the
-        // base control flow block.
-        self.control_frames
-            .push(ControlStackFrame::function_body_block(
-                self.sig.result,
-                self.masm,
-                &mut self.context,
-            ));
-        Ok(())
-    }
-
-    /// The following two helpers, handle else or end instructions when the
-    /// compiler has entered into an unreachable code state. These instructions
-    /// must be observed to determine if the reachability state should be
-    /// restored.
-    ///
-    /// When the compiler is in an unreachable state, all the other instructions
-    /// are not visited.
-    pub fn handle_unreachable_else(&mut self) {
-        let frame = self.control_frames.last_mut().unwrap();
-        match frame {
-            ControlStackFrame::If {
-                reachable,
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => {
-                if *reachable {
-                    // We entered an unreachable state when compiling the
-                    // if-then branch, but if the `if` was reachable at
-                    // entry, the if-else branch will be reachable.
-                    self.context.reachable = true;
-                    // Reset the stack to the original length and offset.
-                    Self::reset_stack(
-                        &mut self.context,
-                        self.masm,
-                        *original_stack_len,
-                        *original_sp_offset,
-                    );
-                    frame.bind_else(self.masm, self.context.reachable);
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    pub fn handle_unreachable_end(&mut self) {
-        let frame = self.control_frames.pop().unwrap();
-        // We just popped the outermost block.
-        let is_outermost = self.control_frames.len() == 0;
-        if frame.is_next_sequence_reachable() {
-            self.context.reachable = true;
-
-            let (value_stack_len, target_sp) = frame.original_stack_len_and_sp_offset();
-            // Reset the stack to the original length and offset.
-            Self::reset_stack(&mut self.context, self.masm, value_stack_len, target_sp);
-            // If the current frame is the outermost frame, which corresponds to the
-            // current function's body, only bind the exit label as we don't need to
-            // push any more values to the value stack, else perform the entire `bind_end`
-            // process, which involves pushing results to the value stack.
-            if is_outermost {
-                frame.bind_exit_label(self.masm);
-            } else {
-                frame.bind_end(self.masm, &mut self.context);
-            }
-        } else if is_outermost {
-            // If we reach the end of the function in an unreachable
-            // state, perform the necessary cleanup to leave the stack
-            // and SP in the expected state.  The compiler can enter
-            // in this state through an infinite loop.
-            let (value_stack_len, target_sp) = frame.original_stack_len_and_sp_offset();
-            Self::reset_stack(&mut self.context, self.masm, value_stack_len, target_sp);
-        }
-    }
-
-    /// Helper function to reset value and stack pointer to the given length and stack pointer
-    /// offset respectively. This function is only used when restoring the code generation's
-    /// reachabiliy state when handling an unreachable `end` or `else`.
-    pub fn reset_stack(
-        context: &mut CodeGenContext,
-        masm: &mut M,
-        target_stack_len: usize,
-        target_sp: u32,
-    ) {
-        // `CodeGenContext::reset_stack` only gets called when
-        // handling unreachable end or unreachable else, so we only
-        // care about freeing any registers in the provided range.
-        let mut bytes_freed = 0;
-        context.drop_last(
-            context.stack.len() - target_stack_len,
-            |regalloc, val| match val {
-                Val::Reg(tr) => regalloc.free(tr.reg),
-                Val::Memory(m) => bytes_freed += m.slot.size,
-                _ => {}
-            },
-        );
-        if masm.sp_offset() > target_sp {
-            let bytes = masm.sp_offset() - target_sp;
-            assert!(bytes_freed == bytes);
-            masm.free_stack(bytes);
-        }
-    }
-
-    fn emit_body(
-        &mut self,
-        body: &mut BinaryReader<'a>,
-        validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<()> {
-        self.spill_register_arguments();
-        let defined_locals_range = &self.context.frame.defined_locals_range;
-        self.masm.zero_mem_range(defined_locals_range.as_range());
-
-        // Save the vmctx pointer to its local slot in case we need to reload it
-        // at any point.
-        let vmctx_addr = self.masm.local_address(&self.context.frame.vmctx_slot);
-        self.masm.store(
-            <M::ABI as ABI>::vmctx_reg().into(),
-            vmctx_addr,
-            OperandSize::S64,
-        );
-
-        while !body.eof() {
-            let offset = body.original_position();
-            body.visit_operator(&mut ValidateThenVisit(validator.visitor(offset), self))??;
-        }
-        validator.finish(body.original_position())?;
-        return Ok(());
-
-        struct ValidateThenVisit<'a, T, U>(T, &'a mut U);
-
-        macro_rules! validate_then_visit {
-            ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
-                $(
-                    fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output {
-                        self.0.$visit($($($arg.clone()),*)?)?;
-                        // Only visit operators if the compiler is in a reachable code state. If
-                        // the compiler is in an unrechable code state, most of the operators are
-                        // ignored except for If, Block, Loop, Else and End. These operators need
-                        // to be observed in order to keep the control stack frames balanced and to
-                        // determine if reachability should be restored.
-                        let visit_when_unreachable = visit_op_when_unreachable(Operator::$op $({ $($arg: $arg.clone()),* })?);
-                        if self.1.is_reachable() || visit_when_unreachable  {
-                            Ok(self.1.$visit($($($arg),*)?))
-                        } else {
-                            Ok(U::Output::default())
-                        }
-                    }
-                )*
-            };
-        }
-
-        fn visit_op_when_unreachable(op: Operator) -> bool {
-            use Operator::*;
-            match op {
-                If { .. } | Block { .. } | Loop { .. } | Else | End => true,
-                _ => false,
-            }
-        }
-
-        /// Trait to handle reachability state.
-        trait ReachableState {
-            /// Returns true if the current state of the program is reachable.
-            fn is_reachable(&self) -> bool;
-        }
-
-        impl<'a, 'b, 'c, M: MacroAssembler> ReachableState for CodeGen<'a, 'b, 'c, M> {
-            fn is_reachable(&self) -> bool {
-                self.context.reachable
-            }
-        }
-
-        impl<'a, T, U> VisitOperator<'a> for ValidateThenVisit<'_, T, U>
-        where
-            T: VisitOperator<'a, Output = wasmparser::Result<()>>,
-            U: VisitOperator<'a> + ReachableState,
-            U::Output: Default,
-        {
-            type Output = Result<U::Output>;
-
-            wasmparser::for_each_operator!(validate_then_visit);
-        }
-    }
-
-    /// Emits a a series of instructions that will type check a function reference call.
-    pub fn emit_typecheck_funcref(&mut self, funcref_ptr: Reg, type_index: TypeIndex) {
-        let ptr_size: OperandSize = self.env.ptr_type().into();
-        let sig_index_bytes = self.env.vmoffsets.size_of_vmshared_signature_index();
-        let sig_size = OperandSize::from_bytes(sig_index_bytes);
-        let sig_index = self.env.translation.module.types[type_index].unwrap_function();
-        let sig_offset = sig_index
-            .as_u32()
-            .checked_mul(sig_index_bytes.into())
-            .unwrap();
-        let signatures_base_offset = self.env.vmoffsets.vmctx_signature_ids_array();
-        let scratch = <M::ABI as ABI>::scratch_reg();
-        let funcref_sig_offset = self.env.vmoffsets.ptr.vm_func_ref_type_index();
-
-        // Load the signatures address into the scratch register.
-        self.masm.load(
-            self.masm.address_at_vmctx(signatures_base_offset),
-            scratch,
-            ptr_size,
-        );
-
-        // Get the caller id.
-        let caller_id = self.context.any_gpr(self.masm);
-        self.masm.load(
-            self.masm.address_at_reg(scratch, sig_offset),
-            caller_id,
-            sig_size,
-        );
-
-        let callee_id = self.context.any_gpr(self.masm);
-        self.masm.load(
-            self.masm
-                .address_at_reg(funcref_ptr, funcref_sig_offset.into()),
-            callee_id,
-            sig_size,
-        );
-
-        // Typecheck.
-        self.masm.cmp(callee_id.into(), caller_id, OperandSize::S32);
-        self.masm.trapif(IntCmpKind::Ne, TrapCode::BadSignature);
-        self.context.free_reg(callee_id);
-        self.context.free_reg(caller_id);
-    }
-
-    /// Emit the usual function end instruction sequence.
-    fn emit_end(&mut self) -> Result<()> {
-        assert!(self.context.stack.len() == 0);
-        self.masm.epilogue(self.context.frame.locals_size);
-        Ok(())
-    }
-
-    fn spill_register_arguments(&mut self) {
-        use WasmType::*;
-        self.sig
-            .params
-            .iter()
-            .enumerate()
-            .filter(|(_, a)| a.is_reg())
-            .for_each(|(index, arg)| {
-                let ty = arg.ty();
-                let local = self
-                    .context
-                    .frame
-                    .get_local(index as u32)
-                    .expect("valid local slot at location");
-                let addr = self.masm.local_address(local);
-                let src = arg
-                    .get_reg()
-                    .expect("arg should be associated to a register");
-
-                match &ty {
-                    I32 | I64 | F32 | F64 => self.masm.store(src.into(), addr, ty.into()),
-                    Ref(rt) => match rt.heap_type {
-                        WasmHeapType::Func => self.masm.store_ptr(src.into(), addr),
-                        ht => unimplemented!("Support for WasmHeapType: {ht}"),
-                    },
-                    _ => unimplemented!("Support for WasmType {ty}"),
-                }
-            });
-    }
-
-    /// Pops the value at the stack top and assigns it to the local at
-    ///
-    /// the given index, returning the typed register holding the
-    /// source value.
-    pub fn emit_set_local(&mut self, addr: M::Address, size: OperandSize) -> TypedReg {
-        let src = self.context.pop_to_reg(self.masm, None);
-        self.masm.store(RegImm::reg(src.reg), addr, size);
-
-        src
-    }
-
-    pub fn emit_lazy_init_funcref(&mut self, table_index: TableIndex) {
-        let table_data = self.env.resolve_table_data(table_index);
-        let ptr_type = self.env.ptr_type();
-        let builtin = self
-            .context
-            .builtins
-            .table_get_lazy_init_func_ref::<M::ABI, M::Ptr>();
-
-        // Request the builtin's  result register and use it to hold the
-        // table element value. We preemptively request this register to
-        // avoid conflict at the control flow merge below.
-        // Requesting the result register is safe since we know ahead-of-time
-        // the builtin's signature.
-        let elem_value: Reg = self
-            .context
-            .reg(builtin.sig().result.result_reg().unwrap(), self.masm)
-            .into();
-
-        let index = self.context.pop_to_reg(self.masm, None);
-        let base = self.context.any_gpr(self.masm);
-
-        let elem_addr =
-            self.masm
-                .table_elem_address(index.into(), base, &table_data, &mut self.context);
-        self.masm.load_ptr(elem_addr, elem_value);
-        // Free the register used as base, once we have loaded the element
-        // address into the element value register.
-        self.context.free_reg(base);
-
-        let (defined, cont) = (self.masm.get_label(), self.masm.get_label());
-
-        // Push the built-in arguments to the stack.
-        self.context.stack.extend([
-            TypedReg::new(ptr_type, <M::ABI as ABI>::vmctx_reg()).into(),
-            table_index.as_u32().try_into().unwrap(),
-            index.into(),
-        ]);
-
-        self.masm.branch(
-            IntCmpKind::Ne,
-            elem_value.into(),
-            elem_value,
-            defined,
-            ptr_type.into(),
-        );
-        // Free the element value register.
-        // This is safe since the FnCall::emit call below, will ensure
-        // that the result register is placed on the value stack.
-        self.context.free_reg(elem_value);
-        FnCall::emit::<M, M::Ptr, _>(self.masm, &mut self.context, |_| {
-            Callee::Builtin(builtin.clone())
-        });
-
-        // We know the signature of the libcall in this case, so we assert that there's
-        // one element in the stack and that it's  the ABI signature's result register.
-        let top = self.context.stack.peek().unwrap();
-        let top = top.get_reg();
-        debug_assert!(top.reg == elem_value);
-        self.masm.jmp(cont);
-
-        // In the defined case, mask the funcref address in place, by peeking into the
-        // last element of the value stack, which was pushed by the `indirect` function
-        // call above.
-        self.masm.bind(defined);
-        let imm = RegImm::i64(FUNCREF_MASK as i64);
-        let dst = top.into();
-        self.masm.and(dst, dst, imm, top.ty.into());
-
-        self.masm.bind(cont);
-    }
-}
-
-/// Returns the index of the [`ControlStackFrame`] for the given
-/// depth.
-pub fn control_index(depth: u32, control_length: usize) -> usize {
-    (control_length - 1)
-        .checked_sub(depth as usize)
-        .unwrap_or_else(|| panic!("expected valid control stack frame at index: {}", depth))
-}

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

@@ -1,189 +0,0 @@
-use crate::{
-    abi::{align_to, ty_size, ABIArg, ABISig, LocalSlot, ABI},
-    masm::MacroAssembler,
-};
-use anyhow::Result;
-use smallvec::SmallVec;
-use std::ops::Range;
-use wasmparser::{BinaryReader, FuncValidator, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, 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(
-        translation: &ModuleTranslation<'_>,
-        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 = translation.module.convert_valtype(ty);
-            for _ in 0..count {
-                let ty_size = ty_size(&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,
-}
-
-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)),
-        );
-
-        let vmctx_slots_size = <A as ABI>::word_bytes();
-        let vmctx_offset = defined_locals_start + defined_locals.stack_size + vmctx_slots_size;
-
-        let locals_size = 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),
-            ),
-        })
-    }
-
-    /// 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 ABIArg 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;
-        let slots: Locals = sig
-            .params
-            .iter()
-            .map(|arg| Self::abi_arg_slot(&arg, &mut next_stack, arg_base_offset))
-            .collect();
-
-        Ok((slots, next_stack))
-    }
-
-    fn abi_arg_slot(arg: &ABIArg, next_stack: &mut u32, arg_base_offset: u32) -> LocalSlot {
-        match arg {
-            // Create a local slot, for input register spilling,
-            // with type-size aligned access.
-            ABIArg::Reg { ty, reg: _ } => {
-                let ty_size = ty_size(&ty);
-                *next_stack = align_to(*next_stack, ty_size) + ty_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.
-            ABIArg::Stack { ty, offset } => LocalSlot::stack_arg(*ty, offset + arg_base_offset),
-        }
-    }
-}