wasmtime 20.0.2 → 21.0.1

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

@@ -1,122 +0,0 @@
-use crate::{Module, ModuleType, PrimaryMap, TypeConvert, WasmFuncType, WasmHeapType};
-use serde_derive::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::ops::Index;
-use wasmparser::types::CoreTypeId;
-use wasmparser::UnpackedIndex;
-use wasmtime_types::{EngineOrModuleTypeIndex, ModuleInternedTypeIndex, TypeIndex};
-
-/// 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)]
-#[allow(missing_docs)]
-pub struct ModuleTypes {
-    wasm_types: PrimaryMap<ModuleInternedTypeIndex, WasmFuncType>,
-}
-
-impl ModuleTypes {
-    /// Returns an iterator over all the wasm function signatures found within
-    /// this module.
-    pub fn wasm_types(&self) -> impl Iterator<Item = (ModuleInternedTypeIndex, &WasmFuncType)> {
-        self.wasm_types.iter()
-    }
-}
-
-impl Index<ModuleInternedTypeIndex> for ModuleTypes {
-    type Output = WasmFuncType;
-
-    fn index(&self, sig: ModuleInternedTypeIndex) -> &WasmFuncType {
-        &self.wasm_types[sig]
-    }
-}
-
-/// A builder for [`ModuleTypes`].
-#[derive(Default)]
-#[allow(missing_docs)]
-pub struct ModuleTypesBuilder {
-    types: ModuleTypes,
-    interned_func_types: HashMap<WasmFuncType, ModuleInternedTypeIndex>,
-    wasmparser_to_wasmtime: HashMap<CoreTypeId, ModuleInternedTypeIndex>,
-}
-
-impl ModuleTypesBuilder {
-    /// Reserves space for `amt` more type signatures.
-    pub fn reserve_wasm_signatures(&mut self, amt: usize) {
-        self.types.wasm_types.reserve(amt);
-    }
-
-    /// Interns the `sig` specified and returns a unique `SignatureIndex` that
-    /// can be looked up within [`ModuleTypes`] to recover the [`WasmFuncType`]
-    /// at runtime.
-    pub fn wasm_func_type(&mut self, id: CoreTypeId, sig: WasmFuncType) -> ModuleInternedTypeIndex {
-        let sig = self.intern_func_type(sig);
-        self.wasmparser_to_wasmtime.insert(id, sig);
-        sig
-    }
-
-    fn intern_func_type(&mut self, sig: WasmFuncType) -> ModuleInternedTypeIndex {
-        if let Some(idx) = self.interned_func_types.get(&sig) {
-            return *idx;
-        }
-
-        let idx = self.types.wasm_types.push(sig.clone());
-        self.interned_func_types.insert(sig, idx);
-        return idx;
-    }
-
-    /// Returns the result [`ModuleTypes`] of this builder.
-    pub fn finish(self) -> ModuleTypes {
-        self.types
-    }
-
-    /// Returns an iterator over all the wasm function signatures found within
-    /// this module.
-    pub fn wasm_signatures(
-        &self,
-    ) -> impl Iterator<Item = (ModuleInternedTypeIndex, &WasmFuncType)> {
-        self.types.wasm_types()
-    }
-}
-
-// Forward the indexing impl to the internal `ModuleTypes`
-impl<T> Index<T> for ModuleTypesBuilder
-where
-    ModuleTypes: Index<T>,
-{
-    type Output = <ModuleTypes as Index<T>>::Output;
-
-    fn index(&self, sig: T) -> &Self::Output {
-        &self.types[sig]
-    }
-}
-
-#[allow(missing_docs)]
-pub struct WasmparserTypeConverter<'a> {
-    pub types: &'a ModuleTypesBuilder,
-    pub module: &'a Module,
-}
-
-impl TypeConvert for WasmparserTypeConverter<'_> {
-    fn lookup_heap_type(&self, index: UnpackedIndex) -> WasmHeapType {
-        match index {
-            UnpackedIndex::Id(id) => {
-                let signature = self.types.wasmparser_to_wasmtime[&id];
-                WasmHeapType::Concrete(EngineOrModuleTypeIndex::Module(signature))
-            }
-            UnpackedIndex::RecGroup(_) => unreachable!(),
-            UnpackedIndex::Module(i) => {
-                let i = TypeIndex::from_u32(i);
-                match self.module.types[i] {
-                    ModuleType::Function(sig) => {
-                        WasmHeapType::Concrete(EngineOrModuleTypeIndex::Module(sig))
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,78 +0,0 @@
-use std::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 { std::slice::from_raw_parts_mut(ptr, len) }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ScopeVec;
-
-    #[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-20.0.2/src/stack_map.rs

@@ -1,36 +0,0 @@
-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-20.0.2/src/trap_encoding.rs

@@ -1,188 +0,0 @@
-use object::{Bytes, LittleEndian, U32Bytes};
-use std::fmt;
-
-/// 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}")
-    }
-}
-
-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
-}

data/ext/cargo-vendor/wasmtime-environ-20.0.2/src/tunables.rs

@@ -1,158 +0,0 @@
-use anyhow::{anyhow, bail, Result};
-use serde_derive::{Deserialize, Serialize};
-use target_lexicon::{PointerWidth, Triple};
-
-/// Tunable parameters for WebAssembly compilation.
-#[derive(Clone, Hash, Serialize, Deserialize, Debug)]
-pub struct Tunables {
-    /// For static heaps, the size in wasm pages of the heap protected by bounds
-    /// checking.
-    pub static_memory_bound: u64,
-
-    /// The size in bytes of the offset guard for static heaps.
-    pub static_memory_offset_guard_size: u64,
-
-    /// The size in bytes of the offset guard for dynamic heaps.
-    pub dynamic_memory_offset_guard_size: u64,
-
-    /// The size, in bytes, of reserved memory at the end of a "dynamic" memory,
-    /// before the guard page, that memory can grow into. This is intended to
-    /// amortize the cost of `memory.grow` in the same manner that `Vec<T>` has
-    /// space not in use to grow into.
-    pub dynamic_memory_growth_reserve: u64,
-
-    /// Whether or not to generate native DWARF debug information.
-    pub generate_native_debuginfo: bool,
-
-    /// Whether or not to retain DWARF sections in compiled modules.
-    pub parse_wasm_debuginfo: bool,
-
-    /// Whether or not fuel is enabled for generated code, meaning that fuel
-    /// will be consumed every time a wasm instruction is executed.
-    pub consume_fuel: bool,
-
-    /// Whether or not we use epoch-based interruption.
-    pub epoch_interruption: bool,
-
-    /// Whether or not to treat the static memory bound as the maximum for
-    /// unbounded heaps.
-    pub static_memory_bound_is_maximum: bool,
-
-    /// Whether or not linear memory allocations will have a guard region at the
-    /// beginning of the allocation in addition to the end.
-    pub guard_before_linear_memory: bool,
-
-    /// Indicates whether an address map from compiled native code back to wasm
-    /// offsets in the original file is generated.
-    pub generate_address_map: bool,
-
-    /// Flag for the component module whether adapter modules have debug
-    /// assertions baked into them.
-    pub debug_adapter_modules: bool,
-
-    /// Whether or not lowerings for relaxed simd instructions are forced to
-    /// be deterministic.
-    pub relaxed_simd_deterministic: bool,
-
-    /// Whether or not Wasm functions can be tail-called or not.
-    pub tail_callable: bool,
-
-    /// Whether or not Wasm functions target the winch abi.
-    pub winch_callable: bool,
-}
-
-impl Tunables {
-    /// Returns a `Tunables` configuration assumed for running code on the host.
-    pub fn default_host() -> Self {
-        if cfg!(miri) {
-            Tunables::default_miri()
-        } else if cfg!(target_pointer_width = "32") {
-            Tunables::default_u32()
-        } else if cfg!(target_pointer_width = "64") {
-            Tunables::default_u64()
-        } else {
-            panic!("unsupported target_pointer_width");
-        }
-    }
-
-    /// Returns the default set of tunables for the given target triple.
-    pub fn default_for_target(target: &Triple) -> Result<Self> {
-        match target
-            .pointer_width()
-            .map_err(|_| anyhow!("failed to retrieve target pointer width"))?
-        {
-            PointerWidth::U32 => Ok(Tunables::default_u32()),
-            PointerWidth::U64 => Ok(Tunables::default_u64()),
-            _ => bail!("unsupported target pointer width"),
-        }
-    }
-
-    /// Returns the default set of tunables for running under MIRI.
-    pub fn default_miri() -> Tunables {
-        Tunables {
-            // No virtual memory tricks are available on miri so make these
-            // limits quite conservative.
-            static_memory_bound: (1 << 20) / crate::WASM_PAGE_SIZE as u64,
-            static_memory_offset_guard_size: 0,
-            dynamic_memory_offset_guard_size: 0,
-            dynamic_memory_growth_reserve: 0,
-
-            // General options which have the same defaults regardless of
-            // architecture.
-            generate_native_debuginfo: false,
-            parse_wasm_debuginfo: true,
-            consume_fuel: false,
-            epoch_interruption: false,
-            static_memory_bound_is_maximum: false,
-            guard_before_linear_memory: true,
-            generate_address_map: true,
-            debug_adapter_modules: false,
-            relaxed_simd_deterministic: false,
-            tail_callable: false,
-            winch_callable: false,
-        }
-    }
-
-    /// Returns the default set of tunables for running under a 32-bit host.
-    pub fn default_u32() -> Tunables {
-        Tunables {
-            // For 32-bit we scale way down to 10MB of reserved memory. This
-            // impacts performance severely but allows us to have more than a
-            // few instances running around.
-            static_memory_bound: (10 * (1 << 20)) / crate::WASM_PAGE_SIZE as u64,
-            static_memory_offset_guard_size: 0x1_0000,
-            dynamic_memory_offset_guard_size: 0x1_0000,
-            dynamic_memory_growth_reserve: 1 << 20, // 1MB
-
-            ..Tunables::default_miri()
-        }
-    }
-
-    /// Returns the default set of tunables for running under a 64-bit host.
-    pub fn default_u64() -> Tunables {
-        Tunables {
-            // 64-bit has tons of address space to static memories can have 4gb
-            // address space reservations liberally by default, allowing us to
-            // help eliminate bounds checks.
-            //
-            // Coupled with a 2 GiB address space guard it lets us translate
-            // wasm offsets into x86 offsets as aggressively as we can.
-            static_memory_bound: 0x1_0000,
-            static_memory_offset_guard_size: 0x8000_0000,
-
-            // Size in bytes of the offset guard for dynamic memories.
-            //
-            // Allocate a small guard to optimize common cases but without
-            // wasting too much memory.
-            dynamic_memory_offset_guard_size: 0x1_0000,
-
-            // We've got lots of address space on 64-bit so use a larger
-            // grow-into-this area, but on 32-bit we aren't as lucky. Miri is
-            // not exactly fast so reduce memory consumption instead of trying
-            // to avoid memory movement.
-            dynamic_memory_growth_reserve: 2 << 30, // 2GB
-
-            ..Tunables::default_miri()
-        }
-    }
-}