wasmtime 11.0.0 → 12.0.1

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

@@ -0,0 +1,316 @@
+// Currently the `VMComponentContext` allocation by field looks like this:
+//
+// struct VMComponentContext {
+//      magic: u32,
+//      libcalls: &'static VMComponentLibcalls,
+//      store: *mut dyn Store,
+//      limits: *const VMRuntimeLimits,
+//      flags: [VMGlobalDefinition; component.num_runtime_component_instances],
+//      trampoline_func_refs: [VMFuncRef; component.num_trampolines],
+//      lowerings: [VMLowering; component.num_lowerings],
+//      memories: [*mut VMMemoryDefinition; component.num_memories],
+//      reallocs: [*mut VMFuncRef; component.num_reallocs],
+//      post_returns: [*mut VMFuncRef; component.num_post_returns],
+//      resource_destructors: [*mut VMFuncRef; component.num_resources],
+// }
+
+use crate::component::*;
+use crate::PtrSize;
+
+/// Equivalent of `VMCONTEXT_MAGIC` except for components.
+///
+/// This is stored at the start of all `VMComponentContext` structures and
+/// double-checked on `VMComponentContext::from_opaque`.
+pub const VMCOMPONENT_MAGIC: u32 = u32::from_le_bytes(*b"comp");
+
+/// Flag for the `VMComponentContext::flags` field which corresponds to the
+/// canonical ABI flag `may_leave`
+pub const FLAG_MAY_LEAVE: i32 = 1 << 0;
+
+/// Flag for the `VMComponentContext::flags` field which corresponds to the
+/// canonical ABI flag `may_enter`
+pub const FLAG_MAY_ENTER: i32 = 1 << 1;
+
+/// Flag for the `VMComponentContext::flags` field which is set whenever a
+/// function is called to indicate that `post_return` must be called next.
+pub const FLAG_NEEDS_POST_RETURN: i32 = 1 << 2;
+
+/// Runtime offsets within a `VMComponentContext` for a specific component.
+#[derive(Debug, Clone, Copy)]
+pub struct VMComponentOffsets<P> {
+    /// The host pointer size
+    pub ptr: P,
+
+    /// The number of lowered functions this component will be creating.
+    pub num_lowerings: u32,
+    /// The number of memories which are recorded in this component for options.
+    pub num_runtime_memories: u32,
+    /// The number of reallocs which are recorded in this component for options.
+    pub num_runtime_reallocs: u32,
+    /// The number of post-returns which are recorded in this component for options.
+    pub num_runtime_post_returns: u32,
+    /// Number of component instances internally in the component (always at
+    /// least 1).
+    pub num_runtime_component_instances: u32,
+    /// Number of cranelift-compiled trampolines required for this component.
+    pub num_trampolines: u32,
+    /// Number of resources within a component which need destructors stored.
+    pub num_resources: u32,
+
+    // precalculated offsets of various member fields
+    magic: u32,
+    libcalls: u32,
+    store: u32,
+    limits: u32,
+    flags: u32,
+    trampoline_func_refs: u32,
+    lowerings: u32,
+    memories: u32,
+    reallocs: u32,
+    post_returns: u32,
+    resource_destructors: u32,
+    size: u32,
+}
+
+#[inline]
+fn align(offset: u32, align: u32) -> u32 {
+    assert!(align.is_power_of_two());
+    (offset + (align - 1)) & !(align - 1)
+}
+
+impl<P: PtrSize> VMComponentOffsets<P> {
+    /// Creates a new set of offsets for the `component` specified configured
+    /// additionally for the `ptr` size specified.
+    pub fn new(ptr: P, component: &Component) -> Self {
+        let mut ret = Self {
+            ptr,
+            num_lowerings: component.num_lowerings,
+            num_runtime_memories: component.num_runtime_memories.try_into().unwrap(),
+            num_runtime_reallocs: component.num_runtime_reallocs.try_into().unwrap(),
+            num_runtime_post_returns: component.num_runtime_post_returns.try_into().unwrap(),
+            num_runtime_component_instances: component
+                .num_runtime_component_instances
+                .try_into()
+                .unwrap(),
+            num_trampolines: component.trampolines.len().try_into().unwrap(),
+            num_resources: component.num_resources,
+            magic: 0,
+            libcalls: 0,
+            store: 0,
+            limits: 0,
+            flags: 0,
+            trampoline_func_refs: 0,
+            lowerings: 0,
+            memories: 0,
+            reallocs: 0,
+            post_returns: 0,
+            resource_destructors: 0,
+            size: 0,
+        };
+
+        // Convenience functions for checked addition and multiplication.
+        // As side effect this reduces binary size by using only a single
+        // `#[track_caller]` location for each function instead of one for
+        // each individual invocation.
+        #[inline]
+        fn cmul(count: u32, size: u8) -> u32 {
+            count.checked_mul(u32::from(size)).unwrap()
+        }
+
+        let mut next_field_offset = 0;
+
+        macro_rules! fields {
+            (size($field:ident) = $size:expr, $($rest:tt)*) => {
+                ret.$field = next_field_offset;
+                next_field_offset = next_field_offset.checked_add(u32::from($size)).unwrap();
+                fields!($($rest)*);
+            };
+            (align($align:expr), $($rest:tt)*) => {
+                next_field_offset = align(next_field_offset, $align);
+                fields!($($rest)*);
+            };
+            () => {};
+        }
+
+        fields! {
+            size(magic) = 4u32,
+            align(u32::from(ret.ptr.size())),
+            size(libcalls) = ret.ptr.size(),
+            size(store) = cmul(2, ret.ptr.size()),
+            size(limits) = ret.ptr.size(),
+            align(16),
+            size(flags) = cmul(ret.num_runtime_component_instances, ret.ptr.size_of_vmglobal_definition()),
+            align(u32::from(ret.ptr.size())),
+            size(trampoline_func_refs) = cmul(ret.num_trampolines, ret.ptr.size_of_vm_func_ref()),
+            size(lowerings) = cmul(ret.num_lowerings, ret.ptr.size() * 2),
+            size(memories) = cmul(ret.num_runtime_memories, ret.ptr.size()),
+            size(reallocs) = cmul(ret.num_runtime_reallocs, ret.ptr.size()),
+            size(post_returns) = cmul(ret.num_runtime_post_returns, ret.ptr.size()),
+            size(resource_destructors) = cmul(ret.num_resources, ret.ptr.size()),
+        }
+
+        ret.size = next_field_offset;
+
+        // This is required by the implementation of
+        // `VMComponentContext::from_opaque`. If this value changes then this
+        // location needs to be updated.
+        assert_eq!(ret.magic, 0);
+
+        return ret;
+    }
+
+    /// The size, in bytes, of the host pointer.
+    #[inline]
+    pub fn pointer_size(&self) -> u8 {
+        self.ptr.size()
+    }
+
+    /// The offset of the `magic` field.
+    #[inline]
+    pub fn magic(&self) -> u32 {
+        self.magic
+    }
+
+    /// The offset of the `libcalls` field.
+    #[inline]
+    pub fn libcalls(&self) -> u32 {
+        self.libcalls
+    }
+
+    /// The offset of the `flags` field.
+    #[inline]
+    pub fn instance_flags(&self, index: RuntimeComponentInstanceIndex) -> u32 {
+        assert!(index.as_u32() < self.num_runtime_component_instances);
+        self.flags + index.as_u32() * u32::from(self.ptr.size_of_vmglobal_definition())
+    }
+
+    /// The offset of the `store` field.
+    #[inline]
+    pub fn store(&self) -> u32 {
+        self.store
+    }
+
+    /// The offset of the `limits` field.
+    #[inline]
+    pub fn limits(&self) -> u32 {
+        self.limits
+    }
+
+    /// The offset of the `trampoline_func_refs` field.
+    #[inline]
+    pub fn trampoline_func_refs(&self) -> u32 {
+        self.trampoline_func_refs
+    }
+
+    /// The offset of `VMFuncRef` for the `index` specified.
+    #[inline]
+    pub fn trampoline_func_ref(&self, index: TrampolineIndex) -> u32 {
+        assert!(index.as_u32() < self.num_trampolines);
+        self.trampoline_func_refs() + index.as_u32() * u32::from(self.ptr.size_of_vm_func_ref())
+    }
+
+    /// The offset of the `lowerings` field.
+    #[inline]
+    pub fn lowerings(&self) -> u32 {
+        self.lowerings
+    }
+
+    /// The offset of the `VMLowering` for the `index` specified.
+    #[inline]
+    pub fn lowering(&self, index: LoweredIndex) -> u32 {
+        assert!(index.as_u32() < self.num_lowerings);
+        self.lowerings() + index.as_u32() * u32::from(2 * self.ptr.size())
+    }
+
+    /// The offset of the `callee` for the `index` specified.
+    #[inline]
+    pub fn lowering_callee(&self, index: LoweredIndex) -> u32 {
+        self.lowering(index) + self.lowering_callee_offset()
+    }
+
+    /// The offset of the `data` for the `index` specified.
+    #[inline]
+    pub fn lowering_data(&self, index: LoweredIndex) -> u32 {
+        self.lowering(index) + self.lowering_data_offset()
+    }
+
+    /// The size of the `VMLowering` type
+    #[inline]
+    pub fn lowering_size(&self) -> u8 {
+        2 * self.ptr.size()
+    }
+
+    /// The offset of the `callee` field within the `VMLowering` type.
+    #[inline]
+    pub fn lowering_callee_offset(&self) -> u32 {
+        0
+    }
+
+    /// The offset of the `data` field within the `VMLowering` type.
+    #[inline]
+    pub fn lowering_data_offset(&self) -> u32 {
+        u32::from(self.ptr.size())
+    }
+
+    /// The offset of the base of the `runtime_memories` field
+    #[inline]
+    pub fn runtime_memories(&self) -> u32 {
+        self.memories
+    }
+
+    /// The offset of the `*mut VMMemoryDefinition` for the runtime index
+    /// provided.
+    #[inline]
+    pub fn runtime_memory(&self, index: RuntimeMemoryIndex) -> u32 {
+        assert!(index.as_u32() < self.num_runtime_memories);
+        self.runtime_memories() + index.as_u32() * u32::from(self.ptr.size())
+    }
+
+    /// The offset of the base of the `runtime_reallocs` field
+    #[inline]
+    pub fn runtime_reallocs(&self) -> u32 {
+        self.reallocs
+    }
+
+    /// The offset of the `*mut VMFuncRef` for the runtime index
+    /// provided.
+    #[inline]
+    pub fn runtime_realloc(&self, index: RuntimeReallocIndex) -> u32 {
+        assert!(index.as_u32() < self.num_runtime_reallocs);
+        self.runtime_reallocs() + index.as_u32() * u32::from(self.ptr.size())
+    }
+
+    /// The offset of the base of the `runtime_post_returns` field
+    #[inline]
+    pub fn runtime_post_returns(&self) -> u32 {
+        self.post_returns
+    }
+
+    /// The offset of the `*mut VMFuncRef` for the runtime index
+    /// provided.
+    #[inline]
+    pub fn runtime_post_return(&self, index: RuntimePostReturnIndex) -> u32 {
+        assert!(index.as_u32() < self.num_runtime_post_returns);
+        self.runtime_post_returns() + index.as_u32() * u32::from(self.ptr.size())
+    }
+
+    /// The offset of the base of the `resource_destructors` field
+    #[inline]
+    pub fn resource_destructors(&self) -> u32 {
+        self.resource_destructors
+    }
+
+    /// The offset of the `*mut VMFuncRef` for the runtime index
+    /// provided.
+    #[inline]
+    pub fn resource_destructor(&self, index: ResourceIndex) -> u32 {
+        assert!(index.as_u32() < self.num_resources);
+        self.resource_destructors() + index.as_u32() * u32::from(self.ptr.size())
+    }
+
+    /// Return the size of the `VMComponentContext` allocation.
+    #[inline]
+    pub fn size_of_vmctx(&self) -> u32 {
+        self.size
+    }
+}

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

@@ -0,0 +1,95 @@
+//! 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 compiler;
+pub mod dfg;
+mod info;
+mod translate;
+mod types;
+mod vmcomponent_offsets;
+pub use self::compiler::*;
+pub use self::info::*;
+pub use self::translate::*;
+pub use self::types::*;
+pub use self::vmcomponent_offsets::*;
+
+/// 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-12.0.1/src/fact/signature.rs

@@ -0,0 +1,135 @@
+//! 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 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>,
+    /// Indicator to whether parameters are indirect, meaning that the first
+    /// entry of `params` is a pointer type which all parameters are loaded
+    /// through.
+    pub params_indirect: bool,
+    /// Indicator whether results are passed indirectly. This may mean that
+    /// `results` is an `i32` or that `params` ends with an `i32` depending on
+    /// the `Context`.
+    pub results_indirect: bool,
+}
+
+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_indirect = false;
+        let mut params = match self.flatten_types(
+            &options.options,
+            MAX_FLAT_PARAMS,
+            self[ty.params].types.iter().copied(),
+        ) {
+            Some(list) => list,
+            None => {
+                params_indirect = true;
+                vec![ptr_ty]
+            }
+        };
+
+        let mut results_indirect = false;
+        let results = match self.flatten_types(
+            &options.options,
+            MAX_FLAT_RESULTS,
+            self[ty.results].types.iter().map(|ty| *ty),
+        ) {
+            Some(list) => list,
+            None => {
+                results_indirect = true;
+                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,
+            params_indirect,
+            results_indirect,
+        }
+    }
+
+    /// 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))
+    }
+}