wasmtime 15.0.1 → 16.0.0

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

@@ -1,136 +0,0 @@
-use self::regs::{ALL_GPR, MAX_FPR, MAX_GPR, NON_ALLOCATABLE_GPR};
-use crate::{
-    abi::ABI,
-    codegen::{CodeGen, CodeGenContext, FuncEnv},
-    frame::{DefinedLocals, Frame},
-    isa::{Builder, CallingConvention, TargetIsa},
-    masm::MacroAssembler,
-    regalloc::RegAlloc,
-    regset::RegBitSet,
-    stack::Stack,
-    BuiltinFunctions, TrampolineKind,
-};
-use anyhow::Result;
-use cranelift_codegen::settings::{self, Flags};
-use cranelift_codegen::{isa::aarch64::settings as aarch64_settings, Final, MachBufferFinalized};
-use cranelift_codegen::{MachTextSectionBuilder, TextSectionBuilder};
-use masm::MacroAssembler as Aarch64Masm;
-use target_lexicon::Triple;
-use wasmparser::{FuncValidator, FunctionBody, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, ModuleTypes, VMOffsets, WasmFuncType};
-
-mod abi;
-mod address;
-mod asm;
-mod masm;
-mod regs;
-
-/// Create an ISA from the given triple.
-pub(crate) fn isa_builder(triple: Triple) -> Builder {
-    Builder::new(
-        triple,
-        aarch64_settings::builder(),
-        |triple, shared_flags, settings| {
-            let isa_flags = aarch64_settings::Flags::new(&shared_flags, settings);
-            let isa = Aarch64::new(triple, shared_flags, isa_flags);
-            Ok(Box::new(isa))
-        },
-    )
-}
-
-/// Aarch64 ISA.
-// Until Aarch64 emission is supported.
-#[allow(dead_code)]
-pub(crate) struct Aarch64 {
-    /// The target triple.
-    triple: Triple,
-    /// ISA specific flags.
-    isa_flags: aarch64_settings::Flags,
-    /// Shared flags.
-    shared_flags: Flags,
-}
-
-impl Aarch64 {
-    /// Create an Aarch64 ISA.
-    pub fn new(triple: Triple, shared_flags: Flags, isa_flags: aarch64_settings::Flags) -> Self {
-        Self {
-            isa_flags,
-            shared_flags,
-            triple,
-        }
-    }
-}
-
-impl TargetIsa for Aarch64 {
-    fn name(&self) -> &'static str {
-        "aarch64"
-    }
-
-    fn triple(&self) -> &Triple {
-        &self.triple
-    }
-
-    fn flags(&self) -> &settings::Flags {
-        &self.shared_flags
-    }
-
-    fn isa_flags(&self) -> Vec<settings::Value> {
-        self.isa_flags.iter().collect()
-    }
-
-    fn is_branch_protection_enabled(&self) -> bool {
-        self.isa_flags.use_bti()
-    }
-
-    fn compile_function(
-        &self,
-        sig: &WasmFuncType,
-        body: &FunctionBody,
-        translation: &ModuleTranslation,
-        types: &ModuleTypes,
-        builtins: &mut BuiltinFunctions,
-        validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<MachBufferFinalized<Final>> {
-        let vmoffsets = VMOffsets::new(self.pointer_bytes(), &translation.module);
-        let mut body = body.get_binary_reader();
-        let mut masm = Aarch64Masm::new(self.shared_flags.clone());
-        let stack = Stack::new();
-        let abi_sig = abi::Aarch64ABI::sig(sig, &CallingConvention::Default);
-
-        let defined_locals = DefinedLocals::new(translation, &mut body, validator)?;
-        let frame = Frame::new::<abi::Aarch64ABI>(&abi_sig, &defined_locals)?;
-        let gpr = RegBitSet::int(
-            ALL_GPR.into(),
-            NON_ALLOCATABLE_GPR.into(),
-            usize::try_from(MAX_GPR).unwrap(),
-        );
-        // TODO: Add floating point bitmask
-        let fpr = RegBitSet::float(0, 0, usize::try_from(MAX_FPR).unwrap());
-        let regalloc = RegAlloc::from(gpr, fpr);
-        let codegen_context = CodeGenContext::new(regalloc, stack, frame, builtins, &vmoffsets);
-        let env = FuncEnv::new(&vmoffsets, translation, types);
-        let mut codegen = CodeGen::new(&mut masm, codegen_context, env, abi_sig);
-
-        codegen.emit(&mut body, validator)?;
-        Ok(masm.finalize())
-    }
-
-    fn text_section_builder(&self, num_funcs: usize) -> Box<dyn TextSectionBuilder> {
-        Box::new(MachTextSectionBuilder::<
-            cranelift_codegen::isa::aarch64::inst::Inst,
-        >::new(num_funcs))
-    }
-
-    fn function_alignment(&self) -> u32 {
-        // See `cranelift_codegen::isa::TargetIsa::function_alignment`.
-        32
-    }
-
-    fn compile_trampoline(
-        &self,
-        _ty: &WasmFuncType,
-        _kind: TrampolineKind,
-    ) -> Result<MachBufferFinalized<Final>> {
-        todo!()
-    }
-}

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

@@ -1,218 +0,0 @@
-use crate::{BuiltinFunctions, TrampolineKind};
-use anyhow::{anyhow, Result};
-use core::fmt::Formatter;
-use cranelift_codegen::isa::{CallConv, IsaBuilder};
-use cranelift_codegen::settings;
-use cranelift_codegen::{Final, MachBufferFinalized, TextSectionBuilder};
-use std::{
-    error,
-    fmt::{self, Debug, Display},
-};
-use target_lexicon::{Architecture, Triple};
-use wasmparser::{FuncValidator, FunctionBody, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, ModuleTypes, WasmFuncType};
-
-#[cfg(feature = "x64")]
-pub(crate) mod x64;
-
-#[cfg(feature = "arm64")]
-pub(crate) mod aarch64;
-
-pub(crate) mod reg;
-
-macro_rules! isa_builder {
-    ($name: ident, $cfg_terms: tt, $triple: ident) => {{
-        #[cfg $cfg_terms]
-        {
-            Ok($name::isa_builder($triple))
-        }
-        #[cfg(not $cfg_terms)]
-        {
-            Err(anyhow!(LookupError::SupportDisabled))
-        }
-    }};
-}
-
-pub type Builder = IsaBuilder<Result<Box<dyn TargetIsa>>>;
-
-/// Look for an ISA builder for the given target triple.
-pub fn lookup(triple: Triple) -> Result<Builder> {
-    match triple.architecture {
-        Architecture::X86_64 => {
-            isa_builder!(x64, (feature = "x64"), triple)
-        }
-        Architecture::Aarch64 { .. } => {
-            isa_builder!(aarch64, (feature = "arm64"), triple)
-        }
-
-        _ => Err(anyhow!(LookupError::Unsupported)),
-    }
-}
-
-impl error::Error for LookupError {}
-impl Display for LookupError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            LookupError::Unsupported => write!(f, "This target is not supported yet"),
-            LookupError::SupportDisabled => write!(f, "Support for this target was disabled"),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum LookupError {
-    Unsupported,
-    // This directive covers the case in which the consumer
-    // enables the `all-arch` feature; in such case, this variant
-    // will never be used. This is most likely going to change
-    // in the future; this is one of the simplest options for now.
-    #[allow(dead_code)]
-    SupportDisabled,
-}
-
-/// Calling conventions supported by Winch. Winch supports the `Wasmtime*`
-/// variations of the system's ABI calling conventions and an internal default
-/// calling convention.
-///
-/// This enum is a reduced subset of the calling conventions defined in
-/// [cranelift_codegen::isa::CallConv]. Introducing this enum makes it easier
-/// to enforce the invariant of all the calling conventions supported by Winch.
-#[derive(Copy, Clone)]
-pub enum CallingConvention {
-    /// See [cranelift_codegen::isa::CallConv::WasmtimeSystemV]
-    WasmtimeSystemV,
-    /// See [cranelift_codegen::isa::CallConv::WindowsFastcall]
-    WindowsFastcall,
-    /// See [cranelift_codegen::isa::CallConv::AppleAarch64]
-    AppleAarch64,
-    /// The default calling convention for Winch. It largely follows SystemV
-    /// for parameter and result handling. This calling convention is part of
-    /// Winch's default ABI [crate::abi::ABI].
-    Default,
-}
-
-impl CallingConvention {
-    /// Returns true if the current calling convention is `WasmtimeFastcall`.
-    fn is_fastcall(&self) -> bool {
-        match &self {
-            CallingConvention::WindowsFastcall => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the current calling convention is `WasmtimeSystemV`.
-    fn is_systemv(&self) -> bool {
-        match &self {
-            CallingConvention::WasmtimeSystemV => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the current calling convention is `WasmtimeAppleAarch64`.
-    fn is_apple_aarch64(&self) -> bool {
-        match &self {
-            CallingConvention::AppleAarch64 => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the current calling convention is `Default`.
-    fn is_default(&self) -> bool {
-        match &self {
-            CallingConvention::Default => true,
-            _ => false,
-        }
-    }
-}
-
-/// A trait representing commonalities between the supported
-/// instruction set architectures.
-pub trait TargetIsa: Send + Sync {
-    /// Get the name of the ISA.
-    fn name(&self) -> &'static str;
-
-    /// Get the target triple of the ISA.
-    fn triple(&self) -> &Triple;
-
-    /// Get the ISA-independent flags that were used to make this trait object.
-    fn flags(&self) -> &settings::Flags;
-
-    /// Get the ISA-dependent flag values that were used to make this trait object.
-    fn isa_flags(&self) -> Vec<settings::Value>;
-
-    /// Get a flag indicating whether branch protection is enabled.
-    fn is_branch_protection_enabled(&self) -> bool {
-        false
-    }
-
-    /// Compile a function.
-    fn compile_function(
-        &self,
-        sig: &WasmFuncType,
-        body: &FunctionBody,
-        translation: &ModuleTranslation,
-        types: &ModuleTypes,
-        builtins: &mut BuiltinFunctions,
-        validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<MachBufferFinalized<Final>>;
-
-    /// Get the default calling convention of the underlying target triple.
-    fn default_call_conv(&self) -> CallConv {
-        CallConv::triple_default(&self.triple())
-    }
-
-    /// Derive Wasmtime's calling convention from the triple's default
-    /// calling convention.
-    fn wasmtime_call_conv(&self) -> CallingConvention {
-        match self.default_call_conv() {
-            CallConv::AppleAarch64 => CallingConvention::AppleAarch64,
-            CallConv::SystemV => CallingConvention::WasmtimeSystemV,
-            CallConv::WindowsFastcall => CallingConvention::WindowsFastcall,
-            cc => unimplemented!("calling convention: {:?}", cc),
-        }
-    }
-
-    /// Get the endianess of the underlying target triple.
-    fn endianness(&self) -> target_lexicon::Endianness {
-        self.triple().endianness().unwrap()
-    }
-
-    /// See `cranelift_codegen::isa::TargetIsa::create_systemv_cie`.
-    fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
-        // By default, an ISA cannot create a System V CIE.
-        None
-    }
-
-    /// See `cranelift_codegen::isa::TargetIsa::text_section_builder`.
-    fn text_section_builder(&self, num_labeled_funcs: usize) -> Box<dyn TextSectionBuilder>;
-
-    /// See `cranelift_codegen::isa::TargetIsa::function_alignment`.
-    fn function_alignment(&self) -> u32;
-
-    /// Compile a trampoline kind.
-    ///
-    /// This function, internally dispatches to the right trampoline to emit
-    /// depending on the `kind` paramter.
-    fn compile_trampoline(
-        &self,
-        ty: &WasmFuncType,
-        kind: TrampolineKind,
-    ) -> Result<MachBufferFinalized<Final>>;
-
-    /// Returns the pointer width of the ISA in bytes.
-    fn pointer_bytes(&self) -> u8 {
-        let width = self.triple().pointer_width().unwrap();
-        width.bytes()
-    }
-}
-
-impl Debug for &dyn TargetIsa {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "Target ISA {{ triple: {:?}, calling convention: {:?} }}",
-            self.triple(),
-            self.default_call_conv()
-        )
-    }
-}