wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasmtime-environ-16.0.0/src/module_types.rs

@@ -0,0 +1,120 @@
+use crate::{
+    Module, ModuleType, PrimaryMap, SignatureIndex, TypeConvert, TypeIndex, WasmFuncType,
+    WasmHeapType,
+};
+use serde_derive::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::ops::Index;
+use wasmparser::types::CoreTypeId;
+use wasmparser::UnpackedIndex;
+
+/// All types used in a core wasm module.
+///
+/// At this time this only contains function types. Note, though, that function
+/// types are deduplicated within this [`ModuleTypes`].
+///
+/// Note that accesing this type is primarily done through the `Index`
+/// implementations for this type.
+#[derive(Default, Serialize, Deserialize)]
+#[allow(missing_docs)]
+pub struct ModuleTypes {
+    wasm_signatures: PrimaryMap<SignatureIndex, WasmFuncType>,
+}
+
+impl ModuleTypes {
+    /// Returns an iterator over all the wasm function signatures found within
+    /// this module.
+    pub fn wasm_signatures(&self) -> impl Iterator<Item = (SignatureIndex, &WasmFuncType)> {
+        self.wasm_signatures.iter()
+    }
+}
+
+impl Index<SignatureIndex> for ModuleTypes {
+    type Output = WasmFuncType;
+
+    fn index(&self, sig: SignatureIndex) -> &WasmFuncType {
+        &self.wasm_signatures[sig]
+    }
+}
+
+/// A builder for [`ModuleTypes`].
+#[derive(Default)]
+#[allow(missing_docs)]
+pub struct ModuleTypesBuilder {
+    types: ModuleTypes,
+    interned_func_types: HashMap<WasmFuncType, SignatureIndex>,
+    wasmparser_to_wasmtime: HashMap<CoreTypeId, SignatureIndex>,
+}
+
+impl ModuleTypesBuilder {
+    /// Reserves space for `amt` more type signatures.
+    pub fn reserve_wasm_signatures(&mut self, amt: usize) {
+        self.types.wasm_signatures.reserve(amt);
+    }
+
+    /// Interns the `sig` specified and returns a unique `SignatureIndex` that
+    /// can be looked up within [`ModuleTypes`] to recover the [`WasmFuncType`]
+    /// at runtime.
+    pub fn wasm_func_type(&mut self, id: CoreTypeId, sig: WasmFuncType) -> SignatureIndex {
+        let sig = self.intern_func_type(sig);
+        self.wasmparser_to_wasmtime.insert(id, sig);
+        sig
+    }
+
+    fn intern_func_type(&mut self, sig: WasmFuncType) -> SignatureIndex {
+        if let Some(idx) = self.interned_func_types.get(&sig) {
+            return *idx;
+        }
+
+        let idx = self.types.wasm_signatures.push(sig.clone());
+        self.interned_func_types.insert(sig, idx);
+        return idx;
+    }
+
+    /// Returns the result [`ModuleTypes`] of this builder.
+    pub fn finish(self) -> ModuleTypes {
+        self.types
+    }
+
+    /// Returns an iterator over all the wasm function signatures found within
+    /// this module.
+    pub fn wasm_signatures(&self) -> impl Iterator<Item = (SignatureIndex, &WasmFuncType)> {
+        self.types.wasm_signatures()
+    }
+}
+
+// Forward the indexing impl to the internal `ModuleTypes`
+impl<T> Index<T> for ModuleTypesBuilder
+where
+    ModuleTypes: Index<T>,
+{
+    type Output = <ModuleTypes as Index<T>>::Output;
+
+    fn index(&self, sig: T) -> &Self::Output {
+        &self.types[sig]
+    }
+}
+
+#[allow(missing_docs)]
+pub struct WasmparserTypeConverter<'a> {
+    pub types: &'a ModuleTypesBuilder,
+    pub module: &'a Module,
+}
+
+impl TypeConvert for WasmparserTypeConverter<'_> {
+    fn lookup_heap_type(&self, index: UnpackedIndex) -> WasmHeapType {
+        match index {
+            UnpackedIndex::Id(id) => {
+                let signature = self.types.wasmparser_to_wasmtime[&id];
+                WasmHeapType::TypedFunc(signature)
+            }
+            UnpackedIndex::RecGroup(_) => unreachable!(),
+            UnpackedIndex::Module(i) => {
+                let i = TypeIndex::from_u32(i);
+                match self.module.types[i] {
+                    ModuleType::Function(sig) => WasmHeapType::TypedFunc(sig),
+                }
+            }
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-environ-16.0.0/src/scopevec.rs

@@ -0,0 +1,78 @@
+use std::cell::RefCell;
+
+/// Small data structure to help extend the lifetime of a slice to a higher
+/// scope.
+///
+/// This is currently used during component translation where translation in
+/// general works on a borrowed slice which contains all input modules, but
+/// generated adapter modules for components don't live within the original
+/// slice but the data structures are much easier if the dynamically generated
+/// adapter modules live for the same lifetime as the original input slice. To
+/// solve this problem this `ScopeVec` helper is used to move ownership of a
+/// `Vec<T>` to a higher scope in the program, then borrowing the slice from
+/// that scope.
+pub struct ScopeVec<T> {
+    data: RefCell<Vec<Box<[T]>>>,
+}
+
+impl<T> ScopeVec<T> {
+    /// Creates a new blank scope.
+    pub fn new() -> ScopeVec<T> {
+        ScopeVec {
+            data: Default::default(),
+        }
+    }
+
+    /// Transfers ownership of `data` into this scope and then yields the slice
+    /// back to the caller.
+    ///
+    /// The original data will be deallocated when `self` is dropped.
+    pub fn push(&self, data: Vec<T>) -> &mut [T] {
+        let data: Box<[T]> = data.into();
+        let len = data.len();
+
+        let mut storage = self.data.borrow_mut();
+        storage.push(data);
+        let ptr = storage.last_mut().unwrap().as_mut_ptr();
+
+        // This should be safe for a few reasons:
+        //
+        // * The returned pointer on the heap that `data` owns. Despite moving
+        //   `data` around it doesn't actually move the slice itself around, so
+        //   the pointer returned should be valid (and length).
+        //
+        // * The lifetime of the returned pointer is connected to the lifetime
+        //   of `self`. This reflects how when `self` is destroyed the `data` is
+        //   destroyed as well, or otherwise the returned slice will be valid
+        //   for as long as `self` is valid since `self` owns the original data
+        //   at that point.
+        //
+        // * This function was given ownership of `data` so it should be safe to
+        //   hand back a mutable reference. Once placed within a `ScopeVec` the
+        //   data is never mutated so the caller will enjoy exclusive access to
+        //   the slice of the original vec.
+        //
+        // This all means that it should be safe to return a mutable slice of
+        // all of `data` after the data has been pushed onto our internal list.
+        unsafe { std::slice::from_raw_parts_mut(ptr, len) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ScopeVec;
+
+    #[test]
+    fn smoke() {
+        let scope = ScopeVec::new();
+        let a = scope.push(Vec::new());
+        let b = scope.push(vec![1, 2, 3]);
+        let c = scope.push(vec![4, 5, 6]);
+        assert_eq!(a.len(), 0);
+        b[0] = 4;
+        c[2] = 5;
+        assert_eq!(a, []);
+        assert_eq!(b, [4, 2, 3]);
+        assert_eq!(c, [4, 5, 5]);
+    }
+}

data/ext/cargo-vendor/wasmtime-fiber-16.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"600225504a85509843d58b39b07b49e052fada57444ce0dce64698ca6cefce02","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"3671a62ab26fc16dfb0c38b7b56d55c3f5d3b1b9f4dd42dd7a935c7e5cc59203","src/lib.rs":"7983500b97f5aaccaae2354b3afff84920308aa63c7ff27b47d49ee4b7f18ea1","src/unix.rs":"acd1c8827d914d057935fa9f23d782e19014c3c5d97288f46bef0f09b63cb0ba","src/unix/aarch64.rs":"d3702b6f8c29040bba7d36fdff2018f22766cca09fb6ac5e24af025a8fdce58b","src/unix/arm.rs":"170f723f4ae5eeab12921ea258d0be446880cb4152c4d480e00d71c98ea5915d","src/unix/riscv64.rs":"6bfab001d2b2d5d112d0738c7f1a0dbe2f61e53b4f12bcbc6dd95db23d5c6b1a","src/unix/s390x.S":"018e6bb57ef1f150e35f0161d39802da1df4d6ad57a5dcc2811437d53d6ba4b2","src/unix/x86.rs":"4ec3db0feeeb37706ef2771e81504be4ef47c56be43e0a0b8ae9938c0c47fcad","src/unix/x86_64.rs":"10f4671c17ffac324e9cab224a9d09ff4e66273fdf20cc65de02f4cd93c8dc45","src/windows.c":"164d7680582e6c7709ad14904304d17b113b8c07cda7c39ea2c9611bc2679b92","src/windows.rs":"b46a47be0cbb92d75e66b78ba521f3a7a13663366453270fc045bf18a7e6e28f"},"package":"40ecf1d3a838b0956b71ad3f8cb80069a228339775bf02dd35d86a5a68bbe443"}

data/ext/cargo-vendor/wasmtime-fiber-16.0.0/Cargo.toml

@@ -0,0 +1,63 @@
+# 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 = "wasmtime-fiber"
+version = "16.0.0"
+authors = ["The Wasmtime Project Developers"]
+description = "Fiber support for Wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.cfg-if]
+version = "1.0"
+
+[dependencies.wasmtime-versioned-export-macros]
+version = "=16.0.0"
+
+[dev-dependencies.backtrace]
+version = "0.3.68"
+
+[build-dependencies.cc]
+version = "1.0"
+
+[build-dependencies.wasmtime-versioned-export-macros]
+version = "=16.0.0"
+
+[target."cfg(unix)".dependencies.rustix]
+version = "0.38.21"
+features = [
+    "mm",
+    "param",
+]
+
+[target."cfg(unix)".dependencies.wasmtime-asm-macros]
+version = "=16.0.0"
+
+[target."cfg(windows)".dependencies.windows-sys]
+version = "0.48.0"
+features = [
+    "Win32_System_Threading",
+    "Win32_Foundation",
+]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wasmtime-fiber-16.0.0/src/lib.rs

@@ -0,0 +1,328 @@
+use anyhow::Error;
+use std::any::Any;
+use std::cell::Cell;
+use std::io;
+use std::marker::PhantomData;
+use std::ops::Range;
+use std::panic::{self, AssertUnwindSafe};
+
+cfg_if::cfg_if! {
+    if #[cfg(windows)] {
+        mod windows;
+        use windows as imp;
+    } else if #[cfg(unix)] {
+        mod unix;
+        use unix as imp;
+    } else {
+        compile_error!("fibers are not supported on this platform");
+    }
+}
+
+/// Represents an execution stack to use for a fiber.
+pub struct FiberStack(imp::FiberStack);
+
+impl FiberStack {
+    /// Creates a new fiber stack of the given size.
+    pub fn new(size: usize) -> io::Result<Self> {
+        Ok(Self(imp::FiberStack::new(size)?))
+    }
+
+    /// Creates a new fiber stack of the given size.
+    pub fn from_custom(custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
+        Ok(Self(imp::FiberStack::from_custom(custom)?))
+    }
+
+    /// Creates a new fiber stack with the given pointer to the bottom of the
+    /// stack plus the byte length of the stack.
+    ///
+    /// The `bottom` pointer should be addressable for `len` bytes. The page
+    /// beneath `bottom` should be unmapped as a guard page.
+    ///
+    /// # Safety
+    ///
+    /// This is unsafe because there is no validation of the given pointer.
+    ///
+    /// The caller must properly allocate the stack space with a guard page and
+    /// make the pages accessible for correct behavior.
+    pub unsafe fn from_raw_parts(bottom: *mut u8, len: usize) -> io::Result<Self> {
+        Ok(Self(imp::FiberStack::from_raw_parts(bottom, len)?))
+    }
+
+    /// Gets the top of the stack.
+    ///
+    /// Returns `None` if the platform does not support getting the top of the
+    /// stack.
+    pub fn top(&self) -> Option<*mut u8> {
+        self.0.top()
+    }
+
+    /// Returns the range of where this stack resides in memory if the platform
+    /// supports it.
+    pub fn range(&self) -> Option<Range<usize>> {
+        self.0.range()
+    }
+}
+
+/// A creator of RuntimeFiberStacks.
+pub unsafe trait RuntimeFiberStackCreator: Send + Sync {
+    /// Creates a new RuntimeFiberStack with the specified size, guard pages should be included,
+    /// memory should be zeroed.
+    ///
+    /// This is useful to plugin previously allocated memory instead of mmap'ing a new stack for
+    /// every instance.
+    fn new_stack(&self, size: usize) -> Result<Box<dyn RuntimeFiberStack>, Error>;
+}
+
+/// A fiber stack backed by custom memory.
+pub unsafe trait RuntimeFiberStack: Send + Sync {
+    /// The top of the allocated stack.
+    fn top(&self) -> *mut u8;
+    /// The valid range of the stack without guard pages.
+    fn range(&self) -> Range<usize>;
+}
+
+pub struct Fiber<'a, Resume, Yield, Return> {
+    stack: FiberStack,
+    inner: imp::Fiber,
+    done: Cell<bool>,
+    _phantom: PhantomData<&'a (Resume, Yield, Return)>,
+}
+
+pub struct Suspend<Resume, Yield, Return> {
+    inner: imp::Suspend,
+    _phantom: PhantomData<(Resume, Yield, Return)>,
+}
+
+enum RunResult<Resume, Yield, Return> {
+    Executing,
+    Resuming(Resume),
+    Yield(Yield),
+    Returned(Return),
+    Panicked(Box<dyn Any + Send>),
+}
+
+impl<'a, Resume, Yield, Return> Fiber<'a, Resume, Yield, Return> {
+    /// Creates a new fiber which will execute `func` on the given stack.
+    ///
+    /// This function returns a `Fiber` which, when resumed, will execute `func`
+    /// to completion. When desired the `func` can suspend itself via
+    /// `Fiber::suspend`.
+    pub fn new(
+        stack: FiberStack,
+        func: impl FnOnce(Resume, &Suspend<Resume, Yield, Return>) -> Return + 'a,
+    ) -> io::Result<Self> {
+        let inner = imp::Fiber::new(&stack.0, func)?;
+
+        Ok(Self {
+            stack,
+            inner,
+            done: Cell::new(false),
+            _phantom: PhantomData,
+        })
+    }
+
+    /// Resumes execution of this fiber.
+    ///
+    /// This function will transfer execution to the fiber and resume from where
+    /// it last left off.
+    ///
+    /// Returns `true` if the fiber finished or `false` if the fiber was
+    /// suspended in the middle of execution.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the current thread is already executing a fiber or if this
+    /// fiber has already finished.
+    ///
+    /// Note that if the fiber itself panics during execution then the panic
+    /// will be propagated to this caller.
+    pub fn resume(&self, val: Resume) -> Result<Return, Yield> {
+        assert!(!self.done.replace(true), "cannot resume a finished fiber");
+        let result = Cell::new(RunResult::Resuming(val));
+        self.inner.resume(&self.stack.0, &result);
+        match result.into_inner() {
+            RunResult::Resuming(_) | RunResult::Executing => unreachable!(),
+            RunResult::Yield(y) => {
+                self.done.set(false);
+                Err(y)
+            }
+            RunResult::Returned(r) => Ok(r),
+            RunResult::Panicked(payload) => std::panic::resume_unwind(payload),
+        }
+    }
+
+    /// Returns whether this fiber has finished executing.
+    pub fn done(&self) -> bool {
+        self.done.get()
+    }
+
+    /// Gets the stack associated with this fiber.
+    pub fn stack(&self) -> &FiberStack {
+        &self.stack
+    }
+}
+
+impl<Resume, Yield, Return> Suspend<Resume, Yield, Return> {
+    /// Suspend execution of a currently running fiber.
+    ///
+    /// This function will switch control back to the original caller of
+    /// `Fiber::resume`. This function will then return once the `Fiber::resume`
+    /// function is called again.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the current thread is not executing a fiber from this library.
+    pub fn suspend(&self, value: Yield) -> Resume {
+        self.inner
+            .switch::<Resume, Yield, Return>(RunResult::Yield(value))
+    }
+
+    fn execute(
+        inner: imp::Suspend,
+        initial: Resume,
+        func: impl FnOnce(Resume, &Suspend<Resume, Yield, Return>) -> Return,
+    ) {
+        let suspend = Suspend {
+            inner,
+            _phantom: PhantomData,
+        };
+        let result = panic::catch_unwind(AssertUnwindSafe(|| (func)(initial, &suspend)));
+        suspend.inner.switch::<Resume, Yield, Return>(match result {
+            Ok(result) => RunResult::Returned(result),
+            Err(panic) => RunResult::Panicked(panic),
+        });
+    }
+}
+
+impl<A, B, C> Drop for Fiber<'_, A, B, C> {
+    fn drop(&mut self) {
+        debug_assert!(self.done.get(), "fiber dropped without finishing");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Fiber, FiberStack};
+    use std::cell::Cell;
+    use std::panic::{self, AssertUnwindSafe};
+    use std::rc::Rc;
+
+    #[test]
+    fn small_stacks() {
+        Fiber::<(), (), ()>::new(FiberStack::new(0).unwrap(), |_, _| {})
+            .unwrap()
+            .resume(())
+            .unwrap();
+        Fiber::<(), (), ()>::new(FiberStack::new(1).unwrap(), |_, _| {})
+            .unwrap()
+            .resume(())
+            .unwrap();
+    }
+
+    #[test]
+    fn smoke() {
+        let hit = Rc::new(Cell::new(false));
+        let hit2 = hit.clone();
+        let fiber = Fiber::<(), (), ()>::new(FiberStack::new(1024 * 1024).unwrap(), move |_, _| {
+            hit2.set(true);
+        })
+        .unwrap();
+        assert!(!hit.get());
+        fiber.resume(()).unwrap();
+        assert!(hit.get());
+    }
+
+    #[test]
+    fn suspend_and_resume() {
+        let hit = Rc::new(Cell::new(false));
+        let hit2 = hit.clone();
+        let fiber = Fiber::<(), (), ()>::new(FiberStack::new(1024 * 1024).unwrap(), move |_, s| {
+            s.suspend(());
+            hit2.set(true);
+            s.suspend(());
+        })
+        .unwrap();
+        assert!(!hit.get());
+        assert!(fiber.resume(()).is_err());
+        assert!(!hit.get());
+        assert!(fiber.resume(()).is_err());
+        assert!(hit.get());
+        assert!(fiber.resume(()).is_ok());
+        assert!(hit.get());
+    }
+
+    #[test]
+    fn backtrace_traces_to_host() {
+        #[inline(never)] // try to get this to show up in backtraces
+        fn look_for_me() {
+            run_test();
+        }
+        fn assert_contains_host() {
+            let trace = backtrace::Backtrace::new();
+            println!("{:?}", trace);
+            assert!(
+                trace
+                .frames()
+                .iter()
+                .flat_map(|f| f.symbols())
+                .filter_map(|s| Some(s.name()?.to_string()))
+                .any(|s| s.contains("look_for_me"))
+                // TODO: apparently windows unwind routines don't unwind through fibers, so this will always fail. Is there a way we can fix that?
+                || cfg!(windows)
+                // TODO: the system libunwind is broken (#2808)
+                || cfg!(all(target_os = "macos", target_arch = "aarch64"))
+            );
+        }
+
+        fn run_test() {
+            let fiber =
+                Fiber::<(), (), ()>::new(FiberStack::new(1024 * 1024).unwrap(), move |(), s| {
+                    assert_contains_host();
+                    s.suspend(());
+                    assert_contains_host();
+                    s.suspend(());
+                    assert_contains_host();
+                })
+                .unwrap();
+            assert!(fiber.resume(()).is_err());
+            assert!(fiber.resume(()).is_err());
+            assert!(fiber.resume(()).is_ok());
+        }
+
+        look_for_me();
+    }
+
+    #[test]
+    fn panics_propagated() {
+        let a = Rc::new(Cell::new(false));
+        let b = SetOnDrop(a.clone());
+        let fiber =
+            Fiber::<(), (), ()>::new(FiberStack::new(1024 * 1024).unwrap(), move |(), _s| {
+                let _ = &b;
+                panic!();
+            })
+            .unwrap();
+        assert!(panic::catch_unwind(AssertUnwindSafe(|| fiber.resume(()))).is_err());
+        assert!(a.get());
+
+        struct SetOnDrop(Rc<Cell<bool>>);
+
+        impl Drop for SetOnDrop {
+            fn drop(&mut self) {
+                self.0.set(true);
+            }
+        }
+    }
+
+    #[test]
+    fn suspend_and_resume_values() {
+        let fiber = Fiber::new(FiberStack::new(1024 * 1024).unwrap(), move |first, s| {
+            assert_eq!(first, 2.0);
+            assert_eq!(s.suspend(4), 3.0);
+            "hello".to_string()
+        })
+        .unwrap();
+        assert_eq!(fiber.resume(2.0), Err(4));
+        assert_eq!(fiber.resume(3.0), Ok("hello".to_string()));
+    }
+}