wasmtime 15.0.1 → 16.0.0

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

@@ -1,456 +0,0 @@
-//! Data structures for control flow emission.
-//!
-//! As of the current implementation, Winch doesn't offer support for the
-//! multi-value proposal, which in the context of control flow constructs it
-//! means that blocks don't take any params and produce 0 or 1 return. The
-//! intention is to implement support for multi-value across the compiler, when
-//! that time comes, here are some general changes that will be needed for
-//! control flow:
-//!
-//! * Consider having a copy of the block params on the side, and push them when
-//! encountering an else or duplicate the block params upfront. If no else is
-//! present, clean the extra copies from the stack.
-//!
-//! * Eagerly load the block params. Params can flow "downward" as the block
-//! results in the case of an empty then or else block:
-//!   (module
-//!     (func (export "params") (param i32) (result i32)
-//!       (i32.const 2)
-//!       (if (param i32) (result i32) (local.get 0)
-//!       (then))
-//!     (i32.const 3)
-//!     (i32.add)
-//!   )
-//!
-//! As a future optimization, we could perform a look ahead to the next
-//! instruction when reaching any of the comparison instructions. If the next
-//! instruction is a control instruction, we could avoid emitting
-//! a [`crate::masm::MacroAssembler::cmp_with_set`] and instead emit
-//! a conditional jump inline when emitting the control flow instruction.
-
-use super::{CodeGenContext, MacroAssembler, OperandSize};
-use crate::{
-    abi::{ABIResult, ABI},
-    masm::IntCmpKind,
-    CallingConvention,
-};
-use cranelift_codegen::MachLabel;
-use wasmtime_environ::WasmType;
-
-/// Holds the necessary metdata to support the emission
-/// of control flow instructions.
-#[derive(Debug)]
-pub(crate) enum ControlStackFrame {
-    If {
-        /// The if continuation label.
-        cont: MachLabel,
-        /// The exit label of the block.
-        exit: MachLabel,
-        /// The return values of the block.
-        result: ABIResult,
-        /// The size of the value stack at the beginning of the If.
-        original_stack_len: usize,
-        /// The stack pointer offset at the beginning of the If.
-        original_sp_offset: u32,
-        /// Local reachability state when entering the block.
-        reachable: bool,
-    },
-    Else {
-        /// The exit label of the block.
-        exit: MachLabel,
-        /// The return values of the block.
-        result: ABIResult,
-        /// The size of the value stack at the beginning of the Else.
-        original_stack_len: usize,
-        /// The stack pointer offset at the beginning of the Else.
-        original_sp_offset: u32,
-        /// Local reachability state when entering the block.
-        reachable: bool,
-    },
-    Block {
-        /// The block exit label.
-        exit: MachLabel,
-        /// The size of the value stack at the beginning of the block.
-        original_stack_len: usize,
-        /// The return values of the block.
-        result: ABIResult,
-        /// The stack pointer offset at the beginning of the Block.
-        original_sp_offset: u32,
-        /// Exit state of the block.
-        ///
-        /// This flag is used to dertermine if a block is a branch
-        /// target. By default, this is false, and it's updated when
-        /// emitting a `br` or `br_if`.
-        is_branch_target: bool,
-    },
-    Loop {
-        /// The start of the loop.
-        head: MachLabel,
-        /// The size of the value stack at the beginning of the block.
-        original_stack_len: usize,
-        /// The stack pointer offset at the beginning of the Block.
-        original_sp_offset: u32,
-        /// The return values of the block.
-        result: ABIResult,
-    },
-}
-
-impl ControlStackFrame {
-    /// Returns [`ControlStackFrame`] for an if.
-    pub fn if_<M: MacroAssembler>(
-        returns: &[WasmType],
-        masm: &mut M,
-        context: &mut CodeGenContext,
-    ) -> Self {
-        let result = <M::ABI as ABI>::result(&returns, &CallingConvention::Default);
-        let mut control = Self::If {
-            cont: masm.get_label(),
-            exit: masm.get_label(),
-            result,
-            reachable: context.reachable,
-            original_stack_len: 0,
-            original_sp_offset: 0,
-        };
-
-        control.emit(masm, context);
-        control
-    }
-
-    /// Creates a block that represents the base
-    /// block for the function body.
-    pub fn function_body_block<M: MacroAssembler>(
-        result: ABIResult,
-        masm: &mut M,
-        context: &mut CodeGenContext,
-    ) -> Self {
-        Self::Block {
-            original_stack_len: context.stack.len(),
-            result,
-            is_branch_target: false,
-            exit: masm.get_label(),
-            original_sp_offset: masm.sp_offset(),
-        }
-    }
-
-    /// Returns [`ControlStackFrame`] for a block.
-    pub fn block<M: MacroAssembler>(
-        returns: &[WasmType],
-        masm: &mut M,
-        context: &mut CodeGenContext,
-    ) -> Self {
-        let result = <M::ABI as ABI>::result(&returns, &CallingConvention::Default);
-        let mut control = Self::Block {
-            original_stack_len: 0,
-            result,
-            is_branch_target: false,
-            exit: masm.get_label(),
-            original_sp_offset: 0,
-        };
-
-        control.emit(masm, context);
-        control
-    }
-
-    /// Returns [`ControlStackFrame`] for a loop.
-    pub fn loop_<M: MacroAssembler>(
-        returns: &[WasmType],
-        masm: &mut M,
-        context: &mut CodeGenContext,
-    ) -> Self {
-        let result = <M::ABI as ABI>::result(&returns, &CallingConvention::Default);
-        let mut control = Self::Loop {
-            original_stack_len: 0,
-            result,
-            head: masm.get_label(),
-            original_sp_offset: 0,
-        };
-
-        control.emit(masm, context);
-        control
-    }
-
-    fn emit<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
-        use ControlStackFrame::*;
-
-        // Do not perform any emissions if we are in an unreachable state.
-        if !context.reachable {
-            return;
-        }
-
-        match self {
-            If {
-                cont,
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => {
-                // Pop the condition value.
-                let top = context.pop_to_reg(masm, None);
-
-                // Unconditionall spill before emitting control flow.
-                context.spill(masm);
-
-                *original_stack_len = context.stack.len();
-                *original_sp_offset = masm.sp_offset();
-                masm.branch(
-                    IntCmpKind::Eq,
-                    top.reg.into(),
-                    top.reg.into(),
-                    *cont,
-                    OperandSize::S32,
-                );
-                context.free_reg(top);
-            }
-            Block {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => {
-                // Unconditional spill before entering the block.
-                // We assume that there are no live registers when
-                // exiting the block.
-                context.spill(masm);
-                *original_stack_len = context.stack.len();
-                *original_sp_offset = masm.sp_offset();
-            }
-            Loop {
-                original_stack_len,
-                original_sp_offset,
-                head,
-                ..
-            } => {
-                // Unconditional spill before entering the loop block.
-                context.spill(masm);
-                *original_stack_len = context.stack.len();
-                *original_sp_offset = masm.sp_offset();
-                masm.bind(*head);
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// Handles the else branch if the current control stack frame is
-    /// [`ControlStackFrame::If`].
-    pub fn emit_else<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
-        use ControlStackFrame::*;
-        match self {
-            If {
-                result,
-                original_stack_len,
-                exit,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
-                // Before emitting an unconditional jump to the exit branch,
-                // we handle the result of the if-then block.
-                context.pop_abi_results(&result, masm);
-                // Before binding the else branch, we emit the jump to the end
-                // label.
-                masm.jmp(*exit);
-                // Bind the else branch.
-                self.bind_else(masm, context.reachable);
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// Binds the else branch label and converts `self` to
-    /// [`ControlStackFrame::Else`].
-    pub fn bind_else<M: MacroAssembler>(&mut self, masm: &mut M, reachable: bool) {
-        use ControlStackFrame::*;
-        match self {
-            If {
-                cont,
-                result,
-                original_stack_len,
-                original_sp_offset,
-                exit,
-                ..
-            } => {
-                // Bind the else branch.
-                masm.bind(*cont);
-
-                // Update the stack control frame with an else control frame.
-                *self = ControlStackFrame::Else {
-                    exit: *exit,
-                    original_stack_len: *original_stack_len,
-                    result: *result,
-                    reachable,
-                    original_sp_offset: *original_sp_offset,
-                };
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// Handles the end of a control stack frame.
-    pub fn emit_end<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
-        use ControlStackFrame::*;
-        match self {
-            If {
-                result,
-                original_stack_len,
-                ..
-            }
-            | Else {
-                result,
-                original_stack_len,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
-                // Before binding the exit label, we handle the block results.
-                context.pop_abi_results(&result, masm);
-                self.bind_end(masm, context);
-            }
-            Block {
-                original_stack_len,
-                result,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
-                context.pop_abi_results(&result, masm);
-                self.bind_end(masm, context);
-            }
-            Loop {
-                result,
-                original_stack_len,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
-            }
-        }
-    }
-
-    /// Binds the exit label of the current control stack frame and pushes the
-    /// ABI results to the value stack.
-    pub fn bind_end<M: MacroAssembler>(&self, masm: &mut M, context: &mut CodeGenContext) {
-        // Push the results to the value stack.
-        context.push_abi_results(self.result(), masm);
-        self.bind_exit_label(masm);
-    }
-
-    /// Binds the exit label of the control stack frame.
-    pub fn bind_exit_label<M: MacroAssembler>(&self, masm: &mut M) {
-        use ControlStackFrame::*;
-        match self {
-            // We use an explicit label to track the exit of an if block. In case there's no
-            // else, we bind the if's continuation block to make sure that any jumps from the if
-            // condition are reachable and we bind the explicit exit label as well to ensure that any
-            // branching instructions are able to correctly reach the block's end.
-            If { cont, .. } => masm.bind(*cont),
-            _ => {}
-        }
-        if let Some(label) = self.exit_label() {
-            masm.bind(*label);
-        }
-    }
-
-    /// Returns the continuation label of the current control stack frame.
-    pub fn label(&self) -> &MachLabel {
-        use ControlStackFrame::*;
-
-        match self {
-            If { exit, .. } | Else { exit, .. } | Block { exit, .. } => exit,
-            Loop { head, .. } => head,
-        }
-    }
-
-    /// Returns the exit label of the current control stack frame. Note that
-    /// this is similar to [`ControlStackFrame::label`], with the only difference that it
-    /// returns `None` for `Loop` since its label doesn't represent an exit.
-    pub fn exit_label(&self) -> Option<&MachLabel> {
-        use ControlStackFrame::*;
-
-        match self {
-            If { exit, .. } | Else { exit, .. } | Block { exit, .. } => Some(exit),
-            Loop { .. } => None,
-        }
-    }
-
-    /// Set the current control stack frame as a branch target.
-    pub fn set_as_target(&mut self) {
-        match self {
-            ControlStackFrame::Block {
-                is_branch_target, ..
-            } => {
-                *is_branch_target = true;
-            }
-            _ => {}
-        }
-    }
-
-    /// Returns [`crate::abi::ABIResult`] of the control stack frame
-    /// block.
-    pub fn result(&self) -> &ABIResult {
-        use ControlStackFrame::*;
-
-        match self {
-            If { result, .. }
-            | Else { result, .. }
-            | Block { result, .. }
-            | Loop { result, .. } => result,
-        }
-    }
-
-    /// This function is used at the end of unreachable code handling
-    /// to determine if the reachability status should be updated.
-    pub fn is_next_sequence_reachable(&self) -> bool {
-        use ControlStackFrame::*;
-
-        match self {
-            // For if/else, the reachability of the next sequence is determined
-            // by the reachability state at the start of the block. An else
-            // block will be reachable if the if block is also reachable at
-            // entry.
-            If { reachable, .. } | Else { reachable, .. } => *reachable,
-            // For blocks, the reachability of the next sequence is determined
-            // if they're a branch target.
-            Block {
-                is_branch_target, ..
-            } => *is_branch_target,
-            // Loops are not used for reachability analysis,
-            // given that they don't have exit branches.
-            Loop { .. } => false,
-        }
-    }
-
-    /// Returns the value stack length and stack pointer offset of the
-    /// control frame registered at entry.
-    pub fn original_stack_len_and_sp_offset(&self) -> (usize, u32) {
-        use ControlStackFrame::*;
-        match self {
-            If {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            }
-            | Else {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            }
-            | Block {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            }
-            | Loop {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => (*original_stack_len, *original_sp_offset),
-        }
-    }
-
-    /// Resolves how to handle results when the current frame is a
-    /// jump target Notably in the case of loops we don't take into
-    /// account the frame's results, just the params (void until
-    /// multi-value is supported).
-    pub fn as_target_result(&self) -> ABIResult {
-        use ControlStackFrame::*;
-        match self {
-            Loop { .. } => ABIResult::void(),
-            f => *f.result(),
-        }
-    }
-}

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

@@ -1,181 +0,0 @@
-use crate::codegen::{BuiltinFunction, OperandSize};
-use smallvec::{smallvec, SmallVec};
-use std::collections::{
-    hash_map::Entry::{Occupied, Vacant},
-    HashMap,
-};
-use wasmparser::BlockType;
-use wasmtime_environ::{
-    FuncIndex, GlobalIndex, ModuleTranslation, ModuleTypes, PtrSize, TableIndex, TablePlan,
-    TypeConvert, TypeIndex, VMOffsets, WasmFuncType, WasmType,
-};
-
-/// Table metadata.
-#[derive(Debug, Copy, Clone)]
-pub struct TableData {
-    /// The offset to the base of the table.
-    pub offset: u32,
-    /// The offset to the current elements field.
-    pub current_elems_offset: u32,
-    /// If the table is imported, return the base
-    /// offset of the `from` field in `VMTableImport`.
-    pub base: Option<u32>,
-    /// The size of the table elements.
-    pub(crate) element_size: OperandSize,
-    /// The size of the current elements field.
-    pub(crate) current_elements_size: OperandSize,
-}
-
-/// A function callee.
-/// It categorizes how the callee should be treated
-/// when performing the call.
-#[derive(Clone)]
-pub enum Callee {
-    /// Locally defined function.
-    Local(CalleeInfo),
-    /// Imported function.
-    Import(CalleeInfo),
-    /// Function reference.
-    FuncRef(WasmFuncType),
-    /// A built-in function.
-    Builtin(BuiltinFunction),
-}
-
-/// Metadata about a function callee. Used by the code generation to
-/// emit function calls to local or imported functions.
-#[derive(Clone)]
-pub struct CalleeInfo {
-    /// The function type.
-    pub ty: WasmFuncType,
-    /// The callee index in the WebAssembly function index space.
-    pub index: FuncIndex,
-}
-
-/// The function environment.
-///
-/// Contains all information about the module and runtime that is accessible to
-/// to a particular function during code generation.
-pub struct FuncEnv<'a, 'translation: 'a, 'data: 'translation, P: PtrSize> {
-    /// Offsets to the fields within the `VMContext` ptr.
-    pub vmoffsets: &'a VMOffsets<P>,
-    /// Metadata about the translation process of a WebAssembly module.
-    pub translation: &'translation ModuleTranslation<'data>,
-    /// The module's function types.
-    pub types: &'translation ModuleTypes,
-    /// Track resolved table information.
-    resolved_tables: HashMap<TableIndex, TableData>,
-}
-
-pub fn ptr_type_from_ptr_size(size: u8) -> WasmType {
-    (size == 8)
-        .then(|| WasmType::I64)
-        .unwrap_or_else(|| unimplemented!("Support for non-64-bit architectures"))
-}
-
-impl<'a, 'translation, 'data, P: PtrSize> FuncEnv<'a, 'translation, 'data, P> {
-    /// Create a new function environment.
-    pub fn new(
-        vmoffsets: &'a VMOffsets<P>,
-        translation: &'translation ModuleTranslation<'data>,
-        types: &'translation ModuleTypes,
-    ) -> Self {
-        Self {
-            vmoffsets,
-            translation,
-            types,
-            resolved_tables: HashMap::new(),
-        }
-    }
-
-    /// Derive the [`WasmType`] from the pointer size.
-    pub(crate) fn ptr_type(&self) -> WasmType {
-        ptr_type_from_ptr_size(self.ptr_size())
-    }
-
-    /// Returns the pointer size for the target ISA.
-    fn ptr_size(&self) -> u8 {
-        self.vmoffsets.ptr.size()
-    }
-
-    /// Resolves a [`Callee::FuncRef`] from a type index.
-    pub fn funcref(&self, idx: TypeIndex) -> Callee {
-        let sig_index = self.translation.module.types[idx].unwrap_function();
-        let ty = self.types[sig_index].clone();
-        Callee::FuncRef(ty)
-    }
-
-    /// Resolves a function [`Callee`] from an index.
-    pub fn callee_from_index(&self, idx: FuncIndex) -> Callee {
-        let types = &self.translation.get_types();
-        let ty = types[types.core_function_at(idx.as_u32())].unwrap_func();
-        let ty = self.translation.module.convert_func_type(ty);
-        let import = self.translation.module.is_imported_function(idx);
-
-        let info = CalleeInfo { ty, index: idx };
-
-        if import {
-            Callee::Import(info)
-        } else {
-            Callee::Local(info)
-        }
-    }
-
-    /// Resolves the type of the block in terms of [`wasmtime_environ::WasmType`].
-    pub fn resolve_block_type(&self, blockty: BlockType) -> SmallVec<[WasmType; 1]> {
-        use BlockType::*;
-        match blockty {
-            Empty => smallvec![],
-            Type(ty) => smallvec![self.translation.module.convert_valtype(ty)],
-            _ => unimplemented!("multi-value"),
-        }
-    }
-
-    /// Resolves the type and offset of a global at the given index.
-    pub fn resolve_global_type_and_offset(&self, index: GlobalIndex) -> (WasmType, u32) {
-        let ty = self.translation.module.globals[index].wasm_ty;
-        let offset = match self.translation.module.defined_global_index(index) {
-            Some(defined_index) => self.vmoffsets.vmctx_vmglobal_definition(defined_index),
-            None => self.vmoffsets.vmctx_vmglobal_import_from(index),
-        };
-
-        (ty, offset)
-    }
-
-    /// Returns the table information for the given table index.
-    pub fn resolve_table_data(&mut self, index: TableIndex) -> TableData {
-        match self.resolved_tables.entry(index) {
-            Occupied(entry) => *entry.get(),
-            Vacant(entry) => {
-                let (from_offset, base_offset, current_elems_offset) =
-                    match self.translation.module.defined_table_index(index) {
-                        Some(defined) => (
-                            None,
-                            self.vmoffsets.vmctx_vmtable_definition_base(defined),
-                            self.vmoffsets
-                                .vmctx_vmtable_definition_current_elements(defined),
-                        ),
-                        None => (
-                            Some(self.vmoffsets.vmctx_vmtable_import_from(index)),
-                            self.vmoffsets.vmtable_definition_base().into(),
-                            self.vmoffsets.vmtable_definition_current_elements().into(),
-                        ),
-                    };
-
-                *entry.insert(TableData {
-                    base: from_offset,
-                    offset: base_offset,
-                    current_elems_offset,
-                    element_size: OperandSize::from_bytes(self.vmoffsets.ptr.size()),
-                    current_elements_size: OperandSize::from_bytes(
-                        self.vmoffsets.size_of_vmtable_definition_current_elements(),
-                    ),
-                })
-            }
-        }
-    }
-
-    /// Get a [`TablePlan`] from a [`TableIndex`].
-    pub fn table_plan(&mut self, index: TableIndex) -> &TablePlan {
-        &self.translation.module.table_plans[index]
-    }
-}