wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/module_artifacts.rs

@@ -0,0 +1,146 @@
+//! Definitions of runtime structures and metadata which are serialized into ELF
+//! with `bincode` as part of a module's compilation process.
+
+use crate::prelude::*;
+use crate::{DefinedFuncIndex, FilePos, FuncIndex, Module, PrimaryMap, StackMap};
+use core::fmt;
+use core::ops::Range;
+use core::str;
+use serde_derive::{Deserialize, Serialize};
+use wasmtime_types::ModuleInternedTypeIndex;
+
+/// Secondary in-memory results of function compilation.
+#[derive(Serialize, Deserialize)]
+pub struct CompiledFunctionInfo {
+    /// The [`WasmFunctionInfo`] for this function.
+    pub wasm_func_info: WasmFunctionInfo,
+    /// The [`FunctionLoc`] indicating the location of this function in the text
+    /// section of the compition artifact.
+    pub wasm_func_loc: FunctionLoc,
+    /// A trampoline for array callers (e.g. `Func::new`) calling into this function (if needed).
+    pub array_to_wasm_trampoline: Option<FunctionLoc>,
+    /// A trampoline for native callers (e.g. `Func::wrap`) calling into this function (if needed).
+    pub native_to_wasm_trampoline: Option<FunctionLoc>,
+}
+
+/// Information about a function, such as trap information, address map,
+/// and stack maps.
+#[derive(Serialize, Deserialize, Default)]
+#[allow(missing_docs)]
+pub struct WasmFunctionInfo {
+    pub start_srcloc: FilePos,
+    pub stack_maps: Box<[StackMapInformation]>,
+}
+
+/// Description of where a function is located in the text section of a
+/// compiled image.
+#[derive(Copy, Clone, Serialize, Deserialize)]
+pub struct FunctionLoc {
+    /// The byte offset from the start of the text section where this
+    /// function starts.
+    pub start: u32,
+    /// The byte length of this function's function body.
+    pub length: u32,
+}
+
+/// The offset within a function of a GC safepoint, and its associated stack
+/// map.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct StackMapInformation {
+    /// The offset of the GC safepoint within the function's native code. It is
+    /// relative to the beginning of the function.
+    pub code_offset: u32,
+
+    /// The stack map for identifying live GC refs at the GC safepoint.
+    pub stack_map: StackMap,
+}
+
+/// Secondary in-memory results of module compilation.
+///
+/// This opaque structure can be optionally passed back to
+/// `CompiledModule::from_artifacts` to avoid decoding extra information there.
+#[derive(Serialize, Deserialize)]
+pub struct CompiledModuleInfo {
+    /// Type information about the compiled WebAssembly module.
+    pub module: Module,
+
+    /// Metadata about each compiled function.
+    pub funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
+
+    /// Sorted list, by function index, of names we have for this module.
+    pub func_names: Vec<FunctionName>,
+
+    /// Metadata about wasm-to-native trampolines. Used when exposing a native
+    /// callee (e.g. `Func::wrap`) to a Wasm caller. Sorted by signature index.
+    pub wasm_to_native_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
+
+    /// General compilation metadata.
+    pub meta: Metadata,
+}
+
+/// The name of a function stored in the
+/// [`ELF_NAME_DATA`](crate::obj::ELF_NAME_DATA) section.
+#[derive(Serialize, Deserialize)]
+pub struct FunctionName {
+    /// The Wasm function index of this function.
+    pub idx: FuncIndex,
+    /// The offset of the name in the
+    /// [`ELF_NAME_DATA`](crate::obj::ELF_NAME_DATA) section.
+    pub offset: u32,
+    /// The length of the name in bytes.
+    pub len: u32,
+}
+
+/// Metadata associated with a compiled ELF artifact.
+#[derive(Serialize, Deserialize)]
+pub struct Metadata {
+    /// Whether or not native debug information is available in `obj`
+    pub native_debug_info_present: bool,
+
+    /// Whether or not the original wasm module contained debug information that
+    /// we skipped and did not parse.
+    pub has_unparsed_debuginfo: bool,
+
+    /// Offset in the original wasm file to the code section.
+    pub code_section_offset: u64,
+
+    /// Whether or not custom wasm-specific dwarf sections were inserted into
+    /// the ELF image.
+    ///
+    /// Note that even if this flag is `true` sections may be missing if they
+    /// weren't found in the original wasm module itself.
+    pub has_wasm_debuginfo: bool,
+
+    /// Dwarf sections and the offsets at which they're stored in the
+    /// ELF_WASMTIME_DWARF
+    pub dwarf: Vec<(u8, Range<u64>)>,
+}
+
+/// Value of a configured setting for a [`Compiler`](crate::Compiler)
+#[derive(Serialize, Deserialize, Hash, Eq, PartialEq, Debug)]
+pub enum FlagValue<'a> {
+    /// Name of the value that has been configured for this setting.
+    Enum(&'a str),
+    /// The numerical value of the configured settings.
+    Num(u8),
+    /// Whether the setting is on or off.
+    Bool(bool),
+}
+
+impl fmt::Display for FlagValue<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Enum(v) => v.fmt(f),
+            Self::Num(v) => v.fmt(f),
+            Self::Bool(v) => v.fmt(f),
+        }
+    }
+}
+
+/// Types of objects that can be created by `Compiler::object`
+pub enum ObjectKind {
+    /// A core wasm compilation artifact
+    Module,
+    /// A component compilation artifact
+    Component,
+}

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/module_types.rs

@@ -0,0 +1,91 @@
+use crate::PrimaryMap;
+use core::ops::{Index, Range};
+use serde_derive::{Deserialize, Serialize};
+use wasmtime_types::{ModuleInternedRecGroupIndex, ModuleInternedTypeIndex, WasmSubType};
+
+/// All types used in a core wasm module.
+///
+/// At this time this only contains function types. Note, though, that function
+/// types are deduplicated within this [`ModuleTypes`].
+///
+/// Note that accesing this type is primarily done through the `Index`
+/// implementations for this type.
+#[derive(Default, Serialize, Deserialize)]
+pub struct ModuleTypes {
+    rec_groups: PrimaryMap<ModuleInternedRecGroupIndex, Range<ModuleInternedTypeIndex>>,
+    wasm_types: PrimaryMap<ModuleInternedTypeIndex, WasmSubType>,
+}
+
+impl ModuleTypes {
+    /// Returns an iterator over all the wasm function signatures found within
+    /// this module.
+    pub fn wasm_types(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (ModuleInternedTypeIndex, &WasmSubType)> {
+        self.wasm_types.iter()
+    }
+
+    /// Get the type at the specified index, if it exists.
+    pub fn get(&self, ty: ModuleInternedTypeIndex) -> Option<&WasmSubType> {
+        self.wasm_types.get(ty)
+    }
+
+    /// Get an iterator over all recursion groups defined in this module and
+    /// their elements.
+    pub fn rec_groups(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (ModuleInternedRecGroupIndex, Range<ModuleInternedTypeIndex>)> + '_
+    {
+        self.rec_groups.iter().map(|(k, v)| (k, v.clone()))
+    }
+
+    /// Get the elements within an already-defined rec group.
+    pub fn rec_group_elements(
+        &self,
+        rec_group: ModuleInternedRecGroupIndex,
+    ) -> impl ExactSizeIterator<Item = ModuleInternedTypeIndex> {
+        let range = &self.rec_groups[rec_group];
+        (range.start.as_u32()..range.end.as_u32()).map(|i| ModuleInternedTypeIndex::from_u32(i))
+    }
+
+    /// Returns the number of types interned.
+    pub fn len_types(&self) -> usize {
+        self.wasm_types.len()
+    }
+
+    /// Adds a new type to this interned list of types.
+    pub fn push(&mut self, ty: WasmSubType) -> ModuleInternedTypeIndex {
+        self.wasm_types.push(ty)
+    }
+
+    /// Adds a new rec group to this interned list of types.
+    pub fn push_rec_group(
+        &mut self,
+        range: Range<ModuleInternedTypeIndex>,
+    ) -> ModuleInternedRecGroupIndex {
+        self.rec_groups.push(range)
+    }
+
+    /// Reserves space for `amt` more types.
+    pub fn reserve(&mut self, amt: usize) {
+        self.wasm_types.reserve(amt)
+    }
+
+    /// Returns the next return value of `push_rec_group`.
+    pub fn next_rec_group(&self) -> ModuleInternedRecGroupIndex {
+        self.rec_groups.next_key()
+    }
+
+    /// Returns the next return value of `push`.
+    pub fn next_ty(&self) -> ModuleInternedTypeIndex {
+        self.wasm_types.next_key()
+    }
+}
+
+impl Index<ModuleInternedTypeIndex> for ModuleTypes {
+    type Output = WasmSubType;
+
+    fn index(&self, sig: ModuleInternedTypeIndex) -> &WasmSubType {
+        &self.wasm_types[sig]
+    }
+}

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/scopevec.rs

@@ -0,0 +1,80 @@
+use crate::prelude::*;
+use core::cell::RefCell;
+
+/// Small data structure to help extend the lifetime of a slice to a higher
+/// scope.
+///
+/// This is currently used during component translation where translation in
+/// general works on a borrowed slice which contains all input modules, but
+/// generated adapter modules for components don't live within the original
+/// slice but the data structures are much easier if the dynamically generated
+/// adapter modules live for the same lifetime as the original input slice. To
+/// solve this problem this `ScopeVec` helper is used to move ownership of a
+/// `Vec<T>` to a higher scope in the program, then borrowing the slice from
+/// that scope.
+pub struct ScopeVec<T> {
+    data: RefCell<Vec<Box<[T]>>>,
+}
+
+impl<T> ScopeVec<T> {
+    /// Creates a new blank scope.
+    pub fn new() -> ScopeVec<T> {
+        ScopeVec {
+            data: Default::default(),
+        }
+    }
+
+    /// Transfers ownership of `data` into this scope and then yields the slice
+    /// back to the caller.
+    ///
+    /// The original data will be deallocated when `self` is dropped.
+    pub fn push(&self, data: Vec<T>) -> &mut [T] {
+        let data: Box<[T]> = data.into();
+        let len = data.len();
+
+        let mut storage = self.data.borrow_mut();
+        storage.push(data);
+        let ptr = storage.last_mut().unwrap().as_mut_ptr();
+
+        // This should be safe for a few reasons:
+        //
+        // * The returned pointer on the heap that `data` owns. Despite moving
+        //   `data` around it doesn't actually move the slice itself around, so
+        //   the pointer returned should be valid (and length).
+        //
+        // * The lifetime of the returned pointer is connected to the lifetime
+        //   of `self`. This reflects how when `self` is destroyed the `data` is
+        //   destroyed as well, or otherwise the returned slice will be valid
+        //   for as long as `self` is valid since `self` owns the original data
+        //   at that point.
+        //
+        // * This function was given ownership of `data` so it should be safe to
+        //   hand back a mutable reference. Once placed within a `ScopeVec` the
+        //   data is never mutated so the caller will enjoy exclusive access to
+        //   the slice of the original vec.
+        //
+        // This all means that it should be safe to return a mutable slice of
+        // all of `data` after the data has been pushed onto our internal list.
+        unsafe { core::slice::from_raw_parts_mut(ptr, len) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ScopeVec;
+    use crate::prelude::*;
+
+    #[test]
+    fn smoke() {
+        let scope = ScopeVec::new();
+        let a = scope.push(Vec::new());
+        let b = scope.push(vec![1, 2, 3]);
+        let c = scope.push(vec![4, 5, 6]);
+        assert_eq!(a.len(), 0);
+        b[0] = 4;
+        c[2] = 5;
+        assert_eq!(a, []);
+        assert_eq!(b, [4, 2, 3]);
+        assert_eq!(c, [4, 5, 5]);
+    }
+}

data/ext/cargo-vendor/wasmtime-environ-21.0.1/src/stack_map.rs

@@ -0,0 +1,37 @@
+use crate::prelude::*;
+use serde_derive::{Deserialize, Serialize};
+
+/// A map for determining where live GC references live in a stack frame.
+///
+/// Note that this is currently primarily documented as cranelift's
+/// `binemit::StackMap`, so for detailed documentation about this please read
+/// the docs over there.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct StackMap {
+    bits: Box<[u32]>,
+    mapped_words: u32,
+}
+
+impl StackMap {
+    /// Creates a new `StackMap`, typically from a preexisting
+    /// `binemit::StackMap`.
+    pub fn new(mapped_words: u32, bits: impl Iterator<Item = u32>) -> StackMap {
+        StackMap {
+            bits: bits.collect(),
+            mapped_words,
+        }
+    }
+
+    /// Returns a specified bit.
+    pub fn get_bit(&self, bit_index: usize) -> bool {
+        assert!(bit_index < 32 * self.bits.len());
+        let word_index = bit_index / 32;
+        let word_offset = bit_index % 32;
+        (self.bits[word_index] & (1 << word_offset)) != 0
+    }
+
+    /// Returns the number of words represented by this stack map.
+    pub fn mapped_words(&self) -> u32 {
+        self.mapped_words
+    }
+}

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

@@ -0,0 +1,189 @@
+use core::fmt;
+use object::{Bytes, LittleEndian, U32Bytes};
+
+/// 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,
+
+    /// Attempt to get the bits of a null `i31ref`.
+    NullI31Ref,
+
+    /// When the `component-model` feature is enabled this trap represents a
+    /// scenario where one component tried to call another component but it
+    /// would have violated the reentrance rules of the component model,
+    /// triggering a trap instead.
+    CannotEnterComponent,
+    // if adding a variant here be sure to update the `check!` macro below
+}
+
+impl Trap {
+    /// Converts a byte back into a `Trap` if its in-bounds
+    pub fn from_u8(byte: u8) -> Option<Trap> {
+        // FIXME: this could use some sort of derive-like thing to avoid having to
+        // deduplicate the names here.
+        //
+        // This simply converts from the a `u8`, to the `Trap` enum.
+        macro_rules! check {
+            ($($name:ident)*) => ($(if byte == Trap::$name as u8 {
+                return Some(Trap::$name);
+            })*);
+        }
+
+        check! {
+            StackOverflow
+            MemoryOutOfBounds
+            HeapMisaligned
+            TableOutOfBounds
+            IndirectCallToNull
+            BadSignature
+            IntegerOverflow
+            IntegerDivisionByZero
+            BadConversionToInteger
+            UnreachableCodeReached
+            Interrupt
+            AlwaysTrapAdapter
+            OutOfFuel
+            AtomicWaitNonSharedMemory
+            NullReference
+            NullI31Ref
+            CannotEnterComponent
+        }
+
+        None
+    }
+}
+
+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",
+            NullI31Ref => "null i31 reference",
+            CannotEnterComponent => "cannot enter component instance",
+        };
+        write!(f, "wasm trap: {desc}")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Trap {}
+
+/// 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 byte = *traps.get(index)?;
+
+    let trap = Trap::from_u8(byte);
+    debug_assert!(trap.is_some(), "missing mapping for {}", byte);
+    trap
+}