wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-environ-10.0.1/src/trap_encoding.rs

@@ -0,0 +1,238 @@
+use crate::obj::ELF_WASMTIME_TRAPS;
+use object::write::{Object, StandardSegment};
+use object::{Bytes, LittleEndian, SectionKind, U32Bytes};
+use std::convert::TryFrom;
+use std::fmt;
+use std::ops::Range;
+
+/// A helper structure to build the custom-encoded section of a wasmtime
+/// compilation image which encodes trap information.
+///
+/// This structure is incrementally fed the results of compiling individual
+/// functions and handles all the encoding internally, allowing usage of
+/// `lookup_trap_code` below with the resulting section.
+#[derive(Default)]
+pub struct TrapEncodingBuilder {
+    offsets: Vec<U32Bytes<LittleEndian>>,
+    traps: Vec<u8>,
+    last_offset: u32,
+}
+
+/// Information about trap.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct TrapInformation {
+    /// The offset of the trapping instruction in native code.
+    ///
+    /// This is relative to the beginning of the function.
+    pub code_offset: u32,
+
+    /// Code of the trap.
+    pub trap_code: Trap,
+}
+
+// The code can be accessed from the c-api, where the possible values are
+// translated into enum values defined there:
+//
+// * `wasm_trap_code` in c-api/src/trap.rs, and
+// * `wasmtime_trap_code_enum` in c-api/include/wasmtime/trap.h.
+//
+// These need to be kept in sync.
+#[non_exhaustive]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+#[allow(missing_docs)]
+pub enum Trap {
+    /// The current stack space was exhausted.
+    StackOverflow,
+
+    /// An out-of-bounds memory access.
+    MemoryOutOfBounds,
+
+    /// A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
+    HeapMisaligned,
+
+    /// An out-of-bounds access to a table.
+    TableOutOfBounds,
+
+    /// Indirect call to a null table entry.
+    IndirectCallToNull,
+
+    /// Signature mismatch on indirect call.
+    BadSignature,
+
+    /// An integer arithmetic operation caused an overflow.
+    IntegerOverflow,
+
+    /// An integer division by zero.
+    IntegerDivisionByZero,
+
+    /// Failed float-to-int conversion.
+    BadConversionToInteger,
+
+    /// Code that was supposed to have been unreachable was reached.
+    UnreachableCodeReached,
+
+    /// Execution has potentially run too long and may be interrupted.
+    Interrupt,
+
+    /// When the `component-model` feature is enabled this trap represents a
+    /// function that was `canon lift`'d, then `canon lower`'d, then called.
+    /// This combination of creation of a function in the component model
+    /// generates a function that always traps and, when called, produces this
+    /// flavor of trap.
+    AlwaysTrapAdapter,
+
+    /// When wasm code is configured to consume fuel and it runs out of fuel
+    /// then this trap will be raised.
+    OutOfFuel,
+
+    /// Used to indicate that a trap was raised by atomic wait operations on non shared memory.
+    AtomicWaitNonSharedMemory,
+
+    /// Call to a null reference.
+    NullReference,
+    // if adding a variant here be sure to update the `check!` macro below
+}
+
+impl fmt::Display for Trap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use Trap::*;
+
+        let desc = match self {
+            StackOverflow => "call stack exhausted",
+            MemoryOutOfBounds => "out of bounds memory access",
+            HeapMisaligned => "unaligned atomic",
+            TableOutOfBounds => "undefined element: out of bounds table access",
+            IndirectCallToNull => "uninitialized element",
+            BadSignature => "indirect call type mismatch",
+            IntegerOverflow => "integer overflow",
+            IntegerDivisionByZero => "integer divide by zero",
+            BadConversionToInteger => "invalid conversion to integer",
+            UnreachableCodeReached => "wasm `unreachable` instruction executed",
+            Interrupt => "interrupt",
+            AlwaysTrapAdapter => "degenerate component adapter called",
+            OutOfFuel => "all fuel consumed by WebAssembly",
+            AtomicWaitNonSharedMemory => "atomic wait on non-shared memory",
+            NullReference => "null reference",
+        };
+        write!(f, "wasm trap: {desc}")
+    }
+}
+
+impl std::error::Error for Trap {}
+
+impl TrapEncodingBuilder {
+    /// Appends trap information about a function into this section.
+    ///
+    /// This function is called to describe traps for the `func` range
+    /// specified. The `func` offsets are specified relative to the text section
+    /// itself, and the `traps` offsets are specified relative to the start of
+    /// `func`.
+    ///
+    /// This is required to be called in-order for increasing ranges of `func`
+    /// to ensure the final array is properly sorted. Additionally `traps` must
+    /// be sorted.
+    pub fn push(&mut self, func: Range<u64>, traps: &[TrapInformation]) {
+        // NB: for now this only supports <=4GB text sections in object files.
+        // Alternative schemes will need to be created for >32-bit offsets to
+        // avoid making this section overly large.
+        let func_start = u32::try_from(func.start).unwrap();
+        let func_end = u32::try_from(func.end).unwrap();
+
+        // Sanity-check to ensure that functions are pushed in-order, otherwise
+        // the `offsets` array won't be sorted which is our goal.
+        assert!(func_start >= self.last_offset);
+
+        self.offsets.reserve(traps.len());
+        self.traps.reserve(traps.len());
+        for info in traps {
+            let pos = func_start + info.code_offset;
+            assert!(pos >= self.last_offset);
+            self.offsets.push(U32Bytes::new(LittleEndian, pos));
+            self.traps.push(info.trap_code as u8);
+            self.last_offset = pos;
+        }
+
+        self.last_offset = func_end;
+    }
+
+    /// Encodes this section into the object provided.
+    pub fn append_to(self, obj: &mut Object) {
+        let section = obj.add_section(
+            obj.segment_name(StandardSegment::Data).to_vec(),
+            ELF_WASMTIME_TRAPS.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+
+        // NB: this matches the encoding expected by `lookup` below.
+        let amt = u32::try_from(self.traps.len()).unwrap();
+        obj.append_section_data(section, &amt.to_le_bytes(), 1);
+        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
+        obj.append_section_data(section, &self.traps, 1);
+    }
+}
+
+/// Decodes the provided trap information section and attempts to find the trap
+/// code corresponding to the `offset` specified.
+///
+/// The `section` provided is expected to have been built by
+/// `TrapEncodingBuilder` above. Additionally the `offset` should be a relative
+/// offset within the text section of the compilation image.
+pub fn lookup_trap_code(section: &[u8], offset: usize) -> Option<Trap> {
+    let mut section = Bytes(section);
+    // NB: this matches the encoding written by `append_to` above.
+    let count = section.read::<U32Bytes<LittleEndian>>().ok()?;
+    let count = usize::try_from(count.get(LittleEndian)).ok()?;
+    let (offsets, traps) =
+        object::slice_from_bytes::<U32Bytes<LittleEndian>>(section.0, count).ok()?;
+    debug_assert_eq!(traps.len(), count);
+
+    // The `offsets` table is sorted in the trap section so perform a binary
+    // search of the contents of this section to find whether `offset` is an
+    // entry in the section. Note that this is a precise search because trap pcs
+    // should always be precise as well as our metadata about them, which means
+    // we expect an exact match to correspond to a trap opcode.
+    //
+    // Once an index is found within the `offsets` array then that same index is
+    // used to lookup from the `traps` list of bytes to get the trap code byte
+    // corresponding to this offset.
+    let offset = u32::try_from(offset).ok()?;
+    let index = offsets
+        .binary_search_by_key(&offset, |val| val.get(LittleEndian))
+        .ok()?;
+    debug_assert!(index < traps.len());
+    let trap = *traps.get(index)?;
+
+    // FIXME: this could use some sort of derive-like thing to avoid having to
+    // deduplicate the names here.
+    //
+    // This simply converts from the `trap`, a `u8`, to the `Trap` enum.
+    macro_rules! check {
+        ($($name:ident)*) => ($(if trap == Trap::$name as u8 {
+            return Some(Trap::$name);
+        })*);
+    }
+
+    check! {
+        StackOverflow
+        MemoryOutOfBounds
+        HeapMisaligned
+        TableOutOfBounds
+        IndirectCallToNull
+        BadSignature
+        IntegerOverflow
+        IntegerDivisionByZero
+        BadConversionToInteger
+        UnreachableCodeReached
+        Interrupt
+        AlwaysTrapAdapter
+        OutOfFuel
+        AtomicWaitNonSharedMemory
+        NullReference
+    }
+
+    if cfg!(debug_assertions) {
+        panic!("missing mapping for {}", trap);
+    } else {
+        None
+    }
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"475d825d55ed54f55bd34ceb45c7ebc53e489b6c9125b2ade10873d2bc39f9fb","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"2d39117dd7f0f031a6a85bc0114860010569159fc918de9a7f2d5e326e92f280","src/lib.rs":"fdd3d6360c03f0616ca132004f7f1ee332071eb2b69167990e3d6bb86a6cfb6c","src/unix.rs":"1688084f5fe0fe8051a476d2119f47942691294d2ca38f66046f2596e0be82b9","src/unix/aarch64.rs":"8b7ddfe73ac35148451c77bb912793da45a00a0e3278d8629459efbfaacf5466","src/unix/arm.rs":"491016126358ec9c69e6e8db4654d42c836867c113e2907a2c799afdd67f8447","src/unix/riscv64.rs":"06ece3ea051e19731c8856430856895696c44e832a6a217a686dac5c6800296b","src/unix/s390x.S":"f6b352d299c9bbd19b1c2c21509a4fd609c6b6a4d2fe54fb7fd9c8e9236972ea","src/unix/x86.rs":"4ec3db0feeeb37706ef2771e81504be4ef47c56be43e0a0b8ae9938c0c47fcad","src/unix/x86_64.rs":"606bba47ffead2ff36f6066cc646fad67c774397d8093ed2ca5c5956477f56d5","src/windows.c":"495e49f3b39b165cb8e55dae4e4c873fcc6c80bf7fc85ba40aacab5a87be4784","src/windows.rs":"8b454ba559051dabe1894308967d33c48f1583190c45a1b5510f9716ac420d5f"},"package":"14309cbdf2c395258b124a24757c727403070c0465a28bcc780c4f82f4bca5ff"}

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

@@ -0,0 +1,46 @@
+# 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 = "10.0.1"
+authors = ["The Wasmtime Project Developers"]
+links = "wasmtime-fiber-shims"
+description = "Fiber support for Wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.cfg-if]
+version = "1.0"
+
+[dev-dependencies.backtrace]
+version = "0.3.61"
+
+[build-dependencies.cc]
+version = "1.0"
+
+[target."cfg(unix)".dependencies.rustix]
+version = "0.37.13"
+features = [
+    "mm",
+    "param",
+]
+
+[target."cfg(unix)".dependencies.wasmtime-asm-macros]
+version = "=10.0.1"
+
+[target."cfg(windows)".dependencies.windows-sys]
+version = "0.48.0"
+features = [
+    "Win32_System_Threading",
+    "Win32_Foundation",
+]

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

@@ -0,0 +1,305 @@
+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.
+#[derive(Debug)]
+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 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()
+    }
+}
+
+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()));
+    }
+}