wasmtime 15.0.1 → 16.0.0

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

@@ -1,152 +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, ConstExpr, ExternalKind, FromReader, RefType, Result,
-    SectionLimited,
-};
-use std::ops::Range;
-
-/// Represents a core WebAssembly element segment.
-#[derive(Clone)]
-pub struct Element<'a> {
-    /// The kind of the element segment.
-    pub kind: ElementKind<'a>,
-    /// The initial elements of the element segment.
-    pub items: ElementItems<'a>,
-    /// The range of the the element segment.
-    pub range: Range<usize>,
-}
-
-/// The kind of element segment.
-#[derive(Clone)]
-pub enum ElementKind<'a> {
-    /// The element segment is passive.
-    Passive,
-    /// The element segment is active.
-    Active {
-        /// The index of the table being initialized.
-        table_index: Option<u32>,
-        /// The initial expression of the element segment.
-        offset_expr: ConstExpr<'a>,
-    },
-    /// The element segment is declared.
-    Declared,
-}
-
-/// Represents the items of an element segment.
-#[derive(Clone)]
-pub enum ElementItems<'a> {
-    /// This element contains function indices.
-    Functions(SectionLimited<'a, u32>),
-    /// This element contains constant expressions used to initialize the table.
-    Expressions(RefType, SectionLimited<'a, ConstExpr<'a>>),
-}
-
-/// A reader for the element section of a WebAssembly module.
-pub type ElementSectionReader<'a> = SectionLimited<'a, Element<'a>>;
-
-impl<'a> FromReader<'a> for Element<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let elem_start = reader.original_position();
-        // The current handling of the flags is largely specified in the `bulk-memory` proposal,
-        // which at the time this commend is written has been merged to the main specification
-        // draft.
-        //
-        // Notably, this proposal allows multiple different encodings of the table index 0. `00`
-        // and `02 00` are both valid ways to specify the 0-th table. However it also makes
-        // another encoding of the 0-th memory `80 00` no longer valid.
-        //
-        // We, however maintain this support by parsing `flags` as a LEB128 integer. In that case,
-        // `80 00` encoding is parsed out as `0` and is therefore assigned a `tableidx` 0, even
-        // though the current specification draft does not allow for this.
-        //
-        // See also https://github.com/WebAssembly/spec/issues/1439
-        let flags = reader.read_var_u32()?;
-        if (flags & !0b111) != 0 {
-            return Err(BinaryReaderError::new(
-                "invalid flags byte in element segment",
-                reader.original_position() - 1,
-            ));
-        }
-        let kind = if flags & 0b001 != 0 {
-            if flags & 0b010 != 0 {
-                ElementKind::Declared
-            } else {
-                ElementKind::Passive
-            }
-        } else {
-            let table_index = if flags & 0b010 == 0 {
-                None
-            } else {
-                Some(reader.read_var_u32()?)
-            };
-            let offset_expr = reader.read()?;
-            ElementKind::Active {
-                table_index,
-                offset_expr,
-            }
-        };
-        let exprs = flags & 0b100 != 0;
-        let ty = if flags & 0b011 != 0 {
-            if exprs {
-                Some(reader.read()?)
-            } else {
-                match reader.read()? {
-                    ExternalKind::Func => None,
-                    _ => {
-                        return Err(BinaryReaderError::new(
-                            "only the function external type is supported in elem segment",
-                            reader.original_position() - 1,
-                        ));
-                    }
-                }
-            }
-        } else {
-            None
-        };
-        // FIXME(#188) ideally wouldn't have to do skips here
-        let data = reader.skip(|reader| {
-            let items_count = reader.read_var_u32()?;
-            if exprs {
-                for _ in 0..items_count {
-                    reader.skip_const_expr()?;
-                }
-            } else {
-                for _ in 0..items_count {
-                    reader.read_var_u32()?;
-                }
-            }
-            Ok(())
-        })?;
-        let items = if exprs {
-            ElementItems::Expressions(
-                ty.unwrap_or(RefType::FUNCREF),
-                SectionLimited::new(data.remaining_buffer(), data.original_position())?,
-            )
-        } else {
-            assert!(ty.is_none());
-            ElementItems::Functions(SectionLimited::new(
-                data.remaining_buffer(),
-                data.original_position(),
-            )?)
-        };
-
-        let elem_end = reader.original_position();
-        let range = elem_start..elem_end;
-
-        Ok(Element { kind, items, range })
-    }
-}

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

@@ -1,65 +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, FromReader, Result, SectionLimited};
-
-/// A reader for the export section of a WebAssembly module.
-pub type ExportSectionReader<'a> = SectionLimited<'a, Export<'a>>;
-
-/// External types as defined [here].
-///
-/// [here]: https://webassembly.github.io/spec/core/syntax/types.html#external-types
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ExternalKind {
-    /// The external kind is a function.
-    Func,
-    /// The external kind if a table.
-    Table,
-    /// The external kind is a memory.
-    Memory,
-    /// The external kind is a global.
-    Global,
-    /// The external kind is a tag.
-    Tag,
-}
-
-/// Represents an export in a WebAssembly module.
-#[derive(Debug, Copy, Clone)]
-pub struct Export<'a> {
-    /// The name of the exported item.
-    pub name: &'a str,
-    /// The kind of the export.
-    pub kind: ExternalKind,
-    /// The index of the exported item.
-    pub index: u32,
-}
-
-impl<'a> FromReader<'a> for Export<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(Export {
-            name: reader.read_string()?,
-            kind: reader.read()?,
-            index: reader.read_var_u32()?,
-        })
-    }
-}
-
-impl<'a> FromReader<'a> for ExternalKind {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let offset = reader.original_position();
-        let byte = reader.read_u8()?;
-        BinaryReader::external_kind_from_byte(byte, offset)
-    }
-}

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

@@ -1,17 +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.
- */
-
-/// A reader for the function section of a WebAssembly module.
-pub type FunctionSectionReader<'a> = crate::SectionLimited<'a, u32>;

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

@@ -1,49 +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, GlobalType, Result, SectionLimited};
-
-/// Represents a core WebAssembly global.
-#[derive(Debug, Copy, Clone)]
-pub struct Global<'a> {
-    /// The global's type.
-    pub ty: GlobalType,
-    /// The global's initialization expression.
-    pub init_expr: ConstExpr<'a>,
-}
-
-/// A reader for the global section of a WebAssembly module.
-pub type GlobalSectionReader<'a> = SectionLimited<'a, Global<'a>>;
-
-impl<'a> FromReader<'a> for Global<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let ty = reader.read()?;
-        let init_expr = reader.read()?;
-        Ok(Global { ty, init_expr })
-    }
-}
-
-impl<'a> FromReader<'a> for GlobalType {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(GlobalType {
-            content_type: reader.read()?,
-            mutable: match reader.read_u8()? {
-                0x00 => false,
-                0x01 => true,
-                _ => bail!(reader.original_position() - 1, "malformed mutability",),
-            },
-        })
-    }
-}

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

@@ -1,76 +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, ExternalKind, FromReader, GlobalType, MemoryType, Result, SectionLimited,
-    TableType, TagType,
-};
-
-/// Represents a reference to a type definition in a WebAssembly module.
-#[derive(Debug, Clone, Copy)]
-pub enum TypeRef {
-    /// The type is a function.
-    ///
-    /// The value is an index into the type section.
-    Func(u32),
-    /// The type is a table.
-    Table(TableType),
-    /// The type is a memory.
-    Memory(MemoryType),
-    /// The type is a global.
-    Global(GlobalType),
-    /// The type is a tag.
-    ///
-    /// This variant is only used for the exception handling proposal.
-    ///
-    /// The value is an index in the types index space.
-    Tag(TagType),
-}
-
-/// Represents an import in a WebAssembly module.
-#[derive(Debug, Copy, Clone)]
-pub struct Import<'a> {
-    /// The module being imported from.
-    pub module: &'a str,
-    /// The name of the imported item.
-    pub name: &'a str,
-    /// The type of the imported item.
-    pub ty: TypeRef,
-}
-
-/// A reader for the import section of a WebAssembly module.
-pub type ImportSectionReader<'a> = SectionLimited<'a, Import<'a>>;
-
-impl<'a> FromReader<'a> for Import<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(Import {
-            module: reader.read()?,
-            name: reader.read()?,
-            ty: reader.read()?,
-        })
-    }
-}
-
-impl<'a> FromReader<'a> for TypeRef {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read()? {
-            ExternalKind::Func => TypeRef::Func(reader.read_var_u32()?),
-            ExternalKind::Table => TypeRef::Table(reader.read()?),
-            ExternalKind::Memory => TypeRef::Memory(reader.read()?),
-            ExternalKind::Global => TypeRef::Global(reader.read()?),
-            ExternalKind::Tag => TypeRef::Tag(reader.read()?),
-        })
-    }
-}

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

@@ -1,51 +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, FromReader, OperatorsReader, Result};
-
-/// Represents an initialization expression.
-#[derive(Debug, Copy, Clone)]
-pub struct ConstExpr<'a> {
-    offset: usize,
-    data: &'a [u8],
-}
-
-impl<'a> ConstExpr<'a> {
-    /// Constructs a new `ConstExpr` from the given data and offset.
-    pub fn new(data: &[u8], offset: usize) -> ConstExpr {
-        ConstExpr { offset, data }
-    }
-
-    /// Gets a binary reader for the initialization expression.
-    pub fn get_binary_reader(&self) -> BinaryReader<'a> {
-        BinaryReader::new_with_offset(self.data, self.offset)
-    }
-
-    /// Gets an operators reader for the initialization expression.
-    pub fn get_operators_reader(&self) -> OperatorsReader<'a> {
-        OperatorsReader::new(self.get_binary_reader())
-    }
-}
-
-impl<'a> FromReader<'a> for ConstExpr<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        // FIXME(#188) ideally shouldn't need to skip here
-        let reader = reader.skip(|r| r.skip_const_expr())?;
-        Ok(ConstExpr::new(
-            reader.remaining_buffer(),
-            reader.original_position(),
-        ))
-    }
-}

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

@@ -1,56 +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, FromReader, MemoryType, Result, SectionLimited};
-
-/// A reader for the memory section of a WebAssembly module.
-pub type MemorySectionReader<'a> = SectionLimited<'a, MemoryType>;
-
-impl<'a> FromReader<'a> for MemoryType {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let pos = reader.original_position();
-        let flags = reader.read_u8()?;
-        if (flags & !0b111) != 0 {
-            bail!(pos, "invalid memory limits flags");
-        }
-
-        let memory64 = flags & 0b100 != 0;
-        let shared = flags & 0b010 != 0;
-        let has_max = flags & 0b001 != 0;
-        Ok(MemoryType {
-            memory64,
-            shared,
-            // FIXME(WebAssembly/memory64#21) as currently specified if the
-            // `shared` flag is set we should be reading a 32-bit limits field
-            // here. That seems a bit odd to me at the time of this writing so
-            // I've taken the liberty of reading a 64-bit limits field in those
-            // situations. I suspect that this is a typo in the spec, but if not
-            // we'll need to update this to read a 32-bit limits field when the
-            // shared flag is set.
-            initial: if memory64 {
-                reader.read_var_u64()?
-            } else {
-                reader.read_var_u32()?.into()
-            },
-            maximum: if !has_max {
-                None
-            } else if memory64 {
-                Some(reader.read_var_u64()?)
-            } else {
-                Some(reader.read_var_u32()?.into())
-            },
-        })
-    }
-}

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

@@ -1,153 +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, FromReader, Result, SectionLimited, Subsection, Subsections,
-};
-use std::ops::Range;
-
-/// Represents a name map from the names custom section.
-pub type NameMap<'a> = SectionLimited<'a, Naming<'a>>;
-
-/// Represents a name for an index from the names section.
-#[derive(Debug, Copy, Clone)]
-pub struct Naming<'a> {
-    /// The index being named.
-    pub index: u32,
-    /// The name for the index.
-    pub name: &'a str,
-}
-
-impl<'a> FromReader<'a> for Naming<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let index = reader.read_var_u32()?;
-        let name = reader.read_string()?;
-        Ok(Naming { index, name })
-    }
-}
-
-/// Represents a reader for indirect names from the names custom section.
-pub type IndirectNameMap<'a> = SectionLimited<'a, IndirectNaming<'a>>;
-
-/// Represents an indirect name in the names custom section.
-#[derive(Debug, Clone)]
-pub struct IndirectNaming<'a> {
-    /// The indirect index of the name.
-    pub index: u32,
-    /// The map of names within the `index` prior.
-    pub names: NameMap<'a>,
-}
-
-impl<'a> FromReader<'a> for IndirectNaming<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let index = reader.read_var_u32()?;
-
-        // Skip the `NameMap` manually here.
-        //
-        // FIXME(#188) shouldn't need to skip here
-        let names = reader.skip(|reader| {
-            let count = reader.read_var_u32()?;
-            for _ in 0..count {
-                reader.read_var_u32()?;
-                reader.skip_string()?;
-            }
-            Ok(())
-        })?;
-
-        Ok(IndirectNaming {
-            index,
-            names: NameMap::new(names.remaining_buffer(), names.original_position())?,
-        })
-    }
-}
-
-/// Represents a name read from the names custom section.
-#[derive(Clone)]
-pub enum Name<'a> {
-    /// The name is for the module.
-    Module {
-        /// The specified name.
-        name: &'a str,
-        /// The byte range that `name` occupies in the original binary.
-        name_range: Range<usize>,
-    },
-    /// The name is for the functions.
-    Function(NameMap<'a>),
-    /// The name is for the function locals.
-    Local(IndirectNameMap<'a>),
-    /// The name is for the function labels.
-    Label(IndirectNameMap<'a>),
-    /// The name is for the types.
-    Type(NameMap<'a>),
-    /// The name is for the tables.
-    Table(NameMap<'a>),
-    /// The name is for the memories.
-    Memory(NameMap<'a>),
-    /// The name is for the globals.
-    Global(NameMap<'a>),
-    /// The name is for the element segments.
-    Element(NameMap<'a>),
-    /// The name is for the data segments.
-    Data(NameMap<'a>),
-    /// An unknown [name subsection](https://webassembly.github.io/spec/core/appendix/custom.html#subsections).
-    Unknown {
-        /// The identifier for this subsection.
-        ty: u8,
-        /// The contents of this subsection.
-        data: &'a [u8],
-        /// The range of bytes, relative to the start of the original data
-        /// stream, that the contents of this subsection reside in.
-        range: Range<usize>,
-    },
-}
-
-/// A reader for the name custom section of a WebAssembly module.
-pub type NameSectionReader<'a> = Subsections<'a, Name<'a>>;
-
-impl<'a> Subsection<'a> for Name<'a> {
-    fn from_reader(id: u8, mut reader: BinaryReader<'a>) -> Result<Self> {
-        let data = reader.remaining_buffer();
-        let offset = reader.original_position();
-        Ok(match id {
-            0 => {
-                let name = reader.read_string()?;
-                if !reader.eof() {
-                    return Err(BinaryReaderError::new(
-                        "trailing data at the end of a name",
-                        reader.original_position(),
-                    ));
-                }
-                Name::Module {
-                    name,
-                    name_range: offset..offset + reader.position,
-                }
-            }
-            1 => Name::Function(NameMap::new(data, offset)?),
-            2 => Name::Local(IndirectNameMap::new(data, offset)?),
-            3 => Name::Label(IndirectNameMap::new(data, offset)?),
-            4 => Name::Type(NameMap::new(data, offset)?),
-            5 => Name::Table(NameMap::new(data, offset)?),
-            6 => Name::Memory(NameMap::new(data, offset)?),
-            7 => Name::Global(NameMap::new(data, offset)?),
-            8 => Name::Element(NameMap::new(data, offset)?),
-            9 => Name::Data(NameMap::new(data, offset)?),
-            ty => Name::Unknown {
-                ty,
-                data,
-                range: offset..offset + data.len(),
-            },
-        })
-    }
-}