wasmtime 14.0.3 → 14.0.4

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/elements.rs

@@ -0,0 +1,220 @@
+use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
+
+/// An encoder for the element section.
+///
+/// Element sections are only supported for modules.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{
+///     Elements, ElementSection, Module, TableSection, TableType,
+///     RefType, ConstExpr
+/// };
+///
+/// let mut tables = TableSection::new();
+/// tables.table(TableType {
+///     element_type: RefType::FUNCREF,
+///     minimum: 128,
+///     maximum: None,
+/// });
+///
+/// let mut elements = ElementSection::new();
+/// let table_index = 0;
+/// let offset = ConstExpr::i32_const(42);
+/// let functions = Elements::Functions(&[
+///     // Function indices...
+/// ]);
+/// elements.active(Some(table_index), &offset, functions);
+///
+/// let mut module = Module::new();
+/// module
+///     .section(&tables)
+///     .section(&elements);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Default, Debug)]
+pub struct ElementSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+/// A sequence of elements in a segment in the element section.
+#[derive(Clone, Copy, Debug)]
+pub enum Elements<'a> {
+    /// A sequences of references to functions by their indices.
+    Functions(&'a [u32]),
+    /// A sequence of reference expressions.
+    Expressions(RefType, &'a [ConstExpr]),
+}
+
+/// An element segment's mode.
+#[derive(Clone, Debug)]
+pub enum ElementMode<'a> {
+    /// A passive element segment.
+    ///
+    /// Passive segments are part of the bulk memory proposal.
+    Passive,
+    /// A declared element segment.
+    ///
+    /// Declared segments are part of the bulk memory proposal.
+    Declared,
+    /// An active element segment.
+    Active {
+        /// The table index.
+        ///
+        /// `Active` element specifying a `None` table forces the MVP encoding and refers to the
+        /// 0th table holding `funcref`s. Non-`None` tables use the encoding introduced with the
+        /// bulk memory proposal and can refer to tables with any valid reference type.
+        table: Option<u32>,
+        /// The offset within the table to place this segment.
+        offset: &'a ConstExpr,
+    },
+}
+
+/// An element segment in the element section.
+#[derive(Clone, Debug)]
+pub struct ElementSegment<'a> {
+    /// The element segment's mode.
+    pub mode: ElementMode<'a>,
+    /// This segment's elements.
+    pub elements: Elements<'a>,
+}
+
+impl ElementSection {
+    /// Create a new element section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of element segments 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 an element segment.
+    pub fn segment<'a>(&mut self, segment: ElementSegment<'a>) -> &mut Self {
+        let expr_bit = match segment.elements {
+            Elements::Expressions(..) => 0b100u32,
+            Elements::Functions(_) => 0b000u32,
+        };
+        let mut encode_type = false;
+        match &segment.mode {
+            ElementMode::Passive => {
+                (0x01 | expr_bit).encode(&mut self.bytes);
+                encode_type = true;
+            }
+            ElementMode::Active { table, offset } => {
+                match (table, &segment.elements) {
+                    // If the `table` is not specified then the 0x00 encoding
+                    // can be used with either function indices or expressions
+                    // that have a `funcref` type.
+                    (None, Elements::Functions(_) | Elements::Expressions(RefType::FUNCREF, _)) => {
+                        (/* 0x00 | */expr_bit).encode(&mut self.bytes);
+                    }
+
+                    // ... otherwise fall through for all other expressions here
+                    // with table 0 or an explicitly specified table to the 0x02
+                    // encoding.
+                    (None, Elements::Expressions(..)) | (Some(_), _) => {
+                        (0x02 | expr_bit).encode(&mut self.bytes);
+                        table.unwrap_or(0).encode(&mut self.bytes);
+                        encode_type = true;
+                    }
+                }
+                offset.encode(&mut self.bytes);
+            }
+            ElementMode::Declared => {
+                (0x03 | expr_bit).encode(&mut self.bytes);
+                encode_type = true;
+            }
+        }
+
+        match segment.elements {
+            Elements::Functions(fs) => {
+                if encode_type {
+                    // elemkind == funcref
+                    self.bytes.push(0x00);
+                }
+                fs.encode(&mut self.bytes);
+            }
+            Elements::Expressions(ty, e) => {
+                if encode_type {
+                    ty.encode(&mut self.bytes);
+                }
+                e.len().encode(&mut self.bytes);
+                for expr in e {
+                    expr.encode(&mut self.bytes);
+                }
+            }
+        }
+
+        self.num_added += 1;
+        self
+    }
+
+    /// Define an active element segment.
+    ///
+    /// `Active` element specifying a `None` table forces the MVP encoding and refers to the 0th
+    /// table holding `funcref`s. Non-`None` tables use the encoding introduced with the bulk
+    /// memory proposal and can refer to tables with any valid reference type.
+    pub fn active(
+        &mut self,
+        table_index: Option<u32>,
+        offset: &ConstExpr,
+        elements: Elements<'_>,
+    ) -> &mut Self {
+        self.segment(ElementSegment {
+            mode: ElementMode::Active {
+                table: table_index,
+                offset,
+            },
+            elements,
+        })
+    }
+
+    /// Encode a passive element segment.
+    ///
+    /// Passive segments are part of the bulk memory proposal.
+    pub fn passive<'a>(&mut self, elements: Elements<'a>) -> &mut Self {
+        self.segment(ElementSegment {
+            mode: ElementMode::Passive,
+            elements,
+        })
+    }
+
+    /// Encode a declared element segment.
+    ///
+    /// Declared segments are part of the bulk memory proposal.
+    pub fn declared<'a>(&mut self, elements: Elements<'a>) -> &mut Self {
+        self.segment(ElementSegment {
+            mode: ElementMode::Declared,
+            elements,
+        })
+    }
+
+    /// Copy a raw, already-encoded element segment into this elements section.
+    pub fn raw(&mut self, raw_bytes: &[u8]) -> &mut Self {
+        self.bytes.extend_from_slice(raw_bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for ElementSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for ElementSection {
+    fn id(&self) -> u8 {
+        SectionId::Element.into()
+    }
+}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/exports.rs

@@ -0,0 +1,98 @@
+use super::{
+    CORE_FUNCTION_SORT, CORE_GLOBAL_SORT, CORE_MEMORY_SORT, CORE_TABLE_SORT, CORE_TAG_SORT,
+};
+use crate::{encode_section, Encode, Section, SectionId};
+
+/// Represents the kind of an export from a WebAssembly module.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum ExportKind {
+    /// The export is a function.
+    Func = CORE_FUNCTION_SORT,
+    /// The export is a table.
+    Table = CORE_TABLE_SORT,
+    /// The export is a memory.
+    Memory = CORE_MEMORY_SORT,
+    /// The export is a global.
+    Global = CORE_GLOBAL_SORT,
+    /// The export is a tag.
+    Tag = CORE_TAG_SORT,
+}
+
+impl Encode for ExportKind {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        sink.push(*self as u8);
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::ExternalKind> for ExportKind {
+    fn from(external_kind: wasmparser::ExternalKind) -> Self {
+        match external_kind {
+            wasmparser::ExternalKind::Func => ExportKind::Func,
+            wasmparser::ExternalKind::Table => ExportKind::Table,
+            wasmparser::ExternalKind::Memory => ExportKind::Memory,
+            wasmparser::ExternalKind::Global => ExportKind::Global,
+            wasmparser::ExternalKind::Tag => ExportKind::Tag,
+        }
+    }
+}
+
+/// An encoder for the export section of WebAssembly module.
+///
+/// # Example
+///
+/// ```rust
+/// use wasm_encoder::{Module, ExportSection, ExportKind};
+///
+/// let mut exports = ExportSection::new();
+/// exports.export("foo", ExportKind::Func, 0);
+///
+/// let mut module = Module::new();
+/// module.section(&exports);
+///
+/// let bytes = module.finish();
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct ExportSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl ExportSection {
+    /// Create a new export section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of exports 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 an export in the export section.
+    pub fn export(&mut self, name: &str, kind: ExportKind, index: u32) -> &mut Self {
+        name.encode(&mut self.bytes);
+        kind.encode(&mut self.bytes);
+        index.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for ExportSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for ExportSection {
+    fn id(&self) -> u8 {
+        SectionId::Export.into()
+    }
+}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/functions.rs

@@ -0,0 +1,63 @@
+use crate::{encode_section, Encode, Section, SectionId};
+
+/// An encoder for the function section of WebAssembly modules.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{Module, FunctionSection, ValType};
+///
+/// let mut functions = FunctionSection::new();
+/// let type_index = 0;
+/// functions.function(type_index);
+///
+/// let mut module = Module::new();
+/// module.section(&functions);
+///
+/// // Note: this will generate an invalid module because we didn't generate a
+/// // code section containing the function body. See the documentation for
+/// // `CodeSection` for details.
+///
+/// let bytes = module.finish();
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct FunctionSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl FunctionSection {
+    /// Construct a new module function section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of functions 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 in a module's function section.
+    pub fn function(&mut self, type_index: u32) -> &mut Self {
+        type_index.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for FunctionSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for FunctionSection {
+    fn id(&self) -> u8 {
+        SectionId::Function.into()
+    }
+}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/globals.rs

@@ -0,0 +1,100 @@
+use crate::{encode_section, ConstExpr, Encode, Section, SectionId, ValType};
+
+/// An encoder for the global section.
+///
+/// Global sections are only supported for modules.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{ConstExpr, Module, GlobalSection, GlobalType, Instruction, ValType};
+///
+/// let mut globals = GlobalSection::new();
+/// globals.global(
+///     GlobalType {
+///         val_type: ValType::I32,
+///         mutable: false,
+///     },
+///     &ConstExpr::i32_const(42),
+/// );
+///
+/// let mut module = Module::new();
+/// module.section(&globals);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Default, Debug)]
+pub struct GlobalSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl GlobalSection {
+    /// Create a new global section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of globals 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 global.
+    pub fn global(&mut self, global_type: GlobalType, init_expr: &ConstExpr) -> &mut Self {
+        global_type.encode(&mut self.bytes);
+        init_expr.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
+    /// Add a raw byte slice into this code section as a global.
+    pub fn raw(&mut self, data: &[u8]) -> &mut Self {
+        self.bytes.extend(data);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for GlobalSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for GlobalSection {
+    fn id(&self) -> u8 {
+        SectionId::Global.into()
+    }
+}
+
+/// A global's type.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub struct GlobalType {
+    /// This global's value type.
+    pub val_type: ValType,
+    /// Whether this global is mutable or not.
+    pub mutable: bool,
+}
+
+impl Encode for GlobalType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.val_type.encode(sink);
+        sink.push(self.mutable as u8);
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::GlobalType> for GlobalType {
+    fn from(global_ty: wasmparser::GlobalType) -> Self {
+        GlobalType {
+            val_type: global_ty.content_type.into(),
+            mutable: global_ty.mutable,
+        }
+    }
+}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/imports.rs

@@ -0,0 +1,155 @@
+use crate::{
+    encode_section, Encode, GlobalType, MemoryType, Section, SectionId, TableType, TagType,
+    CORE_FUNCTION_SORT, CORE_GLOBAL_SORT, CORE_MEMORY_SORT, CORE_TABLE_SORT, CORE_TAG_SORT,
+};
+
+/// The type of an entity.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EntityType {
+    /// A function type.
+    ///
+    /// The value is an index into the types section.
+    Function(u32),
+    /// A table type.
+    Table(TableType),
+    /// A memory type.
+    Memory(MemoryType),
+    /// A global type.
+    Global(GlobalType),
+    /// A tag type.
+    ///
+    /// This variant is used with the exception handling proposal.
+    Tag(TagType),
+}
+
+impl Encode for EntityType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        match self {
+            Self::Function(i) => {
+                sink.push(CORE_FUNCTION_SORT);
+                i.encode(sink);
+            }
+            Self::Table(t) => {
+                sink.push(CORE_TABLE_SORT);
+                t.encode(sink);
+            }
+            Self::Memory(t) => {
+                sink.push(CORE_MEMORY_SORT);
+                t.encode(sink);
+            }
+            Self::Global(t) => {
+                sink.push(CORE_GLOBAL_SORT);
+                t.encode(sink);
+            }
+            Self::Tag(t) => {
+                sink.push(CORE_TAG_SORT);
+                t.encode(sink);
+            }
+        }
+    }
+}
+
+impl From<TableType> for EntityType {
+    fn from(t: TableType) -> Self {
+        Self::Table(t)
+    }
+}
+
+impl From<MemoryType> for EntityType {
+    fn from(t: MemoryType) -> Self {
+        Self::Memory(t)
+    }
+}
+
+impl From<GlobalType> for EntityType {
+    fn from(t: GlobalType) -> Self {
+        Self::Global(t)
+    }
+}
+
+impl From<TagType> for EntityType {
+    fn from(t: TagType) -> Self {
+        Self::Tag(t)
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::TypeRef> for EntityType {
+    fn from(type_ref: wasmparser::TypeRef) -> Self {
+        match type_ref {
+            wasmparser::TypeRef::Func(i) => EntityType::Function(i),
+            wasmparser::TypeRef::Table(t) => EntityType::Table(t.into()),
+            wasmparser::TypeRef::Memory(m) => EntityType::Memory(m.into()),
+            wasmparser::TypeRef::Global(g) => EntityType::Global(g.into()),
+            wasmparser::TypeRef::Tag(t) => EntityType::Tag(t.into()),
+        }
+    }
+}
+
+/// An encoder for the import section of WebAssembly modules.
+///
+/// # Example
+///
+/// ```rust
+/// use wasm_encoder::{MemoryType, Module, ImportSection};
+///
+/// let mut imports = ImportSection::new();
+/// imports.import(
+///     "env",
+///     "memory",
+///     MemoryType {
+///         minimum: 1,
+///         maximum: None,
+///         memory64: false,
+///         shared: false,
+///     }
+/// );
+///
+/// let mut module = Module::new();
+/// module.section(&imports);
+///
+/// let bytes = module.finish();
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct ImportSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl ImportSection {
+    /// Create a new import section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of imports 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 an import in the import section.
+    pub fn import(&mut self, module: &str, field: &str, ty: impl Into<EntityType>) -> &mut Self {
+        module.encode(&mut self.bytes);
+        field.encode(&mut self.bytes);
+        ty.into().encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for ImportSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for ImportSection {
+    fn id(&self) -> u8 {
+        SectionId::Import.into()
+    }
+}