wasmtime 21.0.1 → 22.0.0

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

@@ -1,258 +0,0 @@
-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, WasmValType};
-
-// 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: u32 = 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 as u32) + (ty_size as u32);
-                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.
-    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)),
-        );
-
-        let stack_align = <A as ABI>::stack_align();
-        let defined_locals_end = align_to(
-            defined_locals_start + defined_locals.stack_size,
-            stack_align as u32,
-        );
-
-        // Handle the results base slot for multi value returns.
-        let (results_base_slot, locals_size) = if sig.params.has_retptr() {
-            match sig.params.unwrap_results_area_operand() {
-                // If the results operand is a stack argument, ensure the
-                // offset is correctly calculated, that is, that it includes the
-                // argument base offset.
-                // In this case, the locals size, remains untouched as we don't
-                // need to create an extra slot for it.
-                ABIOperand::Stack { ty, offset, .. } => (
-                    Some(LocalSlot::stack_arg(
-                        *ty,
-                        *offset + (<A as ABI>::arg_base_offset() as u32),
-                    )),
-                    defined_locals_end,
-                ),
-                // If the resuls operand is a register, we give this register
-                // the same treatment as all the other argument registers and
-                // spill it, therefore, we need to increase the locals size by
-                // one slot.
-                ABIOperand::Reg { ty, size, .. } => {
-                    let offs = align_to(defined_locals_end, *size) + *size;
-                    (
-                        Some(LocalSlot::new(*ty, offs)),
-                        align_to(offs, <A as ABI>::stack_align().into()),
-                    )
-                }
-            }
-        } else {
-            (None, defined_locals_end)
-        };
-
-        let vmctx_slot = *locals.get(0).expect("LocalSlot for VMContext");
-        Ok(Self {
-            locals,
-            locals_size,
-            vmctx_slot,
-            defined_locals_range: DefinedLocalsRange(
-                defined_locals_start..(defined_locals_start + defined_locals.stack_size),
-            ),
-            results_base_slot,
-        })
-    }
-
-    // Winch's ABI uses two extra parameters to store the callee and caller
-    // VMContext pointers.
-    // These arguments are spilled and treated as frame locals, but not
-    // WebAssembly locals.
-    const WASM_LOCALS_OFFSET: usize = 2;
-
-    /// Get the [LocalSlot] for a WebAssembly local.
-    /// This method assumes that the index is bound to u32::MAX, representing
-    /// the index space for WebAssembly locals.
-    ///
-    /// # Panics
-    /// This method panics if the index is not associated to a valid WebAssembly
-    /// local.
-    pub fn get_wasm_local(&self, index: u32) -> &LocalSlot {
-        let local_index = Self::WASM_LOCALS_OFFSET + index as usize;
-        self.locals
-            .get(local_index)
-            .unwrap_or_else(|| panic!(" Expected WebAssembly local at slot: {index}"))
-    }
-
-    /// Get the [LocalSlot] for a frame local.
-    /// This method doesn't make any asumptions about the local index passed in,
-    /// and simply delegates the [LocalSlot] retrieval to the underlying locals
-    /// vector.
-    ///
-    /// # Panics
-    /// This method panics if the index is not associated to a valid WebAssembly
-    /// local.
-    pub fn get_frame_local(&self, index: usize) -> &LocalSlot {
-        self.locals
-            .get(index)
-            .unwrap_or_else(|| panic!(" Expected Frame local at slot: {index}"))
-    }
-
-    /// 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,
-    ) -> (WasmValType, M::Address) {
-        let slot = self.get_wasm_local(index);
-        (slot.ty, masm.local_address(&slot))
-    }
-
-    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.19.1/src/isa/aarch64/asm.rs

@@ -1,380 +0,0 @@
-//! Assembler library implementation for Aarch64.
-
-use super::{address::Address, regs};
-use crate::masm::RoundingMode;
-use crate::{masm::OperandSize, reg::Reg};
-use cranelift_codegen::isa::aarch64::inst::{FPUOp1, FPUOp2, FpuRoundMode, ScalarSize};
-use cranelift_codegen::{
-    ir::{MemFlags, SourceLoc},
-    isa::aarch64::inst::{
-        self,
-        emit::{EmitInfo, EmitState},
-        ALUOp, ALUOp3, AMode, ExtendOp, Imm12, Inst, PairAMode,
-    },
-    settings, Final, MachBuffer, MachBufferFinalized, MachInstEmit, MachInstEmitState, MachLabel,
-    Writable,
-};
-
-impl From<OperandSize> for inst::OperandSize {
-    fn from(size: OperandSize) -> Self {
-        match size {
-            OperandSize::S32 => Self::Size32,
-            OperandSize::S64 => Self::Size64,
-            s => panic!("Invalid operand size {:?}", s),
-        }
-    }
-}
-impl Into<ScalarSize> for OperandSize {
-    fn into(self) -> ScalarSize {
-        match self {
-            OperandSize::S8 => ScalarSize::Size8,
-            OperandSize::S16 => ScalarSize::Size16,
-            OperandSize::S32 => ScalarSize::Size32,
-            OperandSize::S64 => ScalarSize::Size64,
-            OperandSize::S128 => ScalarSize::Size128,
-        }
-    }
-}
-
-/// Low level assembler implementation for Aarch64.
-pub(crate) struct Assembler {
-    /// The machine instruction buffer.
-    buffer: MachBuffer<Inst>,
-    /// Constant emission information.
-    emit_info: EmitInfo,
-    /// Emission state.
-    emit_state: EmitState,
-}
-
-impl Assembler {
-    /// Create a new Aarch64 assembler.
-    pub fn new(shared_flags: settings::Flags) -> Self {
-        Self {
-            buffer: MachBuffer::<Inst>::new(),
-            emit_state: Default::default(),
-            emit_info: EmitInfo::new(shared_flags),
-        }
-    }
-}
-
-impl Assembler {
-    /// Return the emitted code.
-    pub fn finalize(mut self, loc: Option<SourceLoc>) -> MachBufferFinalized<Final> {
-        let constants = Default::default();
-        let stencil = self
-            .buffer
-            .finish(&constants, self.emit_state.ctrl_plane_mut());
-        stencil.apply_base_srcloc(loc.unwrap_or_default())
-    }
-
-    fn emit(&mut self, inst: Inst) {
-        inst.emit(&[], &mut self.buffer, &self.emit_info, &mut self.emit_state);
-    }
-
-    /// Load a constant into a register.
-    pub fn load_constant(&mut self, imm: u64, rd: Reg) {
-        let writable = Writable::from_reg(rd.into());
-        Inst::load_constant(writable, imm, &mut |_| writable)
-            .into_iter()
-            .for_each(|i| self.emit(i));
-    }
-
-    /// Store a pair of registers.
-    pub fn stp(&mut self, xt1: Reg, xt2: Reg, addr: Address) {
-        let mem: PairAMode = addr.try_into().unwrap();
-        self.emit(Inst::StoreP64 {
-            rt: xt1.into(),
-            rt2: xt2.into(),
-            mem,
-            flags: MemFlags::trusted(),
-        });
-    }
-
-    /// Store a register.
-    pub fn str(&mut self, reg: Reg, addr: Address, size: OperandSize) {
-        let mem: AMode = addr.try_into().unwrap();
-        let flags = MemFlags::trusted();
-
-        use OperandSize::*;
-        let inst = match size {
-            S64 => Inst::Store64 {
-                rd: reg.into(),
-                mem,
-                flags,
-            },
-            S32 => Inst::Store32 {
-                rd: reg.into(),
-                mem,
-                flags,
-            },
-
-            _ => unreachable!(),
-        };
-
-        self.emit(inst);
-    }
-
-    /// Load a register.
-    pub fn ldr(&mut self, addr: Address, rd: Reg, size: OperandSize) {
-        use OperandSize::*;
-        let writable_reg = Writable::from_reg(rd.into());
-        let mem: AMode = addr.try_into().unwrap();
-        let flags = MemFlags::trusted();
-
-        let inst = match size {
-            S64 => Inst::ULoad64 {
-                rd: writable_reg,
-                mem,
-                flags,
-            },
-            S32 => Inst::ULoad32 {
-                rd: writable_reg,
-                mem,
-                flags,
-            },
-            _ => unreachable!(),
-        };
-
-        self.emit(inst);
-    }
-
-    /// Load a pair of registers.
-    pub fn ldp(&mut self, xt1: Reg, xt2: Reg, addr: Address) {
-        let writable_xt1 = Writable::from_reg(xt1.into());
-        let writable_xt2 = Writable::from_reg(xt2.into());
-        let mem = addr.try_into().unwrap();
-
-        self.emit(Inst::LoadP64 {
-            rt: writable_xt1,
-            rt2: writable_xt2,
-            mem,
-            flags: MemFlags::trusted(),
-        });
-    }
-
-    /// Register to register move.
-    pub fn mov_rr(&mut self, rm: Reg, rd: Reg, size: OperandSize) {
-        let writable_rd = Writable::from_reg(rd.into());
-        self.emit(Inst::Mov {
-            size: size.into(),
-            rd: writable_rd,
-            rm: rm.into(),
-        });
-    }
-
-    /// Floating point register to register move.
-    pub fn fmov_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
-        let writable = Writable::from_reg(rd.into());
-        let inst = match size {
-            OperandSize::S32 => Inst::FpuMove32 {
-                rd: writable,
-                rn: rn.into(),
-            },
-            OperandSize::S64 => Inst::FpuMove64 {
-                rd: writable,
-                rn: rn.into(),
-            },
-            _ => unreachable!(),
-        };
-
-        self.emit(inst);
-    }
-
-    pub fn mov_to_fpu(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
-        let writable_rd = Writable::from_reg(rd.into());
-        self.emit(Inst::MovToFpu {
-            size: size.into(),
-            rd: writable_rd,
-            rn: rn.into(),
-        });
-    }
-
-    /// Add with three registers.
-    pub fn add_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_alu_rrr_extend(ALUOp::Add, rm, rn, rd, size);
-    }
-
-    /// Add immediate and register.
-    pub fn add_ir(&mut self, imm: u64, rn: Reg, rd: Reg, size: OperandSize) {
-        let alu_op = ALUOp::Add;
-        if let Some(imm) = Imm12::maybe_from_u64(imm) {
-            self.emit_alu_rri(alu_op, imm, rn, rd, size);
-        } else {
-            let scratch = regs::scratch();
-            self.load_constant(imm, scratch);
-            self.emit_alu_rrr_extend(alu_op, scratch, rn, rd, size);
-        }
-    }
-
-    /// Substract with three registers.
-    pub fn sub_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_alu_rrr_extend(ALUOp::Sub, rm, rn, rd, size);
-    }
-
-    /// Subtract immediate and register.
-    pub fn sub_ir(&mut self, imm: u64, rn: Reg, rd: Reg, size: OperandSize) {
-        let alu_op = ALUOp::Sub;
-        if let Some(imm) = Imm12::maybe_from_u64(imm) {
-            self.emit_alu_rri(alu_op, imm, rn, rd, size);
-        } else {
-            let scratch = regs::scratch();
-            self.load_constant(imm, scratch);
-            self.emit_alu_rrr_extend(alu_op, scratch, rn, rd, size);
-        }
-    }
-
-    /// Multiply with three registers.
-    pub fn mul_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_alu_rrrr(ALUOp3::MAdd, rm, rn, rd, regs::zero(), size);
-    }
-
-    /// Multiply immediate and register.
-    pub fn mul_ir(&mut self, imm: u64, rn: Reg, rd: Reg, size: OperandSize) {
-        let scratch = regs::scratch();
-        self.load_constant(imm, scratch);
-        self.emit_alu_rrrr(ALUOp3::MAdd, scratch, rn, rd, regs::zero(), size);
-    }
-
-    /// Float add with three registers.
-    pub fn fadd_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rrr(FPUOp2::Add, rm, rn, rd, size);
-    }
-
-    /// Float sub with three registers.
-    pub fn fsub_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rrr(FPUOp2::Sub, rm, rn, rd, size);
-    }
-
-    /// Float multiply with three registers.
-    pub fn fmul_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rrr(FPUOp2::Mul, rm, rn, rd, size);
-    }
-
-    /// Float division with three registers.
-    pub fn fdiv_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rrr(FPUOp2::Div, rm, rn, rd, size);
-    }
-
-    /// Float max with three registers.
-    pub fn fmax_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rrr(FPUOp2::Max, rm, rn, rd, size);
-    }
-
-    /// Float min with three registers.
-    pub fn fmin_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rrr(FPUOp2::Min, rm, rn, rd, size);
-    }
-
-    /// Float neg with two registers.
-    pub fn fneg_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rr(FPUOp1::Neg, rn, rd, size);
-    }
-
-    /// Float abs with two registers.
-    pub fn fabs_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rr(FPUOp1::Abs, rn, rd, size);
-    }
-
-    /// Float sqrt with two registers.
-    pub fn fsqrt_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit_fpu_rr(FPUOp1::Sqrt, rn, rd, size);
-    }
-
-    /// Float round (ceil, trunc, floor) with two registers.
-    pub fn fround_rr(&mut self, rn: Reg, rd: Reg, mode: RoundingMode, size: OperandSize) {
-        let fpu_mode = match (mode, size) {
-            (RoundingMode::Nearest, OperandSize::S32) => FpuRoundMode::Nearest32,
-            (RoundingMode::Up, OperandSize::S32) => FpuRoundMode::Plus32,
-            (RoundingMode::Down, OperandSize::S32) => FpuRoundMode::Minus32,
-            (RoundingMode::Zero, OperandSize::S32) => FpuRoundMode::Zero32,
-            (RoundingMode::Nearest, OperandSize::S64) => FpuRoundMode::Nearest64,
-            (RoundingMode::Up, OperandSize::S64) => FpuRoundMode::Plus64,
-            (RoundingMode::Down, OperandSize::S64) => FpuRoundMode::Minus64,
-            (RoundingMode::Zero, OperandSize::S64) => FpuRoundMode::Zero64,
-            (m, o) => panic!("Invalid rounding mode or operand size {:?}, {:?}", m, o),
-        };
-        self.emit_fpu_round(fpu_mode, rn, rd)
-    }
-
-    /// Return instruction.
-    pub fn ret(&mut self) {
-        self.emit(Inst::Ret {});
-    }
-
-    // Helpers for ALU operations.
-
-    fn emit_alu_rri(&mut self, op: ALUOp, imm: Imm12, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit(Inst::AluRRImm12 {
-            alu_op: op,
-            size: size.into(),
-            rd: Writable::from_reg(rd.into()),
-            rn: rn.into(),
-            imm12: imm,
-        });
-    }
-
-    fn emit_alu_rrr_extend(&mut self, op: ALUOp, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit(Inst::AluRRRExtend {
-            alu_op: op,
-            size: size.into(),
-            rd: Writable::from_reg(rd.into()),
-            rn: rn.into(),
-            rm: rm.into(),
-            extendop: ExtendOp::UXTX,
-        });
-    }
-
-    fn emit_alu_rrrr(&mut self, op: ALUOp3, rm: Reg, rn: Reg, rd: Reg, ra: Reg, size: OperandSize) {
-        self.emit(Inst::AluRRRR {
-            alu_op: op,
-            size: size.into(),
-            rd: Writable::from_reg(rd.into()),
-            rn: rn.into(),
-            rm: rm.into(),
-            ra: ra.into(),
-        });
-    }
-
-    fn emit_fpu_rrr(&mut self, op: FPUOp2, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit(Inst::FpuRRR {
-            fpu_op: op,
-            size: size.into(),
-            rd: Writable::from_reg(rd.into()),
-            rn: rn.into(),
-            rm: rm.into(),
-        });
-    }
-
-    fn emit_fpu_rr(&mut self, op: FPUOp1, rn: Reg, rd: Reg, size: OperandSize) {
-        self.emit(Inst::FpuRR {
-            fpu_op: op,
-            size: size.into(),
-            rd: Writable::from_reg(rd.into()),
-            rn: rn.into(),
-        });
-    }
-
-    fn emit_fpu_round(&mut self, op: FpuRoundMode, rn: Reg, rd: Reg) {
-        self.emit(Inst::FpuRound {
-            op: op,
-            rd: Writable::from_reg(rd.into()),
-            rn: rn.into(),
-        });
-    }
-
-    /// Get a label from the underlying machine code buffer.
-    pub fn get_label(&mut self) -> MachLabel {
-        self.buffer.get_label()
-    }
-
-    /// Get a mutable reference to underlying
-    /// machine buffer.
-    pub fn buffer_mut(&mut self) -> &mut MachBuffer<Inst> {
-        &mut self.buffer
-    }
-
-    /// Get a reference to the underlying machine buffer.
-    pub fn buffer(&self) -> &MachBuffer<Inst> {
-        &self.buffer
-    }
-}