wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wiggle-macro-10.0.1/src/lib.rs

@@ -0,0 +1,210 @@
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::parse_macro_input;
+
+/// This macro expands to a set of `pub` Rust modules:
+///
+/// * The `types` module contains definitions for each `typename` declared in
+///   the witx document. Type names are translated to the Rust-idiomatic
+///   CamelCase.
+///
+/// * For each `module` defined in the witx document, a Rust module is defined
+///   containing definitions for that module. Module names are translated to the
+///   Rust-idiomatic snake\_case.
+///
+///     * For each `@interface func` defined in a witx module, an abi-level
+///       function is generated which takes ABI-level arguments, along with
+///       a ref that impls the module trait, and a `GuestMemory` implementation.
+///       Users typically won't use these abi-level functions: Either the
+///       `wasmtime_integration` macro or the `lucet-wiggle` crates adapt these
+///       to work with a particular WebAssembly engine.
+///
+///     * A public "module trait" is defined (called the module name, in
+///       SnakeCase) which has a `&self` method for each function in the
+///       module. These methods takes idiomatic Rust types for each argument
+///       and return `Result<($return_types),$error_type>`
+///
+///     * When the `wiggle` crate is built with the `wasmtime_integration`
+///     feature, each module contains an `add_to_linker` function to add it to
+///     a `wasmtime::Linker`.
+///
+/// Arguments are provided using Rust struct value syntax.
+///
+/// * `witx` takes a list of string literal paths. Paths are relative to the
+///   CARGO_MANIFEST_DIR of the crate where the macro is invoked. Alternatively,
+///   `witx_literal` takes a string containing a complete witx document.
+/// * Optional: `errors` takes a mapping of witx identifiers to types, e.g
+///   `{ errno => YourErrnoType }`. This allows you to use the `UserErrorConversion`
+///   trait to map these rich errors into the flat witx type, or to terminate
+///   WebAssembly execution by trapping.
+///     * Instead of requiring the user to define an error type, wiggle can
+///       generate an error type for the user which has conversions to/from
+///       the base type, and permits trapping, using the syntax
+///       `errno => trappable AnErrorType`.
+/// * Optional: `async` takes a set of witx modules and functions which are
+///   made Rust `async` functions in the module trait.
+///
+/// ## Example
+///
+/// ```
+/// use wiggle::GuestPtr;
+/// wiggle::from_witx!({
+///     witx_literal: "
+///         (typename $errno
+///           (enum (@witx tag u32)
+///             $ok
+///             $invalid_arg
+///             $io
+///             $overflow))
+///          (typename $alias_to_float f32)
+///          (module $example
+///            (@interface func (export \"int_float_args\")
+///              (param $an_int u32)
+///              (param $some_floats (list f32))
+///              (result $r (expected (error $errno))))
+///            (@interface func (export \"double_int_return_float\")
+///              (param $an_int u32)
+///              (result $r (expected $alias_to_float (error $errno)))))
+///     ",
+///     errors: { errno => YourRichError },
+///     async: { example::double_int_return_float },
+/// });
+///
+/// /// Witx generates a set of traits, which the user must impl on a
+/// /// type they define. We call this the ctx type. It stores any context
+/// /// these functions need to execute.
+/// pub struct YourCtxType {}
+///
+/// /// Witx provides a hook to translate "rich" (arbitrary Rust type) errors
+/// /// into the flat error enums used at the WebAssembly interface. You will
+/// /// need to impl the `types::UserErrorConversion` trait to provide a translation
+/// /// from this rich type.
+/// #[derive(Debug)]
+/// pub enum YourRichError {
+///     InvalidArg(String),
+///     Io(std::io::Error),
+///     Overflow,
+///     Trap(String),
+/// }
+///
+/// /// The above witx text contains one module called `$example`. So, we must
+/// /// implement this one method trait for our ctx type.
+/// #[wiggle::async_trait]
+/// /// We specified in the `async_` field that `example::double_int_return_float`
+/// /// is an asynchronous method. Therefore, we use the `async_trait` proc macro
+/// /// to define this trait, so that `double_int_return_float` can be an `async fn`.
+/// /// `wiggle::async_trait` is defined as `#[async_trait::async_trait(?Send)]` -
+/// /// in wiggle, async methods do not have the Send constaint.
+/// impl example::Example for YourCtxType {
+///     /// The arrays module has two methods, shown here.
+///     /// Note that the `GuestPtr` type comes from `wiggle`,
+///     /// whereas the witx-defined types like `Excuse` and `Errno` come
+///     /// from the `pub mod types` emitted by the `wiggle::from_witx!`
+///     /// invocation above.
+///     fn int_float_args(&mut self, _int: u32, _floats: &GuestPtr<[f32]>)
+///         -> Result<(), YourRichError> {
+///         unimplemented!()
+///     }
+///     async fn double_int_return_float(&mut self, int: u32)
+///         -> Result<f32, YourRichError> {
+///         Ok(int.checked_mul(2).ok_or(YourRichError::Overflow)? as f32)
+///     }
+/// }
+///
+/// /// For all types used in the `error` an `expected` in the witx document,
+/// /// you must implement `GuestErrorType` which tells wiggle-generated
+/// /// code what value to return when the method returns Ok(...).
+/// impl wiggle::GuestErrorType for types::Errno {
+///     fn success() -> Self {
+///         unimplemented!()
+///     }
+/// }
+///
+/// /// If you specify a `error` mapping to the macro, you must implement the
+/// /// `types::UserErrorConversion` for your ctx type as well. This trait gives
+/// /// you an opportunity to store or log your rich error type, while returning
+/// /// a basic witx enum to the WebAssembly caller. It also gives you the ability
+/// /// to terminate WebAssembly execution by trapping.
+///
+/// impl types::UserErrorConversion for YourCtxType {
+///     fn errno_from_your_rich_error(&mut self, e: YourRichError)
+///         -> Result<types::Errno, wiggle::wasmtime_crate::Error>
+///     {
+///         println!("Rich error: {:?}", e);
+///         match e {
+///             YourRichError::InvalidArg{..} => Ok(types::Errno::InvalidArg),
+///             YourRichError::Io{..} => Ok(types::Errno::Io),
+///             YourRichError::Overflow => Ok(types::Errno::Overflow),
+///             YourRichError::Trap(s) => Err(wiggle::wasmtime_crate::Error::msg(s)),
+///         }
+///     }
+/// }
+///
+/// # fn main() { println!("this fools doc tests into compiling the above outside a function body")
+/// # }
+/// ```
+#[proc_macro]
+pub fn from_witx(args: TokenStream) -> TokenStream {
+    let config = parse_macro_input!(args as wiggle_generate::Config);
+
+    let doc = config.load_document();
+
+    let settings = wiggle_generate::CodegenSettings::new(
+        &config.errors,
+        &config.async_,
+        &doc,
+        config.wasmtime,
+        &config.tracing,
+        config.mutable,
+    )
+    .expect("validating codegen settings");
+
+    let code = wiggle_generate::generate(&doc, &settings);
+    let metadata = if cfg!(feature = "wiggle_metadata") {
+        wiggle_generate::generate_metadata(&doc)
+    } else {
+        quote!()
+    };
+
+    TokenStream::from(quote! { #code #metadata })
+}
+
+#[proc_macro_attribute]
+pub fn async_trait(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let _ = parse_macro_input!(attr as syn::parse::Nothing);
+    let item = proc_macro2::TokenStream::from(item);
+    TokenStream::from(quote! {
+        #[wiggle::async_trait_crate::async_trait]
+        #item
+    })
+}
+
+/// Define the structs required to integrate a Wiggle implementation with Wasmtime.
+///
+/// ## Arguments
+///
+/// Arguments are provided using struct syntax e.g. `{ arg_name: value }`.
+///
+/// * `target`: The path of the module where the Wiggle implementation is defined.
+#[proc_macro]
+pub fn wasmtime_integration(args: TokenStream) -> TokenStream {
+    let config = parse_macro_input!(args as wiggle_generate::WasmtimeConfig);
+    let doc = config.c.load_document();
+
+    let settings = wiggle_generate::CodegenSettings::new(
+        &config.c.errors,
+        &config.c.async_,
+        &doc,
+        true,
+        &config.c.tracing,
+        config.c.mutable,
+    )
+    .expect("validating codegen settings");
+
+    let modules = doc.modules().map(|module| {
+        wiggle_generate::wasmtime::link_module(&module, Some(&config.target), &settings)
+    });
+    quote!( #(#modules)* ).into()
+}

data/ext/cargo-vendor/winch-codegen-0.8.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"40d5a5be7a45cefffcbeabacbda57fbaf0fa08bceff30ae0c11d39dc79727cca","LICENSE":"a6c48161a09acc75a0e25503bab66a731eb5fba5392ed4bb4743e4ba5085327a","build.rs":"d19fe439db9b48a8bf91af26001c20ea6010633133bc52a13679720187a7cf1b","src/abi/local.rs":"9ad1d5acd30f25ca4f5fdc162164a885544b69ebf61e80d779c71e509636e5f0","src/abi/mod.rs":"ab508b9c96cf0d8e62fc7bcce8cb834741147b0498b66d5189c95f70558e4e26","src/codegen/call.rs":"fa92c997f42a511b5f97df67825d6878793cff67e8a69290a8590563265f7bae","src/codegen/context.rs":"492ea094e8088710facfa322b4ce429e1ac6bb2433b719bb2bbeac0cea06cfe3","src/codegen/env.rs":"235f616cf88c240ff95552edb5a318bd27b9d2c2354ac33425a4630219ca2838","src/codegen/mod.rs":"a4dcd78254abfc97375e9a52cc7b867f75adb7c2a0d0691c3ac59343fe4f8347","src/frame/mod.rs":"b63637e32c99ffae244f5e16b6a575ae27ebebc5837d862b58bb8ade238d7713","src/isa/aarch64/abi.rs":"d5d645bbfc546e20ac2145bda5b6140540434ba4adfd353f09c5a9af62ab4ebc","src/isa/aarch64/address.rs":"1e876d8003fd6eab8cfff387a38942f781c2db497059bdec5582d022773bc180","src/isa/aarch64/asm.rs":"f65dba407755ac8315345dba0717d4d53be3f562a76001760925a11a181bd520","src/isa/aarch64/masm.rs":"687535c92e8e1efef65a07c4736d43c1d89e372e2360c5ca3f35cf3da995737c","src/isa/aarch64/mod.rs":"0f760a84f5cbe64d42aa5dbf08a2dac982a1216c028d478c7aae3d2df7dcda58","src/isa/aarch64/regs.rs":"6e33edfdc3011e6612346e4e8999a3b1739b8dd022845eb07673f7a19ac448c5","src/isa/mod.rs":"f0830bbe07b467afffab6defc76811aaeaec9d975df0c7e7a3abc5e99f80acd3","src/isa/reg.rs":"da6b570252d913d70a2b8ffa67745e83bd3438b26b74e45adf683a0596a5d14d","src/isa/x64/abi.rs":"a4a54690748c9c673d04f7279b63d1accea7f113d7de267df9c7d5b931a28145","src/isa/x64/address.rs":"38810e5806d7102fe1d9a7f34d131d55474341a6c43501bc087ffcf33ae3882d","src/isa/x64/asm.rs":"32162b0bf5b3347bf837d41c8e9f92a40d2e005565ca859ad9e7781bf5beb606","src/isa/x64/masm.rs":"facbaf8c767f821c18fbedd913de0f6c4212170e12aa428ba3af27cf0132f774","src/isa/x64/mod.rs":"3920db439c300e9078f3f6688238031954787287a42f5879d231251bdf0bf22b","src/isa/x64/regs.rs":"241bf1079bc75cc274924c5d6e6a799e4411c24cd9201f0805f7e9ef279052dc","src/lib.rs":"d57d657ee8425b77292ed0a835c05b4047bc75f81ff79d61efd48a8d7f8ac69b","src/masm.rs":"3dfa7b55a0204b65e460ded4177f42497eb30169b75663d3931180c3ff3d3356","src/regalloc.rs":"14cce7251efd0536f5e1c1e925aeb2cefd4b6e017ae76b3681db2882a127589e","src/regset.rs":"020e076ee2f1f10cc4c7249a56f2a09d48b2097f38775e4a7431200d357db435","src/stack.rs":"0ba246a23c84e745988c0edbedc27605a13c8901f409c4aca070ecba371f1761","src/trampoline.rs":"860edde29ae0eba4cb28c8c77125ae974961f818d7c97d7069ac326a9107731a","src/visitor.rs":"da16ebc7a9eb2de9d253a0158c53d227309fe6fa07aef501429dce0757a61b85"},"package":"525fdd0d4e82d1bd3083bd87e8ca8014abfbdc5bf290d1d5371dac440d351e89"}

data/ext/cargo-vendor/winch-codegen-0.8.1/Cargo.toml

@@ -0,0 +1,62 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "winch-codegen"
+version = "0.8.1"
+authors = ["The Winch Project Developers"]
+description = "Winch code generation library"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.cranelift-codegen]
+version = "0.97.1"
+
+[dependencies.gimli]
+version = "0.27.0"
+features = [
+    "read",
+    "std",
+]
+default-features = false
+
+[dependencies.regalloc2]
+version = "0.9.1"
+
+[dependencies.smallvec]
+version = "1.6.1"
+features = ["union"]
+
+[dependencies.target-lexicon]
+version = "0.12.3"
+features = [
+    "std",
+    "std",
+]
+default-features = false
+
+[dependencies.wasmparser]
+version = "0.107.0"
+
+[dependencies.wasmtime-environ]
+version = "=10.0.1"
+
+[features]
+all-arch = [
+    "x64",
+    "arm64",
+]
+arm64 = ["cranelift-codegen/arm64"]
+x64 = ["cranelift-codegen/x86"]

data/ext/cargo-vendor/winch-codegen-0.8.1/src/abi/local.rs

@@ -0,0 +1,70 @@
+use wasmtime_environ::WasmType;
+
+/// Base register used to address the local slot.
+///
+/// Slots for stack arguments are addressed from the frame pointer.
+/// Slots for function-defined locals and for registers are addressed
+/// from the stack pointer.
+#[derive(Clone, Eq, PartialEq)]
+enum Base {
+    FP,
+    SP,
+}
+
+/// A local slot.
+///
+/// Represents the type, location and addressing mode of a local
+/// in the stack's local and argument area.
+#[derive(Clone)]
+pub(crate) struct LocalSlot {
+    /// The offset of the local slot.
+    pub offset: u32,
+    /// The type contained by this local slot.
+    pub ty: WasmType,
+    /// Base register associated to this local slot.
+    base: Base,
+}
+
+impl LocalSlot {
+    /// Creates a local slot for a function defined local or
+    /// for a spilled argument register.
+    pub fn new(ty: WasmType, offset: u32) -> Self {
+        Self {
+            ty,
+            offset,
+            base: Base::SP,
+        }
+    }
+
+    /// Int32 shortcut for `new`.
+    pub fn i32(offset: u32) -> Self {
+        Self {
+            ty: WasmType::I32,
+            offset,
+            base: Base::SP,
+        }
+    }
+
+    /// Int64 shortcut for `new`.
+    pub fn i64(offset: u32) -> Self {
+        Self {
+            ty: WasmType::I64,
+            offset,
+            base: Base::SP,
+        }
+    }
+
+    /// Creates a local slot for a stack function argument.
+    pub fn stack_arg(ty: WasmType, offset: u32) -> Self {
+        Self {
+            ty,
+            offset,
+            base: Base::FP,
+        }
+    }
+
+    /// Check if the local is addressed from the stack pointer.
+    pub fn addressed_from_sp(&self) -> bool {
+        self.base == Base::SP
+    }
+}

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

@@ -0,0 +1,237 @@
+//! This module provides all the necessary building blocks for
+//! implementing ISA specific ABIs.
+//!
+//! # Default ABI
+//!
+//! Winch uses a default internal ABI, for all internal functions.
+//! This allows us to push the complexity of system ABI compliance to
+//! the trampolines (not yet implemented).  The default ABI treats all
+//! allocatable registers as caller saved, which means that (i) all
+//! register values in the Wasm value stack (which are normally
+//! referred to as "live"), must be saved onto the machine stack (ii)
+//! function prologues and epilogues don't store/restore other
+//! registers more than the non-allocatable ones (e.g. rsp/rbp in
+//! x86_64).
+//!
+//! The calling convention in the default ABI, uses registers to a
+//! certain fixed count for arguments and return values, and then the
+//! stack is used for all additional arguments.
+//!
+//! Generally the stack layout looks like:
+//! +-------------------------------+
+//! |                               |
+//! |                               |
+//! |         Stack Args            |
+//! |                               |
+//! |                               |
+//! +-------------------------------+----> SP @ function entry
+//! |         Ret addr              |
+//! +-------------------------------+
+//! |            SP                 |
+//! +-------------------------------+----> SP @ Function prologue
+//! |                               |
+//! |                               |
+//! |                               |
+//! |        Stack slots            |
+//! |        + `VMContext` slot     |
+//! |        + dynamic space        |
+//! |                               |
+//! |                               |
+//! |                               |
+//! +-------------------------------+----> SP @ callsite (after)
+//! |        alignment              |
+//! |        + arguments            |
+//! |                               | ----> Space allocated for calls
+//! |                               |
+use crate::isa::{reg::Reg, CallingConvention};
+use smallvec::SmallVec;
+use std::ops::{Add, BitAnd, Not, Sub};
+use wasmtime_environ::{WasmFuncType, WasmType};
+
+pub(crate) mod local;
+pub(crate) use local::*;
+
+/// Trait implemented by a specific ISA and used to provide
+/// information about alignment, parameter passing, usage of
+/// specific registers, etc.
+pub(crate) trait ABI {
+    /// The required stack alignment.
+    fn stack_align() -> u8;
+
+    /// The required stack alignment for calls.
+    fn call_stack_align() -> u8;
+
+    /// The offset to the argument base, relative to the frame pointer.
+    fn arg_base_offset() -> u8;
+
+    /// The offset to the return address, relative to the frame pointer.
+    fn ret_addr_offset() -> u8;
+
+    /// Construct the ABI-specific signature from a WebAssembly
+    /// function type.
+    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig;
+
+    /// Returns the number of bits in a word.
+    fn word_bits() -> u32;
+
+    /// Returns the number of bytes in a word.
+    fn word_bytes() -> u32 {
+        Self::word_bits() / 8
+    }
+
+    /// Returns the designated scratch register.
+    fn scratch_reg() -> Reg;
+
+    /// Returns the frame pointer register.
+    fn fp_reg() -> Reg;
+
+    /// Returns the stack pointer register.
+    fn sp_reg() -> Reg;
+
+    /// Returns the pinned register used to hold
+    /// the `VMContext`.
+    fn vmctx_reg() -> Reg;
+
+    /// Returns the callee-saved registers for the given
+    /// calling convention.
+    fn callee_saved_regs(call_conv: &CallingConvention) -> SmallVec<[Reg; 9]>;
+}
+
+/// ABI-specific representation of a function argument.
+#[derive(Debug)]
+pub(crate) enum ABIArg {
+    /// A register argument.
+    Reg {
+        /// Type of the argument.
+        ty: WasmType,
+        /// Register holding the argument.
+        reg: Reg,
+    },
+    /// A stack argument.
+    Stack {
+        /// The type of the argument.
+        ty: WasmType,
+        /// Offset of the argument relative to the frame pointer.
+        offset: u32,
+    },
+}
+
+impl ABIArg {
+    /// Allocate a new register abi arg.
+    pub fn reg(reg: Reg, ty: WasmType) -> Self {
+        Self::Reg { reg, ty }
+    }
+
+    /// Allocate a new stack abi arg.
+    pub fn stack_offset(offset: u32, ty: WasmType) -> Self {
+        Self::Stack { ty, offset }
+    }
+
+    /// Is this abi arg in a register.
+    pub fn is_reg(&self) -> bool {
+        match *self {
+            ABIArg::Reg { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Get the register associated to this arg.
+    pub fn get_reg(&self) -> Option<Reg> {
+        match *self {
+            ABIArg::Reg { reg, .. } => Some(reg),
+            _ => None,
+        }
+    }
+
+    /// Get the type associated to this arg.
+    pub fn ty(&self) -> WasmType {
+        match *self {
+            ABIArg::Reg { ty, .. } | ABIArg::Stack { ty, .. } => ty,
+        }
+    }
+}
+
+/// ABI-specific representation of the function result.
+pub(crate) enum ABIResult {
+    Reg {
+        /// Type of the result.
+        ty: Option<WasmType>,
+        /// Register to hold the result.
+        reg: Reg,
+    },
+}
+
+impl ABIResult {
+    /// Create a register ABI result.
+    pub fn reg(ty: Option<WasmType>, reg: Reg) -> Self {
+        Self::Reg { ty, reg }
+    }
+
+    /// Get the result reg.
+    pub fn result_reg(&self) -> Reg {
+        match self {
+            Self::Reg { reg, .. } => *reg,
+        }
+    }
+
+    /// Checks if the result is void.
+    pub fn is_void(&self) -> bool {
+        match self {
+            Self::Reg { ty, .. } => ty.is_none(),
+        }
+    }
+}
+
+pub(crate) type ABIParams = SmallVec<[ABIArg; 6]>;
+
+/// An ABI-specific representation of a function signature.
+pub(crate) struct ABISig {
+    /// Function parameters.
+    pub params: ABIParams,
+    /// Function result.
+    pub result: ABIResult,
+    /// Stack space needed for stack arguments.
+    pub stack_bytes: u32,
+}
+
+impl ABISig {
+    /// Create a new ABI signature.
+    pub fn new(params: ABIParams, result: ABIResult, stack_bytes: u32) -> Self {
+        Self {
+            params,
+            result,
+            stack_bytes,
+        }
+    }
+}
+
+/// Returns the size in bytes of a given WebAssembly type.
+pub(crate) fn ty_size(ty: &WasmType) -> u32 {
+    match *ty {
+        WasmType::I32 | WasmType::F32 => 4,
+        WasmType::I64 | WasmType::F64 => 8,
+        _ => panic!(),
+    }
+}
+
+/// Align a value up to the given power-of-two-alignment.
+// See https://sites.google.com/site/theoryofoperatingsystems/labs/malloc/align8
+pub(crate) fn align_to<N>(value: N, alignment: N) -> N
+where
+    N: Not<Output = N>
+        + BitAnd<N, Output = N>
+        + Add<N, Output = N>
+        + Sub<N, Output = N>
+        + From<u8>
+        + Copy,
+{
+    let alignment_mask = alignment - 1.into();
+    (value + alignment_mask) & !alignment_mask
+}
+
+/// Calculates the delta needed to adjust a function's frame plus some
+/// addend to a given alignment.
+pub(crate) fn calculate_frame_adjustment(frame_size: u32, addend: u32, alignment: u32) -> u32 {
+    let total = frame_size + addend;
+    (alignment - (total % alignment)) % alignment
+}