wasmtime 16.0.0 → 17.0.1

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

@@ -1,251 +0,0 @@
-use crate::{
-    abi::{ABIResults, ABIResultsData},
-    codegen::{BuiltinFunction, OperandSize, ABI},
-    CallingConvention,
-};
-use std::collections::{
-    hash_map::Entry::{Occupied, Vacant},
-    HashMap,
-};
-use wasmparser::BlockType;
-use wasmtime_environ::{
-    FuncIndex, GlobalIndex, ModuleTranslation, ModuleTypesBuilder, PtrSize, TableIndex, TablePlan,
-    TypeConvert, TypeIndex, VMOffsets, WasmFuncType, WasmHeapType, 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,
-}
-
-/// Holds information about a block's param and return count.
-#[derive(Default, Debug, Copy, Clone)]
-pub(crate) struct BlockTypeInfo {
-    /// Parameter count.
-    pub param_count: usize,
-    /// Result count.
-    pub result_count: usize,
-}
-
-impl BlockTypeInfo {
-    /// Creates a [`BlockTypeInfo`] with one result.
-    pub fn with_single_result() -> Self {
-        Self {
-            param_count: 0,
-            result_count: 1,
-        }
-    }
-
-    /// Creates a new [`BlockTypeInfo`] with the given param and result
-    /// count.
-    pub fn new(params: usize, results: usize) -> Self {
-        Self {
-            param_count: params,
-            result_count: results,
-        }
-    }
-}
-
-/// 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 ModuleTypesBuilder,
-    /// 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 ModuleTypesBuilder,
-    ) -> 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.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)
-        }
-    }
-
-    pub(crate) fn resolve_block_type_info(&self, ty: BlockType) -> BlockTypeInfo {
-        use BlockType::*;
-        match ty {
-            Empty => BlockTypeInfo::default(),
-            Type(_) => BlockTypeInfo::with_single_result(),
-            FuncType(idx) => {
-                let sig_index =
-                    self.translation.module.types[TypeIndex::from_u32(idx)].unwrap_function();
-                let sig = &self.types[sig_index];
-                BlockTypeInfo::new(sig.params().len(), sig.returns().len())
-            }
-        }
-    }
-
-    /// Resolves the type of the block in terms of [`wasmtime_environ::WasmType`].
-    // TODO::
-    // Profile this operation and if proven to be significantly expensive,
-    // intern ABIResultsData instead of recreating it every time.
-    pub(crate) fn resolve_block_results_data<A: ABI>(&self, blockty: BlockType) -> ABIResultsData {
-        use BlockType::*;
-        match blockty {
-            Empty => ABIResultsData::wrap(ABIResults::default()),
-            Type(ty) => {
-                let ty = self.convert_valtype(ty);
-                let results = <A as ABI>::abi_results(&[ty], &CallingConvention::Default);
-                ABIResultsData::wrap(results)
-            }
-            FuncType(idx) => {
-                let sig_index =
-                    self.translation.module.types[TypeIndex::from_u32(idx)].unwrap_function();
-                let results = <A as ABI>::abi_results(
-                    &self.types[sig_index].returns(),
-                    &CallingConvention::Default,
-                );
-                ABIResultsData::wrap(results)
-            }
-        }
-    }
-
-    /// 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]
-    }
-}
-
-impl<P: PtrSize> TypeConvert for FuncEnv<'_, '_, '_, P> {
-    fn lookup_heap_type(&self, idx: wasmparser::UnpackedIndex) -> WasmHeapType {
-        wasmtime_environ::WasmparserTypeConverter {
-            module: &self.translation.module,
-            types: self.types,
-        }
-        .lookup_heap_type(idx)
-    }
-}

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

@@ -1,444 +0,0 @@
-use super::{abi::Aarch64ABI, address::Address, asm::Assembler, regs};
-use crate::{
-    abi::{self, local::LocalSlot},
-    codegen::{ptr_type_from_ptr_size, CodeGenContext, TableData},
-    isa::reg::Reg,
-    masm::{
-        CalleeKind, DivKind, FloatCmpKind, Imm as I, IntCmpKind, MacroAssembler as Masm,
-        OperandSize, RegImm, RemKind, RoundingMode, SPOffset, ShiftKind, StackSlot, TrapCode,
-    },
-};
-use cranelift_codegen::{settings, Final, MachBufferFinalized, MachLabel};
-use wasmtime_environ::PtrSize;
-
-/// Aarch64 MacroAssembler.
-pub(crate) struct MacroAssembler {
-    /// Low level assembler.
-    asm: Assembler,
-    /// Stack pointer offset.
-    sp_offset: u32,
-    /// The target pointer size.
-    ptr_size: OperandSize,
-}
-
-impl MacroAssembler {
-    /// Create an Aarch64 MacroAssembler.
-    pub fn new(ptr_size: impl PtrSize, shared_flags: settings::Flags) -> Self {
-        Self {
-            asm: Assembler::new(shared_flags),
-            sp_offset: 0u32,
-            ptr_size: ptr_type_from_ptr_size(ptr_size.size()).into(),
-        }
-    }
-}
-
-impl Masm for MacroAssembler {
-    type Address = Address;
-    type Ptr = u8;
-    type ABI = Aarch64ABI;
-
-    fn prologue(&mut self) {
-        let lr = regs::lr();
-        let fp = regs::fp();
-        let sp = regs::sp();
-        let addr = Address::pre_indexed_from_sp(-16);
-
-        self.asm.stp(fp, lr, addr);
-        self.asm.mov_rr(sp, fp, OperandSize::S64);
-        self.move_sp_to_shadow_sp();
-    }
-
-    fn epilogue(&mut self, locals_size: u32) {
-        assert!(self.sp_offset == locals_size);
-
-        let sp = regs::sp();
-        if locals_size > 0 {
-            self.asm
-                .add_ir(locals_size as u64, sp, sp, OperandSize::S64);
-            self.move_sp_to_shadow_sp();
-        }
-
-        let lr = regs::lr();
-        let fp = regs::fp();
-        let addr = Address::post_indexed_from_sp(16);
-
-        self.asm.ldp(fp, lr, addr);
-        self.asm.ret();
-    }
-
-    fn reserve_stack(&mut self, bytes: u32) {
-        if bytes == 0 {
-            return;
-        }
-
-        let sp = regs::sp();
-        self.asm.sub_ir(bytes as u64, sp, sp, OperandSize::S64);
-        self.move_sp_to_shadow_sp();
-
-        self.increment_sp(bytes);
-    }
-
-    fn free_stack(&mut self, _bytes: u32) {
-        todo!()
-    }
-
-    fn reset_stack_pointer(&mut self, offset: SPOffset) {
-        self.sp_offset = offset.as_u32();
-    }
-
-    fn local_address(&mut self, local: &LocalSlot) -> Address {
-        let (reg, offset) = local
-            .addressed_from_sp()
-            .then(|| {
-                let offset = self.sp_offset.checked_sub(local.offset).expect(&format!(
-                    "Invalid local offset = {}; sp offset = {}",
-                    local.offset, self.sp_offset
-                ));
-                (regs::shadow_sp(), offset)
-            })
-            .unwrap_or((regs::fp(), local.offset));
-
-        Address::offset(reg, offset as i64)
-    }
-
-    fn table_elem_address(
-        &mut self,
-        _index: Reg,
-        _base: Reg,
-        _table_data: &TableData,
-        _context: &mut CodeGenContext,
-    ) -> Self::Address {
-        todo!()
-    }
-
-    fn table_size(&mut self, _table_data: &TableData, _context: &mut CodeGenContext) {
-        todo!()
-    }
-
-    fn address_from_sp(&self, _offset: SPOffset) -> Self::Address {
-        todo!()
-    }
-
-    fn address_at_sp(&self, _offset: SPOffset) -> Self::Address {
-        todo!()
-    }
-
-    fn address_at_vmctx(&self, _offset: u32) -> Self::Address {
-        todo!()
-    }
-
-    fn store_ptr(&mut self, src: Reg, dst: Self::Address) {
-        self.store(src.into(), dst, self.ptr_size);
-    }
-
-    fn store(&mut self, src: RegImm, dst: Address, size: OperandSize) {
-        let src = match src {
-            RegImm::Imm(v) => {
-                let imm = match v {
-                    I::I32(v) => v as u64,
-                    I::I64(v) => v,
-                    _ => unreachable!(),
-                };
-                let scratch = regs::scratch();
-                self.asm.load_constant(imm, scratch);
-                scratch
-            }
-            RegImm::Reg(reg) => reg,
-        };
-
-        self.asm.str(src, dst, size);
-    }
-
-    fn call(
-        &mut self,
-        _stack_args_size: u32,
-        _load_callee: impl FnMut(&mut Self) -> CalleeKind,
-    ) -> u32 {
-        todo!()
-    }
-
-    fn load(&mut self, src: Address, dst: Reg, size: OperandSize) {
-        self.asm.ldr(src, dst, size);
-    }
-
-    fn load_ptr(&mut self, _src: Self::Address, _dst: Reg) {
-        todo!()
-    }
-
-    fn load_addr(&mut self, _src: Self::Address, _dst: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn pop(&mut self, _dst: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn sp_offset(&self) -> SPOffset {
-        SPOffset::from_u32(self.sp_offset)
-    }
-
-    fn finalize(self) -> MachBufferFinalized<Final> {
-        self.asm.finalize()
-    }
-
-    fn mov(&mut self, src: RegImm, dst: Reg, size: OperandSize) {
-        match (src, dst) {
-            (RegImm::Imm(v), rd) => {
-                let imm = match v {
-                    I::I32(v) => v as u64,
-                    I::I64(v) => v,
-                    _ => panic!(),
-                };
-
-                let scratch = regs::scratch();
-                self.asm.load_constant(imm, scratch);
-                self.asm.mov_rr(scratch, rd, size);
-            }
-            (RegImm::Reg(rs), rd) => {
-                self.asm.mov_rr(rs, rd, size);
-            }
-        }
-    }
-
-    fn cmov(&mut self, _src: Reg, _dst: Reg, _cc: IntCmpKind, _size: OperandSize) {
-        todo!()
-    }
-
-    fn add(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
-        match (rhs, lhs, dst) {
-            (RegImm::Imm(v), rn, rd) => {
-                let imm = match v {
-                    I::I32(v) => v as u64,
-                    I::I64(v) => v,
-                    _ => unreachable!(),
-                };
-
-                self.asm.add_ir(imm, rn, rd, size);
-            }
-
-            (RegImm::Reg(rm), rn, rd) => {
-                self.asm.add_rrr(rm, rn, rd, size);
-            }
-        }
-    }
-
-    fn sub(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
-        match (rhs, lhs, dst) {
-            (RegImm::Imm(v), rn, rd) => {
-                let imm = match v {
-                    I::I32(v) => v as u64,
-                    I::I64(v) => v,
-                    _ => unreachable!(),
-                };
-
-                self.asm.sub_ir(imm, rn, rd, size);
-            }
-
-            (RegImm::Reg(rm), rn, rd) => {
-                self.asm.sub_rrr(rm, rn, rd, size);
-            }
-        }
-    }
-
-    fn mul(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
-        match (rhs, lhs, dst) {
-            (RegImm::Imm(v), rn, rd) => {
-                let imm = match v {
-                    I::I32(v) => v as u64,
-                    I::I64(v) => v,
-                    _ => unreachable!(),
-                };
-
-                self.asm.mul_ir(imm, rn, rd, size);
-            }
-
-            (RegImm::Reg(rm), rn, rd) => {
-                self.asm.mul_rrr(rm, rn, rd, size);
-            }
-        }
-    }
-
-    fn float_add(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_sub(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_mul(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_div(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_min(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_max(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_copysign(&mut self, _dst: Reg, _lhs: Reg, _rhs: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_neg(&mut self, _dst: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_abs(&mut self, _dst: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_round(
-        &mut self,
-        _mode: RoundingMode,
-        _context: &mut CodeGenContext,
-        _size: OperandSize,
-    ) {
-        todo!();
-    }
-
-    fn float_sqrt(&mut self, _dst: Reg, _src: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn and(&mut self, _dst: Reg, _lhs: Reg, _rhs: RegImm, _size: OperandSize) {
-        todo!()
-    }
-
-    fn or(&mut self, _dst: Reg, _lhs: Reg, _rhs: RegImm, _size: OperandSize) {
-        todo!()
-    }
-
-    fn xor(&mut self, _dst: Reg, _lhs: Reg, _rhs: RegImm, _size: OperandSize) {
-        todo!()
-    }
-
-    fn shift(&mut self, _context: &mut CodeGenContext, _kind: ShiftKind, _size: OperandSize) {
-        todo!()
-    }
-
-    fn div(&mut self, _context: &mut CodeGenContext, _kind: DivKind, _size: OperandSize) {
-        todo!()
-    }
-
-    fn rem(&mut self, _context: &mut CodeGenContext, _kind: RemKind, _size: OperandSize) {
-        todo!()
-    }
-
-    fn zero(&mut self, reg: Reg) {
-        self.asm.load_constant(0, reg);
-    }
-
-    fn popcnt(&mut self, _context: &mut CodeGenContext, _size: OperandSize) {
-        todo!()
-    }
-
-    fn push(&mut self, reg: Reg, _size: OperandSize) -> StackSlot {
-        let size = <Self::ABI as abi::ABI>::word_bytes();
-        self.reserve_stack(size);
-        let address = Address::from_shadow_sp(size as i64);
-        self.asm.str(reg, address, OperandSize::S64);
-
-        StackSlot {
-            offset: SPOffset::from_u32(self.sp_offset),
-            size,
-        }
-    }
-
-    fn address_at_reg(&self, reg: Reg, offset: u32) -> Self::Address {
-        Address::offset(reg, offset as i64)
-    }
-
-    fn cmp_with_set(&mut self, _src: RegImm, _dst: Reg, _kind: IntCmpKind, _size: OperandSize) {
-        todo!()
-    }
-
-    fn cmp(&mut self, _src: RegImm, _dest: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn float_cmp_with_set(
-        &mut self,
-        _src1: Reg,
-        _src2: Reg,
-        _dst: Reg,
-        _kind: FloatCmpKind,
-        _size: OperandSize,
-    ) {
-        todo!()
-    }
-
-    fn clz(&mut self, _src: Reg, _dst: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn ctz(&mut self, _src: Reg, _dst: Reg, _size: OperandSize) {
-        todo!()
-    }
-
-    fn get_label(&mut self) -> MachLabel {
-        self.asm.get_label()
-    }
-
-    fn bind(&mut self, label: MachLabel) {
-        let buffer = self.asm.buffer_mut();
-        buffer.bind_label(label, &mut Default::default());
-    }
-
-    fn branch(
-        &mut self,
-        _kind: IntCmpKind,
-        _lhs: RegImm,
-        _rhs: Reg,
-        _taken: MachLabel,
-        _size: OperandSize,
-    ) {
-        todo!()
-    }
-
-    fn jmp(&mut self, _target: MachLabel) {
-        todo!()
-    }
-
-    fn unreachable(&mut self) {
-        todo!()
-    }
-
-    fn jmp_table(&mut self, _targets: &[MachLabel], _index: Reg, _tmp: Reg) {
-        todo!()
-    }
-
-    fn trapz(&mut self, _src: Reg, _code: TrapCode) {
-        todo!()
-    }
-
-    fn trapif(&mut self, _cc: IntCmpKind, _code: TrapCode) {
-        todo!()
-    }
-}
-
-impl MacroAssembler {
-    fn increment_sp(&mut self, bytes: u32) {
-        self.sp_offset += bytes;
-    }
-
-    // Copies the value of the stack pointer to the shadow stack
-    // pointer: mov x28, sp
-
-    // This function is usually called whenever the real stack pointer
-    // changes, for example after allocating or deallocating stack
-    // space, or after performing a push or pop.
-    // For more details around the stack pointer and shadow stack
-    // pointer see the docs at regs::shadow_sp().
-    fn move_sp_to_shadow_sp(&mut self) {
-        let sp = regs::sp();
-        let shadow_sp = regs::shadow_sp();
-        self.asm.mov_rr(sp, shadow_sp, OperandSize::S64);
-    }
-}