wasmtime 14.0.3 → 14.0.4

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

@@ -0,0 +1,180 @@
+use std::borrow::Cow;
+
+use crate::{CustomSection, Encode, Section, SectionId};
+
+/// An encoder for the [producers custom
+/// section](https://github.com/WebAssembly/tool-conventions/blob/main/ProducersSection.md).
+///
+/// This section is a non-standard convention that is supported by many toolchains.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{ProducersSection, ProducersField, Module};
+///
+/// // Create a new producers section.
+/// let mut field = ProducersField::new();
+/// field.value("clang", "14.0.4");
+/// field.value("rustc", "1.66.1 (90743e729 2023-01-10)");
+/// let mut producers = ProducersSection::new();
+/// producers.field("processed-by", &field);
+///
+/// // Add the producers section to a new Wasm module and get the encoded bytes.
+/// let mut module = Module::new();
+/// module.section(&producers);
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Debug)]
+pub struct ProducersSection {
+    bytes: Vec<u8>,
+    num_fields: u32,
+}
+
+impl ProducersSection {
+    /// Construct an empty encoder for the producers custom section.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add a field to the section. The spec recommends names for this section
+    /// are "language", "processed-by", and "sdk".  Each field in section must
+    /// have a unique name.
+    pub fn field(&mut self, name: &str, values: &ProducersField) -> &mut Self {
+        name.encode(&mut self.bytes);
+        values.encode(&mut self.bytes);
+        self.num_fields += 1;
+        self
+    }
+}
+
+impl Default for ProducersSection {
+    fn default() -> Self {
+        Self {
+            bytes: Vec::new(),
+            num_fields: 0,
+        }
+    }
+}
+
+impl Encode for ProducersSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        let mut data = Vec::new();
+        self.num_fields.encode(&mut data);
+        data.extend(&self.bytes);
+
+        CustomSection {
+            name: "producers".into(),
+            data: Cow::Borrowed(&data),
+        }
+        .encode(sink);
+    }
+}
+
+impl Section for ProducersSection {
+    fn id(&self) -> u8 {
+        SectionId::Custom.into()
+    }
+}
+
+/// The value of a field in the producers custom section
+#[derive(Clone, Debug)]
+pub struct ProducersField {
+    bytes: Vec<u8>,
+    num_values: u32,
+}
+
+impl ProducersField {
+    /// Construct an empty encoder for a producers field value
+    pub fn new() -> Self {
+        ProducersField::default()
+    }
+
+    /// Add a value to the field encoder. Each value in a field must have a
+    /// unique name. If there is no sensible value for `version`, use the
+    /// empty string.
+    pub fn value(&mut self, name: &str, version: &str) -> &mut Self {
+        name.encode(&mut self.bytes);
+        version.encode(&mut self.bytes);
+        self.num_values += 1;
+        self
+    }
+}
+
+impl Default for ProducersField {
+    fn default() -> Self {
+        Self {
+            bytes: Vec::new(),
+            num_values: 0,
+        }
+    }
+}
+
+impl Encode for ProducersField {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.num_values.encode(sink);
+        sink.extend(&self.bytes);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn roundtrip_example() {
+        use crate::{Module, ProducersField, ProducersSection};
+        use wasmparser::{Parser, Payload, ProducersSectionReader};
+
+        // Create a new producers section.
+        let mut field = ProducersField::new();
+        field.value("clang", "14.0.4");
+        field.value("rustc", "1.66.1");
+        let mut producers = ProducersSection::new();
+        producers.field("processed-by", &field);
+
+        // Add the producers section to a new Wasm module and get the encoded bytes.
+        let mut module = Module::new();
+        module.section(&producers);
+        let wasm_bytes = module.finish();
+
+        let mut parser = Parser::new(0).parse_all(&wasm_bytes);
+        let payload = parser
+            .next()
+            .expect("parser is not empty")
+            .expect("element is a payload");
+        match payload {
+            Payload::Version { .. } => {}
+            _ => panic!(""),
+        }
+        let payload = parser
+            .next()
+            .expect("parser is not empty")
+            .expect("element is a payload");
+        match payload {
+            Payload::CustomSection(c) => {
+                assert_eq!(c.name(), "producers");
+                let mut section = ProducersSectionReader::new(c.data(), c.data_offset())
+                    .expect("readable as a producers section")
+                    .into_iter();
+                let field = section
+                    .next()
+                    .expect("section has an element")
+                    .expect("element is a producers field");
+                assert_eq!(field.name, "processed-by");
+                let mut values = field.values.into_iter();
+                let value = values
+                    .next()
+                    .expect("values has an element")
+                    .expect("element is a producers field value");
+                assert_eq!(value.name, "clang");
+                assert_eq!(value.version, "14.0.4");
+
+                let value = values
+                    .next()
+                    .expect("values has another element")
+                    .expect("element is a producers field value");
+                assert_eq!(value.name, "rustc");
+                assert_eq!(value.version, "1.66.1");
+            }
+            _ => panic!("unexpected payload"),
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+use crate::{encoding_size, Encode, Section, SectionId};
+
+/// An encoder for the start section of WebAssembly modules.
+///
+/// # Example
+///
+/// Note: this doesn't actually define the function at index 0, its type, or its
+/// code body, so the resulting Wasm module will be invalid. See `TypeSection`,
+/// `FunctionSection`, and `CodeSection` for details on how to generate those
+/// things.
+///
+/// ```
+/// use wasm_encoder::{Module, StartSection};
+///
+/// let start = StartSection { function_index: 0 };
+///
+/// let mut module = Module::new();
+/// module.section(&start);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Copy, Debug)]
+pub struct StartSection {
+    /// The index of the start function.
+    pub function_index: u32,
+}
+
+impl Encode for StartSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encoding_size(self.function_index).encode(sink);
+        self.function_index.encode(sink);
+    }
+}
+
+impl Section for StartSection {
+    fn id(&self) -> u8 {
+        SectionId::Start.into()
+    }
+}

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

@@ -0,0 +1,115 @@
+use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
+
+/// An encoder for the table section.
+///
+/// Table sections are only supported for modules.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{Module, TableSection, TableType, RefType};
+///
+/// let mut tables = TableSection::new();
+/// tables.table(TableType {
+///     element_type: RefType::FUNCREF,
+///     minimum: 128,
+///     maximum: None,
+/// });
+///
+/// let mut module = Module::new();
+/// module.section(&tables);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Default, Debug)]
+pub struct TableSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl TableSection {
+    /// Construct a new table section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of tables 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 table.
+    pub fn table(&mut self, table_type: TableType) -> &mut Self {
+        table_type.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
+    /// Define a table with an explicit initialization expression.
+    ///
+    /// Note that this is part of the function-references proposal.
+    pub fn table_with_init(&mut self, table_type: TableType, init: &ConstExpr) -> &mut Self {
+        self.bytes.push(0x40);
+        self.bytes.push(0x00);
+        table_type.encode(&mut self.bytes);
+        init.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for TableSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for TableSection {
+    fn id(&self) -> u8 {
+        SectionId::Table.into()
+    }
+}
+
+/// A table's type.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct TableType {
+    /// The table's element type.
+    pub element_type: RefType,
+    /// Minimum size, in elements, of this table
+    pub minimum: u32,
+    /// Maximum size, in elements, of this table
+    pub maximum: Option<u32>,
+}
+
+impl Encode for TableType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        let mut flags = 0;
+        if self.maximum.is_some() {
+            flags |= 0b001;
+        }
+
+        self.element_type.encode(sink);
+        sink.push(flags);
+        self.minimum.encode(sink);
+
+        if let Some(max) = self.maximum {
+            max.encode(sink);
+        }
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::TableType> for TableType {
+    fn from(table_ty: wasmparser::TableType) -> Self {
+        TableType {
+            element_type: table_ty.element_type.into(),
+            minimum: table_ty.initial,
+            maximum: table_ty.maximum,
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+use crate::{encode_section, Encode, Section, SectionId};
+
+/// An encoder for the tag section.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{Module, TagSection, TagType, TagKind};
+///
+/// let mut tags = TagSection::new();
+/// tags.tag(TagType {
+///     kind: TagKind::Exception,
+///     func_type_idx: 0,
+/// });
+///
+/// let mut module = Module::new();
+/// module.section(&tags);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Default, Debug)]
+pub struct TagSection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl TagSection {
+    /// Create a new tag section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of tags 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 tag.
+    pub fn tag(&mut self, tag_type: TagType) -> &mut Self {
+        tag_type.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for TagSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for TagSection {
+    fn id(&self) -> u8 {
+        SectionId::Tag.into()
+    }
+}
+
+/// Represents a tag kind.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TagKind {
+    /// The tag is an exception type.
+    Exception = 0x0,
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::TagKind> for TagKind {
+    fn from(kind: wasmparser::TagKind) -> Self {
+        match kind {
+            wasmparser::TagKind::Exception => TagKind::Exception,
+        }
+    }
+}
+
+/// A tag's type.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TagType {
+    /// The kind of tag
+    pub kind: TagKind,
+    /// The function type this tag uses
+    pub func_type_idx: u32,
+}
+
+impl Encode for TagType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        sink.push(self.kind as u8);
+        self.func_type_idx.encode(sink);
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::TagType> for TagType {
+    fn from(tag_ty: wasmparser::TagType) -> Self {
+        TagType {
+            kind: tag_ty.kind.into(),
+            func_type_idx: tag_ty.func_type_idx,
+        }
+    }
+}