wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/cranelift-codegen-shared-0.109.0/src/constants.rs

@@ -0,0 +1,28 @@
+//! This module contains constants that are shared between the codegen and the meta crate, so they
+//! are kept in sync.
+
+// Numbering scheme for value types:
+//
+// 0: Void
+// 0x01-0x6f: Special types
+// 0x70-0x7d: Lane types
+// 0x7e-0x7f: Reference types
+// 0x80-0xff: Vector types
+// 0x100-0x17f: Dynamic Vector types
+//
+// Vector types are encoded with the lane type in the low 4 bits and log2(lanes)
+// in the next highest 4 bits, giving a range of 2-256 lanes.
+
+// Dynamic vector types are encoded similarly.
+
+/// Start of the lane types.
+pub const LANE_BASE: u16 = 0x70;
+
+/// Base for reference types.
+pub const REFERENCE_BASE: u16 = 0x7E;
+
+/// Start of the 2-lane vector types.
+pub const VECTOR_BASE: u16 = 0x80;
+
+/// Start of the dynamic vector types.
+pub const DYNAMIC_VECTOR_BASE: u16 = 0x100;

data/ext/cargo-vendor/cranelift-control-0.109.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"eacf4e06a0f4ebd678928b50a310e2d8ea0aa3a2e303ef08d48c9331f9aecc25","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"9266e3c8ff78a0f5948eb24292a2b51ec272d9417816ffe23de0b1ea4589acb4","src/chaos.rs":"2249bbd902abb610258e8a0545e4ce3d526ea4f29f04aa4724195cd2d7ee28a3","src/lib.rs":"4da5d01c3d43954437288a96f8842f11f01431d99fbf4a7210e9bb71b56393dc","src/zero_sized.rs":"4f970663f3502a2644162033aaf6a7b65336e3e1a9b064737f5cace89636e556"},"package":"0100f33b704cdacd01ad66ff41f8c5030d57cbff078e2a4e49ab1822591299fa"}

data/ext/cargo-vendor/cranelift-control-0.109.0/Cargo.toml

@@ -0,0 +1,30 @@
+# 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 = "cranelift-control"
+version = "0.109.0"
+authors = ["The Cranelift Project Developers"]
+description = "White-box fuzz testing framework"
+readme = "README.md"
+keywords = [
+    "fuzz",
+    "test",
+]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.arbitrary]
+version = "1.3.1"
+
+[features]
+chaos = []

data/ext/cargo-vendor/cranelift-entity-0.109.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"e43e08b4e7eea25436b8b2ea490295b1530eb53add743d6e6abcc1104dbbc5e0","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"96ceffbfd88fb06e3b41aa4d3087cffbbf8441d04eba7ab09662a72ab600a321","src/boxed_slice.rs":"69d539b72460c0aba1d30e0b72efb0c29d61558574d751c784794e14abf41352","src/iter.rs":"61fefdc49cafad4cacba5f5a7ad2396a23160642c688a7f0b0734277391847cd","src/keys.rs":"b8c2fba26dee15bf3d1880bb2b41e8d66fe1428d242ee6d9fd30ee94bbd0407d","src/lib.rs":"6bc71b2445d143a779ffaecab03114b6882660c2cc621a5f500245fe78eb862b","src/list.rs":"bd62ec1b6373b84efb27e69f34f482163308a4cfb6fb28c0122edaa6e7a4c5d1","src/map.rs":"d5e004471acf75d71cebaac0e65a45fe052781507f4a616120d264a8056a5d92","src/packed_option.rs":"5835517c24397e79db5075201950d43956f9f8c7e6ac0df738b1372d5c3e725a","src/primary.rs":"701c2e495df50179295005e21c4ab24d3e70c24c44d7c1e88f37ed51355434c6","src/set.rs":"bf0a16799d53f879d4c6f3638e180bb6d4a805582fcf94a4dd23891892578be8","src/sparse.rs":"e0c2c35e7253aeff882816e6b25959ce054fdcc91ae2b0888bb67ae2e0453943","src/unsigned.rs":"cb50cc8387466857a46dca6f0368c8be80a5c01036876fe6b10c477880202878"},"package":"a8cfdc315e5d18997093e040a8d234bea1ac1e118a716d3e30f40d449e78207b"}

data/ext/cargo-vendor/cranelift-entity-0.109.0/Cargo.toml

@@ -0,0 +1,53 @@
+# 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 = "cranelift-entity"
+version = "0.109.0"
+authors = ["The Cranelift Project Developers"]
+description = "Data structures using entity references as mapping keys"
+documentation = "https://docs.rs/cranelift-entity"
+readme = "README.md"
+keywords = [
+    "entity",
+    "set",
+    "map",
+]
+categories = ["no-std"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.serde]
+version = "1.0.188"
+features = ["alloc"]
+optional = true
+default-features = false
+
+[dependencies.serde_derive]
+version = "1.0.188"
+optional = true
+
+[features]
+enable-serde = [
+    "serde",
+    "serde_derive",
+]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/cranelift-entity-0.109.0/src/set.rs

@@ -0,0 +1,290 @@
+//! Densely numbered entity references as set keys.
+
+use crate::keys::Keys;
+use crate::EntityRef;
+use alloc::vec::Vec;
+use core::marker::PhantomData;
+
+// How many bits are used to represent a single element in `EntitySet`.
+const BITS: usize = core::mem::size_of::<usize>() * 8;
+
+/// A set of `K` for densely indexed entity references.
+///
+/// The `EntitySet` data structure uses the dense index space to implement a set with a bitvector.
+/// Like `SecondaryMap`, an `EntitySet` is used to associate secondary information with entities.
+#[derive(Debug, Clone)]
+pub struct EntitySet<K>
+where
+    K: EntityRef,
+{
+    elems: Vec<usize>,
+    len: usize,
+    unused: PhantomData<K>,
+}
+
+impl<K: EntityRef> Default for EntitySet<K> {
+    fn default() -> Self {
+        Self {
+            elems: Vec::new(),
+            len: 0,
+            unused: PhantomData,
+        }
+    }
+}
+
+/// Shared `EntitySet` implementation for all value types.
+impl<K> EntitySet<K>
+where
+    K: EntityRef,
+{
+    /// Create a new empty set.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Creates a new empty set with the specified capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            elems: Vec::with_capacity((capacity + (BITS - 1)) / BITS),
+            ..Self::new()
+        }
+    }
+
+    /// Get the element at `k` if it exists.
+    pub fn contains(&self, k: K) -> bool {
+        let index = k.index();
+        if index < self.len {
+            (self.elems[index / BITS] & (1 << (index % BITS))) != 0
+        } else {
+            false
+        }
+    }
+
+    /// Is this set completely empty?
+    pub fn is_empty(&self) -> bool {
+        if self.len != 0 {
+            false
+        } else {
+            self.elems.iter().all(|&e| e == 0)
+        }
+    }
+
+    /// Returns the cardinality of the set. More precisely, it returns the number of calls to
+    /// `insert` with different key values, that have happened since the set was most recently
+    /// `clear`ed or created with `new`.
+    pub fn cardinality(&self) -> usize {
+        self.elems[..(self.len + (BITS - 1)) / BITS]
+            .iter()
+            .map(|x| x.count_ones() as usize)
+            .sum()
+    }
+
+    /// Remove all entries from this set.
+    pub fn clear(&mut self) {
+        self.len = 0;
+        self.elems.clear()
+    }
+
+    /// Iterate over all the keys in this set.
+    pub fn keys(&self) -> Keys<K> {
+        Keys::with_len(self.len)
+    }
+
+    /// Resize the set to have `n` entries by adding default entries as needed.
+    pub fn resize(&mut self, n: usize) {
+        self.elems.resize((n + (BITS - 1)) / BITS, 0);
+        self.len = n
+    }
+
+    /// Insert the element at `k`.
+    pub fn insert(&mut self, k: K) -> bool {
+        let index = k.index();
+        if index >= self.len {
+            self.resize(index + 1)
+        }
+        let result = !self.contains(k);
+        self.elems[index / BITS] |= 1 << (index % BITS);
+        result
+    }
+
+    /// Removes and returns the entity from the set if it exists.
+    pub fn pop(&mut self) -> Option<K> {
+        if self.len == 0 {
+            return None;
+        }
+
+        // Clear the last known entity in the list.
+        let last_index = self.len - 1;
+        self.elems[last_index / BITS] &= !(1 << (last_index % BITS));
+
+        // Set the length to the next last stored entity or zero if we pop'ed
+        // the last entity.
+        self.len = self
+            .elems
+            .iter()
+            .enumerate()
+            .rev()
+            .find(|(_, &elem)| elem != 0)
+            // Map `i` from `elem` index to bit level index.
+            // `(i + 1) * BITS` = Last bit in `elem`.
+            // `last - elem.leading_zeros()` = last set bit in `elem`.
+            // `as usize` won't ever truncate as the potential range is `0..=8`.
+            .map_or(0, |(i, elem)| {
+                ((i + 1) * BITS) - elem.leading_zeros() as usize
+            });
+
+        Some(K::new(last_index))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use core::u32;
+
+    // `EntityRef` impl for testing.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+    struct E(u32);
+
+    impl EntityRef for E {
+        fn new(i: usize) -> Self {
+            E(i as u32)
+        }
+        fn index(self) -> usize {
+            self.0 as usize
+        }
+    }
+
+    #[test]
+    fn basic() {
+        let r0 = E(0);
+        let r1 = E(1);
+        let r2 = E(2);
+        let mut m = EntitySet::new();
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, []);
+        assert!(m.is_empty());
+
+        m.insert(r2);
+        m.insert(r1);
+
+        assert!(!m.contains(r0));
+        assert!(m.contains(r1));
+        assert!(m.contains(r2));
+        assert!(!m.contains(E(3)));
+        assert!(!m.is_empty());
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, [r0, r1, r2]);
+
+        m.resize(20);
+        assert!(!m.contains(E(3)));
+        assert!(!m.contains(E(4)));
+        assert!(!m.contains(E(8)));
+        assert!(!m.contains(E(15)));
+        assert!(!m.contains(E(19)));
+
+        m.insert(E(8));
+        m.insert(E(15));
+        assert!(!m.contains(E(3)));
+        assert!(!m.contains(E(4)));
+        assert!(m.contains(E(8)));
+        assert!(!m.contains(E(9)));
+        assert!(!m.contains(E(14)));
+        assert!(m.contains(E(15)));
+        assert!(!m.contains(E(16)));
+        assert!(!m.contains(E(19)));
+        assert!(!m.contains(E(20)));
+        assert!(!m.contains(E(u32::MAX)));
+
+        m.clear();
+        assert!(m.is_empty());
+    }
+
+    #[test]
+    fn pop_ordered() {
+        let r0 = E(0);
+        let r1 = E(1);
+        let r2 = E(2);
+        let mut m = EntitySet::new();
+        m.insert(r0);
+        m.insert(r1);
+        m.insert(r2);
+
+        assert_eq!(r2, m.pop().unwrap());
+        assert_eq!(r1, m.pop().unwrap());
+        assert_eq!(r0, m.pop().unwrap());
+        assert!(m.pop().is_none());
+        assert!(m.pop().is_none());
+    }
+
+    #[test]
+    fn pop_unordered() {
+        let mut blocks = [
+            E(0),
+            E(1),
+            E(6),
+            E(7),
+            E(5),
+            E(9),
+            E(10),
+            E(2),
+            E(3),
+            E(11),
+            E(12),
+        ];
+
+        let mut m = EntitySet::new();
+        for &block in &blocks {
+            m.insert(block);
+        }
+        assert_eq!(m.len, 13);
+        blocks.sort();
+
+        for &block in blocks.iter().rev() {
+            assert_eq!(block, m.pop().unwrap());
+        }
+
+        assert!(m.is_empty());
+    }
+
+    #[test]
+    fn cardinality() {
+        let mut m = EntitySet::new();
+
+        m.insert(E(1));
+        assert!(m.cardinality() == 1);
+
+        m.insert(E(0));
+        assert!(m.cardinality() == 2);
+
+        m.insert(E(1));
+        assert!(m.cardinality() == 2);
+
+        m.insert(E(BITS as u32 - 1));
+        assert!(m.cardinality() == 3);
+
+        m.insert(E(BITS as u32));
+        assert!(m.cardinality() == 4);
+
+        m.insert(E(BITS as u32 - 1));
+        assert!(m.cardinality() == 4);
+
+        assert!(m.pop() == Some(E(BITS as u32)));
+        assert!(m.cardinality() == 3);
+        assert!(m.pop() == Some(E(BITS as u32 - 1)));
+        assert!(m.cardinality() == 2);
+
+        m.insert(E(100));
+        assert!(m.cardinality() == 3);
+
+        assert!(m.pop() == Some(E(100)));
+        assert!(m.cardinality() == 2);
+
+        m.insert(E(100));
+        m.insert(E(101));
+        m.insert(E(102));
+        assert!(m.cardinality() == 5);
+    }
+}

data/ext/cargo-vendor/cranelift-frontend-0.109.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"82752fc241fb6e19ca61c1675cbea8ba56e365247d3d2d17481e51e3d1ff3157","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"dea43e8044284df50f8b8772e9b48ba8b109b45c74111ff73619775d57ad8d67","src/frontend.rs":"4991dc71de7a9bb8184b43c5f9c91801118b27a914332f90d4cbfce5acc960c8","src/lib.rs":"6e5927d9bc6c1529cb04f4ca197e51a7c50f82a971fd8fb9c533ad848d24cd7b","src/ssa.rs":"751149215a2d434825e1e50ed9aedcdb5fb351776de329052550f2e62104aa9a","src/switch.rs":"9676498786f19ce22739ed37bfcf653332083334a19c4a236660c5d6f9577f39","src/variable.rs":"ad628b3c6de9a8c008dc31f869bf9d853f2dd3b590dc4e2e3c6da70ba6bf7adf"},"package":"0f74b84f16af2e982b0c0c72233503d9d55cbfe3865dbe807ca28dc6642a28b5"}

data/ext/cargo-vendor/cranelift-frontend-0.109.0/Cargo.toml

@@ -0,0 +1,68 @@
+# 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 = "cranelift-frontend"
+version = "0.109.0"
+authors = ["The Cranelift Project Developers"]
+description = "Cranelift IR builder helper"
+documentation = "https://docs.rs/cranelift-frontend"
+readme = "README.md"
+categories = ["no-std"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.cranelift-codegen]
+version = "0.109.0"
+features = [
+    "std",
+    "unwind",
+    "trace-log",
+]
+default-features = false
+
+[dependencies.hashbrown]
+version = "0.14"
+optional = true
+default-features = false
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.smallvec]
+version = "1.6.1"
+features = ["union"]
+
+[dependencies.target-lexicon]
+version = "0.12.13"
+
+[dev-dependencies.similar]
+version = "2.1.0"
+
+[features]
+core = [
+    "hashbrown",
+    "cranelift-codegen/core",
+]
+default = ["std"]
+std = ["cranelift-codegen/std"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"