wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-fiber-10.0.1/src/unix.rs

@@ -0,0 +1,212 @@
+//! The unix fiber implementation has some platform-specific details
+//! (naturally) but there's a few details of the stack layout which are common
+//! amongst all platforms using this file. Remember that none of this applies to
+//! Windows, which is entirely separate.
+//!
+//! The stack is expected to look pretty standard with a guard page at the end.
+//! Currently allocation happens in this file but this is probably going to be
+//! refactored to happen somewhere else. Otherwise though the stack layout is
+//! expected to look like so:
+//!
+//!
+//! ```text
+//! 0xB000 +-----------------------+   <- top of stack
+//!        | &Cell<RunResult>      |   <- where to store results
+//! 0xAff8 +-----------------------+
+//!        | *const u8             |   <- last sp to resume from
+//! 0xAff0 +-----------------------+   <- 16-byte aligned
+//!        |                       |
+//!        ~        ...            ~   <- actual native stack space to use
+//!        |                       |
+//! 0x1000 +-----------------------+
+//!        |  guard page           |
+//! 0x0000 +-----------------------+
+//! ```
+//!
+//! Here `0xAff8` is filled in temporarily while `resume` is running. The fiber
+//! started with 0xB000 as a parameter so it knows how to find this.
+//! Additionally `resumes` stores state at 0xAff0 to restart execution, and
+//! `suspend`, which has 0xB000 so it can find this, will read that and write
+//! its own resumption information into this slot as well.
+
+#![allow(unused_macros)]
+
+use crate::RunResult;
+use std::cell::Cell;
+use std::io;
+use std::ops::Range;
+use std::ptr;
+
+#[derive(Debug)]
+pub struct FiberStack {
+    // The top of the stack; for stacks allocated by the fiber implementation itself,
+    // the base address of the allocation will be `top.sub(len.unwrap())`
+    top: *mut u8,
+    // The length of the stack
+    len: usize,
+    // whether or not this stack was mmap'd
+    mmap: bool,
+}
+
+impl FiberStack {
+    pub fn new(size: usize) -> io::Result<Self> {
+        // Round up our stack size request to the nearest multiple of the
+        // page size.
+        let page_size = rustix::param::page_size();
+        let size = if size == 0 {
+            page_size
+        } else {
+            (size + (page_size - 1)) & (!(page_size - 1))
+        };
+
+        unsafe {
+            // Add in one page for a guard page and then ask for some memory.
+            let mmap_len = size + page_size;
+            let mmap = rustix::mm::mmap_anonymous(
+                ptr::null_mut(),
+                mmap_len,
+                rustix::mm::ProtFlags::empty(),
+                rustix::mm::MapFlags::PRIVATE,
+            )?;
+
+            rustix::mm::mprotect(
+                mmap.cast::<u8>().add(page_size).cast(),
+                size,
+                rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
+            )?;
+
+            Ok(Self {
+                top: mmap.cast::<u8>().add(mmap_len),
+                len: mmap_len,
+                mmap: true,
+            })
+        }
+    }
+
+    pub unsafe fn from_raw_parts(base: *mut u8, len: usize) -> io::Result<Self> {
+        Ok(Self {
+            top: base.add(len),
+            len,
+            mmap: false,
+        })
+    }
+
+    pub fn top(&self) -> Option<*mut u8> {
+        Some(self.top)
+    }
+
+    pub fn range(&self) -> Option<Range<usize>> {
+        let base = unsafe { self.top.sub(self.len) as usize };
+        Some(base..base + self.len)
+    }
+}
+
+impl Drop for FiberStack {
+    fn drop(&mut self) {
+        unsafe {
+            if self.mmap {
+                let ret = rustix::mm::munmap(self.top.sub(self.len) as _, self.len);
+                debug_assert!(ret.is_ok());
+            }
+        }
+    }
+}
+
+pub struct Fiber;
+
+pub struct Suspend(*mut u8);
+
+extern "C" {
+    fn wasmtime_fiber_init(
+        top_of_stack: *mut u8,
+        entry: extern "C" fn(*mut u8, *mut u8),
+        entry_arg0: *mut u8,
+    );
+    fn wasmtime_fiber_switch(top_of_stack: *mut u8);
+    #[allow(dead_code)] // only used in inline assembly for some platforms
+    fn wasmtime_fiber_start();
+}
+
+extern "C" fn fiber_start<F, A, B, C>(arg0: *mut u8, top_of_stack: *mut u8)
+where
+    F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+{
+    unsafe {
+        let inner = Suspend(top_of_stack);
+        let initial = inner.take_resume::<A, B, C>();
+        super::Suspend::<A, B, C>::execute(inner, initial, Box::from_raw(arg0.cast::<F>()))
+    }
+}
+
+impl Fiber {
+    pub fn new<F, A, B, C>(stack: &FiberStack, func: F) -> io::Result<Self>
+    where
+        F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+    {
+        unsafe {
+            let data = Box::into_raw(Box::new(func)).cast();
+            wasmtime_fiber_init(stack.top, fiber_start::<F, A, B, C>, data);
+        }
+
+        Ok(Self)
+    }
+
+    pub(crate) fn resume<A, B, C>(&self, stack: &FiberStack, result: &Cell<RunResult<A, B, C>>) {
+        unsafe {
+            // Store where our result is going at the very tip-top of the
+            // stack, otherwise known as our reserved slot for this information.
+            //
+            // In the diagram above this is updating address 0xAff8
+            let addr = stack.top.cast::<usize>().offset(-1);
+            addr.write(result as *const _ as usize);
+
+            wasmtime_fiber_switch(stack.top);
+
+            // null this out to help catch use-after-free
+            addr.write(0);
+        }
+    }
+}
+
+impl Suspend {
+    pub(crate) fn switch<A, B, C>(&self, result: RunResult<A, B, C>) -> A {
+        unsafe {
+            // Calculate 0xAff8 and then write to it
+            (*self.result_location::<A, B, C>()).set(result);
+            wasmtime_fiber_switch(self.0);
+            self.take_resume::<A, B, C>()
+        }
+    }
+
+    unsafe fn take_resume<A, B, C>(&self) -> A {
+        match (*self.result_location::<A, B, C>()).replace(RunResult::Executing) {
+            RunResult::Resuming(val) => val,
+            _ => panic!("not in resuming state"),
+        }
+    }
+
+    unsafe fn result_location<A, B, C>(&self) -> *const Cell<RunResult<A, B, C>> {
+        let ret = self.0.cast::<*const u8>().offset(-1).read();
+        assert!(!ret.is_null());
+        ret.cast()
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "aarch64")] {
+        mod aarch64;
+    } else if #[cfg(target_arch = "x86_64")] {
+        mod x86_64;
+    } else if #[cfg(target_arch = "x86")] {
+        mod x86;
+    } else if #[cfg(target_arch = "arm")] {
+        mod arm;
+    } else if #[cfg(target_arch = "s390x")] {
+        // currently `global_asm!` isn't stable on s390x so this is an external
+        // assembler file built with the `build.rs`.
+    } else if #[cfg(target_arch = "riscv64")]  {
+        mod riscv64;
+    }else {
+        compile_error!("fibers are not supported on this CPU architecture");
+    }
+}

data/ext/cargo-vendor/wasmtime-fiber-10.0.1/src/windows.rs

@@ -0,0 +1,161 @@
+use crate::RunResult;
+use std::cell::Cell;
+use std::ffi::c_void;
+use std::io;
+use std::ops::Range;
+use std::ptr;
+use windows_sys::Win32::Foundation::*;
+use windows_sys::Win32::System::Threading::*;
+
+#[derive(Debug)]
+pub struct FiberStack(usize);
+
+impl FiberStack {
+    pub fn new(size: usize) -> io::Result<Self> {
+        Ok(Self(size))
+    }
+
+    pub unsafe fn from_raw_parts(_base: *mut u8, _len: usize) -> io::Result<Self> {
+        Err(io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as i32))
+    }
+
+    pub fn top(&self) -> Option<*mut u8> {
+        None
+    }
+
+    pub fn range(&self) -> Option<Range<usize>> {
+        None
+    }
+}
+
+pub struct Fiber {
+    fiber: *mut c_void,
+    state: Box<StartState>,
+}
+
+pub struct Suspend {
+    state: *const StartState,
+}
+
+struct StartState {
+    parent: Cell<*mut c_void>,
+    initial_closure: Cell<*mut u8>,
+    result_location: Cell<*const u8>,
+}
+
+const FIBER_FLAG_FLOAT_SWITCH: u32 = 1;
+
+extern "C" {
+    fn wasmtime_fiber_get_current() -> *mut c_void;
+}
+
+unsafe extern "system" fn fiber_start<F, A, B, C>(data: *mut c_void)
+where
+    F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+{
+    // Set the stack guarantee to be consistent with what Rust expects for threads
+    // This value is taken from:
+    // https://github.com/rust-lang/rust/blob/0d97f7a96877a96015d70ece41ad08bb7af12377/library/std/src/sys/windows/stack_overflow.rs
+    if SetThreadStackGuarantee(&mut 0x5000) == 0 {
+        panic!("failed to set fiber stack guarantee");
+    }
+
+    let state = data.cast::<StartState>();
+    let func = Box::from_raw((*state).initial_closure.get().cast::<F>());
+    (*state).initial_closure.set(ptr::null_mut());
+    let suspend = Suspend { state };
+    let initial = suspend.take_resume::<A, B, C>();
+    super::Suspend::<A, B, C>::execute(suspend, initial, *func);
+}
+
+impl Fiber {
+    pub fn new<F, A, B, C>(stack: &FiberStack, func: F) -> io::Result<Self>
+    where
+        F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+    {
+        unsafe {
+            let state = Box::new(StartState {
+                initial_closure: Cell::new(Box::into_raw(Box::new(func)).cast()),
+                parent: Cell::new(ptr::null_mut()),
+                result_location: Cell::new(ptr::null()),
+            });
+
+            let fiber = CreateFiberEx(
+                0,
+                stack.0,
+                FIBER_FLAG_FLOAT_SWITCH,
+                Some(fiber_start::<F, A, B, C>),
+                &*state as *const StartState as *mut _,
+            );
+
+            if fiber.is_null() {
+                drop(Box::from_raw(state.initial_closure.get().cast::<F>()));
+                return Err(io::Error::last_os_error());
+            }
+
+            Ok(Self { fiber, state })
+        }
+    }
+
+    pub(crate) fn resume<A, B, C>(&self, _stack: &FiberStack, result: &Cell<RunResult<A, B, C>>) {
+        unsafe {
+            let is_fiber = IsThreadAFiber() != 0;
+            let parent_fiber = if is_fiber {
+                wasmtime_fiber_get_current()
+            } else {
+                ConvertThreadToFiber(ptr::null_mut())
+            };
+            assert!(
+                !parent_fiber.is_null(),
+                "failed to make current thread a fiber"
+            );
+            self.state
+                .result_location
+                .set(result as *const _ as *const _);
+            self.state.parent.set(parent_fiber);
+            SwitchToFiber(self.fiber);
+            self.state.parent.set(ptr::null_mut());
+            self.state.result_location.set(ptr::null());
+            if !is_fiber {
+                let res = ConvertFiberToThread();
+                assert!(res != 0, "failed to convert main thread back");
+            }
+        }
+    }
+}
+
+impl Drop for Fiber {
+    fn drop(&mut self) {
+        unsafe {
+            DeleteFiber(self.fiber);
+        }
+    }
+}
+
+impl Suspend {
+    pub(crate) fn switch<A, B, C>(&self, result: RunResult<A, B, C>) -> A {
+        unsafe {
+            (*self.result_location::<A, B, C>()).set(result);
+            debug_assert!(IsThreadAFiber() != 0);
+            let parent = (*self.state).parent.get();
+            debug_assert!(!parent.is_null());
+            SwitchToFiber(parent);
+            self.take_resume::<A, B, C>()
+        }
+    }
+    unsafe fn take_resume<A, B, C>(&self) -> A {
+        match (*self.result_location::<A, B, C>()).replace(RunResult::Executing) {
+            RunResult::Resuming(val) => val,
+            _ => panic!("not in resuming state"),
+        }
+    }
+
+    unsafe fn result_location<A, B, C>(&self) -> *const Cell<RunResult<A, B, C>> {
+        let ret = (*self.state)
+            .result_location
+            .get()
+            .cast::<Cell<RunResult<A, B, C>>>();
+        assert!(!ret.is_null());
+        return ret;
+    }
+}

data/ext/cargo-vendor/wasmtime-jit-10.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7c01449160279c963da1dabd6ab8ce9dd61bcd0f99186e26c9f460c30f46a1ca","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","src/code_memory.rs":"d292ff94ff6899f72edc4c2b3e493ec3c12eb4411482a2979cec0e0c3480fc57","src/debug.rs":"2c456040843b5fac05be191f86190b8f13760e9bda7f693e2003f7220330d56c","src/demangling.rs":"682861f3a7c8bd7db4fb05eeea39fc8389b6c907c99a9436bdfdcb24a313618f","src/instantiate.rs":"e526308a1e01079567f8a4f5782e0dec1a8caee08ec69bc3841f54bac4730d9e","src/lib.rs":"802cb165833919d75a516bd452b5054b57d0e92ad657b596715f5a12d5f419eb","src/profiling.rs":"488b57db9d2b9b12a440f298058b48eed817daa3d4db0abcaad42999445820ad","src/profiling/jitdump.rs":"951da77e9af3b44b6fb0455dd42ede2b9e74953fcaed3830a8eda0c931a1dfc1","src/profiling/perfmap.rs":"bfb2b57a5999a910383357ba1867a800b5a9384902231ee73ed6d0d7bed2814a","src/profiling/vtune.rs":"765fd1de824304cba864b63e6eb3cb7c9d33f285945c37521d415d9a921d7764","src/unwind.rs":"6ad66d47ceb5ed67a121160ee33c182306dc0f9b18138ba8c402fe1e0d90ffd3","src/unwind/miri.rs":"97ce68d3929b988f6e4e4c3266e8d18d4292be2fe69547b7c1905ce2a4f887c1","src/unwind/systemv.rs":"06ee37895b6043874ad8dad61cf684b822bbfc33a1de8ce2f5d4b483d0a0a10b","src/unwind/winx64.rs":"ffe8e747b4a5e78b048ba16895adb33bebcbe1010637ab785639c32fd5d07d44"},"package":"5f0f2eaeb01bb67266416507829bd8e0bb60278444e4cbd048e280833ebeaa02"}

data/ext/cargo-vendor/wasmtime-jit-10.0.1/Cargo.toml

@@ -0,0 +1,104 @@
+# 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-jit"
+version = "10.0.1"
+authors = ["The Wasmtime Project Developers"]
+description = "JIT-style execution for WebAsssembly code in Cranelift"
+documentation = "https://docs.rs/wasmtime-jit"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.addr2line]
+version = "0.19.0"
+default-features = false
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.bincode]
+version = "1.2.1"
+
+[dependencies.cfg-if]
+version = "1.0"
+
+[dependencies.cpp_demangle]
+version = "0.3.2"
+
+[dependencies.gimli]
+version = "0.27.0"
+features = [
+    "read",
+    "std",
+]
+default-features = false
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.object]
+version = "0.30.3"
+features = [
+    "read_core",
+    "elf",
+    "std",
+]
+default-features = false
+
+[dependencies.rustc-demangle]
+version = "0.1.16"
+
+[dependencies.serde]
+version = "1.0.94"
+features = ["derive"]
+
+[dependencies.target-lexicon]
+version = "0.12.3"
+features = ["std"]
+default-features = false
+
+[dependencies.wasmtime-environ]
+version = "=10.0.1"
+
+[dependencies.wasmtime-jit-debug]
+version = "=10.0.1"
+features = ["perf_jitdump"]
+optional = true
+
+[dependencies.wasmtime-jit-icache-coherence]
+version = "=10.0.1"
+
+[dependencies.wasmtime-runtime]
+version = "=10.0.1"
+
+[features]
+jitdump = ["wasmtime-jit-debug"]
+vtune = ["ittapi"]
+
+[target."cfg(target_arch = \"x86_64\")".dependencies.ittapi]
+version = "0.3.3"
+optional = true
+
+[target."cfg(target_os = \"linux\")".dependencies.rustix]
+version = "0.37.13"
+features = ["thread"]
+
+[target."cfg(target_os = \"windows\")".dependencies.windows-sys]
+version = "0.48.0"
+features = ["Win32_System_Diagnostics_Debug"]