wasmtime 15.0.1 → 16.0.0

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

@@ -1,354 +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, ValType};
-
-/// Represents a block type.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum BlockType {
-    /// The block produces consumes nor produces any values.
-    Empty,
-    /// The block produces a singular value of the given type ([] -> \[t]).
-    Type(ValType),
-    /// The block is described by a function type.
-    ///
-    /// The index is to a function type in the types section.
-    FuncType(u32),
-}
-
-/// Represents a memory immediate in a WebAssembly memory instruction.
-#[derive(Debug, Copy, Clone)]
-pub struct MemArg {
-    /// Alignment, stored as `n` where the actual alignment is `2^n`
-    pub align: u8,
-    /// Maximum alignment, stored as `n` where the actual alignment is `2^n`.
-    ///
-    /// Note that this field is not actually read from the binary format, it
-    /// will be a constant depending on which instruction this `MemArg` is a
-    /// payload for.
-    pub max_align: u8,
-    /// A fixed byte-offset that this memory immediate specifies.
-    ///
-    /// Note that the memory64 proposal can specify a full 64-bit byte offset
-    /// while otherwise only 32-bit offsets are allowed. Once validated
-    /// memory immediates for 32-bit memories are guaranteed to be at most
-    /// `u32::MAX` whereas 64-bit memories can use the full 64-bits.
-    pub offset: u64,
-    /// The index of the memory this immediate points to.
-    ///
-    /// Note that this points within the module's own memory index space, and
-    /// is always zero unless the multi-memory proposal of WebAssembly is
-    /// enabled.
-    pub memory: u32,
-}
-
-/// A br_table entries representation.
-#[derive(Clone)]
-pub struct BrTable<'a> {
-    pub(crate) reader: crate::BinaryReader<'a>,
-    pub(crate) cnt: u32,
-    pub(crate) default: u32,
-}
-
-/// An IEEE binary32 immediate floating point value, represented as a u32
-/// containing the bit pattern.
-///
-/// All bit patterns are allowed.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct Ieee32(pub(crate) u32);
-
-impl Ieee32 {
-    /// Gets the underlying bits of the 32-bit float.
-    pub fn bits(self) -> u32 {
-        self.0
-    }
-}
-
-/// An IEEE binary64 immediate floating point value, represented as a u64
-/// containing the bit pattern.
-///
-/// All bit patterns are allowed.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct Ieee64(pub(crate) u64);
-
-impl Ieee64 {
-    /// Gets the underlying bits of the 64-bit float.
-    pub fn bits(self) -> u64 {
-        self.0
-    }
-}
-
-/// Represents a 128-bit vector value.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct V128(pub(crate) [u8; 16]);
-
-impl V128 {
-    /// Gets the bytes of the vector value.
-    pub fn bytes(&self) -> &[u8; 16] {
-        &self.0
-    }
-
-    /// Gets a signed 128-bit integer value from the vector's bytes.
-    pub fn i128(&self) -> i128 {
-        i128::from_le_bytes(self.0)
-    }
-}
-
-macro_rules! define_operator {
-    ($(@$proposal:ident $op:ident $({ $($payload:tt)* })? => $visit:ident)*) => {
-        /// Instructions as defined [here].
-        ///
-        /// [here]: https://webassembly.github.io/spec/core/binary/instructions.html
-        #[derive(Debug, Clone)]
-        #[allow(missing_docs)]
-        pub enum Operator<'a> {
-            $(
-                $op $({ $($payload)* })?,
-            )*
-        }
-    }
-}
-for_each_operator!(define_operator);
-
-/// A reader for a core WebAssembly function's operators.
-#[derive(Clone)]
-pub struct OperatorsReader<'a> {
-    pub(crate) reader: BinaryReader<'a>,
-}
-
-impl<'a> OperatorsReader<'a> {
-    pub(crate) fn new(reader: BinaryReader<'a>) -> OperatorsReader<'a> {
-        OperatorsReader { reader }
-    }
-
-    /// Determines if the reader is at the end of the operators.
-    pub fn eof(&self) -> bool {
-        self.reader.eof()
-    }
-
-    /// Gets the original position of the reader.
-    pub fn original_position(&self) -> usize {
-        self.reader.original_position()
-    }
-
-    /// Whether or not to allow 64-bit memory arguments in the
-    /// the operators being read.
-    ///
-    /// This is intended to be `true` when support for the memory64
-    /// WebAssembly proposal is also enabled.
-    pub fn allow_memarg64(&mut self, allow: bool) {
-        self.reader.allow_memarg64(allow);
-    }
-
-    /// Ensures the reader is at the end.
-    ///
-    /// This function returns an error if there is extra data after the operators.
-    pub fn ensure_end(&self) -> Result<()> {
-        if self.eof() {
-            return Ok(());
-        }
-        Err(BinaryReaderError::new(
-            "unexpected data at the end of operators",
-            self.reader.original_position(),
-        ))
-    }
-
-    /// Reads an operator from the reader.
-    pub fn read(&mut self) -> Result<Operator<'a>> {
-        self.reader.read_operator()
-    }
-
-    /// Converts to an iterator of operators paired with offsets.
-    pub fn into_iter_with_offsets(self) -> OperatorsIteratorWithOffsets<'a> {
-        OperatorsIteratorWithOffsets {
-            reader: self,
-            err: false,
-        }
-    }
-
-    /// Reads an operator with its offset.
-    pub fn read_with_offset(&mut self) -> Result<(Operator<'a>, usize)> {
-        let pos = self.reader.original_position();
-        Ok((self.read()?, pos))
-    }
-
-    /// Visit a single operator with the specified [`VisitOperator`] instance.
-    ///
-    /// See [`BinaryReader::visit_operator`] for more information.
-    pub fn visit_operator<T>(&mut self, visitor: &mut T) -> Result<<T as VisitOperator<'a>>::Output>
-    where
-        T: VisitOperator<'a>,
-    {
-        self.reader.visit_operator(visitor)
-    }
-
-    /// Gets a binary reader from this operators reader.
-    pub fn get_binary_reader(&self) -> BinaryReader<'a> {
-        self.reader.clone()
-    }
-}
-
-impl<'a> IntoIterator for OperatorsReader<'a> {
-    type Item = Result<Operator<'a>>;
-    type IntoIter = OperatorsIterator<'a>;
-
-    /// Reads content of the code section.
-    ///
-    /// # Examples
-    /// ```
-    /// use wasmparser::{Operator, CodeSectionReader, Result};
-    /// # let data: &[u8] = &[
-    /// #     0x01, 0x03, 0x00, 0x01, 0x0b];
-    /// let code_reader = CodeSectionReader::new(data, 0).unwrap();
-    /// for body in code_reader {
-    ///     let body = body.expect("function body");
-    ///     let mut op_reader = body.get_operators_reader().expect("op reader");
-    ///     let ops = op_reader.into_iter().collect::<Result<Vec<Operator>>>().expect("ops");
-    ///     assert!(
-    ///         if let [Operator::Nop, Operator::End] = ops.as_slice() { true } else { false },
-    ///         "found {:?}",
-    ///         ops
-    ///     );
-    /// }
-    /// ```
-    fn into_iter(self) -> Self::IntoIter {
-        OperatorsIterator {
-            reader: self,
-            err: false,
-        }
-    }
-}
-
-/// An iterator over a function's operators.
-pub struct OperatorsIterator<'a> {
-    reader: OperatorsReader<'a>,
-    err: bool,
-}
-
-impl<'a> Iterator for OperatorsIterator<'a> {
-    type Item = Result<Operator<'a>>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.err || self.reader.eof() {
-            return None;
-        }
-        let result = self.reader.read();
-        self.err = result.is_err();
-        Some(result)
-    }
-}
-
-/// An iterator over a function's operators with offsets.
-pub struct OperatorsIteratorWithOffsets<'a> {
-    reader: OperatorsReader<'a>,
-    err: bool,
-}
-
-impl<'a> Iterator for OperatorsIteratorWithOffsets<'a> {
-    type Item = Result<(Operator<'a>, usize)>;
-
-    /// Reads content of the code section with offsets.
-    ///
-    /// # Examples
-    /// ```
-    /// use wasmparser::{Operator, CodeSectionReader, Result};
-    /// # let data: &[u8] = &[
-    /// #     0x01, 0x03, 0x00, /* offset = 23 */ 0x01, 0x0b];
-    /// let code_reader = CodeSectionReader::new(data, 20).unwrap();
-    /// for body in code_reader {
-    ///     let body = body.expect("function body");
-    ///     let mut op_reader = body.get_operators_reader().expect("op reader");
-    ///     let ops = op_reader.into_iter_with_offsets().collect::<Result<Vec<(Operator, usize)>>>().expect("ops");
-    ///     assert!(
-    ///         if let [(Operator::Nop, 23), (Operator::End, 24)] = ops.as_slice() { true } else { false },
-    ///         "found {:?}",
-    ///         ops
-    ///     );
-    /// }
-    /// ```
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.err || self.reader.eof() {
-            return None;
-        }
-        let result = self.reader.read_with_offset();
-        self.err = result.is_err();
-        Some(result)
-    }
-}
-
-macro_rules! define_visit_operator {
-    ($(@$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
-        $(
-            fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output;
-        )*
-    }
-}
-
-/// Trait implemented by types that can visit all [`Operator`] variants.
-#[allow(missing_docs)]
-pub trait VisitOperator<'a> {
-    /// The result type of the visitor.
-    type Output: 'a;
-
-    /// Visits the [`Operator`] `op` using the given `offset`.
-    ///
-    /// # Note
-    ///
-    /// This is a convenience method that is intended for non-performance
-    /// critical use cases. For performance critical implementations users
-    /// are recommended to directly use the respective `visit` methods or
-    /// implement [`VisitOperator`] on their own.
-    fn visit_operator(&mut self, op: &Operator<'a>) -> Self::Output {
-        macro_rules! visit_operator {
-            ($(@$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
-                match op {
-                    $(
-                        Operator::$op $({ $($arg),* })? => self.$visit($($($arg.clone()),*)?),
-                    )*
-                }
-            }
-
-        }
-        for_each_operator!(visit_operator)
-    }
-
-    for_each_operator!(define_visit_operator);
-}
-
-macro_rules! define_visit_operator_delegate {
-    ($(@$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
-        $(
-            fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output {
-                V::$visit(&mut *self, $($($arg),*)?)
-            }
-        )*
-    }
-}
-
-impl<'a, 'b, V: VisitOperator<'a> + ?Sized> VisitOperator<'a> for &'b mut V {
-    type Output = V::Output;
-    fn visit_operator(&mut self, op: &Operator<'a>) -> Self::Output {
-        V::visit_operator(*self, op)
-    }
-    for_each_operator!(define_visit_operator_delegate);
-}
-
-impl<'a, V: VisitOperator<'a> + ?Sized> VisitOperator<'a> for Box<V> {
-    type Output = V::Output;
-    fn visit_operator(&mut self, op: &Operator<'a>) -> Self::Output {
-        V::visit_operator(&mut *self, op)
-    }
-    for_each_operator!(define_visit_operator_delegate);
-}

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

@@ -1,83 +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::{BinaryReader, FromReader, Result, SectionLimited};
-
-/// A reader for the producers custom section of a WebAssembly module.
-///
-/// # Examples
-///
-/// ```
-/// # let data: &[u8] = &[0x01, 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65,
-/// #     0x02, 0x03, 0x77, 0x61, 0x74, 0x01, 0x31, 0x01, 0x43, 0x03, 0x39, 0x2e, 0x30];
-/// use wasmparser::{ProducersSectionReader, ProducersFieldValue, Result};
-/// let reader = ProducersSectionReader::new(data, 0).expect("producers reader");
-/// let field = reader.into_iter().next().unwrap().expect("producers field");
-/// assert!(field.name == "language");
-/// let value = field.values.into_iter().collect::<Result<Vec<_>>>().expect("values");
-/// assert!(value.len() == 2);
-/// assert!(value[0].name == "wat" && value[0].version == "1");
-/// assert!(value[1].name == "C" && value[1].version == "9.0");
-/// ```
-pub type ProducersSectionReader<'a> = SectionLimited<'a, ProducersField<'a>>;
-
-/// A field from the producers custom section.
-#[derive(Debug, Clone)]
-pub struct ProducersField<'a> {
-    /// The name of the field.
-    pub name: &'a str,
-    /// The values specified for this field
-    pub values: SectionLimited<'a, ProducersFieldValue<'a>>,
-}
-
-impl<'a> FromReader<'a> for ProducersField<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let offset = reader.original_position();
-        let name = reader.read_string()?;
-        match name {
-            "language" | "sdk" | "processed-by" => {}
-            _ => bail!(offset, "invalid producers field name: `{name}`"),
-        }
-        let values = reader.skip(|reader| {
-            // FIXME(#188) ideally shouldn't need to skip here
-            for _ in 0..reader.read_var_u32()? {
-                reader.skip_string()?;
-                reader.skip_string()?;
-            }
-            Ok(())
-        })?;
-        Ok(ProducersField {
-            name,
-            values: SectionLimited::new(values.remaining_buffer(), values.original_position())?,
-        })
-    }
-}
-
-/// Represents a field value in the producers custom section.
-#[derive(Debug, Copy, Clone)]
-pub struct ProducersFieldValue<'a> {
-    /// The field name.
-    pub name: &'a str,
-    /// The field version.
-    pub version: &'a str,
-}
-
-impl<'a> FromReader<'a> for ProducersFieldValue<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let name = reader.read_string()?;
-        let version = reader.read_string()?;
-        Ok(ProducersFieldValue { name, version })
-    }
-}

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

@@ -1,87 +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, ConstExpr, FromReader, Result, SectionLimited, TableType};
-
-/// A reader for the table section of a WebAssembly module.
-pub type TableSectionReader<'a> = SectionLimited<'a, Table<'a>>;
-
-/// Type information about a table defined in the table section of a WebAssembly
-/// module.
-#[derive(Debug)]
-pub struct Table<'a> {
-    /// The type of this table, including its element type and its limits.
-    pub ty: TableType,
-    /// The initialization expression for the table.
-    pub init: TableInit<'a>,
-}
-
-/// Different modes of initializing a table.
-#[derive(Debug)]
-pub enum TableInit<'a> {
-    /// The table is initialized to all null elements.
-    RefNull,
-    /// Each element in the table is initialized with the specified constant
-    /// expression.
-    Expr(ConstExpr<'a>),
-}
-
-impl<'a> FromReader<'a> for Table<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let has_init_expr = if reader.peek()? == 0x40 {
-            reader.read_u8()?;
-            true
-        } else {
-            false
-        };
-
-        if has_init_expr {
-            if reader.read_u8()? != 0x00 {
-                bail!(reader.original_position() - 1, "invalid table encoding");
-            }
-        }
-
-        let ty = reader.read::<TableType>()?;
-        let init = if has_init_expr {
-            TableInit::Expr(reader.read()?)
-        } else {
-            TableInit::RefNull
-        };
-        Ok(Table { ty, init })
-    }
-}
-
-impl<'a> FromReader<'a> for TableType {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let element_type = reader.read()?;
-        let has_max = match reader.read_u8()? {
-            0x00 => false,
-            0x01 => true,
-            _ => {
-                bail!(
-                    reader.original_position() - 1,
-                    "invalid table resizable limits flags",
-                )
-            }
-        };
-        let initial = reader.read()?;
-        let maximum = if has_max { Some(reader.read()?) } else { None };
-        Ok(TableType {
-            element_type,
-            initial,
-            maximum,
-        })
-    }
-}

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

@@ -1,32 +0,0 @@
-/* Copyright 2020 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, FromReader, Result, SectionLimited, TagKind, TagType};
-
-/// A reader for the tags section of a WebAssembly module.
-pub type TagSectionReader<'a> = SectionLimited<'a, TagType>;
-
-impl<'a> FromReader<'a> for TagType {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let attribute = reader.read_u8()?;
-        if attribute != 0 {
-            bail!(reader.original_position() - 1, "invalid tag attributes");
-        }
-        Ok(TagType {
-            kind: TagKind::Exception,
-            func_type_idx: reader.read_var_u32()?,
-        })
-    }
-}