wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/component.rs

@@ -0,0 +1,107 @@
+//! Support for the component model in Wasmtime.
+//!
+//! This module contains all of the internal type definitions used by Wasmtime
+//! to process the component model. Despite everything being `pub` here this is
+//! not the public interface of Wasmtime to the component model. Instead this is
+//! the internal support to mirror the core wasm support that Wasmtime already
+//! implements.
+//!
+//! Some main items contained within here are:
+//!
+//! * Type hierarchy information for the component model
+//! * Translation of a component into Wasmtime's representation
+//! * Type information about a component used at runtime
+//!
+//! This module also contains a lot of Serialize/Deserialize types which are
+//! encoded in the final compiled image for a component.
+//!
+//! Note that this entire module is gated behind the `component-model` Cargo
+//! feature.
+//!
+//! ## Warning: In-progress
+//!
+//! As-of the time of this writing this module is incomplete and under
+//! development. It will be added to incrementally over time as more features
+//! are implemented. Current design decisions are also susceptible to change at
+//! any time. Some comments may reflect historical rather than current state as
+//! well (sorry).
+
+/// Canonical ABI-defined constant for the maximum number of "flat" parameters
+/// to a wasm function, or the maximum number of parameters a core wasm function
+/// will take for just the parameters used. Over this number the heap is used
+/// for transferring parameters.
+pub const MAX_FLAT_PARAMS: usize = 16;
+
+/// Canonical ABI-defined constant for the maximum number of "flat" results.
+/// This number of results are returned directly from wasm and otherwise results
+/// are transferred through memory.
+pub const MAX_FLAT_RESULTS: usize = 1;
+
+mod artifacts;
+mod info;
+mod types;
+mod vmcomponent_offsets;
+pub use self::artifacts::*;
+pub use self::info::*;
+pub use self::types::*;
+pub use self::vmcomponent_offsets::*;
+
+#[cfg(feature = "compile")]
+mod compiler;
+#[cfg(feature = "compile")]
+pub mod dfg;
+#[cfg(feature = "compile")]
+mod translate;
+#[cfg(feature = "compile")]
+mod types_builder;
+#[cfg(feature = "compile")]
+pub use self::compiler::*;
+#[cfg(feature = "compile")]
+pub use self::translate::*;
+#[cfg(feature = "compile")]
+pub use self::types_builder::*;
+
+/// Helper macro to iterate over the transcoders that the host will provide
+/// adapter modules through libcalls.
+#[macro_export]
+macro_rules! foreach_transcoder {
+    ($mac:ident) => {
+        $mac! {
+            utf8_to_utf8(src: ptr_u8, len: size, dst: ptr_u8);
+            utf16_to_utf16(src: ptr_u16, len: size, dst: ptr_u16);
+            latin1_to_latin1(src: ptr_u8, len: size, dst: ptr_u8);
+            latin1_to_utf16(src: ptr_u8, len: size, dst: ptr_u16);
+            utf8_to_utf16(src: ptr_u8, len: size, dst: ptr_u16) -> size;
+            utf16_to_utf8(src: ptr_u16, src_len: size, dst: ptr_u8, dst_len: size, ret2: ptr_size) -> size;
+            latin1_to_utf8(src: ptr_u8, src_len: size, dst: ptr_u8, dst_len: size, ret2: ptr_size) -> size;
+            utf16_to_compact_probably_utf16(src: ptr_u16, len: size, dst: ptr_u16) -> size;
+            utf8_to_latin1(src: ptr_u8, len: size, dst: ptr_u8, ret2: ptr_size) -> size;
+            utf16_to_latin1(src: ptr_u16, len: size, dst: ptr_u8, ret2: ptr_size) -> size;
+            utf8_to_compact_utf16(src: ptr_u8, src_len: size, dst: ptr_u16, dst_len: size, bytes_so_far: size) -> size;
+            utf16_to_compact_utf16(src: ptr_u16, src_len: size, dst: ptr_u16, dst_len: size, bytes_so_far: size) -> size;
+        }
+    };
+}
+
+/// Helper macro, like `foreach_transcoder`, to iterate over builtins for
+/// components unrelated to transcoding.
+#[macro_export]
+macro_rules! foreach_builtin_component_function {
+    ($mac:ident) => {
+        $mac! {
+            resource_new32(vmctx: vmctx, resource: u32, rep: u32) -> u32;
+            resource_rep32(vmctx: vmctx, resource: u32, idx: u32) -> u32;
+
+            // Returns an `Option<u32>` where `None` is "no destructor needed"
+            // and `Some(val)` is "run the destructor on this rep". The option
+            // is encoded as a 64-bit integer where the low bit is Some/None
+            // and bits 1-33 are the payload.
+            resource_drop(vmctx: vmctx, resource: u32, idx: u32) -> u64;
+
+            resource_transfer_own(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u32;
+            resource_transfer_borrow(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u32;
+            resource_enter_call(vmctx: vmctx);
+            resource_exit_call(vmctx: vmctx);
+        }
+    };
+}

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/demangling.rs

@@ -0,0 +1,28 @@
+//! Helpers for demangling function names.
+
+/// Demangles a single function name into a user-readable form.
+///
+/// Currently supported: Rust/C/C++ function names.
+pub fn demangle_function_name(writer: &mut impl core::fmt::Write, name: &str) -> core::fmt::Result {
+    #[cfg(feature = "demangle")]
+    if let Ok(demangled) = rustc_demangle::try_demangle(name) {
+        return write!(writer, "{}", demangled);
+    } else if let Ok(demangled) = cpp_demangle::Symbol::new(name) {
+        return write!(writer, "{}", demangled);
+    }
+
+    write!(writer, "{}", name)
+}
+
+/// Demangles a function name if it's provided, or returns a unified representation based on the
+/// function index otherwise.
+pub fn demangle_function_name_or_index(
+    writer: &mut impl core::fmt::Write,
+    name: Option<&str>,
+    func_id: usize,
+) -> core::fmt::Result {
+    match name {
+        Some(name) => demangle_function_name(writer, name),
+        None => write!(writer, "<wasm function {}>", func_id),
+    }
+}

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/fact/core_types.rs

@@ -0,0 +1,25 @@
+use crate::prelude::*;
+use std::collections::HashMap;
+use wasm_encoder::{TypeSection, ValType};
+
+/// A simple representation of the type section which automatically intern's
+/// types and ensures they're only defined once.
+#[derive(Default)]
+pub struct CoreTypes {
+    pub section: TypeSection,
+    intern: HashMap<(Vec<ValType>, Vec<ValType>), u32>,
+}
+
+impl CoreTypes {
+    pub fn function(&mut self, params: &[ValType], results: &[ValType]) -> u32 {
+        *self
+            .intern
+            .entry((params.to_vec(), results.to_vec()))
+            .or_insert_with(|| {
+                let idx = self.section.len();
+                self.section
+                    .function(params.iter().copied(), results.iter().copied());
+                idx
+            })
+    }
+}

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/fact/signature.rs

@@ -0,0 +1,119 @@
+//! Size, align, and flattening information about component model types.
+
+use crate::component::{ComponentTypesBuilder, InterfaceType, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS};
+use crate::fact::{AdapterOptions, Context, Options};
+use crate::prelude::*;
+use wasm_encoder::ValType;
+
+/// Metadata about a core wasm signature which is created for a component model
+/// signature.
+#[derive(Debug)]
+pub struct Signature {
+    /// Core wasm parameters.
+    pub params: Vec<ValType>,
+    /// Core wasm results.
+    pub results: Vec<ValType>,
+}
+
+impl ComponentTypesBuilder {
+    /// Calculates the core wasm function signature for the component function
+    /// type specified within `Context`.
+    ///
+    /// This is used to generate the core wasm signatures for functions that are
+    /// imported (matching whatever was `canon lift`'d) and functions that are
+    /// exported (matching the generated function from `canon lower`).
+    pub(super) fn signature(&self, options: &AdapterOptions, context: Context) -> Signature {
+        let ty = &self[options.ty];
+        let ptr_ty = options.options.ptr();
+
+        let mut params = match self.flatten_types(
+            &options.options,
+            MAX_FLAT_PARAMS,
+            self[ty.params].types.iter().copied(),
+        ) {
+            Some(list) => list,
+            None => {
+                vec![ptr_ty]
+            }
+        };
+
+        let results = match self.flatten_types(
+            &options.options,
+            MAX_FLAT_RESULTS,
+            self[ty.results].types.iter().map(|ty| *ty),
+        ) {
+            Some(list) => list,
+            None => {
+                match context {
+                    // For a lifted function too-many-results gets translated to a
+                    // returned pointer where results are read from. The callee
+                    // allocates space here.
+                    Context::Lift => vec![ptr_ty],
+                    // For a lowered function too-many-results becomes a return
+                    // pointer which is passed as the last argument. The caller
+                    // allocates space here.
+                    Context::Lower => {
+                        params.push(ptr_ty);
+                        Vec::new()
+                    }
+                }
+            }
+        };
+        Signature { params, results }
+    }
+
+    /// Pushes the flat version of a list of component types into a final result
+    /// list.
+    pub(super) fn flatten_types(
+        &self,
+        opts: &Options,
+        max: usize,
+        tys: impl IntoIterator<Item = InterfaceType>,
+    ) -> Option<Vec<ValType>> {
+        let mut dst = Vec::new();
+        for ty in tys {
+            for ty in opts.flat_types(&ty, self)? {
+                if dst.len() == max {
+                    return None;
+                }
+                dst.push((*ty).into());
+            }
+        }
+        Some(dst)
+    }
+
+    pub(super) fn align(&self, opts: &Options, ty: &InterfaceType) -> u32 {
+        self.size_align(opts, ty).1
+    }
+
+    /// Returns a (size, align) pair corresponding to the byte-size and
+    /// byte-alignment of the type specified.
+    //
+    // TODO: this is probably inefficient to entire recalculate at all phases,
+    // seems like it would be best to intern this in some sort of map somewhere.
+    pub(super) fn size_align(&self, opts: &Options, ty: &InterfaceType) -> (u32, u32) {
+        let abi = self.canonical_abi(ty);
+        if opts.memory64 {
+            (abi.size64, abi.align64)
+        } else {
+            (abi.size32, abi.align32)
+        }
+    }
+
+    /// Tests whether the type signature for `options` contains a borrowed
+    /// resource anywhere.
+    pub(super) fn contains_borrow_resource(&self, options: &AdapterOptions) -> bool {
+        let ty = &self[options.ty];
+
+        // Only parameters need to be checked since results should never have
+        // borrowed resources.
+        debug_assert!(!self[ty.results]
+            .types
+            .iter()
+            .any(|t| self.ty_contains_borrow_resource(t)));
+        self[ty.params]
+            .types
+            .iter()
+            .any(|t| self.ty_contains_borrow_resource(t))
+    }
+}