wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasmparser-0.116.1/src/readers.rs

@@ -1,316 +0,0 @@
-/* Copyright 2018 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::{BinaryReader, BinaryReaderError, Result};
-use std::fmt;
-use std::marker;
-use std::ops::Range;
-
-mod component;
-mod core;
-
-pub use self::component::*;
-pub use self::core::*;
-
-/// A trait implemented for items that can be decoded directly from a
-/// `BinaryReader`, or that which can be parsed from the WebAssembly binary
-/// format.
-///
-/// Note that this is also accessible as a [`BinaryReader::read`] method.
-pub trait FromReader<'a>: Sized {
-    /// Attempts to read `Self` from the provided binary reader, returning an
-    /// error if it is unable to do so.
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self>;
-}
-
-impl<'a> FromReader<'a> for u32 {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        reader.read_var_u32()
-    }
-}
-
-impl<'a> FromReader<'a> for &'a str {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        reader.read_string()
-    }
-}
-
-impl<'a, T, U> FromReader<'a> for (T, U)
-where
-    T: FromReader<'a>,
-    U: FromReader<'a>,
-{
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok((reader.read()?, reader.read()?))
-    }
-}
-
-/// A generic structure for reading a section of a WebAssembly binary which has
-/// a limited number of items within it.
-///
-/// Many WebAssembly sections are a count of items followed by that many items.
-/// This helper structure can be used to parse these sections and provides
-/// an iteration-based API for reading the contents.
-///
-/// Note that this always implements the [`Clone`] trait to represent the
-/// ability to parse the section multiple times.
-pub struct SectionLimited<'a, T> {
-    reader: BinaryReader<'a>,
-    count: u32,
-    _marker: marker::PhantomData<T>,
-}
-
-impl<'a, T> SectionLimited<'a, T> {
-    /// Creates a new section reader from the provided contents.
-    ///
-    /// The `data` provided here is the data of the section itself that will be
-    /// parsed. The `offset` argument is the byte offset, in the original wasm
-    /// binary, that the section was found. The `offset` argument is used
-    /// for error reporting.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if a 32-bit count couldn't be read from the `data`.
-    pub fn new(data: &'a [u8], offset: usize) -> Result<Self> {
-        let mut reader = BinaryReader::new_with_offset(data, offset);
-        let count = reader.read_var_u32()?;
-        Ok(SectionLimited {
-            reader,
-            count,
-            _marker: marker::PhantomData,
-        })
-    }
-
-    /// Returns the count of total items within this section.
-    pub fn count(&self) -> u32 {
-        self.count
-    }
-
-    /// Returns whether the original byte offset of this section.
-    pub fn original_position(&self) -> usize {
-        self.reader.original_position()
-    }
-
-    /// Returns the range, as byte offsets, of this section within the original
-    /// wasm binary.
-    pub fn range(&self) -> Range<usize> {
-        self.reader.range()
-    }
-
-    /// Returns an iterator which yields not only each item in this section but
-    /// additionally the offset of each item within the section.
-    pub fn into_iter_with_offsets(self) -> SectionLimitedIntoIterWithOffsets<'a, T>
-    where
-        T: FromReader<'a>,
-    {
-        SectionLimitedIntoIterWithOffsets {
-            iter: self.into_iter(),
-        }
-    }
-}
-
-impl<T> Clone for SectionLimited<'_, T> {
-    fn clone(&self) -> Self {
-        SectionLimited {
-            reader: self.reader.clone(),
-            count: self.count,
-            _marker: self._marker,
-        }
-    }
-}
-
-impl<T> fmt::Debug for SectionLimited<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("SectionLimited")
-            .field("count", &self.count)
-            .field("range", &self.range())
-            .finish()
-    }
-}
-
-impl<'a, T> IntoIterator for SectionLimited<'a, T>
-where
-    T: FromReader<'a>,
-{
-    type Item = Result<T>;
-    type IntoIter = SectionLimitedIntoIter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        SectionLimitedIntoIter {
-            remaining: self.count,
-            section: self,
-            end: false,
-        }
-    }
-}
-
-/// A consuming iterator of a [`SectionLimited`].
-///
-/// This is created via the [`IntoIterator`] `impl` for the [`SectionLimited`]
-/// type.
-pub struct SectionLimitedIntoIter<'a, T> {
-    section: SectionLimited<'a, T>,
-    remaining: u32,
-    end: bool,
-}
-
-impl<T> SectionLimitedIntoIter<'_, T> {
-    /// Returns the current byte offset of the section within this iterator.
-    pub fn original_position(&self) -> usize {
-        self.section.reader.original_position()
-    }
-}
-
-impl<'a, T> Iterator for SectionLimitedIntoIter<'a, T>
-where
-    T: FromReader<'a>,
-{
-    type Item = Result<T>;
-
-    fn next(&mut self) -> Option<Result<T>> {
-        if self.end {
-            return None;
-        }
-        if self.remaining == 0 {
-            self.end = true;
-            if self.section.reader.eof() {
-                return None;
-            }
-            return Some(Err(BinaryReaderError::new(
-                "section size mismatch: unexpected data at the end of the section",
-                self.section.reader.original_position(),
-            )));
-        }
-        let result = self.section.reader.read();
-        self.end = result.is_err();
-        self.remaining -= 1;
-        Some(result)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let remaining = self.remaining as usize;
-        (remaining, Some(remaining))
-    }
-}
-
-impl<'a, T> ExactSizeIterator for SectionLimitedIntoIter<'a, T> where T: FromReader<'a> {}
-
-/// An iterator over a limited section iterator.
-pub struct SectionLimitedIntoIterWithOffsets<'a, T> {
-    iter: SectionLimitedIntoIter<'a, T>,
-}
-
-impl<'a, T> Iterator for SectionLimitedIntoIterWithOffsets<'a, T>
-where
-    T: FromReader<'a>,
-{
-    type Item = Result<(usize, T)>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let pos = self.iter.section.reader.original_position();
-        Some(self.iter.next()?.map(|item| (pos, item)))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-impl<'a, T> ExactSizeIterator for SectionLimitedIntoIterWithOffsets<'a, T> where T: FromReader<'a> {}
-
-/// A trait implemented for subsections of another outer section.
-///
-/// This is currently only used for subsections within custom sections, such as
-/// the `name` section of core wasm.
-///
-/// This is used in conjunction with [`Subsections`].
-pub trait Subsection<'a>: Sized {
-    /// Converts the section identifier provided with the section contents into
-    /// a typed section
-    fn from_reader(id: u8, reader: BinaryReader<'a>) -> Result<Self>;
-}
-
-/// Iterator/reader over the contents of a section which is composed of
-/// subsections.
-///
-/// This reader is used for the core `name` section, for example. This type
-/// primarily implements [`Iterator`] for advancing through the sections.
-pub struct Subsections<'a, T> {
-    reader: BinaryReader<'a>,
-    _marker: marker::PhantomData<T>,
-}
-
-impl<'a, T> Subsections<'a, T> {
-    /// Creates a new reader for the specified section contents starting at
-    /// `offset` within the original wasm file.
-    pub fn new(data: &'a [u8], offset: usize) -> Self {
-        Subsections {
-            reader: BinaryReader::new_with_offset(data, offset),
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns whether the original byte offset of this section.
-    pub fn original_position(&self) -> usize {
-        self.reader.original_position()
-    }
-
-    /// Returns the range, as byte offsets, of this section within the original
-    /// wasm binary.
-    pub fn range(&self) -> Range<usize> {
-        self.reader.range()
-    }
-
-    fn read(&mut self) -> Result<T>
-    where
-        T: Subsection<'a>,
-    {
-        let subsection_id = self.reader.read_u7()?;
-        let reader = self.reader.read_reader("unexpected end of section")?;
-        T::from_reader(subsection_id, reader)
-    }
-}
-
-impl<T> Clone for Subsections<'_, T> {
-    fn clone(&self) -> Self {
-        Subsections {
-            reader: self.reader.clone(),
-            _marker: self._marker,
-        }
-    }
-}
-
-impl<T> fmt::Debug for Subsections<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Subsections")
-            .field("range", &self.range())
-            .finish()
-    }
-}
-
-impl<'a, T> Iterator for Subsections<'a, T>
-where
-    T: Subsection<'a>,
-{
-    type Item = Result<T>;
-
-    fn next(&mut self) -> Option<Result<T>> {
-        if self.reader.eof() {
-            None
-        } else {
-            Some(self.read())
-        }
-    }
-}

data/ext/cargo-vendor/wasmparser-0.116.1/src/resources.rs

@@ -1,398 +0,0 @@
-/* Copyright 2019 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::{
-    BinaryReaderError, FuncType, GlobalType, HeapType, MemoryType, RefType, TableType, ValType,
-    WasmFeatures,
-};
-use std::ops::Range;
-
-/// Types that qualify as Wasm function types for validation purposes.
-pub trait WasmFuncType {
-    /// Returns the number of input types.
-    fn len_inputs(&self) -> usize;
-    /// Returns the number of output types.
-    fn len_outputs(&self) -> usize;
-    /// Returns the type at given index if any.
-    ///
-    /// # Note
-    ///
-    /// The returned type may be wrapped by the user crate and thus
-    /// the actually returned type only has to be comparable to a Wasm type.
-    fn input_at(&self, at: u32) -> Option<ValType>;
-    /// Returns the type at given index if any.
-    ///
-    /// # Note
-    ///
-    /// The returned type may be wrapped by the user crate and thus
-    /// the actually returned type only has to be comparable to a Wasm type.
-    fn output_at(&self, at: u32) -> Option<ValType>;
-
-    /// Returns the list of inputs as an iterator.
-    fn inputs(&self) -> WasmFuncTypeInputs<'_, Self>
-    where
-        Self: Sized,
-    {
-        WasmFuncTypeInputs {
-            func_type: self,
-            range: 0..self.len_inputs() as u32,
-        }
-    }
-
-    /// Returns the list of outputs as an iterator.
-    fn outputs(&self) -> WasmFuncTypeOutputs<'_, Self>
-    where
-        Self: Sized,
-    {
-        WasmFuncTypeOutputs {
-            func_type: self,
-            range: 0..self.len_outputs() as u32,
-        }
-    }
-}
-
-impl<T> WasmFuncType for &'_ T
-where
-    T: ?Sized + WasmFuncType,
-{
-    fn len_inputs(&self) -> usize {
-        T::len_inputs(self)
-    }
-    fn len_outputs(&self) -> usize {
-        T::len_outputs(self)
-    }
-    fn input_at(&self, at: u32) -> Option<ValType> {
-        T::input_at(self, at)
-    }
-    fn output_at(&self, at: u32) -> Option<ValType> {
-        T::output_at(self, at)
-    }
-}
-
-/// Iterator over the inputs of a Wasm function type.
-pub struct WasmFuncTypeInputs<'a, T> {
-    /// The iterated-over function type.
-    func_type: &'a T,
-    /// The range we're iterating over.
-    range: Range<u32>,
-}
-
-impl<T> Iterator for WasmFuncTypeInputs<'_, T>
-where
-    T: WasmFuncType,
-{
-    type Item = crate::ValType;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.range
-            .next()
-            .map(|i| self.func_type.input_at(i).unwrap())
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.range.size_hint()
-    }
-}
-
-impl<T> DoubleEndedIterator for WasmFuncTypeInputs<'_, T>
-where
-    T: WasmFuncType,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.range
-            .next_back()
-            .map(|i| self.func_type.input_at(i).unwrap())
-    }
-}
-
-impl<T> ExactSizeIterator for WasmFuncTypeInputs<'_, T>
-where
-    T: WasmFuncType,
-{
-    fn len(&self) -> usize {
-        self.range.len()
-    }
-}
-
-impl<'a, T> Clone for WasmFuncTypeInputs<'a, T> {
-    fn clone(&self) -> WasmFuncTypeInputs<'a, T> {
-        WasmFuncTypeInputs {
-            func_type: self.func_type,
-            range: self.range.clone(),
-        }
-    }
-}
-
-/// Iterator over the outputs of a Wasm function type.
-pub struct WasmFuncTypeOutputs<'a, T> {
-    /// The iterated-over function type.
-    func_type: &'a T,
-    /// The range we're iterating over.
-    range: Range<u32>,
-}
-
-impl<T> Iterator for WasmFuncTypeOutputs<'_, T>
-where
-    T: WasmFuncType,
-{
-    type Item = crate::ValType;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.range
-            .next()
-            .map(|i| self.func_type.output_at(i).unwrap())
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.range.size_hint()
-    }
-}
-
-impl<T> DoubleEndedIterator for WasmFuncTypeOutputs<'_, T>
-where
-    T: WasmFuncType,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.range
-            .next_back()
-            .map(|i| self.func_type.output_at(i).unwrap())
-    }
-}
-
-impl<T> ExactSizeIterator for WasmFuncTypeOutputs<'_, T>
-where
-    T: WasmFuncType,
-{
-    fn len(&self) -> usize {
-        self.range.len()
-    }
-}
-
-impl<'a, T> Clone for WasmFuncTypeOutputs<'a, T> {
-    fn clone(&self) -> WasmFuncTypeOutputs<'a, T> {
-        WasmFuncTypeOutputs {
-            func_type: self.func_type,
-            range: self.range.clone(),
-        }
-    }
-}
-
-/// Types that qualify as Wasm validation database.
-///
-/// # Note
-///
-/// The `wasmparser` crate provides a builtin validation framework but allows
-/// users of this crate to also feed the parsed Wasm into their own data
-/// structure while parsing and also validate at the same time without
-/// the need of an additional parsing or validation step or copying data around.
-pub trait WasmModuleResources {
-    /// The function type used for validation.
-    type FuncType: WasmFuncType;
-
-    /// Returns the table at given index if any.
-    fn table_at(&self, at: u32) -> Option<TableType>;
-    /// Returns the linear memory at given index.
-    fn memory_at(&self, at: u32) -> Option<MemoryType>;
-    /// Returns the tag at given index.
-    fn tag_at(&self, at: u32) -> Option<&Self::FuncType>;
-    /// Returns the global variable at given index.
-    fn global_at(&self, at: u32) -> Option<GlobalType>;
-    /// Returns the `FuncType` associated with the given type index.
-    fn func_type_at(&self, type_idx: u32) -> Option<&Self::FuncType>;
-    /// Returns the type index associated with the given function
-    /// index. type_of_function = func_type_at(type_index_of_function)
-    fn type_index_of_function(&self, func_idx: u32) -> Option<u32>;
-    /// Returns the `FuncType` associated with the given function index.
-    fn type_of_function(&self, func_idx: u32) -> Option<&Self::FuncType>;
-    /// Returns the element type at the given index.
-    fn element_type_at(&self, at: u32) -> Option<RefType>;
-    /// Under the function references proposal, returns whether t1 <=
-    /// t2. Otherwise, returns whether t1 == t2
-    fn matches(&self, t1: ValType, t2: ValType) -> bool;
-    /// Check a value type. This requires using func_type_at to check references
-    fn check_value_type(
-        &self,
-        t: ValType,
-        features: &WasmFeatures,
-        offset: usize,
-    ) -> Result<(), BinaryReaderError>;
-
-    /// Checks that a `HeapType` is valid, notably its function index if one is
-    /// used.
-    fn check_heap_type(
-        &self,
-        heap_type: HeapType,
-        features: &WasmFeatures,
-        offset: usize,
-    ) -> Result<(), BinaryReaderError> {
-        // Delegate to the generic value type validation which will have the
-        // same validity checks.
-        self.check_value_type(
-            RefType::new(true, heap_type)
-                .ok_or_else(|| {
-                    BinaryReaderError::new(
-                        "heap type index beyond this crate's implementation limits",
-                        offset,
-                    )
-                })?
-                .into(),
-            features,
-            offset,
-        )
-    }
-
-    /// Returns the number of elements.
-    fn element_count(&self) -> u32;
-    /// Returns the number of bytes in the Wasm data section.
-    fn data_count(&self) -> Option<u32>;
-    /// Returns whether the function index is referenced in the module anywhere
-    /// outside of the start/function sections.
-    fn is_function_referenced(&self, idx: u32) -> bool;
-}
-
-impl<T> WasmModuleResources for &'_ T
-where
-    T: ?Sized + WasmModuleResources,
-{
-    type FuncType = T::FuncType;
-
-    fn table_at(&self, at: u32) -> Option<TableType> {
-        T::table_at(self, at)
-    }
-    fn memory_at(&self, at: u32) -> Option<MemoryType> {
-        T::memory_at(self, at)
-    }
-    fn tag_at(&self, at: u32) -> Option<&Self::FuncType> {
-        T::tag_at(self, at)
-    }
-    fn global_at(&self, at: u32) -> Option<GlobalType> {
-        T::global_at(self, at)
-    }
-    fn func_type_at(&self, at: u32) -> Option<&Self::FuncType> {
-        T::func_type_at(self, at)
-    }
-    fn type_index_of_function(&self, func_idx: u32) -> Option<u32> {
-        T::type_index_of_function(self, func_idx)
-    }
-    fn type_of_function(&self, func_idx: u32) -> Option<&Self::FuncType> {
-        T::type_of_function(self, func_idx)
-    }
-    fn check_value_type(
-        &self,
-        t: ValType,
-        features: &WasmFeatures,
-        offset: usize,
-    ) -> Result<(), BinaryReaderError> {
-        T::check_value_type(self, t, features, offset)
-    }
-    fn element_type_at(&self, at: u32) -> Option<RefType> {
-        T::element_type_at(self, at)
-    }
-    fn matches(&self, t1: ValType, t2: ValType) -> bool {
-        T::matches(self, t1, t2)
-    }
-
-    fn element_count(&self) -> u32 {
-        T::element_count(self)
-    }
-    fn data_count(&self) -> Option<u32> {
-        T::data_count(self)
-    }
-    fn is_function_referenced(&self, idx: u32) -> bool {
-        T::is_function_referenced(self, idx)
-    }
-}
-
-impl<T> WasmModuleResources for std::sync::Arc<T>
-where
-    T: WasmModuleResources,
-{
-    type FuncType = T::FuncType;
-
-    fn table_at(&self, at: u32) -> Option<TableType> {
-        T::table_at(self, at)
-    }
-
-    fn memory_at(&self, at: u32) -> Option<MemoryType> {
-        T::memory_at(self, at)
-    }
-
-    fn tag_at(&self, at: u32) -> Option<&Self::FuncType> {
-        T::tag_at(self, at)
-    }
-
-    fn global_at(&self, at: u32) -> Option<GlobalType> {
-        T::global_at(self, at)
-    }
-
-    fn func_type_at(&self, type_idx: u32) -> Option<&Self::FuncType> {
-        T::func_type_at(self, type_idx)
-    }
-
-    fn type_index_of_function(&self, func_idx: u32) -> Option<u32> {
-        T::type_index_of_function(self, func_idx)
-    }
-
-    fn type_of_function(&self, func_idx: u32) -> Option<&Self::FuncType> {
-        T::type_of_function(self, func_idx)
-    }
-
-    fn check_value_type(
-        &self,
-        t: ValType,
-        features: &WasmFeatures,
-        offset: usize,
-    ) -> Result<(), BinaryReaderError> {
-        T::check_value_type(self, t, features, offset)
-    }
-
-    fn element_type_at(&self, at: u32) -> Option<RefType> {
-        T::element_type_at(self, at)
-    }
-
-    fn matches(&self, t1: ValType, t2: ValType) -> bool {
-        T::matches(self, t1, t2)
-    }
-
-    fn element_count(&self) -> u32 {
-        T::element_count(self)
-    }
-
-    fn data_count(&self) -> Option<u32> {
-        T::data_count(self)
-    }
-
-    fn is_function_referenced(&self, idx: u32) -> bool {
-        T::is_function_referenced(self, idx)
-    }
-}
-
-impl WasmFuncType for FuncType {
-    fn len_inputs(&self) -> usize {
-        self.params().len()
-    }
-
-    fn len_outputs(&self) -> usize {
-        self.results().len()
-    }
-
-    fn input_at(&self, at: u32) -> Option<ValType> {
-        self.params().get(at as usize).copied()
-    }
-
-    fn output_at(&self, at: u32) -> Option<ValType> {
-        self.results().get(at as usize).copied()
-    }
-}