wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/cranelift-codegen-0.110.2/src/ir/jumptable.rs

@@ -0,0 +1,168 @@
+//! Jump table representation.
+//!
+//! Jump tables are declared in the preamble and assigned an `ir::entities::JumpTable` reference.
+//! The actual table of destinations is stored in a `JumpTableData` struct defined in this module.
+
+use crate::ir::instructions::ValueListPool;
+use crate::ir::BlockCall;
+use alloc::vec::Vec;
+use core::fmt::{self, Display, Formatter};
+use core::slice::{Iter, IterMut};
+
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+
+/// Contents of a jump table.
+///
+/// All jump tables use 0-based indexing and are densely populated.
+///
+/// The default block for the jump table is stored as the first element of the underlying vector.
+/// It can be accessed through the `default_block` and `default_block_mut` functions. All blocks
+/// may be iterated using the `all_branches` and `all_branches_mut` functions, which will both
+/// iterate over the default block first.
+#[derive(Debug, Clone, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct JumpTableData {
+    // Table entries.
+    table: Vec<BlockCall>,
+}
+
+impl JumpTableData {
+    /// Create a new jump table with the provided blocks.
+    pub fn new(def: BlockCall, table: &[BlockCall]) -> Self {
+        Self {
+            table: std::iter::once(def).chain(table.iter().copied()).collect(),
+        }
+    }
+
+    /// Fetch the default block for this jump table.
+    pub fn default_block(&self) -> BlockCall {
+        *self.table.first().unwrap()
+    }
+
+    /// Mutable access to the default block of this jump table.
+    pub fn default_block_mut(&mut self) -> &mut BlockCall {
+        self.table.first_mut().unwrap()
+    }
+
+    /// The jump table and default block as a single slice. The default block will always be first.
+    pub fn all_branches(&self) -> &[BlockCall] {
+        self.table.as_slice()
+    }
+
+    /// The jump table and default block as a single mutable slice. The default block will always
+    /// be first.
+    pub fn all_branches_mut(&mut self) -> &mut [BlockCall] {
+        self.table.as_mut_slice()
+    }
+
+    /// Access the jump table as a slice. This excludes the default block.
+    pub fn as_slice(&self) -> &[BlockCall] {
+        &self.table.as_slice()[1..]
+    }
+
+    /// Access the jump table as a mutable slice. This excludes the default block.
+    pub fn as_mut_slice(&mut self) -> &mut [BlockCall] {
+        &mut self.table.as_mut_slice()[1..]
+    }
+
+    /// Returns an iterator to the jump table, excluding the default block.
+    #[deprecated(since = "7.0.0", note = "please use `.as_slice()` instead")]
+    pub fn iter(&self) -> Iter<BlockCall> {
+        self.as_slice().iter()
+    }
+
+    /// Returns an iterator that allows modifying each value, excluding the default block.
+    #[deprecated(since = "7.0.0", note = "please use `.as_mut_slice()` instead")]
+    pub fn iter_mut(&mut self) -> IterMut<BlockCall> {
+        self.as_mut_slice().iter_mut()
+    }
+
+    /// Clears all entries in this jump table, except for the default block.
+    pub fn clear(&mut self) {
+        self.table.drain(1..);
+    }
+
+    /// Return a value that can display the contents of this jump table.
+    pub fn display<'a>(&'a self, pool: &'a ValueListPool) -> DisplayJumpTable<'a> {
+        DisplayJumpTable { jt: self, pool }
+    }
+}
+
+/// A wrapper for the context required to display a [JumpTableData].
+pub struct DisplayJumpTable<'a> {
+    jt: &'a JumpTableData,
+    pool: &'a ValueListPool,
+}
+
+impl<'a> Display for DisplayJumpTable<'a> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        write!(fmt, "{}, [", self.jt.default_block().display(self.pool))?;
+        if let Some((first, rest)) = self.jt.as_slice().split_first() {
+            write!(fmt, "{}", first.display(self.pool))?;
+            for block in rest {
+                write!(fmt, ", {}", block.display(self.pool))?;
+            }
+        }
+        write!(fmt, "]")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::JumpTableData;
+    use crate::entity::EntityRef;
+    use crate::ir::instructions::ValueListPool;
+    use crate::ir::{Block, BlockCall, Value};
+    use std::string::ToString;
+
+    #[test]
+    fn empty() {
+        let mut pool = ValueListPool::default();
+        let def = BlockCall::new(Block::new(0), &[], &mut pool);
+
+        let jt = JumpTableData::new(def, &[]);
+
+        assert_eq!(jt.all_branches().get(0), Some(&def));
+
+        assert_eq!(jt.as_slice().get(0), None);
+        assert_eq!(jt.as_slice().get(10), None);
+
+        assert_eq!(jt.display(&pool).to_string(), "block0, []");
+
+        assert_eq!(jt.all_branches(), [def]);
+        assert_eq!(jt.as_slice(), []);
+    }
+
+    #[test]
+    fn insert() {
+        let mut pool = ValueListPool::default();
+
+        let v0 = Value::new(0);
+        let v1 = Value::new(1);
+
+        let e0 = Block::new(0);
+        let e1 = Block::new(1);
+        let e2 = Block::new(2);
+
+        let def = BlockCall::new(e0, &[], &mut pool);
+        let b1 = BlockCall::new(e1, &[v0], &mut pool);
+        let b2 = BlockCall::new(e2, &[], &mut pool);
+        let b3 = BlockCall::new(e1, &[v1], &mut pool);
+
+        let jt = JumpTableData::new(def, &[b1, b2, b3]);
+
+        assert_eq!(jt.default_block(), def);
+        assert_eq!(
+            jt.display(&pool).to_string(),
+            "block0, [block1(v0), block2, block1(v1)]"
+        );
+
+        assert_eq!(jt.all_branches(), [def, b1, b2, b3]);
+        assert_eq!(jt.as_slice(), [b1, b2, b3]);
+
+        assert_eq!(jt.as_slice()[0].args_slice(&pool), [v0]);
+        assert_eq!(jt.as_slice()[1].args_slice(&pool), []);
+        assert_eq!(jt.as_slice()[2].args_slice(&pool), [v1]);
+    }
+}

data/ext/cargo-vendor/cranelift-codegen-0.110.2/src/ir/mod.rs

@@ -0,0 +1,110 @@
+//! Representation of Cranelift IR functions.
+
+mod atomic_rmw_op;
+mod builder;
+pub mod condcodes;
+pub mod constant;
+pub mod dfg;
+pub mod dynamic_type;
+pub mod entities;
+mod extfunc;
+mod extname;
+pub mod function;
+mod globalvalue;
+pub mod immediates;
+pub mod instructions;
+pub mod jumptable;
+pub(crate) mod known_symbol;
+pub mod layout;
+pub(crate) mod libcall;
+mod memflags;
+mod memtype;
+pub mod pcc;
+mod progpoint;
+mod sourceloc;
+pub mod stackslot;
+mod trapcode;
+pub mod types;
+mod user_stack_maps;
+
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+
+pub use crate::ir::atomic_rmw_op::AtomicRmwOp;
+pub use crate::ir::builder::{
+    InsertBuilder, InstBuilder, InstBuilderBase, InstInserterBase, ReplaceBuilder,
+};
+pub use crate::ir::constant::{ConstantData, ConstantPool};
+pub use crate::ir::dfg::{BlockData, DataFlowGraph, ValueDef};
+pub use crate::ir::dynamic_type::{dynamic_to_fixed, DynamicTypeData, DynamicTypes};
+pub use crate::ir::entities::{
+    Block, Constant, DynamicStackSlot, DynamicType, FuncRef, GlobalValue, Immediate, Inst,
+    JumpTable, MemoryType, SigRef, StackSlot, UserExternalNameRef, Value,
+};
+pub use crate::ir::extfunc::{
+    AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature,
+};
+pub use crate::ir::extname::{ExternalName, UserExternalName, UserFuncName};
+pub use crate::ir::function::Function;
+pub use crate::ir::globalvalue::GlobalValueData;
+pub use crate::ir::instructions::{
+    BlockCall, InstructionData, Opcode, ValueList, ValueListPool, VariableArgs,
+};
+pub use crate::ir::jumptable::JumpTableData;
+pub use crate::ir::known_symbol::KnownSymbol;
+pub use crate::ir::layout::Layout;
+pub use crate::ir::libcall::{get_probestack_funcref, LibCall};
+pub use crate::ir::memflags::{AliasRegion, Endianness, MemFlags};
+pub use crate::ir::memtype::{MemoryTypeData, MemoryTypeField};
+pub use crate::ir::pcc::{BaseExpr, Expr, Fact, FactContext, PccError, PccResult};
+pub use crate::ir::progpoint::ProgramPoint;
+pub use crate::ir::sourceloc::RelSourceLoc;
+pub use crate::ir::sourceloc::SourceLoc;
+pub use crate::ir::stackslot::{
+    DynamicStackSlotData, DynamicStackSlots, StackSlotData, StackSlotKind, StackSlots,
+};
+pub use crate::ir::trapcode::TrapCode;
+pub use crate::ir::types::Type;
+pub use crate::ir::user_stack_maps::{UserStackMap, UserStackMapEntry};
+
+use crate::entity::{entity_impl, PrimaryMap, SecondaryMap};
+
+/// Map of jump tables.
+pub type JumpTables = PrimaryMap<JumpTable, JumpTableData>;
+
+/// Source locations for instructions.
+pub(crate) type SourceLocs = SecondaryMap<Inst, RelSourceLoc>;
+
+/// Marked with a label value.
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct ValueLabel(u32);
+entity_impl!(ValueLabel, "val");
+
+/// A label of a Value.
+#[derive(Debug, Clone, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct ValueLabelStart {
+    /// Source location when it is in effect
+    pub from: RelSourceLoc,
+
+    /// The label index.
+    pub label: ValueLabel,
+}
+
+/// Value label assignments: label starts or value aliases.
+#[derive(Debug, Clone, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum ValueLabelAssignments {
+    /// Original value labels assigned at transform.
+    Starts(alloc::vec::Vec<ValueLabelStart>),
+
+    /// A value alias to original value.
+    Alias {
+        /// Source location when it is in effect
+        from: RelSourceLoc,
+
+        /// The label index.
+        value: Value,
+    },
+}

data/ext/cargo-vendor/cranelift-codegen-0.110.2/src/ir/trapcode.rs

@@ -0,0 +1,148 @@
+//! Trap codes describing the reason for a trap.
+
+use core::fmt::{self, Display, Formatter};
+use core::str::FromStr;
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+
+/// A trap code describing the reason for a trap.
+///
+/// All trap instructions have an explicit trap code.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum TrapCode {
+    /// The current stack space was exhausted.
+    StackOverflow,
+
+    /// A `heap_addr` instruction detected an out-of-bounds error.
+    ///
+    /// Note that not all out-of-bounds heap accesses are reported this way;
+    /// some are detected by a segmentation fault on the heap unmapped or
+    /// offset-guard pages.
+    HeapOutOfBounds,
+
+    /// A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
+    HeapMisaligned,
+
+    /// A `table_addr` instruction detected an out-of-bounds error.
+    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,
+
+    /// A user-defined trap code.
+    User(u16),
+
+    /// A null reference was encountered which was required to be non-null.
+    NullReference,
+
+    /// A null `i31ref` was encountered which was required to be non-null.
+    NullI31Ref,
+}
+
+impl TrapCode {
+    /// Returns a slice of all traps except `TrapCode::User` traps
+    pub const fn non_user_traps() -> &'static [TrapCode] {
+        &[
+            TrapCode::StackOverflow,
+            TrapCode::HeapOutOfBounds,
+            TrapCode::HeapMisaligned,
+            TrapCode::TableOutOfBounds,
+            TrapCode::IndirectCallToNull,
+            TrapCode::BadSignature,
+            TrapCode::IntegerOverflow,
+            TrapCode::IntegerDivisionByZero,
+            TrapCode::BadConversionToInteger,
+            TrapCode::UnreachableCodeReached,
+            TrapCode::Interrupt,
+            TrapCode::NullReference,
+        ]
+    }
+}
+
+impl Display for TrapCode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        use self::TrapCode::*;
+        let identifier = match *self {
+            StackOverflow => "stk_ovf",
+            HeapOutOfBounds => "heap_oob",
+            HeapMisaligned => "heap_misaligned",
+            TableOutOfBounds => "table_oob",
+            IndirectCallToNull => "icall_null",
+            BadSignature => "bad_sig",
+            IntegerOverflow => "int_ovf",
+            IntegerDivisionByZero => "int_divz",
+            BadConversionToInteger => "bad_toint",
+            UnreachableCodeReached => "unreachable",
+            Interrupt => "interrupt",
+            User(x) => return write!(f, "user{}", x),
+            NullReference => "null_reference",
+            NullI31Ref => "null_i31ref",
+        };
+        f.write_str(identifier)
+    }
+}
+
+impl FromStr for TrapCode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use self::TrapCode::*;
+        match s {
+            "stk_ovf" => Ok(StackOverflow),
+            "heap_oob" => Ok(HeapOutOfBounds),
+            "heap_misaligned" => Ok(HeapMisaligned),
+            "table_oob" => Ok(TableOutOfBounds),
+            "icall_null" => Ok(IndirectCallToNull),
+            "bad_sig" => Ok(BadSignature),
+            "int_ovf" => Ok(IntegerOverflow),
+            "int_divz" => Ok(IntegerDivisionByZero),
+            "bad_toint" => Ok(BadConversionToInteger),
+            "unreachable" => Ok(UnreachableCodeReached),
+            "interrupt" => Ok(Interrupt),
+            "null_reference" => Ok(NullReference),
+            "null_i31ref" => Ok(NullI31Ref),
+            _ if s.starts_with("user") => s[4..].parse().map(User).map_err(|_| ()),
+            _ => Err(()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloc::string::ToString;
+
+    #[test]
+    fn display() {
+        for r in TrapCode::non_user_traps() {
+            let tc = *r;
+            assert_eq!(tc.to_string().parse(), Ok(tc));
+        }
+        assert_eq!("bogus".parse::<TrapCode>(), Err(()));
+
+        assert_eq!(TrapCode::User(17).to_string(), "user17");
+        assert_eq!("user22".parse(), Ok(TrapCode::User(22)));
+        assert_eq!("user".parse::<TrapCode>(), Err(()));
+        assert_eq!("user-1".parse::<TrapCode>(), Err(()));
+        assert_eq!("users".parse::<TrapCode>(), Err(()));
+    }
+}