wasmtime 11.0.0 → 12.0.1

data/ext/cargo-vendor/wasmtime-wasi-12.0.1/src/preview2/table.rs

@@ -0,0 +1,287 @@
+use std::any::Any;
+use std::collections::{BTreeSet, HashMap};
+
+#[derive(thiserror::Error, Debug)]
+pub enum TableError {
+    #[error("table has no free keys")]
+    Full,
+    #[error("value not present")]
+    NotPresent,
+    #[error("value is of another type")]
+    WrongType,
+    #[error("entry still has children")]
+    HasChildren,
+}
+
+/// The `Table` type is designed to map u32 handles to resources. The table is now part of the
+/// public interface to a `WasiCtx` - it is reference counted so that it can be shared beyond a
+/// `WasiCtx` with other WASI proposals (e.g. `wasi-crypto` and `wasi-nn`) to manage their
+/// resources. Elements in the `Table` are `Any` typed.
+///
+/// The `Table` type is intended to model how the Interface Types concept of Resources is shaping
+/// up. Right now it is just an approximation.
+#[derive(Debug)]
+pub struct Table {
+    map: HashMap<u32, TableEntry>,
+    next_key: u32,
+}
+
+/// This structure tracks parent and child relationships for a given table entry.
+///
+/// Parents and children are referred to by table index. We maintain the
+/// following invariants to prevent orphans and cycles:
+/// * parent can only be assigned on creating the entry.
+/// * parent, if some, must exist when creating the entry.
+/// * whenever a child is created, its index is added to children.
+/// * whenever a child is deleted, its index is removed from children.
+/// * an entry with children may not be deleted.
+#[derive(Debug)]
+struct TableEntry {
+    /// The entry in the table, as a boxed dynamically-typed object
+    entry: Box<dyn Any + Send + Sync>,
+    /// The index of the parent of this entry, if it has one.
+    parent: Option<u32>,
+    /// The indicies of any children of this entry.
+    children: BTreeSet<u32>,
+}
+
+impl TableEntry {
+    fn new(entry: Box<dyn Any + Send + Sync>, parent: Option<u32>) -> Self {
+        Self {
+            entry,
+            parent,
+            children: BTreeSet::new(),
+        }
+    }
+    fn add_child(&mut self, child: u32) {
+        debug_assert!(!self.children.contains(&child));
+        self.children.insert(child);
+    }
+    fn remove_child(&mut self, child: u32) {
+        let was_removed = self.children.remove(&child);
+        debug_assert!(was_removed);
+    }
+}
+
+/// Like [`std::collections::hash_map::OccupiedEntry`], with a subset of
+/// methods available in order to uphold [`Table`] invariants.
+pub struct OccupiedEntry<'a> {
+    table: &'a mut Table,
+    index: u32,
+}
+impl<'a> OccupiedEntry<'a> {
+    /// Get the dynamically-typed reference to the resource.
+    pub fn get(&self) -> &(dyn Any + Send + Sync + 'static) {
+        self.table.map.get(&self.index).unwrap().entry.as_ref()
+    }
+    /// Get the dynamically-typed mutable reference to the resource.
+    pub fn get_mut(&mut self) -> &mut (dyn Any + Send + Sync + 'static) {
+        self.table.map.get_mut(&self.index).unwrap().entry.as_mut()
+    }
+    /// Remove the resource from the table, returning the contents of the
+    /// resource.
+    /// May fail with [`TableError::HasChildren`] if the entry has any
+    /// children, see [`Table::push_child`].
+    /// If this method fails, the [`OccupiedEntry`] is consumed, but the
+    /// resource remains in the table.
+    pub fn remove_entry(self) -> Result<Box<dyn Any + Send + Sync>, TableError> {
+        self.table.delete_entry(self.index).map(|e| e.entry)
+    }
+}
+
+impl Table {
+    /// Create an empty table
+    pub fn new() -> Self {
+        Table {
+            map: HashMap::new(),
+            // 0, 1 and 2 are formerly (preview 1) for stdio. To prevent users from assuming these
+            // indicies are still valid ways to access stdio, they are deliberately left empty.
+            // Once we have a full implementation of resources, this confusion should hopefully be
+            // impossible :)
+            next_key: 3,
+        }
+    }
+
+    /// Insert a resource at the next available index.
+    pub fn push(&mut self, entry: Box<dyn Any + Send + Sync>) -> Result<u32, TableError> {
+        self.push_(TableEntry::new(entry, None))
+    }
+
+    /// Insert a resource at the next available index, and track that it has a
+    /// parent resource.
+    ///
+    /// The parent must exist to create a child. All children resources must
+    /// be destroyed before a parent can be destroyed - otherwise [`Table::delete`]
+    /// or [`OccupiedEntry::remove_entry`] will fail with
+    /// [`TableError::HasChildren`].
+    ///
+    /// Parent-child relationships are tracked inside the table to ensure that
+    /// a parent resource is not deleted while it has live children. This
+    /// allows child resources to hold "references" to a parent by table
+    /// index, to avoid needing e.g. an `Arc<Mutex<parent>>` and the associated
+    /// locking overhead and design issues, such as child existence extending
+    /// lifetime of parent referent even after parent resource is destroyed,
+    /// possibility for deadlocks.
+    ///
+    /// Parent-child relationships may not be modified once created. There
+    /// is no way to observe these relationships through the [`Table`] methods
+    /// except for erroring on deletion, or the [`std::fmt::Debug`] impl.
+    pub fn push_child(
+        &mut self,
+        entry: Box<dyn Any + Send + Sync>,
+        parent: u32,
+    ) -> Result<u32, TableError> {
+        if !self.contains_key(parent) {
+            return Err(TableError::NotPresent);
+        }
+        let child = self.push_(TableEntry::new(entry, Some(parent)))?;
+        self.map
+            .get_mut(&parent)
+            .expect("parent existence assured above")
+            .add_child(child);
+        Ok(child)
+    }
+
+    fn push_(&mut self, e: TableEntry) -> Result<u32, TableError> {
+        // NOTE: The performance of this new key calculation could be very bad once keys wrap
+        // around.
+        if self.map.len() == u32::MAX as usize {
+            return Err(TableError::Full);
+        }
+        loop {
+            let key = self.next_key;
+            self.next_key = self.next_key.wrapping_add(1);
+            if self.map.contains_key(&key) {
+                continue;
+            }
+            self.map.insert(key, e);
+            return Ok(key);
+        }
+    }
+
+    /// Check if the table has a resource at the given index.
+    pub fn contains_key(&self, key: u32) -> bool {
+        self.map.contains_key(&key)
+    }
+
+    /// Check if the resource at a given index can be downcast to a given type.
+    /// Note: this will always fail if the resource is already borrowed.
+    pub fn is<T: Any + Sized>(&self, key: u32) -> bool {
+        if let Some(r) = self.map.get(&key) {
+            r.entry.is::<T>()
+        } else {
+            false
+        }
+    }
+
+    /// Get an immutable reference to a resource of a given type at a given index. Multiple
+    /// immutable references can be borrowed at any given time. Borrow failure
+    /// results in a trapping error.
+    pub fn get<T: Any + Sized>(&self, key: u32) -> Result<&T, TableError> {
+        if let Some(r) = self.map.get(&key) {
+            r.entry
+                .downcast_ref::<T>()
+                .ok_or_else(|| TableError::WrongType)
+        } else {
+            Err(TableError::NotPresent)
+        }
+    }
+
+    /// Get a mutable reference to a resource of a given type at a given index. Only one mutable
+    /// reference can be borrowed at any given time. Borrow failure results in a trapping error.
+    pub fn get_mut<T: Any + Sized>(&mut self, key: u32) -> Result<&mut T, TableError> {
+        if let Some(r) = self.map.get_mut(&key) {
+            r.entry
+                .downcast_mut::<T>()
+                .ok_or_else(|| TableError::WrongType)
+        } else {
+            Err(TableError::NotPresent)
+        }
+    }
+
+    /// Get an [`OccupiedEntry`] corresponding to a table entry, if it exists. This allows you to
+    /// remove or replace the entry based on its contents. The methods available are a subset of
+    /// [`std::collections::hash_map::OccupiedEntry`] - it does not give access to the key, it
+    /// restricts replacing the entry to items of the same type, and it does not allow for deletion.
+    pub fn entry(&mut self, index: u32) -> Result<OccupiedEntry, TableError> {
+        if self.map.contains_key(&index) {
+            Ok(OccupiedEntry { table: self, index })
+        } else {
+            Err(TableError::NotPresent)
+        }
+    }
+
+    fn delete_entry(&mut self, key: u32) -> Result<TableEntry, TableError> {
+        if !self
+            .map
+            .get(&key)
+            .ok_or(TableError::NotPresent)?
+            .children
+            .is_empty()
+        {
+            return Err(TableError::HasChildren);
+        }
+        let e = self.map.remove(&key).unwrap();
+        if let Some(parent) = e.parent {
+            // Remove deleted resource from parent's child list.
+            // Parent must still be present because it cant be deleted while still having
+            // children:
+            self.map
+                .get_mut(&parent)
+                .expect("missing parent")
+                .remove_child(key);
+        }
+        Ok(e)
+    }
+
+    /// Remove a resource at a given index from the table.
+    ///
+    /// If this method fails, the resource remains in the table.
+    ///
+    /// May fail with [`TableError::HasChildren`] if the resource has any live
+    /// children.
+    pub fn delete<T: Any + Sized>(&mut self, key: u32) -> Result<T, TableError> {
+        let e = self.delete_entry(key)?;
+        match e.entry.downcast::<T>() {
+            Ok(v) => Ok(*v),
+            Err(entry) => {
+                // Re-insert into parent list
+                if let Some(parent) = e.parent {
+                    self.map
+                        .get_mut(&parent)
+                        .expect("already checked parent exists")
+                        .add_child(key);
+                }
+                // Insert the value back
+                self.map.insert(
+                    key,
+                    TableEntry {
+                        entry,
+                        children: e.children,
+                        parent: e.parent,
+                    },
+                );
+                Err(TableError::WrongType)
+            }
+        }
+    }
+
+    /// Zip the values of the map with mutable references to table entries corresponding to each
+    /// key. As the keys in the [HashMap] are unique, this iterator can give mutable references
+    /// with the same lifetime as the mutable reference to the [Table].
+    pub fn iter_entries<'a, T>(
+        &'a mut self,
+        map: HashMap<u32, T>,
+    ) -> impl Iterator<Item = (Result<&'a mut dyn Any, TableError>, T)> {
+        map.into_iter().map(move |(k, v)| {
+            let item = self
+                .map
+                .get_mut(&k)
+                .map(|e| Box::as_mut(&mut e.entry))
+                // Safety: extending the lifetime of the mutable reference.
+                .map(|item| unsafe { &mut *(item as *mut dyn Any) })
+                .ok_or(TableError::NotPresent);
+            (item, v)
+        })
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-12.0.1/wit/deps/io/streams.wit

@@ -0,0 +1,254 @@
+package wasi:io
+
+/// WASI I/O is an I/O abstraction API which is currently focused on providing
+/// stream types.
+///
+/// In the future, the component model is expected to add built-in stream types;
+/// when it does, they are expected to subsume this API.
+interface streams {
+    use wasi:poll/poll.{pollable}
+
+    /// An error type returned from a stream operation.
+    ///
+    /// TODO: need to figure out the actual contents of this error. Used to be
+    /// an empty record but that's no longer allowed. The `dummy` field is
+    /// only here to have this be a valid in the component model by being
+    /// non-empty.
+    record stream-error {
+      dummy: u32,
+    }
+
+    /// Streams provide a sequence of data and then end; once they end, they
+    /// no longer provide any further data.
+    ///
+    /// For example, a stream reading from a file ends when the stream reaches
+    /// the end of the file. For another example, a stream reading from a
+    /// socket ends when the socket is closed.
+    enum stream-status {
+        /// The stream is open and may produce further data.
+        open,
+        /// When reading, this indicates that the stream will not produce
+        /// further data.
+        /// When writing, this indicates that the stream will no longer be read.
+        /// Further writes are still permitted.
+        ended,
+    }
+
+    /// An input bytestream. In the future, this will be replaced by handle
+    /// types.
+    ///
+    /// This conceptually represents a `stream<u8, _>`. It's temporary
+    /// scaffolding until component-model's async features are ready.
+    ///
+    /// `input-stream`s are *non-blocking* to the extent practical on underlying
+    /// platforms. I/O operations always return promptly; if fewer bytes are
+    /// promptly available than requested, they return the number of bytes promptly
+    /// available, which could even be zero. To wait for data to be available,
+    /// use the `subscribe-to-input-stream` function to obtain a `pollable` which
+    /// can be polled for using `wasi_poll`.
+    ///
+    /// And at present, it is a `u32` instead of being an actual handle, until
+    /// the wit-bindgen implementation of handles and resources is ready.
+    ///
+    /// This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+    type input-stream = u32
+
+    /// Perform a non-blocking read from the stream.
+    ///
+    /// This function returns a list of bytes containing the data that was
+    /// read, along with a `stream-status` which, indicates whether further
+    /// reads are expected to produce data. The returned list will contain up to
+    /// `len` bytes; it may return fewer than requested, but not more.
+    ///
+    /// Once a stream has reached the end, subsequent calls to read or
+    /// `skip` will always report end-of-stream rather than producing more
+    /// data.
+    ///
+    /// If `len` is 0, it represents a request to read 0 bytes, which should
+    /// always succeed, assuming the stream hasn't reached its end yet, and
+    /// return an empty list.
+    ///
+    /// The len here is a `u64`, but some callees may not be able to allocate
+    /// a buffer as large as that would imply.
+    /// FIXME: describe what happens if allocation fails.
+    ///
+    /// When the returned `stream-status` is `open`, the length of the returned
+    /// value may be less than `len`. When an empty list is returned, this
+    /// indicates that no more bytes were available from the stream at that
+    /// time. In that case the subscribe-to-input-stream pollable will indicate
+    /// when additional bytes are available for reading.
+    read: func(
+        this: input-stream,
+        /// The maximum number of bytes to read
+        len: u64
+    ) -> result<tuple<list<u8>, stream-status>, stream-error>
+
+    /// Read bytes from a stream, with blocking.
+    ///
+    /// This is similar to `read`, except that it blocks until at least one
+    /// byte can be read.
+    blocking-read: func(
+        this: input-stream,
+        /// The maximum number of bytes to read
+        len: u64
+    ) -> result<tuple<list<u8>, stream-status>, stream-error>
+
+    /// Skip bytes from a stream.
+    ///
+    /// This is similar to the `read` function, but avoids copying the
+    /// bytes into the instance.
+    ///
+    /// Once a stream has reached the end, subsequent calls to read or
+    /// `skip` will always report end-of-stream rather than producing more
+    /// data.
+    ///
+    /// This function returns the number of bytes skipped, along with a bool
+    /// indicating whether the end of the stream was reached. The returned
+    /// value will be at most `len`; it may be less.
+    skip: func(
+        this: input-stream,
+        /// The maximum number of bytes to skip.
+        len: u64,
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Skip bytes from a stream, with blocking.
+    ///
+    /// This is similar to `skip`, except that it blocks until at least one
+    /// byte can be consumed.
+    blocking-skip: func(
+        this: input-stream,
+        /// The maximum number of bytes to skip.
+        len: u64,
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Create a `pollable` which will resolve once either the specified stream
+    /// has bytes available to read or the other end of the stream has been
+    /// closed.
+    subscribe-to-input-stream: func(this: input-stream) -> pollable
+
+    /// Dispose of the specified `input-stream`, after which it may no longer
+    /// be used.
+    drop-input-stream: func(this: input-stream)
+
+    /// An output bytestream. In the future, this will be replaced by handle
+    /// types.
+    ///
+    /// This conceptually represents a `stream<u8, _>`. It's temporary
+    /// scaffolding until component-model's async features are ready.
+    ///
+    /// `output-stream`s are *non-blocking* to the extent practical on
+    /// underlying platforms. Except where specified otherwise, I/O operations also
+    /// always return promptly, after the number of bytes that can be written
+    /// promptly, which could even be zero. To wait for the stream to be ready to
+    /// accept data, the `subscribe-to-output-stream` function to obtain a
+    /// `pollable` which can be polled for using `wasi:poll`.
+    ///
+    /// And at present, it is a `u32` instead of being an actual handle, until
+    /// the wit-bindgen implementation of handles and resources is ready.
+    ///
+    /// This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+    type output-stream = u32
+
+    /// Perform a non-blocking write of bytes to a stream.
+    ///
+    /// This function returns a `u64` and a `stream-status`. The `u64` indicates
+    /// the number of bytes from `buf` that were written, which may be less than
+    /// the length of `buf`. The `stream-status` indicates if further writes to
+    /// the stream are expected to be read.
+    ///
+    /// When the returned `stream-status` is `open`, the `u64` return value may
+    /// be less than the length of `buf`. This indicates that no more bytes may
+    /// be written to the stream promptly. In that case the
+    /// subscribe-to-output-stream pollable will indicate when additional bytes
+    /// may be promptly written.
+    ///
+    /// TODO: document what happens when an empty list is written
+    write: func(
+        this: output-stream,
+        /// Data to write
+        buf: list<u8>
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Write bytes to a stream, with blocking.
+    ///
+    /// This is similar to `write`, except that it blocks until at least one
+    /// byte can be written.
+    blocking-write: func(
+        this: output-stream,
+        /// Data to write
+        buf: list<u8>
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Write multiple zero bytes to a stream.
+    ///
+    /// This function returns a `u64` indicating the number of zero bytes
+    /// that were written; it may be less than `len`.
+    write-zeroes: func(
+        this: output-stream,
+        /// The number of zero bytes to write
+        len: u64
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Write multiple zero bytes to a stream, with blocking.
+    ///
+    /// This is similar to `write-zeroes`, except that it blocks until at least
+    /// one byte can be written.
+    blocking-write-zeroes: func(
+        this: output-stream,
+        /// The number of zero bytes to write
+        len: u64
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Read from one stream and write to another.
+    ///
+    /// This function returns the number of bytes transferred; it may be less
+    /// than `len`.
+    ///
+    /// Unlike other I/O functions, this function blocks until all the data
+    /// read from the input stream has been written to the output stream.
+    splice: func(
+        this: output-stream,
+        /// The stream to read from
+        src: input-stream,
+        /// The number of bytes to splice
+        len: u64,
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Read from one stream and write to another, with blocking.
+    ///
+    /// This is similar to `splice`, except that it blocks until at least
+    /// one byte can be read.
+    blocking-splice: func(
+        this: output-stream,
+        /// The stream to read from
+        src: input-stream,
+        /// The number of bytes to splice
+        len: u64,
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Forward the entire contents of an input stream to an output stream.
+    ///
+    /// This function repeatedly reads from the input stream and writes
+    /// the data to the output stream, until the end of the input stream
+    /// is reached, or an error is encountered.
+    ///
+    /// Unlike other I/O functions, this function blocks until the end
+    /// of the input stream is seen and all the data has been written to
+    /// the output stream.
+    ///
+    /// This function returns the number of bytes transferred, and the status of
+    /// the output stream.
+    forward: func(
+        this: output-stream,
+        /// The stream to read from
+        src: input-stream
+    ) -> result<tuple<u64, stream-status>, stream-error>
+
+    /// Create a `pollable` which will resolve once either the specified stream
+    /// is ready to accept bytes or the other end of the stream has been closed.
+    subscribe-to-output-stream: func(this: output-stream) -> pollable
+
+    /// Dispose of the specified `output-stream`, after which it may no longer
+    /// be used.
+    drop-output-stream: func(this: output-stream)
+}

data/ext/cargo-vendor/wasmtime-wasi-12.0.1/wit/test.wit

@@ -0,0 +1,28 @@
+// only used as part of `test-programs`
+world test-reactor {
+
+  import wasi:cli-base/environment
+  import wasi:io/streams
+  import wasi:cli-base/preopens
+  import wasi:filesystem/filesystem
+  import wasi:cli-base/exit
+
+  export add-strings: func(s: list<string>) -> u32
+  export get-strings: func() -> list<string>
+
+  use wasi:io/streams.{output-stream}
+
+  export write-strings-to: func(o: output-stream) -> result
+
+  use wasi:filesystem/filesystem.{descriptor-stat}
+  export pass-an-imported-record: func(d: descriptor-stat) -> string
+}
+
+world test-command {
+  import wasi:poll/poll
+  import wasi:io/streams
+  import wasi:cli-base/environment
+  import wasi:cli-base/stdin
+  import wasi:cli-base/stdout
+  import wasi:cli-base/stderr
+}

data/ext/cargo-vendor/wasmtime-winch-12.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"6dd4a1ee180208d650b80afd6d8c7601e41f9ffe43faddd21d92226bdc943f2c","LICENSE":"a6c48161a09acc75a0e25503bab66a731eb5fba5392ed4bb4743e4ba5085327a","src/builder.rs":"99f5a906a1ba1ee68470831a4252baef3bb3063daa015bb3ab0d6c114929fcb0","src/compiler.rs":"b7c53be3cc4e1769ebebb7f5f8fa5cf0b42b57a9b0cfb818beaef955b13f3dda","src/lib.rs":"af1ae41ca004ba001c133bc39d3d148377d6c986ca9dbe2775c8681d8d244e9f"},"package":"f9d016c3f1d0c8ac905bfda51936cb6dae040e0d8edc75b7a1ef9f21773a19f6"}

data/ext/cargo-vendor/wasmtime-winch-12.0.1/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-winch"
+version = "12.0.1"
+authors = ["The Wasmtime Project Developers"]
+description = "Integration between Wasmtime and Winch"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.cranelift-codegen]
+version = "0.99.1"
+
+[dependencies.gimli]
+version = "0.27.0"
+features = [
+    "read",
+    "std",
+]
+default-features = false
+
+[dependencies.object]
+version = "0.31.1"
+features = [
+    "read_core",
+    "elf",
+    "std",
+]
+default-features = false
+
+[dependencies.target-lexicon]
+version = "0.12.3"
+features = ["std"]
+default-features = false
+
+[dependencies.wasmparser]
+version = "0.110.0"
+
+[dependencies.wasmtime-cranelift-shared]
+version = "=12.0.1"
+
+[dependencies.wasmtime-environ]
+version = "=12.0.1"
+
+[dependencies.winch-codegen]
+version = "=0.10.1"
+
+[features]
+all-arch = ["winch-codegen/all-arch"]
+component-model = ["wasmtime-environ/component-model"]