wasmtime 15.0.1 → 16.0.0

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

@@ -1,78 +0,0 @@
-use crate::{PrimaryMap, SignatureIndex, WasmFuncType};
-use serde_derive::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::ops::Index;
-
-/// 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>,
-}
-
-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, 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
-    }
-}
-
-// 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]
-    }
-}

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

@@ -1,57 +0,0 @@
-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 mut data: Box<[T]> = data.into();
-        let ptr = data.as_mut_ptr();
-        let len = data.len();
-        self.data.borrow_mut().push(data);
-
-        // 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) }
-    }
-}

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

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"ae6708ea46b343bf2d8c5af5ce770dd144c63849f0fb2c23525dd5724f205945","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"3671a62ab26fc16dfb0c38b7b56d55c3f5d3b1b9f4dd42dd7a935c7e5cc59203","src/lib.rs":"58b82e5d72a50cbc3f9f4eeb8a1beee81a0853fd33a9e70badee216b95bd234e","src/unix.rs":"7603152a47fd42b3f08c4f60dc9f83c6b661048de114cf1eecc7c0d280f9cb67","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":"ab3854b2e1e0300f55ad5e898bbd9156d02ca40f15c6b4902da3c6f5878e3edb","src/windows.rs":"b46a47be0cbb92d75e66b78ba521f3a7a13663366453270fc045bf18a7e6e28f"},"package":"404741f4c6d7f4e043be2e8b466406a2aee289ccdba22bf9eba6399921121b97"}

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

@@ -1,54 +0,0 @@
-# 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 = "15.0.1"
-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 = "=15.0.1"
-
-[dev-dependencies.backtrace]
-version = "0.3.68"
-
-[build-dependencies.cc]
-version = "1.0"
-
-[build-dependencies.wasmtime-versioned-export-macros]
-version = "=15.0.1"
-
-[target."cfg(unix)".dependencies.rustix]
-version = "0.38.21"
-features = [
-    "mm",
-    "param",
-]
-
-[target."cfg(unix)".dependencies.wasmtime-asm-macros]
-version = "=15.0.1"
-
-[target."cfg(windows)".dependencies.windows-sys]
-version = "0.48.0"
-features = [
-    "Win32_System_Threading",
-    "Win32_Foundation",
-]

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

@@ -1,327 +0,0 @@
-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.
-    ///
-    /// 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()));
-    }
-}