wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/cranelift-entity-0.102.1/src/primary.rs

@@ -1,456 +0,0 @@
-//! Densely numbered entity references as mapping keys.
-use crate::boxed_slice::BoxedSlice;
-use crate::iter::{IntoIter, Iter, IterMut};
-use crate::keys::Keys;
-use crate::EntityRef;
-use alloc::boxed::Box;
-use alloc::vec::Vec;
-use core::iter::FromIterator;
-use core::marker::PhantomData;
-use core::ops::{Index, IndexMut};
-use core::slice;
-#[cfg(feature = "enable-serde")]
-use serde_derive::{Deserialize, Serialize};
-
-/// A primary mapping `K -> V` allocating dense entity references.
-///
-/// The `PrimaryMap` data structure uses the dense index space to implement a map with a vector.
-///
-/// A primary map contains the main definition of an entity, and it can be used to allocate new
-/// entity references with the `push` method.
-///
-/// There should only be a single `PrimaryMap` instance for a given `EntityRef` type, otherwise
-/// conflicting references will be created. Using unknown keys for indexing will cause a panic.
-///
-/// Note that `PrimaryMap` doesn't implement `Deref` or `DerefMut`, which would allow
-/// `&PrimaryMap<K, V>` to convert to `&[V]`. One of the main advantages of `PrimaryMap` is
-/// that it only allows indexing with the distinct `EntityRef` key type, so converting to a
-/// plain slice would make it easier to use incorrectly. To make a slice of a `PrimaryMap`, use
-/// `into_boxed_slice`.
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    elems: Vec<V>,
-    unused: PhantomData<K>,
-}
-
-impl<K, V> PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    /// Create a new empty map.
-    pub fn new() -> Self {
-        Self {
-            elems: Vec::new(),
-            unused: PhantomData,
-        }
-    }
-
-    /// Create a new empty map with the given capacity.
-    pub fn with_capacity(capacity: usize) -> Self {
-        Self {
-            elems: Vec::with_capacity(capacity),
-            unused: PhantomData,
-        }
-    }
-
-    /// Check if `k` is a valid key in the map.
-    pub fn is_valid(&self, k: K) -> bool {
-        k.index() < self.elems.len()
-    }
-
-    /// Get the element at `k` if it exists.
-    pub fn get(&self, k: K) -> Option<&V> {
-        self.elems.get(k.index())
-    }
-
-    /// Get the element at `k` if it exists, mutable version.
-    pub fn get_mut(&mut self, k: K) -> Option<&mut V> {
-        self.elems.get_mut(k.index())
-    }
-
-    /// Is this map completely empty?
-    pub fn is_empty(&self) -> bool {
-        self.elems.is_empty()
-    }
-
-    /// Get the total number of entity references created.
-    pub fn len(&self) -> usize {
-        self.elems.len()
-    }
-
-    /// Iterate over all the keys in this map.
-    pub fn keys(&self) -> Keys<K> {
-        Keys::with_len(self.elems.len())
-    }
-
-    /// Iterate over all the values in this map.
-    pub fn values(&self) -> slice::Iter<V> {
-        self.elems.iter()
-    }
-
-    /// Iterate over all the values in this map, mutable edition.
-    pub fn values_mut(&mut self) -> slice::IterMut<V> {
-        self.elems.iter_mut()
-    }
-
-    /// Iterate over all the keys and values in this map.
-    pub fn iter(&self) -> Iter<K, V> {
-        Iter::new(self.elems.iter())
-    }
-
-    /// Iterate over all the keys and values in this map, mutable edition.
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
-        IterMut::new(self.elems.iter_mut())
-    }
-
-    /// Remove all entries from this map.
-    pub fn clear(&mut self) {
-        self.elems.clear()
-    }
-
-    /// Get the key that will be assigned to the next pushed value.
-    pub fn next_key(&self) -> K {
-        K::new(self.elems.len())
-    }
-
-    /// Append `v` to the mapping, assigning a new key which is returned.
-    pub fn push(&mut self, v: V) -> K {
-        let k = self.next_key();
-        self.elems.push(v);
-        k
-    }
-
-    /// Returns the last element that was inserted in the map.
-    pub fn last(&self) -> Option<(K, &V)> {
-        let len = self.elems.len();
-        let last = self.elems.last()?;
-        Some((K::new(len - 1), last))
-    }
-
-    /// Returns the last element that was inserted in the map.
-    pub fn last_mut(&mut self) -> Option<(K, &mut V)> {
-        let len = self.elems.len();
-        let last = self.elems.last_mut()?;
-        Some((K::new(len - 1), last))
-    }
-
-    /// Reserves capacity for at least `additional` more elements to be inserted.
-    pub fn reserve(&mut self, additional: usize) {
-        self.elems.reserve(additional)
-    }
-
-    /// Reserves the minimum capacity for exactly `additional` more elements to be inserted.
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.elems.reserve_exact(additional)
-    }
-
-    /// Shrinks the capacity of the `PrimaryMap` as much as possible.
-    pub fn shrink_to_fit(&mut self) {
-        self.elems.shrink_to_fit()
-    }
-
-    /// Consumes this `PrimaryMap` and produces a `BoxedSlice`.
-    pub fn into_boxed_slice(self) -> BoxedSlice<K, V> {
-        unsafe { BoxedSlice::<K, V>::from_raw(Box::<[V]>::into_raw(self.elems.into_boxed_slice())) }
-    }
-
-    /// Performs a binary search on the values with a key extraction function.
-    ///
-    /// Assumes that the values are sorted by the key extracted by the function.
-    ///
-    /// If the value is found then `Ok(K)` is returned, containing the entity key
-    /// of the matching value.
-    ///
-    /// If there are multiple matches, then any one of the matches could be returned.
-    ///
-    /// If the value is not found then Err(K) is returned, containing the entity key
-    /// where a matching element could be inserted while maintaining sorted order.
-    pub fn binary_search_values_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<K, K>
-    where
-        F: FnMut(&'a V) -> B,
-        B: Ord,
-    {
-        self.elems
-            .binary_search_by_key(b, f)
-            .map(|i| K::new(i))
-            .map_err(|i| K::new(i))
-    }
-}
-
-impl<K, V> Default for PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    fn default() -> PrimaryMap<K, V> {
-        PrimaryMap::new()
-    }
-}
-
-/// Immutable indexing into an `PrimaryMap`.
-/// The indexed value must be in the map.
-impl<K, V> Index<K> for PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    type Output = V;
-
-    fn index(&self, k: K) -> &V {
-        &self.elems[k.index()]
-    }
-}
-
-/// Mutable indexing into an `PrimaryMap`.
-impl<K, V> IndexMut<K> for PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    fn index_mut(&mut self, k: K) -> &mut V {
-        &mut self.elems[k.index()]
-    }
-}
-
-impl<K, V> IntoIterator for PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    type Item = (K, V);
-    type IntoIter = IntoIter<K, V>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self.elems.into_iter())
-    }
-}
-
-impl<'a, K, V> IntoIterator for &'a PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    type Item = (K, &'a V);
-    type IntoIter = Iter<'a, K, V>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Iter::new(self.elems.iter())
-    }
-}
-
-impl<'a, K, V> IntoIterator for &'a mut PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    type Item = (K, &'a mut V);
-    type IntoIter = IterMut<'a, K, V>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IterMut::new(self.elems.iter_mut())
-    }
-}
-
-impl<K, V> FromIterator<V> for PrimaryMap<K, V>
-where
-    K: EntityRef,
-{
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = V>,
-    {
-        Self {
-            elems: Vec::from_iter(iter),
-            unused: PhantomData,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // `EntityRef` impl for testing.
-    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-    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 m = PrimaryMap::<E, isize>::new();
-
-        let v: Vec<E> = m.keys().collect();
-        assert_eq!(v, []);
-
-        assert!(!m.is_valid(r0));
-        assert!(!m.is_valid(r1));
-    }
-
-    #[test]
-    fn push() {
-        let mut m = PrimaryMap::new();
-        let k0: E = m.push(12);
-        let k1 = m.push(33);
-
-        assert_eq!(m[k0], 12);
-        assert_eq!(m[k1], 33);
-
-        let v: Vec<E> = m.keys().collect();
-        assert_eq!(v, [k0, k1]);
-    }
-
-    #[test]
-    fn iter() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let mut i = 0;
-        for (key, value) in &m {
-            assert_eq!(key.index(), i);
-            match i {
-                0 => assert_eq!(*value, 12),
-                1 => assert_eq!(*value, 33),
-                _ => panic!(),
-            }
-            i += 1;
-        }
-        i = 0;
-        for (key_mut, value_mut) in m.iter_mut() {
-            assert_eq!(key_mut.index(), i);
-            match i {
-                0 => assert_eq!(*value_mut, 12),
-                1 => assert_eq!(*value_mut, 33),
-                _ => panic!(),
-            }
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn iter_rev() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let mut i = 2;
-        for (key, value) in m.iter().rev() {
-            i -= 1;
-            assert_eq!(key.index(), i);
-            match i {
-                0 => assert_eq!(*value, 12),
-                1 => assert_eq!(*value, 33),
-                _ => panic!(),
-            }
-        }
-
-        i = 2;
-        for (key, value) in m.iter_mut().rev() {
-            i -= 1;
-            assert_eq!(key.index(), i);
-            match i {
-                0 => assert_eq!(*value, 12),
-                1 => assert_eq!(*value, 33),
-                _ => panic!(),
-            }
-        }
-    }
-    #[test]
-    fn keys() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let mut i = 0;
-        for key in m.keys() {
-            assert_eq!(key.index(), i);
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn keys_rev() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let mut i = 2;
-        for key in m.keys().rev() {
-            i -= 1;
-            assert_eq!(key.index(), i);
-        }
-    }
-
-    #[test]
-    fn values() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let mut i = 0;
-        for value in m.values() {
-            match i {
-                0 => assert_eq!(*value, 12),
-                1 => assert_eq!(*value, 33),
-                _ => panic!(),
-            }
-            i += 1;
-        }
-        i = 0;
-        for value_mut in m.values_mut() {
-            match i {
-                0 => assert_eq!(*value_mut, 12),
-                1 => assert_eq!(*value_mut, 33),
-                _ => panic!(),
-            }
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn values_rev() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let mut i = 2;
-        for value in m.values().rev() {
-            i -= 1;
-            match i {
-                0 => assert_eq!(*value, 12),
-                1 => assert_eq!(*value, 33),
-                _ => panic!(),
-            }
-        }
-        i = 2;
-        for value_mut in m.values_mut().rev() {
-            i -= 1;
-            match i {
-                0 => assert_eq!(*value_mut, 12),
-                1 => assert_eq!(*value_mut, 33),
-                _ => panic!(),
-            }
-        }
-    }
-
-    #[test]
-    fn from_iter() {
-        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
-        m.push(12);
-        m.push(33);
-
-        let n = m.values().collect::<PrimaryMap<E, _>>();
-        assert!(m.len() == n.len());
-        for (me, ne) in m.values().zip(n.values()) {
-            assert!(*me == **ne);
-        }
-    }
-}

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

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"7a6a531bff38cda2efcd19a43038168bc2f5cf1c394ce73ef214a971aa7b9402","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"dea43e8044284df50f8b8772e9b48ba8b109b45c74111ff73619775d57ad8d67","src/frontend.rs":"712cbce058ca2aea229debf0600c6b0eee0d02d3102bf49a52db96f67e3a0d03","src/lib.rs":"ae3dabd023da94ba5d1ffc17e749d266f7bd15582a23dbfa2ca950eab0aadfb0","src/ssa.rs":"9d1a47cb6d6328f31997f0ee09b0326067e4507284f363e5d09074e2c306f303","src/switch.rs":"ca77eeb97db8c43566c5cfc1cc5e7a0c394fc72e306b985117e47d6d6f5bb5cc","src/variable.rs":"ad628b3c6de9a8c008dc31f869bf9d853f2dd3b590dc4e2e3c6da70ba6bf7adf"},"package":"e57374fd11d72cf9ffb85ff64506ed831440818318f58d09f45b4185e5e9c376"}

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

@@ -1,59 +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 = "cranelift-frontend"
-version = "0.102.1"
-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.102.1"
-features = [
-    "std",
-    "unwind",
-]
-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.12"
-features = ["std"]
-default-features = false
-
-[dev-dependencies.similar]
-version = "2.1.0"
-
-[features]
-core = [
-    "hashbrown",
-    "cranelift-codegen/core",
-]
-default = ["std"]
-std = ["cranelift-codegen/std"]

data/ext/cargo-vendor/cranelift-frontend-0.102.1/src/lib.rs

@@ -1,191 +0,0 @@
-//! Cranelift IR builder library.
-//!
-//! Provides a straightforward way to create a Cranelift IR function and fill it with instructions
-//! corresponding to your source program written in another language.
-//!
-//! To get started, create an [`FunctionBuilderContext`](struct.FunctionBuilderContext.html) and
-//! pass it as an argument to a [`FunctionBuilder`](struct.FunctionBuilder.html).
-//!
-//! # Mutable variables and Cranelift IR values
-//!
-//! The most interesting feature of this API is that it provides a single way to deal with all your
-//! variable problems. Indeed, the [`FunctionBuilder`](struct.FunctionBuilder.html) struct has a
-//! type `Variable` that should be an index of your source language variables. Then, through
-//! calling the functions
-//! [`declare_var`](struct.FunctionBuilder.html#method.declare_var),
-//! [`def_var`](struct.FunctionBuilder.html#method.def_var) and
-//! [`use_var`](struct.FunctionBuilder.html#method.use_var), the
-//! [`FunctionBuilder`](struct.FunctionBuilder.html) will create for you all the Cranelift IR
-//! values corresponding to your variables.
-//!
-//! This API has been designed to help you translate your mutable variables into
-//! [`SSA`](https://en.wikipedia.org/wiki/Static_single_assignment_form) form.
-//! [`use_var`](struct.FunctionBuilder.html#method.use_var) will return the Cranelift IR value
-//! that corresponds to your mutable variable at a precise point in the program. However, if you know
-//! beforehand that one of your variables is defined only once, for instance if it is the result
-//! of an intermediate expression in an expression-based language, then you can translate it
-//! directly by the Cranelift IR value returned by the instruction builder. Using the
-//! [`use_var`](struct.FunctionBuilder.html#method.use_var) API for such an immutable variable
-//! would also work but with a slight additional overhead (the SSA algorithm does not know
-//! beforehand if a variable is immutable or not).
-//!
-//! The moral is that you should use these three functions to handle all your mutable variables,
-//! even those that are not present in the source code but artifacts of the translation. It is up
-//! to you to keep a mapping between the mutable variables of your language and their `Variable`
-//! index that is used by Cranelift. Caution: as the `Variable` is used by Cranelift to index an
-//! array containing information about your mutable variables, when you create a new `Variable`
-//! with [`Variable::new(var_index)`] you should make sure that `var_index` is provided by a
-//! counter incremented by 1 each time you encounter a new mutable variable.
-//!
-//! # Example
-//!
-//! Here is a pseudo-program we want to transform into Cranelift IR:
-//!
-//! ```clif
-//! function(x) {
-//! x, y, z : i32
-//! block0:
-//!    y = 2;
-//!    z = x + y;
-//!    jump block1
-//! block1:
-//!    z = z + y;
-//!    brif y, block3, block2
-//! block2:
-//!    z = z - x;
-//!    return y
-//! block3:
-//!    y = y - x
-//!    jump block1
-//! }
-//! ```
-//!
-//! Here is how you build the corresponding Cranelift IR function using `FunctionBuilderContext`:
-//!
-//! ```rust
-//! extern crate cranelift_codegen;
-//! extern crate cranelift_frontend;
-//!
-//! use cranelift_codegen::entity::EntityRef;
-//! use cranelift_codegen::ir::types::*;
-//! use cranelift_codegen::ir::{AbiParam, UserFuncName, Function, InstBuilder, Signature};
-//! use cranelift_codegen::isa::CallConv;
-//! use cranelift_codegen::settings;
-//! use cranelift_codegen::verifier::verify_function;
-//! use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
-//!
-//! let mut sig = Signature::new(CallConv::SystemV);
-//! sig.returns.push(AbiParam::new(I32));
-//! sig.params.push(AbiParam::new(I32));
-//! let mut fn_builder_ctx = FunctionBuilderContext::new();
-//! let mut func = Function::with_name_signature(UserFuncName::user(0, 0), sig);
-//! {
-//!     let mut builder = FunctionBuilder::new(&mut func, &mut fn_builder_ctx);
-//!
-//!     let block0 = builder.create_block();
-//!     let block1 = builder.create_block();
-//!     let block2 = builder.create_block();
-//!     let block3 = builder.create_block();
-//!     let x = Variable::new(0);
-//!     let y = Variable::new(1);
-//!     let z = Variable::new(2);
-//!     builder.declare_var(x, I32);
-//!     builder.declare_var(y, I32);
-//!     builder.declare_var(z, I32);
-//!     builder.append_block_params_for_function_params(block0);
-//!
-//!     builder.switch_to_block(block0);
-//!     builder.seal_block(block0);
-//!     {
-//!         let tmp = builder.block_params(block0)[0]; // the first function parameter
-//!         builder.def_var(x, tmp);
-//!     }
-//!     {
-//!         let tmp = builder.ins().iconst(I32, 2);
-//!         builder.def_var(y, tmp);
-//!     }
-//!     {
-//!         let arg1 = builder.use_var(x);
-//!         let arg2 = builder.use_var(y);
-//!         let tmp = builder.ins().iadd(arg1, arg2);
-//!         builder.def_var(z, tmp);
-//!     }
-//!     builder.ins().jump(block1, &[]);
-//!
-//!     builder.switch_to_block(block1);
-//!     {
-//!         let arg1 = builder.use_var(y);
-//!         let arg2 = builder.use_var(z);
-//!         let tmp = builder.ins().iadd(arg1, arg2);
-//!         builder.def_var(z, tmp);
-//!     }
-//!     {
-//!         let arg = builder.use_var(y);
-//!         builder.ins().brif(arg, block3, &[], block2, &[]);
-//!     }
-//!
-//!     builder.switch_to_block(block2);
-//!     builder.seal_block(block2);
-//!     {
-//!         let arg1 = builder.use_var(z);
-//!         let arg2 = builder.use_var(x);
-//!         let tmp = builder.ins().isub(arg1, arg2);
-//!         builder.def_var(z, tmp);
-//!     }
-//!     {
-//!         let arg = builder.use_var(y);
-//!         builder.ins().return_(&[arg]);
-//!     }
-//!
-//!     builder.switch_to_block(block3);
-//!     builder.seal_block(block3);
-//!
-//!     {
-//!         let arg1 = builder.use_var(y);
-//!         let arg2 = builder.use_var(x);
-//!         let tmp = builder.ins().isub(arg1, arg2);
-//!         builder.def_var(y, tmp);
-//!     }
-//!     builder.ins().jump(block1, &[]);
-//!     builder.seal_block(block1);
-//!
-//!     builder.finalize();
-//! }
-//!
-//! let flags = settings::Flags::new(settings::builder());
-//! let res = verify_function(&func, &flags);
-//! println!("{}", func.display());
-//! if let Err(errors) = res {
-//!     panic!("{}", errors);
-//! }
-//! ```
-
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "std", deny(unstable_features))]
-#![no_std]
-
-#[allow(unused_imports)] // #[macro_use] is required for no_std
-#[macro_use]
-extern crate alloc;
-
-#[cfg(feature = "std")]
-#[macro_use]
-extern crate std;
-
-#[cfg(not(feature = "std"))]
-use hashbrown::HashMap;
-#[cfg(feature = "std")]
-use std::collections::HashMap;
-
-pub use crate::frontend::{FuncInstBuilder, FunctionBuilder, FunctionBuilderContext};
-pub use crate::switch::Switch;
-pub use crate::variable::Variable;
-
-mod frontend;
-mod ssa;
-mod switch;
-mod variable;
-
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");