wasmtime 10.0.1 → 11.0.0

data/ext/cargo-vendor/wasmtime-runtime-11.0.0/src/libcalls.rs

@@ -0,0 +1,626 @@
+//! Runtime library calls.
+//!
+//! Note that Wasm compilers may sometimes perform these inline rather than
+//! calling them, particularly when CPUs have special instructions which compute
+//! them directly.
+//!
+//! These functions are called by compiled Wasm code, and therefore must take
+//! certain care about some things:
+//!
+//! * They must only contain basic, raw i32/i64/f32/f64/pointer parameters that
+//!   are safe to pass across the system ABI.
+//!
+//! * If any nested function propagates an `Err(trap)` out to the library
+//!   function frame, we need to raise it. This involves some nasty and quite
+//!   unsafe code under the covers! Notably, after raising the trap, drops
+//!   **will not** be run for local variables! This can lead to things like
+//!   leaking `InstanceHandle`s which leads to never deallocating JIT code,
+//!   instances, and modules if we are not careful!
+//!
+//! * The libcall must be entered via a Wasm-to-libcall trampoline that saves
+//!   the last Wasm FP and PC for stack walking purposes. (For more details, see
+//!   `crates/runtime/src/backtrace.rs`.)
+//!
+//! To make it easier to correctly handle all these things, **all** libcalls
+//! must be defined via the `libcall!` helper macro! See its doc comments below
+//! for an example, or just look at the rest of the file.
+//!
+//! ## Dealing with `externref`s
+//!
+//! When receiving a raw `*mut u8` that is actually a `VMExternRef` reference,
+//! convert it into a proper `VMExternRef` with `VMExternRef::clone_from_raw` as
+//! soon as apossible. Any GC before raw pointer is converted into a reference
+//! can potentially collect the referenced object, which could lead to use after
+//! free.
+//!
+//! Avoid this by eagerly converting into a proper `VMExternRef`! (Unfortunately
+//! there is no macro to help us automatically get this correct, so stay
+//! vigilant!)
+//!
+//! ```ignore
+//! pub unsafe extern "C" my_libcall_takes_ref(raw_extern_ref: *mut u8) {
+//!     // Before `clone_from_raw`, `raw_extern_ref` is potentially unrooted,
+//!     // and doing GC here could lead to use after free!
+//!
+//!     let my_extern_ref = if raw_extern_ref.is_null() {
+//!         None
+//!     } else {
+//!         Some(VMExternRef::clone_from_raw(raw_extern_ref))
+//!     };
+//!
+//!     // Now that we did `clone_from_raw`, it is safe to do a GC (or do
+//!     // anything else that might transitively GC, like call back into
+//!     // Wasm!)
+//! }
+//! ```
+
+use crate::externref::VMExternRef;
+use crate::table::{Table, TableElementType};
+use crate::vmcontext::VMFuncRef;
+use crate::{Instance, TrapReason};
+use anyhow::Result;
+use std::mem;
+use std::ptr::{self, NonNull};
+use std::time::{Duration, Instant};
+use wasmtime_environ::{
+    DataIndex, ElemIndex, FuncIndex, GlobalIndex, MemoryIndex, TableIndex, Trap,
+};
+
+/// Actually public trampolines which are used by the runtime as the entrypoint
+/// for libcalls.
+///
+/// Note that the trampolines here are actually defined in inline assembly right
+/// now to ensure that the fp/sp on exit are recorded for backtraces to work
+/// properly.
+pub mod trampolines {
+    use crate::{Instance, TrapReason, VMContext};
+
+    macro_rules! libcall {
+        (
+            $(
+                $( #[$attr:meta] )*
+                $name:ident( vmctx: vmctx $(, $pname:ident: $param:ident )* ) $( -> $result:ident )?;
+            )*
+        ) => {paste::paste! {
+            $(
+                // The actual libcall itself, which has the `pub` name here, is
+                // defined via the `wasm_to_libcall_trampoline!` macro on
+                // supported platforms or otherwise in inline assembly for
+                // platforms like s390x which don't have stable `global_asm!`
+                // yet.
+                extern "C" {
+                    #[allow(missing_docs)]
+                    #[allow(improper_ctypes)]
+                    pub fn $name(
+                        vmctx: *mut VMContext,
+                        $( $pname: libcall!(@ty $param), )*
+                    ) $(-> libcall!(@ty $result))?;
+                }
+
+                wasm_to_libcall_trampoline!($name ; [<impl_ $name>]);
+
+                // This is the direct entrypoint from the inline assembly which
+                // still has the same raw signature as the trampoline itself.
+                // This will delegate to the outer module to the actual
+                // implementation and automatically perform `catch_unwind` along
+                // with conversion of the return value in the face of traps.
+                //
+                // Note that rust targets which support `global_asm!` can use
+                // the `sym` operator to get the symbol here, but other targets
+                // like s390x need to use outlined assembly files which requires
+                // `no_mangle`.
+                #[cfg_attr(target_arch = "s390x", no_mangle)]
+                unsafe extern "C" fn [<impl_ $name>](
+                    vmctx: *mut VMContext,
+                    $( $pname : libcall!(@ty $param), )*
+                ) $( -> libcall!(@ty $result))? {
+                    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                        Instance::from_vmctx(vmctx, |instance| {
+                            super::$name(instance, $($pname),*)
+                        })
+                    }));
+                    match result {
+                        Ok(ret) => LibcallResult::convert(ret),
+                        Err(panic) => crate::traphandlers::resume_panic(panic),
+                    }
+                }
+
+                // This works around a `rustc` bug where compiling with LTO
+                // will sometimes strip out some of these symbols resulting
+                // in a linking failure.
+                #[allow(non_upper_case_globals)]
+                #[used]
+                static [<impl_ $name _ref>]: unsafe extern "C" fn(
+                    *mut VMContext,
+                    $( $pname : libcall!(@ty $param), )*
+                ) $( -> libcall!(@ty $result))? = [<impl_ $name>];
+
+            )*
+        }};
+
+        (@ty i32) => (u32);
+        (@ty i64) => (u64);
+        (@ty reference) => (*mut u8);
+        (@ty pointer) => (*mut u8);
+        (@ty vmctx) => (*mut VMContext);
+    }
+
+    wasmtime_environ::foreach_builtin_function!(libcall);
+
+    // Helper trait to convert results of libcalls below into the ABI of what
+    // the libcall expects.
+    //
+    // This basically entirely exists for the `Result` implementation which
+    // "unwraps" via a throwing of a trap.
+    trait LibcallResult {
+        type Abi;
+        unsafe fn convert(self) -> Self::Abi;
+    }
+
+    impl LibcallResult for () {
+        type Abi = ();
+        unsafe fn convert(self) {}
+    }
+
+    impl<T, E> LibcallResult for Result<T, E>
+    where
+        E: Into<TrapReason>,
+    {
+        type Abi = T;
+        unsafe fn convert(self) -> T {
+            match self {
+                Ok(t) => t,
+                Err(e) => crate::traphandlers::raise_trap(e.into()),
+            }
+        }
+    }
+
+    impl LibcallResult for *mut u8 {
+        type Abi = *mut u8;
+        unsafe fn convert(self) -> *mut u8 {
+            self
+        }
+    }
+}
+
+fn memory32_grow(
+    instance: &mut Instance,
+    delta: u64,
+    memory_index: u32,
+) -> Result<*mut u8, TrapReason> {
+    let memory_index = MemoryIndex::from_u32(memory_index);
+    let result =
+        match instance
+            .memory_grow(memory_index, delta)
+            .map_err(|error| TrapReason::User {
+                error,
+                needs_backtrace: true,
+            })? {
+            Some(size_in_bytes) => size_in_bytes / (wasmtime_environ::WASM_PAGE_SIZE as usize),
+            None => usize::max_value(),
+        };
+    Ok(result as *mut _)
+}
+
+// Implementation of `table.grow`.
+unsafe fn table_grow(
+    instance: &mut Instance,
+    table_index: u32,
+    delta: u32,
+    // NB: we don't know whether this is a pointer to a `VMFuncRef`
+    // or is a `VMExternRef` until we look at the table type.
+    init_value: *mut u8,
+) -> Result<u32> {
+    let table_index = TableIndex::from_u32(table_index);
+    let element = match instance.table_element_type(table_index) {
+        TableElementType::Func => (init_value as *mut VMFuncRef).into(),
+        TableElementType::Extern => {
+            let init_value = if init_value.is_null() {
+                None
+            } else {
+                Some(VMExternRef::clone_from_raw(init_value))
+            };
+            init_value.into()
+        }
+    };
+    Ok(match instance.table_grow(table_index, delta, element)? {
+        Some(r) => r,
+        None => -1_i32 as u32,
+    })
+}
+
+use table_grow as table_grow_func_ref;
+use table_grow as table_grow_externref;
+
+// Implementation of `table.fill`.
+unsafe fn table_fill(
+    instance: &mut Instance,
+    table_index: u32,
+    dst: u32,
+    // NB: we don't know whether this is a `VMExternRef` or a pointer to a
+    // `VMFuncRef` until we look at the table's element type.
+    val: *mut u8,
+    len: u32,
+) -> Result<(), Trap> {
+    let table_index = TableIndex::from_u32(table_index);
+    let table = &mut *instance.get_table(table_index);
+    match table.element_type() {
+        TableElementType::Func => {
+            let val = val as *mut VMFuncRef;
+            table.fill(dst, val.into(), len)
+        }
+        TableElementType::Extern => {
+            let val = if val.is_null() {
+                None
+            } else {
+                Some(VMExternRef::clone_from_raw(val))
+            };
+            table.fill(dst, val.into(), len)
+        }
+    }
+}
+
+use table_fill as table_fill_func_ref;
+use table_fill as table_fill_externref;
+
+// Implementation of `table.copy`.
+unsafe fn table_copy(
+    instance: &mut Instance,
+    dst_table_index: u32,
+    src_table_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let dst_table_index = TableIndex::from_u32(dst_table_index);
+    let src_table_index = TableIndex::from_u32(src_table_index);
+    let dst_table = instance.get_table(dst_table_index);
+    // Lazy-initialize the whole range in the source table first.
+    let src_range = src..(src.checked_add(len).unwrap_or(u32::MAX));
+    let src_table = instance.get_table_with_lazy_init(src_table_index, src_range);
+    Table::copy(dst_table, src_table, dst, src, len)
+}
+
+// Implementation of `table.init`.
+fn table_init(
+    instance: &mut Instance,
+    table_index: u32,
+    elem_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let table_index = TableIndex::from_u32(table_index);
+    let elem_index = ElemIndex::from_u32(elem_index);
+    instance.table_init(table_index, elem_index, dst, src, len)
+}
+
+// Implementation of `elem.drop`.
+fn elem_drop(instance: &mut Instance, elem_index: u32) {
+    let elem_index = ElemIndex::from_u32(elem_index);
+    instance.elem_drop(elem_index)
+}
+
+// Implementation of `memory.copy`.
+fn memory_copy(
+    instance: &mut Instance,
+    dst_index: u32,
+    dst: u64,
+    src_index: u32,
+    src: u64,
+    len: u64,
+) -> Result<(), Trap> {
+    let src_index = MemoryIndex::from_u32(src_index);
+    let dst_index = MemoryIndex::from_u32(dst_index);
+    instance.memory_copy(dst_index, dst, src_index, src, len)
+}
+
+// Implementation of `memory.fill` for locally defined memories.
+fn memory_fill(
+    instance: &mut Instance,
+    memory_index: u32,
+    dst: u64,
+    val: u32,
+    len: u64,
+) -> Result<(), Trap> {
+    let memory_index = MemoryIndex::from_u32(memory_index);
+    instance.memory_fill(memory_index, dst, val as u8, len)
+}
+
+// Implementation of `memory.init`.
+fn memory_init(
+    instance: &mut Instance,
+    memory_index: u32,
+    data_index: u32,
+    dst: u64,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let memory_index = MemoryIndex::from_u32(memory_index);
+    let data_index = DataIndex::from_u32(data_index);
+    instance.memory_init(memory_index, data_index, dst, src, len)
+}
+
+// Implementation of `ref.func`.
+fn ref_func(instance: &mut Instance, func_index: u32) -> *mut u8 {
+    instance
+        .get_func_ref(FuncIndex::from_u32(func_index))
+        .expect("ref_func: funcref should always be available for given func index")
+        .cast()
+}
+
+// Implementation of `data.drop`.
+fn data_drop(instance: &mut Instance, data_index: u32) {
+    let data_index = DataIndex::from_u32(data_index);
+    instance.data_drop(data_index)
+}
+
+// Returns a table entry after lazily initializing it.
+unsafe fn table_get_lazy_init_func_ref(
+    instance: &mut Instance,
+    table_index: u32,
+    index: u32,
+) -> *mut u8 {
+    let table_index = TableIndex::from_u32(table_index);
+    let table = instance.get_table_with_lazy_init(table_index, std::iter::once(index));
+    let elem = (*table)
+        .get(index)
+        .expect("table access already bounds-checked");
+
+    elem.into_ref_asserting_initialized()
+}
+
+// Drop a `VMExternRef`.
+unsafe fn drop_externref(_instance: &mut Instance, externref: *mut u8) {
+    let externref = externref as *mut crate::externref::VMExternData;
+    let externref = NonNull::new(externref).unwrap().into();
+    crate::externref::VMExternData::drop_and_dealloc(externref);
+}
+
+// Do a GC and insert the given `externref` into the
+// `VMExternRefActivationsTable`.
+unsafe fn activations_table_insert_with_gc(instance: &mut Instance, externref: *mut u8) {
+    let externref = VMExternRef::clone_from_raw(externref);
+    let limits = *instance.runtime_limits();
+    let (activations_table, module_info_lookup) = (*instance.store()).externref_activations_table();
+
+    // Invariant: all `externref`s on the stack have an entry in the activations
+    // table. So we need to ensure that this `externref` is in the table
+    // *before* we GC, even though `insert_with_gc` will ensure that it is in
+    // the table *after* the GC. This technically results in one more hash table
+    // look up than is strictly necessary -- which we could avoid by having an
+    // additional GC method that is aware of these GC-triggering references --
+    // but it isn't really a concern because this is already a slow path.
+    activations_table.insert_without_gc(externref.clone());
+
+    activations_table.insert_with_gc(limits, externref, module_info_lookup);
+}
+
+// Perform a Wasm `global.get` for `externref` globals.
+unsafe fn externref_global_get(instance: &mut Instance, index: u32) -> *mut u8 {
+    let index = GlobalIndex::from_u32(index);
+    let limits = *instance.runtime_limits();
+    let global = instance.defined_or_imported_global_ptr(index);
+    match (*global).as_externref().clone() {
+        None => ptr::null_mut(),
+        Some(externref) => {
+            let raw = externref.as_raw();
+            let (activations_table, module_info_lookup) =
+                (*instance.store()).externref_activations_table();
+            activations_table.insert_with_gc(limits, externref, module_info_lookup);
+            raw
+        }
+    }
+}
+
+// Perform a Wasm `global.set` for `externref` globals.
+unsafe fn externref_global_set(instance: &mut Instance, index: u32, externref: *mut u8) {
+    let externref = if externref.is_null() {
+        None
+    } else {
+        Some(VMExternRef::clone_from_raw(externref))
+    };
+
+    let index = GlobalIndex::from_u32(index);
+    let global = instance.defined_or_imported_global_ptr(index);
+
+    // Swap the new `externref` value into the global before we drop the old
+    // value. This protects against an `externref` with a `Drop` implementation
+    // that calls back into Wasm and touches this global again (we want to avoid
+    // it observing a halfway-deinitialized value).
+    let old = mem::replace((*global).as_externref_mut(), externref);
+    drop(old);
+}
+
+// Implementation of `memory.atomic.notify` for locally defined memories.
+fn memory_atomic_notify(
+    instance: &mut Instance,
+    memory_index: u32,
+    addr_index: u64,
+    count: u32,
+) -> Result<u32, Trap> {
+    let memory = MemoryIndex::from_u32(memory_index);
+    instance
+        .get_runtime_memory(memory)
+        .atomic_notify(addr_index, count)
+}
+
+// Implementation of `memory.atomic.wait32` for locally defined memories.
+fn memory_atomic_wait32(
+    instance: &mut Instance,
+    memory_index: u32,
+    addr_index: u64,
+    expected: u32,
+    timeout: u64,
+) -> Result<u32, Trap> {
+    // convert timeout to Instant, before any wait happens on locking
+    let timeout = (timeout as i64 >= 0).then(|| Instant::now() + Duration::from_nanos(timeout));
+    let memory = MemoryIndex::from_u32(memory_index);
+    Ok(instance
+        .get_runtime_memory(memory)
+        .atomic_wait32(addr_index, expected, timeout)? as u32)
+}
+
+// Implementation of `memory.atomic.wait64` for locally defined memories.
+fn memory_atomic_wait64(
+    instance: &mut Instance,
+    memory_index: u32,
+    addr_index: u64,
+    expected: u64,
+    timeout: u64,
+) -> Result<u32, Trap> {
+    // convert timeout to Instant, before any wait happens on locking
+    let timeout = (timeout as i64 >= 0).then(|| Instant::now() + Duration::from_nanos(timeout));
+    let memory = MemoryIndex::from_u32(memory_index);
+    Ok(instance
+        .get_runtime_memory(memory)
+        .atomic_wait64(addr_index, expected, timeout)? as u32)
+}
+
+// Hook for when an instance runs out of fuel.
+unsafe fn out_of_gas(instance: &mut Instance) -> Result<()> {
+    (*instance.store()).out_of_gas()
+}
+
+// Hook for when an instance observes that the epoch has changed.
+unsafe fn new_epoch(instance: &mut Instance) -> Result<u64> {
+    (*instance.store()).new_epoch()
+}
+
+/// This module contains functions which are used for resolving relocations at
+/// runtime if necessary.
+///
+/// These functions are not used by default and currently the only platform
+/// they're used for is on x86_64 when SIMD is disabled and then SSE features
+/// are further disabled. In these configurations Cranelift isn't allowed to use
+/// native CPU instructions so it falls back to libcalls and we rely on the Rust
+/// standard library generally for implementing these.
+#[allow(missing_docs)]
+pub mod relocs {
+    pub extern "C" fn floorf32(f: f32) -> f32 {
+        f.floor()
+    }
+
+    pub extern "C" fn floorf64(f: f64) -> f64 {
+        f.floor()
+    }
+
+    pub extern "C" fn ceilf32(f: f32) -> f32 {
+        f.ceil()
+    }
+
+    pub extern "C" fn ceilf64(f: f64) -> f64 {
+        f.ceil()
+    }
+
+    pub extern "C" fn truncf32(f: f32) -> f32 {
+        f.trunc()
+    }
+
+    pub extern "C" fn truncf64(f: f64) -> f64 {
+        f.trunc()
+    }
+
+    const TOINT_32: f32 = 1.0 / f32::EPSILON;
+    const TOINT_64: f64 = 1.0 / f64::EPSILON;
+
+    // NB: replace with `round_ties_even` from libstd when it's stable as
+    // tracked by rust-lang/rust#96710
+    pub extern "C" fn nearestf32(x: f32) -> f32 {
+        // Rust doesn't have a nearest function; there's nearbyint, but it's not
+        // stabilized, so do it manually.
+        // Nearest is either ceil or floor depending on which is nearest or even.
+        // This approach exploited round half to even default mode.
+        let i = x.to_bits();
+        let e = i >> 23 & 0xff;
+        if e >= 0x7f_u32 + 23 {
+            // Check for NaNs.
+            if e == 0xff {
+                // Read the 23-bits significand.
+                if i & 0x7fffff != 0 {
+                    // Ensure it's arithmetic by setting the significand's most
+                    // significant bit to 1; it also works for canonical NaNs.
+                    return f32::from_bits(i | (1 << 22));
+                }
+            }
+            x
+        } else {
+            (x.abs() + TOINT_32 - TOINT_32).copysign(x)
+        }
+    }
+
+    pub extern "C" fn nearestf64(x: f64) -> f64 {
+        let i = x.to_bits();
+        let e = i >> 52 & 0x7ff;
+        if e >= 0x3ff_u64 + 52 {
+            // Check for NaNs.
+            if e == 0x7ff {
+                // Read the 52-bits significand.
+                if i & 0xfffffffffffff != 0 {
+                    // Ensure it's arithmetic by setting the significand's most
+                    // significant bit to 1; it also works for canonical NaNs.
+                    return f64::from_bits(i | (1 << 51));
+                }
+            }
+            x
+        } else {
+            (x.abs() + TOINT_64 - TOINT_64).copysign(x)
+        }
+    }
+
+    pub extern "C" fn fmaf32(a: f32, b: f32, c: f32) -> f32 {
+        a.mul_add(b, c)
+    }
+
+    pub extern "C" fn fmaf64(a: f64, b: f64, c: f64) -> f64 {
+        a.mul_add(b, c)
+    }
+
+    // This intrinsic is only used on x86_64 platforms as an implementation of
+    // the `pshufb` instruction when SSSE3 is not available.
+    #[cfg(target_arch = "x86_64")]
+    use std::arch::x86_64::__m128i;
+    #[cfg(target_arch = "x86_64")]
+    #[allow(improper_ctypes_definitions)]
+    pub extern "C" fn x86_pshufb(a: __m128i, b: __m128i) -> __m128i {
+        union U {
+            reg: __m128i,
+            mem: [u8; 16],
+        }
+
+        unsafe {
+            let a = U { reg: a }.mem;
+            let b = U { reg: b }.mem;
+
+            let select = |arr: &[u8; 16], byte: u8| {
+                if byte & 0x80 != 0 {
+                    0x00
+                } else {
+                    arr[(byte & 0xf) as usize]
+                }
+            };
+
+            U {
+                mem: [
+                    select(&a, b[0]),
+                    select(&a, b[1]),
+                    select(&a, b[2]),
+                    select(&a, b[3]),
+                    select(&a, b[4]),
+                    select(&a, b[5]),
+                    select(&a, b[6]),
+                    select(&a, b[7]),
+                    select(&a, b[8]),
+                    select(&a, b[9]),
+                    select(&a, b[10]),
+                    select(&a, b[11]),
+                    select(&a, b[12]),
+                    select(&a, b[13]),
+                    select(&a, b[14]),
+                    select(&a, b[15]),
+                ],
+            }
+            .reg
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-types-11.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"a54dfccc340d60d0dab9347a375f3130bf22206a886b0f9bdc80ba8ec6c48974","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","src/error.rs":"9d3f8f05879059c8c99724df5f8bff8d1ea6aad7af532df1137cd2e641e110aa","src/lib.rs":"7acc3f39a4ceb8c9b25d4d246b1b6f59650ecbdfe37907d2382a5d56f5d67baf"},"package":"768f6c5e7afc3a02eff2753196741db8e5ac5faf26a1e2204d7341b30a637c6f"}

data/ext/cargo-vendor/wasmtime-types-11.0.1/Cargo.toml

@@ -0,0 +1,34 @@
+# 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 = "wasmtime-types"
+version = "11.0.1"
+authors = ["The Wasmtime Project Developers"]
+description = "WebAssembly type definitions for Cranelift"
+documentation = "https://docs.rs/wasmtime-types"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.cranelift-entity]
+version = "0.98.1"
+features = ["enable-serde"]
+
+[dependencies.serde]
+version = "1.0.94"
+features = ["derive"]
+
+[dependencies.thiserror]
+version = "1.0.15"
+
+[dependencies.wasmparser]
+version = "0.107.0"

data/ext/cargo-vendor/wasmtime-wasi-11.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"5bece8ba69b88fd4051dfa712621b9ef3ce6d23a55d5ec011679234e6e7c3e2c","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"d10a0436ee6b8130a4a891c25e68794b81b94130eec3ad2697ce083daa62b739","build.rs":"fc113f7c1fba12815760158d2ff76756bf20f2e82e239a971c741cd693756049","src/lib.rs":"fb4301793b95b19f97461b3a14b412c38a10f8a2f634ae3cb11e853eec8d77cb","src/preview2/clocks.rs":"b85a21f069c25041116fc32677109a0bb93a9822b1f0df2a2dbc8f2bb337dd5b","src/preview2/clocks/host.rs":"6fc84f65dc43b66d5dcfb1e4ae30ab73a86ae2c4bf8f78b936c02f40700c9240","src/preview2/ctx.rs":"9c48f37a03fef6c9d058e4e06e07ca8c53c482eaa766a292842c1da26432d958","src/preview2/error.rs":"6e8ece06c274ecaa75547305d9833fe67522f6d5c9ea167141b1ad6600099378","src/preview2/filesystem.rs":"6cd6105aeeb98ccec468c61521808bde50198af3cc3290e69e4b219f77cc0a43","src/preview2/mod.rs":"bc9dad89c052991a37fe11ad8c87c19e476f71507c38f67365862831bbe657d4","src/preview2/pipe.rs":"bc796d5504eb1dfc927c3ea3aea35d5f44c5bcf5709770a61bede042d8613166","src/preview2/preview1/mod.rs":"397cea3f01ab8e2752b335138eb3d2a313e109d945883744d1fc20af1c5ee9d5","src/preview2/preview2/clocks.rs":"f43dcb05a8d8eab7f9b2053eafea4a92e17925b30f5e8169214bd9cc98fb251d","src/preview2/preview2/env.rs":"8dd8cc7c070acd57187a16a8514e855fbdd4de2b091a5b8c31e2744aae53f79c","src/preview2/preview2/exit.rs":"41727bce01efa0daad9802604f9c01c56acedcf9fd372173885903bd7ae8f861","src/preview2/preview2/filesystem.rs":"01989dc530259cd581900f060823170f2d754f4f75ac813460712e47dab7ecf2","src/preview2/preview2/io.rs":"8a45f464b3a3b7ccc8d09028df8966543c9e6eedfb5068c50f665eab8ab5225f","src/preview2/preview2/mod.rs":"27dd31c6d8ec1275f84bd5b5b52f315f6fa2c0222f46586c996bd0bdd9574dd3","src/preview2/preview2/poll.rs":"fab8853c8baf6df9d42f95d030acd7299d9aee74e8c4ed4ac4bd8e866a30d67e","src/preview2/preview2/random.rs":"5eaa5cd7021b92cf32af809f9de850eed9dc676af35b78b656bc4a5fd316bb14","src/preview2/random.rs":"26cdafc43822a1edf588ca03ccf8a8291976b372ccb2c735bc4ae9ce066a31a0","src/preview2/sched.rs":"dbf3b6d22fadc3cc662b44e63b1283ae14bc3165177f46ed5e65e8fb8323d897","src/preview2/sched/subscription.rs":"61843977d64d5c6c8d79a2ab5960f37b1fe4216dcc3167d113f17a8595ad0daf","src/preview2/sched/sync.rs":"37037b17eafd783c1e39cea76d965cfa27f88b96103dd45d277bd63757ad333d","src/preview2/stdio.rs":"e958abeb56ab133223dade4ec11ef22bd69277902a0c25259688ca3c01620b67","src/preview2/stream.rs":"91bb5261cf98bb0dc8bb4294c0805192343ccd9637b8f427acc933a5a0e5579b","src/preview2/table.rs":"0f22f7c36a9dae74c9c9d8a1aaf9c10fb9ae77e3449bcbfb289e21b59ca94039","src/preview2/wasi/command.rs":"58494966660984a88835e32079effe1b55d5b9dd3a4ecfa84325afb1fcc9d55e","src/preview2/wasi/mod.rs":"58fe0e28254e346c907e5d9059598e58cb02e2b7e85959231c0cdebaadbdb9b2","wit/deps/clocks/monotonic-clock.wit":"f0418770f24f7130d2eaf5f43316edc145ec4a524e77f02ace7db6171dcd8c76","wit/deps/clocks/timezone.wit":"caf183ddda4bb6693f0cc9d3249e42a58a21091ff1764e92f652dfc8a1bbff6c","wit/deps/clocks/wall-clock.wit":"44e062d552753f939b4dec8ce87b499ba46fdc0e88e8d630d7fd1bc0d29f7e13","wit/deps/filesystem/filesystem.wit":"ce4e225baf21a915435f807a0bb47bc34f43227c0424156cab7c6c536a5d1755","wit/deps/http/incoming-handler.wit":"f607b4aef7df1e0f477a96be9ce2cbf82c3d6f90ebc27a9f30355b47259f9d21","wit/deps/http/outgoing-handler.wit":"ac73f8fdbea26cc5563ef862be3dd268c061aa9ab88e9d9f1b7f346259dce947","wit/deps/http/types.wit":"4dd2bdb01cdcbd55205ddbc265fb26a5cbaf8b3fa788ea765aed0b22f0eb1116","wit/deps/io/streams.wit":"27ece43f048c9997632c201188d9adae2f6efcbeda741c0d3ba5514d0e159d0b","wit/deps/logging/handler.wit":"2e29db6549ec2322ca4a6b8f66762ffc772de35aaafd75a10794316af5842317","wit/deps/poll/poll.wit":"40e46e93169820658e1ad238bbe972a7633e7fe76ab81b2512464087b88044a4","wit/deps/preview/command-extended.wit":"d323eabd2189b063a9d5947b6b89a87f781d423e646a5877cc8f018fc597a318","wit/deps/preview/command.wit":"4661ef6c88d9adcae9cdc96a2421d76b2b4f72a2c5d158dd5df61ba1c9ca9e7c","wit/deps/preview/proxy.wit":"2f587e6cd655b66083e6491b8a2b2ff7a1a678b8cb41e8f1a682b979f6014db0","wit/deps/preview/reactor.wit":"4f462525df7e94785276ac98282a0a520e4a9375d03dda29c711da40bae09cc5","wit/deps/random/insecure-seed.wit":"fe552ca7a0022a71f8912927511232cd9f3469bc4736acca77470c6bc87e72b0","wit/deps/random/insecure.wit":"b8b1cabaa61ce696b47272d2b891280b067665a34e95b4bb9889784557950885","wit/deps/random/random.wit":"ce2f75c21c2d1d1d667d1ec645cd507e5b8308e9336004907e68368862543759","wit/deps/sockets/instance-network.wit":"4cd31f5437b1bffcdf0372e0494105603e1388c0770b3efc69be1b673924fc59","wit/deps/sockets/ip-name-lookup.wit":"7225d7e087d1df7da574706f1493bd34c9ec83ee7a07361f9cca77b225e6739d","wit/deps/sockets/network.wit":"1fce35e2e98696741cb992927366fc6e3f291ef9f78a02de5cc8ee7b75d2ec0d","wit/deps/sockets/tcp-create-socket.wit":"7274c1e028e07472e8c5fe79ce3abc304dc28c4076268b51c2fa6f5e31ab8a8d","wit/deps/sockets/tcp.wit":"963fec57fd378b2875dc75dfe05295fe42de9ecdc8396815239a58b13962a7cf","wit/deps/sockets/udp-create-socket.wit":"e5b16fce0bb815b03ad0770a0ac755c853fa9b160b0971b5489369c7fb298ae0","wit/deps/sockets/udp.wit":"87fbdf0e620223a9eb7fd6e42d046e0434031db1fc0acd7c824bdb1175538121","wit/deps/wasi-cli-base/environment.wit":"9354ebdd897f2e1836d1e524837f3c196dff39a67af7396f82264b8e6f206e3d","wit/deps/wasi-cli-base/exit.wit":"399c33a025a677db0037d1cf14a6e8efdd68c3f81bc56c3ced4e5804dd063648","wit/deps/wasi-cli-base/preopens.wit":"8a43df4ad8e4eea910221a3c51a0f46be5f54d8642a50c60bf7e1e28ce68d14c","wit/deps/wasi-cli-base/stdio.wit":"93f082447b7b29469d05650c72ae355c1801dfffa07b125e2b4c33f2f7fe6209","wit/main.wit":"e23e2fac3598b3309128372260bf80ed06b085a90d19a89a56986ba1a6b991fd","wit/test.wit":"1acba81c156472499d88b04a11641fb6c3177ca90ddba458f2f5f59c8b89db85","witx/typenames.witx":"65b41b94060e923ef543621080c2bdcb258bc550494a819ade2688eb1fcccfa6","witx/wasi_snapshot_preview1.witx":"56135b1fdfe9eb4e2fbaabf93178070cd5b0cc5fe451ae74d218ebfc7dda7e88"},"package":"eb789f8fbccad71eec6c79800e288193f58ea512f1be66953b92b2a74a287821"}