wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasm-encoder-0.207.0/src/core/types.rs

@@ -0,0 +1,678 @@
+use crate::{encode_section, Encode, Section, SectionId};
+
+/// Represents a subtype of possible other types in a WebAssembly module.
+#[derive(Debug, Clone)]
+pub struct SubType {
+    /// Is the subtype final.
+    pub is_final: bool,
+    /// The list of supertype indexes. As of GC MVP, there can be at most one supertype.
+    pub supertype_idx: Option<u32>,
+    /// The composite type of the subtype.
+    pub composite_type: CompositeType,
+}
+
+impl Encode for SubType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        // We only need to emit a prefix byte before the actual composite type
+        // when either the type is not final or it has a declared super type.
+        if self.supertype_idx.is_some() || !self.is_final {
+            sink.push(if self.is_final { 0x4f } else { 0x50 });
+            self.supertype_idx.encode(sink);
+        }
+        self.composite_type.encode(sink);
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::SubType> for SubType {
+    type Error = ();
+
+    fn try_from(sub_ty: wasmparser::SubType) -> Result<Self, Self::Error> {
+        Ok(SubType {
+            is_final: sub_ty.is_final,
+            supertype_idx: sub_ty
+                .supertype_idx
+                .map(|i| i.as_module_index().ok_or(()))
+                .transpose()?,
+            composite_type: sub_ty.composite_type.try_into()?,
+        })
+    }
+}
+
+/// Represents a composite type in a WebAssembly module.
+#[derive(Debug, Clone)]
+pub enum CompositeType {
+    /// The type is for a function.
+    Func(FuncType),
+    /// The type is for an array.
+    Array(ArrayType),
+    /// The type is for a struct.
+    Struct(StructType),
+}
+
+impl Encode for CompositeType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        match self {
+            CompositeType::Func(ty) => TypeSection::encode_function(
+                sink,
+                ty.params().iter().copied(),
+                ty.results().iter().copied(),
+            ),
+            CompositeType::Array(ArrayType(ty)) => {
+                TypeSection::encode_array(sink, &ty.element_type, ty.mutable)
+            }
+            CompositeType::Struct(ty) => {
+                TypeSection::encode_struct(sink, ty.fields.iter().cloned())
+            }
+        }
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::CompositeType> for CompositeType {
+    type Error = ();
+    fn try_from(composite_ty: wasmparser::CompositeType) -> Result<Self, Self::Error> {
+        Ok(match composite_ty {
+            wasmparser::CompositeType::Func(f) => CompositeType::Func(f.try_into()?),
+            wasmparser::CompositeType::Array(a) => CompositeType::Array(a.try_into()?),
+            wasmparser::CompositeType::Struct(s) => CompositeType::Struct(s.try_into()?),
+        })
+    }
+}
+
+/// Represents a type of a function in a WebAssembly module.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct FuncType {
+    /// The combined parameters and result types.
+    params_results: Box<[ValType]>,
+    /// The number of parameter types.
+    len_params: usize,
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::FuncType> for FuncType {
+    type Error = ();
+    fn try_from(func_ty: wasmparser::FuncType) -> Result<Self, Self::Error> {
+        let mut buf = Vec::with_capacity(func_ty.params().len() + func_ty.results().len());
+        for ty in func_ty.params().iter().chain(func_ty.results()).copied() {
+            buf.push(ty.try_into()?);
+        }
+        Ok(FuncType::from_parts(buf.into(), func_ty.params().len()))
+    }
+}
+
+/// Represents a type of an array in a WebAssembly module.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub struct ArrayType(pub FieldType);
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::ArrayType> for ArrayType {
+    type Error = ();
+    fn try_from(array_ty: wasmparser::ArrayType) -> Result<Self, Self::Error> {
+        Ok(ArrayType(array_ty.0.try_into()?))
+    }
+}
+
+/// Represents a type of a struct in a WebAssembly module.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct StructType {
+    /// Struct fields.
+    pub fields: Box<[FieldType]>,
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::StructType> for StructType {
+    type Error = ();
+    fn try_from(struct_ty: wasmparser::StructType) -> Result<Self, Self::Error> {
+        Ok(StructType {
+            fields: struct_ty
+                .fields
+                .iter()
+                .cloned()
+                .map(TryInto::try_into)
+                .collect::<Result<_, _>>()?,
+        })
+    }
+}
+
+/// Field type in composite types (structs, arrays).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct FieldType {
+    /// Storage type of the field.
+    pub element_type: StorageType,
+    /// Is the field mutable.
+    pub mutable: bool,
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::FieldType> for FieldType {
+    type Error = ();
+    fn try_from(field_ty: wasmparser::FieldType) -> Result<Self, Self::Error> {
+        Ok(FieldType {
+            element_type: field_ty.element_type.try_into()?,
+            mutable: field_ty.mutable,
+        })
+    }
+}
+
+/// Storage type for composite type fields.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum StorageType {
+    /// The `i8` type.
+    I8,
+    /// The `i16` type.
+    I16,
+    /// A value type.
+    Val(ValType),
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::StorageType> for StorageType {
+    type Error = ();
+    fn try_from(storage_ty: wasmparser::StorageType) -> Result<Self, Self::Error> {
+        Ok(match storage_ty {
+            wasmparser::StorageType::I8 => StorageType::I8,
+            wasmparser::StorageType::I16 => StorageType::I16,
+            wasmparser::StorageType::Val(v) => StorageType::Val(v.try_into()?),
+        })
+    }
+}
+
+impl StorageType {
+    /// Is this storage type defaultable?
+    pub fn is_defaultable(&self) -> bool {
+        self.unpack().is_defaultable()
+    }
+
+    /// Unpack this storage type into a value type.
+    pub fn unpack(&self) -> ValType {
+        match self {
+            StorageType::I8 | StorageType::I16 => ValType::I32,
+            StorageType::Val(v) => *v,
+        }
+    }
+}
+
+/// The type of a core WebAssembly value.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum ValType {
+    /// The `i32` type.
+    I32,
+    /// The `i64` type.
+    I64,
+    /// The `f32` type.
+    F32,
+    /// The `f64` type.
+    F64,
+    /// The `v128` type.
+    ///
+    /// Part of the SIMD proposal.
+    V128,
+    /// A reference type.
+    ///
+    /// The `funcref` and `externref` type fall into this category and the full
+    /// generalization here is due to the implementation of the
+    /// function-references proposal.
+    Ref(RefType),
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::ValType> for ValType {
+    type Error = ();
+    fn try_from(val_ty: wasmparser::ValType) -> Result<Self, Self::Error> {
+        Ok(match val_ty {
+            wasmparser::ValType::I32 => ValType::I32,
+            wasmparser::ValType::I64 => ValType::I64,
+            wasmparser::ValType::F32 => ValType::F32,
+            wasmparser::ValType::F64 => ValType::F64,
+            wasmparser::ValType::V128 => ValType::V128,
+            wasmparser::ValType::Ref(r) => ValType::Ref(r.try_into()?),
+        })
+    }
+}
+
+impl ValType {
+    /// Is this a numeric value type?
+    pub fn is_numeric(&self) -> bool {
+        match self {
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 => true,
+            ValType::V128 | ValType::Ref(_) => false,
+        }
+    }
+
+    /// Is this a vector type?
+    pub fn is_vector(&self) -> bool {
+        match self {
+            ValType::V128 => true,
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::Ref(_) => false,
+        }
+    }
+
+    /// Is this a reference type?
+    pub fn is_reference(&self) -> bool {
+        match self {
+            ValType::Ref(_) => true,
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => false,
+        }
+    }
+}
+
+impl FuncType {
+    /// Creates a new [`FuncType`] from the given `params` and `results`.
+    pub fn new<P, R>(params: P, results: R) -> Self
+    where
+        P: IntoIterator<Item = ValType>,
+        R: IntoIterator<Item = ValType>,
+    {
+        let mut buffer = params.into_iter().collect::<Vec<_>>();
+        let len_params = buffer.len();
+        buffer.extend(results);
+        Self::from_parts(buffer.into(), len_params)
+    }
+
+    #[inline]
+    pub(crate) fn from_parts(params_results: Box<[ValType]>, len_params: usize) -> Self {
+        Self {
+            params_results,
+            len_params,
+        }
+    }
+
+    /// Returns a shared slice to the parameter types of the [`FuncType`].
+    #[inline]
+    pub fn params(&self) -> &[ValType] {
+        &self.params_results[..self.len_params]
+    }
+
+    /// Returns a shared slice to the result types of the [`FuncType`].
+    #[inline]
+    pub fn results(&self) -> &[ValType] {
+        &self.params_results[self.len_params..]
+    }
+}
+
+impl ValType {
+    /// Alias for the `funcref` type in WebAssembly
+    pub const FUNCREF: ValType = ValType::Ref(RefType::FUNCREF);
+    /// Alias for the `externref` type in WebAssembly
+    pub const EXTERNREF: ValType = ValType::Ref(RefType::EXTERNREF);
+    /// Alias for the `exnref` type in WebAssembly
+    pub const EXNREF: ValType = ValType::Ref(RefType::EXNREF);
+
+    /// Is this value defaultable?
+    pub fn is_defaultable(&self) -> bool {
+        match self {
+            ValType::Ref(r) => r.nullable,
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => true,
+        }
+    }
+}
+
+impl Encode for StorageType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        match self {
+            StorageType::I8 => sink.push(0x78),
+            StorageType::I16 => sink.push(0x77),
+            StorageType::Val(vt) => vt.encode(sink),
+        }
+    }
+}
+
+impl Encode for ValType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        match self {
+            ValType::I32 => sink.push(0x7F),
+            ValType::I64 => sink.push(0x7E),
+            ValType::F32 => sink.push(0x7D),
+            ValType::F64 => sink.push(0x7C),
+            ValType::V128 => sink.push(0x7B),
+            ValType::Ref(rt) => rt.encode(sink),
+        }
+    }
+}
+
+/// A reference type.
+///
+/// This is largely part of the function references proposal for WebAssembly but
+/// additionally is used by the `funcref` and `externref` types. The full
+/// generality of this type is only exercised with function-references.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+#[allow(missing_docs)]
+pub struct RefType {
+    pub nullable: bool,
+    pub heap_type: HeapType,
+}
+
+impl RefType {
+    /// Alias for the `funcref` type in WebAssembly
+    pub const FUNCREF: RefType = RefType {
+        nullable: true,
+        heap_type: HeapType::Func,
+    };
+
+    /// Alias for the `externref` type in WebAssembly
+    pub const EXTERNREF: RefType = RefType {
+        nullable: true,
+        heap_type: HeapType::Extern,
+    };
+
+    /// Alias for the `exnref` type in WebAssembly
+    pub const EXNREF: RefType = RefType {
+        nullable: true,
+        heap_type: HeapType::Exn,
+    };
+}
+
+impl Encode for RefType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        if self.nullable {
+            // Favor the original encodings of `funcref` and `externref` where
+            // possible
+            match self.heap_type {
+                HeapType::Func => return sink.push(0x70),
+                HeapType::Extern => return sink.push(0x6f),
+                _ => {}
+            }
+        }
+
+        if self.nullable {
+            sink.push(0x63);
+        } else {
+            sink.push(0x64);
+        }
+        self.heap_type.encode(sink);
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::RefType> for RefType {
+    type Error = ();
+
+    fn try_from(ref_type: wasmparser::RefType) -> Result<Self, Self::Error> {
+        Ok(RefType {
+            nullable: ref_type.is_nullable(),
+            heap_type: ref_type.heap_type().try_into()?,
+        })
+    }
+}
+
+impl From<RefType> for ValType {
+    fn from(ty: RefType) -> ValType {
+        ValType::Ref(ty)
+    }
+}
+
+/// Part of the function references proposal.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum HeapType {
+    /// Untyped (any) function.
+    Func,
+
+    /// The abstract external heap type.
+    Extern,
+
+    /// The abstract `any` heap type.
+    ///
+    /// The common supertype (a.k.a. top) of all internal types.
+    Any,
+
+    /// The abstract `none` heap type.
+    ///
+    /// The common subtype (a.k.a. bottom) of all internal types.
+    None,
+
+    /// The abstract `noextern` heap type.
+    ///
+    /// The common subtype (a.k.a. bottom) of all external types.
+    NoExtern,
+
+    /// The abstract `nofunc` heap type.
+    ///
+    /// The common subtype (a.k.a. bottom) of all function types.
+    NoFunc,
+
+    /// The abstract `eq` heap type.
+    ///
+    /// The common supertype of all referenceable types on which comparison
+    /// (ref.eq) is allowed.
+    Eq,
+
+    /// The abstract `struct` heap type.
+    ///
+    /// The common supertype of all struct types.
+    Struct,
+
+    /// The abstract `array` heap type.
+    ///
+    /// The common supertype of all array types.
+    Array,
+
+    /// The unboxed `i31` heap type.
+    I31,
+
+    /// The abstract `exception` heap type.
+    Exn,
+
+    /// The abstract `noexn` heap type.
+    NoExn,
+
+    /// A concrete Wasm-defined type at the given index.
+    Concrete(u32),
+}
+
+impl Encode for HeapType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        match self {
+            HeapType::Func => sink.push(0x70),
+            HeapType::Extern => sink.push(0x6F),
+            HeapType::Any => sink.push(0x6E),
+            HeapType::None => sink.push(0x71),
+            HeapType::NoExtern => sink.push(0x72),
+            HeapType::NoFunc => sink.push(0x73),
+            HeapType::Eq => sink.push(0x6D),
+            HeapType::Struct => sink.push(0x6B),
+            HeapType::Array => sink.push(0x6A),
+            HeapType::I31 => sink.push(0x6C),
+            HeapType::Exn => sink.push(0x69),
+            HeapType::NoExn => sink.push(0x74),
+            // Note that this is encoded as a signed type rather than unsigned
+            // as it's decoded as an s33
+            HeapType::Concrete(i) => i64::from(*i).encode(sink),
+        }
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::HeapType> for HeapType {
+    type Error = ();
+
+    fn try_from(heap_type: wasmparser::HeapType) -> Result<Self, Self::Error> {
+        Ok(match heap_type {
+            wasmparser::HeapType::Concrete(i) => HeapType::Concrete(i.as_module_index().ok_or(())?),
+            wasmparser::HeapType::Func => HeapType::Func,
+            wasmparser::HeapType::Extern => HeapType::Extern,
+            wasmparser::HeapType::Any => HeapType::Any,
+            wasmparser::HeapType::None => HeapType::None,
+            wasmparser::HeapType::NoExtern => HeapType::NoExtern,
+            wasmparser::HeapType::NoFunc => HeapType::NoFunc,
+            wasmparser::HeapType::Eq => HeapType::Eq,
+            wasmparser::HeapType::Struct => HeapType::Struct,
+            wasmparser::HeapType::Array => HeapType::Array,
+            wasmparser::HeapType::I31 => HeapType::I31,
+            wasmparser::HeapType::Exn => HeapType::Exn,
+            wasmparser::HeapType::NoExn => HeapType::NoExn,
+        })
+    }
+}
+
+/// An encoder for the type section of WebAssembly modules.
+///
+/// # Example
+///
+/// ```rust
+/// use wasm_encoder::{Module, TypeSection, ValType};
+///
+/// let mut types = TypeSection::new();
+///
+/// types.function([ValType::I32, ValType::I32], [ValType::I64]);
+///
+/// let mut module = Module::new();
+/// module.section(&types);
+///
+/// let bytes = module.finish();
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct TypeSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl TypeSection {
+    /// Create a new module type section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of types in the section.
+    pub fn len(&self) -> u32 {
+        self.num_added
+    }
+
+    /// Determines if the section is empty.
+    pub fn is_empty(&self) -> bool {
+        self.num_added == 0
+    }
+
+    /// Define a function type in this type section.
+    pub fn function<P, R>(&mut self, params: P, results: R) -> &mut Self
+    where
+        P: IntoIterator<Item = ValType>,
+        P::IntoIter: ExactSizeIterator,
+        R: IntoIterator<Item = ValType>,
+        R::IntoIter: ExactSizeIterator,
+    {
+        Self::encode_function(&mut self.bytes, params, results);
+        self.num_added += 1;
+        self
+    }
+
+    fn encode_function<P, R>(sink: &mut Vec<u8>, params: P, results: R)
+    where
+        P: IntoIterator<Item = ValType>,
+        P::IntoIter: ExactSizeIterator,
+        R: IntoIterator<Item = ValType>,
+        R::IntoIter: ExactSizeIterator,
+    {
+        let params = params.into_iter();
+        let results = results.into_iter();
+
+        sink.push(0x60);
+        params.len().encode(sink);
+        params.for_each(|p| p.encode(sink));
+        results.len().encode(sink);
+        results.for_each(|p| p.encode(sink));
+    }
+
+    /// Define an array type in this type section.
+    pub fn array(&mut self, ty: &StorageType, mutable: bool) -> &mut Self {
+        Self::encode_array(&mut self.bytes, ty, mutable);
+        self.num_added += 1;
+        self
+    }
+
+    fn encode_array(sink: &mut Vec<u8>, ty: &StorageType, mutable: bool) {
+        sink.push(0x5e);
+        Self::encode_field(sink, ty, mutable);
+    }
+
+    fn encode_field(sink: &mut Vec<u8>, ty: &StorageType, mutable: bool) {
+        ty.encode(sink);
+        sink.push(mutable as u8);
+    }
+
+    /// Define a struct type in this type section.
+    pub fn struct_<F>(&mut self, fields: F) -> &mut Self
+    where
+        F: IntoIterator<Item = FieldType>,
+        F::IntoIter: ExactSizeIterator,
+    {
+        Self::encode_struct(&mut self.bytes, fields);
+        self.num_added += 1;
+        self
+    }
+
+    fn encode_struct<F>(sink: &mut Vec<u8>, fields: F)
+    where
+        F: IntoIterator<Item = FieldType>,
+        F::IntoIter: ExactSizeIterator,
+    {
+        let fields = fields.into_iter();
+        sink.push(0x5f);
+        fields.len().encode(sink);
+        for f in fields {
+            Self::encode_field(sink, &f.element_type, f.mutable);
+        }
+    }
+
+    /// Define an explicit subtype in this type section.
+    pub fn subtype(&mut self, ty: &SubType) -> &mut Self {
+        ty.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
+    /// Define an explicit recursion group in this type section.
+    pub fn rec<T>(&mut self, types: T) -> &mut Self
+    where
+        T: IntoIterator<Item = SubType>,
+        T::IntoIter: ExactSizeIterator,
+    {
+        let types = types.into_iter();
+        self.bytes.push(0x4e);
+        types.len().encode(&mut self.bytes);
+        types.for_each(|t| t.encode(&mut self.bytes));
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for TypeSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for TypeSection {
+    fn id(&self) -> u8 {
+        SectionId::Type.into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use wasmparser::WasmFeatures;
+
+    use super::*;
+    use crate::Module;
+
+    #[test]
+    fn func_types_dont_require_wasm_gc() {
+        let mut types = TypeSection::new();
+        types.subtype(&SubType {
+            is_final: true,
+            supertype_idx: None,
+            composite_type: CompositeType::Func(FuncType::new([], [])),
+        });
+
+        let mut module = Module::new();
+        module.section(&types);
+        let wasm_bytes = module.finish();
+
+        let mut validator =
+            wasmparser::Validator::new_with_features(WasmFeatures::default() & !WasmFeatures::GC);
+
+        validator.validate_all(&wasm_bytes).expect(
+            "Encoding pre Wasm GC type should not accidentally use Wasm GC specific encoding",
+        );
+    }
+}

data/ext/cargo-vendor/wasmparser-0.207.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"53b35840fcbaea633ae8cc58b769d71265097a7078c83af62d7e0641cf76a837","Cargo.toml":"9b77f4d4e65d3f3e026fac9e6d543fe656c4dd516f3b7a26cd41659f21415c9f","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/benchmark.rs":"45ed921b97a85df370298186ff3b2ccea8c39664b12e0b4d475dea0e95f74118","examples/simple.rs":"e9eb076367cc0932e2a32651372defa4a27ef800f47fad28c0ef840ba8ea7e08","src/binary_reader.rs":"36b8ba437f83ef71e4ebc915432ae3589a7dcadd550b8b19ceed926c51397974","src/lib.rs":"2a2c91d52cd708495069a0f201b05200ddc903c75f867a4329b307e71e2e5196","src/limits.rs":"279274a5e8c314457b5e4745a4f13a84666f8285da1408a627b4ad534a3f28b2","src/map.rs":"46f0cb67bda07e9c0c61d2bffd9ed60fb560cf45c192314ce949daf13e7761b8","src/parser.rs":"42d6713d0c5eb4176a917df5abdaa18f843ed82bd21b5c6c91fc01d5ddc4d7b2","src/readers.rs":"59c8cfad81f43c40f32f74892910595da00fe6fe46db851e78800889c5493b6a","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"72f3339cb452c1b055bd080281fe4923d132c280da112fcd1182594811b87494","src/readers/component/canonicals.rs":"a6e7ceebb624e0fa6e740fe3a73446154e88b42c8dadee015870fd21e30a5e0f","src/readers/component/exports.rs":"177f05b11de2276a26842481b1260a8eface092f03736853a55f30d532994c28","src/readers/component/imports.rs":"032db44269c6c772a62d0ad66fd6b4cfa3bf9a4caa5a0ba62ee4c04abe91e113","src/readers/component/instances.rs":"1efefe9a5a7e78c5a2df766d5985a406ea6edbd3ae2d43910f6208e73a420f41","src/readers/component/names.rs":"5b81f9663976bb637687a22334a3ca2f513118437a7ac829b3ed3aaf899ec0e2","src/readers/component/start.rs":"9c37d1eea486ee951547a328693bcf9f2a27f48e2207478daf23c1cd9e9f95f3","src/readers/component/types.rs":"dac81dd6932776a176c43328d730c5666b44bd14965f9126ccde34097684faaf","src/readers/core.rs":"f77e1eb46e1d05abeabb9be2bd7bdd66acadfc4c651912f2a67b7e5f7d29d041","src/readers/core/branch_hinting.rs":"05d834d34cae2267712401a2b03d952deb99890d9855bd0c74681825caae382f","src/readers/core/code.rs":"0c42e78a8b4d3701b45ea6f733043062f2f5d9d2713626bd894e3c92aba5ec0e","src/readers/core/coredumps.rs":"d6d2ffcb7109672b265414096c185384df15e9a46bd77f740eda8811afc20cfe","src/readers/core/custom.rs":"1330840e85a070968106bb0ef8de94c38397728c9cca555cc45565969fc5ef23","src/readers/core/data.rs":"bb40dc052759f2f78a606c1d39790fb07dc208630d9e760b64a38ec48212badf","src/readers/core/dylink0.rs":"bd3de09ccd7a9b1dc1aacc3d4ebd7a70d31978c634c864aa2ca08a381ef24318","src/readers/core/elements.rs":"07e394df4808f131e5929dfdeb594d8e2fb4f811ad0ba745bc14b5415327417a","src/readers/core/exports.rs":"50dc1ee51b73f03f24077f7c290bca756966563cedbad9e49d735d60f60c91db","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"076fee0cf6e92126e4f477dea988a6f97dde0c3b62d6e4cb5cdee3dca1d92850","src/readers/core/imports.rs":"4d247e8cac0b3cef7425d93f7a7f2412b2ae8979da944080d565415499e27e87","src/readers/core/init.rs":"ec6717063b0b7f2e9aa17ae52083019cee52594bf5a8b6858f2d77b10d7a0639","src/readers/core/linking.rs":"2c8a1ea4703ec10907905e086af74036d25505baea48904561410db6a233a383","src/readers/core/memories.rs":"1db19b6bf640bb150be1ac84bf852687567f8c93d53f0ec66c47ab607676a4d9","src/readers/core/names.rs":"4d833dfb4251a4015c29ab1bb9e559b49859048c91db7c06f99dc0df258c8864","src/readers/core/operators.rs":"139fdb8115d6056c29166911a58275a95e4bbf26e8af9c11dfd9bfe1eb5f88cf","src/readers/core/producers.rs":"5b53d0979a68008f9aec0bb9bca64c071e49a6a1879d8459f1114fa666e661c5","src/readers/core/reloc.rs":"e413c39fc7e1144d13b57cfd0b195e1fb39a983675f88c758a35e995f026bc24","src/readers/core/tables.rs":"1376a26c608dd70e8231dd58face474ceeb830fd4f7735acc6f31cd8b9f62a0a","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"c07b4db774a6e68cf99cc2f421ee58f85a19000163eef8a78956ebce223567b0","src/readers/core/types/matches.rs":"ff84f472b8589ef39cf513cbef2eedef9db071a9e74e1deddb4ef579097260ab","src/resources.rs":"375749dd1ad8f365fb3fd436f25f04139ec113101378e666ff85598ebd31b922","src/validator.rs":"16d986d77e78a3071e048ce6a2fed23910d94129cacd8481476b9c641d603df7","src/validator/component.rs":"11e74e23f2f7553303cd78f278899239bbfba9196d437501e60e0bbadb63fc8e","src/validator/core.rs":"66e943416e5845eec3f0b1c1bbdf9653ac4a2d6bbfd150875769dbddee6e8ea5","src/validator/core/canonical.rs":"20a025745ce95637f5f932b255c507f9551a9ba920a24779b460f0577a7d8b97","src/validator/func.rs":"2e362db7dcfc345d38c56a6e261b2b2441b56da96427a0d6104488e2870b6f9f","src/validator/names.rs":"56963116580fa6c5eede0ffd5a6a9e74e940021d9a9c8937c1bba626c8d29b1b","src/validator/operators.rs":"7bfb81bc4bfae77faab8d95dd687953aaae99bf0ec19cfa7b06b3aaf3208a31b","src/validator/types.rs":"d22e8048d292b0e1e23e34e223cd34e8f26e55ec60de435386298ee6a650d6a6","tests/big-module.rs":"2d956dedf1a9f0b1e976dd63c97d3707cd726da10166cad2f16ae33000ed13b3"},"package":"e19bb9f8ab07616da582ef8adb24c54f1424c7ec876720b7da9db8ec0626c92c"}