wasmtime 20.0.2 → 21.0.1

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

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"040657aa81602753d01bdded99ab03f501ec822023d0152608a343d0e923a170","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"3671a62ab26fc16dfb0c38b7b56d55c3f5d3b1b9f4dd42dd7a935c7e5cc59203","src/lib.rs":"7983500b97f5aaccaae2354b3afff84920308aa63c7ff27b47d49ee4b7f18ea1","src/unix.rs":"a757c3faae8df5c8027f43b29ceceb4721cee788e878e16ed23dbf9c27524d86","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":"4dbdf3053e7e7ced0cd4ed76579995b62169a1a43696890584eae2de2e33bf54"}

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

@@ -1,63 +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 = "20.0.2"
-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 = "=20.0.2"
-
-[dev-dependencies.backtrace]
-version = "0.3.68"
-
-[build-dependencies.cc]
-version = "1.0"
-
-[build-dependencies.wasmtime-versioned-export-macros]
-version = "=20.0.2"
-
-[target."cfg(unix)".dependencies.rustix]
-version = "0.38.31"
-features = [
-    "mm",
-    "param",
-]
-
-[target."cfg(unix)".dependencies.wasmtime-asm-macros]
-version = "=20.0.2"
-
-[target."cfg(windows)".dependencies.windows-sys]
-version = "0.52.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-20.0.2/build.rs

@@ -1,26 +0,0 @@
-use std::env;
-use wasmtime_versioned_export_macros::versioned_suffix;
-
-fn main() {
-    let mut build = cc::Build::new();
-    let arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    let os = env::var("CARGO_CFG_TARGET_OS").unwrap();
-    if os == "windows" {
-        println!("cargo:rerun-if-changed=src/windows.c");
-        build.file("src/windows.c");
-        build.define("VERSIONED_SUFFIX", Some(versioned_suffix!()));
-    } else if arch == "s390x" {
-        println!("cargo:rerun-if-changed=src/unix/s390x.S");
-        build.file("src/unix/s390x.S");
-        build.define("VERSIONED_SUFFIX", Some(versioned_suffix!()));
-    } else {
-        // assume that this is included via inline assembly in the crate itself,
-        // and the crate will otherwise have a `compile_error!` for unsupported
-        // platforms.
-        println!("cargo:rerun-if-changed=build.rs");
-        return;
-    }
-    build.define(&format!("CFG_TARGET_OS_{}", os), None);
-    build.define(&format!("CFG_TARGET_ARCH_{}", arch), None);
-    build.compile("wasmtime-fiber");
-}

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

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

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

@@ -1,265 +0,0 @@
-//! 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, RuntimeFiberStack};
-use std::cell::Cell;
-use std::io;
-use std::ops::Range;
-use std::ptr;
-
-pub enum FiberStack {
-    Default {
-        // 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,
-        mmap: bool,
-    },
-    Custom(Box<dyn RuntimeFiberStack>),
-}
-
-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.byte_add(page_size).cast(),
-                size,
-                rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
-            )?;
-
-            Ok(Self::Default {
-                top: mmap.byte_add(mmap_len).cast(),
-                len: mmap_len,
-                mmap: true,
-            })
-        }
-    }
-
-    pub unsafe fn from_raw_parts(base: *mut u8, len: usize) -> io::Result<Self> {
-        Ok(Self::Default {
-            top: base.add(len),
-            len,
-            mmap: false,
-        })
-    }
-
-    pub fn from_custom(custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
-        Ok(Self::Custom(custom))
-    }
-
-    pub fn top(&self) -> Option<*mut u8> {
-        Some(match self {
-            FiberStack::Default {
-                top,
-                len: _,
-                mmap: _,
-            } => *top,
-            FiberStack::Custom(r) => {
-                let top = r.top();
-                let page_size = rustix::param::page_size();
-                assert!(
-                    top.align_offset(page_size) == 0,
-                    "expected fiber stack top ({}) to be page aligned ({})",
-                    top as usize,
-                    page_size
-                );
-                top
-            }
-        })
-    }
-
-    pub fn range(&self) -> Option<Range<usize>> {
-        Some(match self {
-            FiberStack::Default { top, len, mmap: _ } => {
-                let base = unsafe { top.sub(*len) as usize };
-                base..base + len
-            }
-            FiberStack::Custom(s) => {
-                let range = s.range();
-                let page_size = rustix::param::page_size();
-                let start_ptr = range.start as *const u8;
-                assert!(
-                    start_ptr.align_offset(page_size) == 0,
-                    "expected fiber stack end ({}) to be page aligned ({})",
-                    range.start,
-                    page_size
-                );
-                let end_ptr = range.end as *const u8;
-                assert!(
-                    end_ptr.align_offset(page_size) == 0,
-                    "expected fiber stack start ({}) to be page aligned ({})",
-                    range.end,
-                    page_size
-                );
-                range
-            }
-        })
-    }
-}
-
-impl Drop for FiberStack {
-    fn drop(&mut self) {
-        unsafe {
-            if let FiberStack::Default {
-                top,
-                len,
-                mmap: true,
-            } = self
-            {
-                let ret = rustix::mm::munmap(top.sub(*len) as _, *len);
-                debug_assert!(ret.is_ok());
-            }
-        }
-    }
-}
-
-pub struct Fiber;
-
-pub struct Suspend(*mut u8);
-
-extern "C" {
-    #[wasmtime_versioned_export_macros::versioned_link]
-    fn wasmtime_fiber_init(
-        top_of_stack: *mut u8,
-        entry: extern "C" fn(*mut u8, *mut u8),
-        entry_arg0: *mut u8,
-    );
-    #[wasmtime_versioned_export_macros::versioned_link]
-    fn wasmtime_fiber_switch(top_of_stack: *mut u8);
-    #[allow(dead_code)] // only used in inline assembly for some platforms
-    #[wasmtime_versioned_export_macros::versioned_link]
-    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().unwrap(), 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().unwrap().cast::<usize>().offset(-1);
-            addr.write(result as *const _ as usize);
-
-            wasmtime_fiber_switch(stack.top().unwrap());
-
-            // 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");
-    }
-}