wasmtime 17.0.1 → 18.0.3

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

@@ -0,0 +1,168 @@
+mod code;
+mod custom;
+mod data;
+mod dump;
+mod elements;
+mod exports;
+mod functions;
+mod globals;
+mod imports;
+mod linking;
+mod memories;
+mod names;
+mod producers;
+mod start;
+mod tables;
+mod tags;
+mod types;
+
+pub use code::*;
+pub use custom::*;
+pub use data::*;
+pub use dump::*;
+pub use elements::*;
+pub use exports::*;
+pub use functions::*;
+pub use globals::*;
+pub use imports::*;
+pub use linking::*;
+pub use memories::*;
+pub use names::*;
+pub use producers::*;
+pub use start::*;
+pub use tables::*;
+pub use tags::*;
+pub use types::*;
+
+use crate::Encode;
+
+pub(crate) const CORE_FUNCTION_SORT: u8 = 0x00;
+pub(crate) const CORE_TABLE_SORT: u8 = 0x01;
+pub(crate) const CORE_MEMORY_SORT: u8 = 0x02;
+pub(crate) const CORE_GLOBAL_SORT: u8 = 0x03;
+pub(crate) const CORE_TAG_SORT: u8 = 0x04;
+
+/// A WebAssembly module section.
+///
+/// Various builders defined in this crate already implement this trait, but you
+/// can also implement it yourself for your own custom section builders, or use
+/// `RawSection` to use a bunch of raw bytes as a section.
+pub trait Section: Encode {
+    /// Gets the section identifier for this section.
+    fn id(&self) -> u8;
+
+    /// Appends this section to the specified destination list of bytes.
+    fn append_to(&self, dst: &mut Vec<u8>) {
+        dst.push(self.id());
+        self.encode(dst);
+    }
+}
+
+/// Known section identifiers of WebAssembly modules.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+#[repr(u8)]
+pub enum SectionId {
+    /// The custom section.
+    Custom = 0,
+    /// The type section.
+    Type = 1,
+    /// The import section.
+    Import = 2,
+    /// The function section.
+    Function = 3,
+    /// The table section.
+    Table = 4,
+    /// The memory section.
+    Memory = 5,
+    /// The global section.
+    Global = 6,
+    /// The export section.
+    Export = 7,
+    /// The start section.
+    Start = 8,
+    /// The element section.
+    Element = 9,
+    /// The code section.
+    Code = 10,
+    /// The data section.
+    Data = 11,
+    /// The data count section.
+    DataCount = 12,
+    /// The tag section.
+    ///
+    /// This section is supported by the exception handling proposal.
+    Tag = 13,
+}
+
+impl From<SectionId> for u8 {
+    #[inline]
+    fn from(id: SectionId) -> u8 {
+        id as u8
+    }
+}
+
+impl Encode for SectionId {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        sink.push(*self as u8);
+    }
+}
+
+/// Represents a WebAssembly component that is being encoded.
+///
+/// Sections within a WebAssembly module are encoded in a specific order.
+///
+/// Modules may also added as a section to a WebAssembly component.
+#[derive(Clone, Debug)]
+pub struct Module {
+    pub(crate) bytes: Vec<u8>,
+}
+
+impl Module {
+    /// The 8-byte header at the beginning of all core wasm modules.
+    #[rustfmt::skip]
+    pub const HEADER: [u8; 8] = [
+        // Magic
+        0x00, 0x61, 0x73, 0x6D,
+        // Version
+        0x01, 0x00, 0x00, 0x00,
+    ];
+
+    /// Begin writing a new `Module`.
+    #[rustfmt::skip]
+    pub fn new() -> Self {
+        Module {
+            bytes: Self::HEADER.to_vec(),
+        }
+    }
+
+    /// Write a section into this module.
+    ///
+    /// It is your responsibility to define the sections in the [proper
+    /// order](https://webassembly.github.io/spec/core/binary/modules.html#binary-module),
+    /// and to ensure that each kind of section (other than custom sections) is
+    /// only defined once. While this is a potential footgun, it also allows you
+    /// to use this crate to easily construct test cases for bad Wasm module
+    /// encodings.
+    pub fn section(&mut self, section: &impl Section) -> &mut Self {
+        self.bytes.push(section.id());
+        section.encode(&mut self.bytes);
+        self
+    }
+
+    /// Get the encoded Wasm module as a slice.
+    pub fn as_slice(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    /// Finish writing this Wasm module and extract ownership of the encoded
+    /// bytes.
+    pub fn finish(self) -> Vec<u8> {
+        self.bytes
+    }
+}
+
+impl Default for Module {
+    fn default() -> Self {
+        Self::new()
+    }
+}

data/ext/cargo-vendor/wasm-encoder-0.41.2/src/lib.rs

@@ -0,0 +1,215 @@
+//! A WebAssembly encoder.
+//!
+//! The main builder is the [`Module`]. You can build a section with a
+//! section-specific builder, like [`TypeSection`] or [`ImportSection`], and
+//! then add it to the module with [`Module::section`]. When you are finished
+//! building the module, call either [`Module::as_slice`] or [`Module::finish`]
+//! to get the encoded bytes. The former gives a shared reference to the
+//! underlying bytes as a slice, while the latter gives you ownership of them as
+//! a vector.
+//!
+//! # Example
+//!
+//! If we wanted to build this module:
+//!
+//! ```wasm
+//! (module
+//!   (type (func (param i32 i32) (result i32)))
+//!   (func (type 0)
+//!     local.get 0
+//!     local.get 1
+//!     i32.add)
+//!   (export "f" (func 0)))
+//! ```
+//!
+//! then we would do this:
+//!
+//! ```
+//! use wasm_encoder::{
+//!     CodeSection, ExportKind, ExportSection, Function, FunctionSection, Instruction,
+//!     Module, TypeSection, ValType,
+//! };
+//!
+//! let mut module = Module::new();
+//!
+//! // Encode the type section.
+//! let mut types = TypeSection::new();
+//! let params = vec![ValType::I32, ValType::I32];
+//! let results = vec![ValType::I32];
+//! types.function(params, results);
+//! module.section(&types);
+//!
+//! // Encode the function section.
+//! let mut functions = FunctionSection::new();
+//! let type_index = 0;
+//! functions.function(type_index);
+//! module.section(&functions);
+//!
+//! // Encode the export section.
+//! let mut exports = ExportSection::new();
+//! exports.export("f", ExportKind::Func, 0);
+//! module.section(&exports);
+//!
+//! // Encode the code section.
+//! let mut codes = CodeSection::new();
+//! let locals = vec![];
+//! let mut f = Function::new(locals);
+//! f.instruction(&Instruction::LocalGet(0));
+//! f.instruction(&Instruction::LocalGet(1));
+//! f.instruction(&Instruction::I32Add);
+//! f.instruction(&Instruction::End);
+//! codes.function(&f);
+//! module.section(&codes);
+//!
+//! // Extract the encoded Wasm bytes for this module.
+//! let wasm_bytes = module.finish();
+//!
+//! // We generated a valid Wasm module!
+//! assert!(wasmparser::validate(&wasm_bytes).is_ok());
+//! ```
+
+#![deny(missing_docs, missing_debug_implementations)]
+
+mod component;
+mod core;
+mod raw;
+
+pub use self::component::*;
+pub use self::core::*;
+pub use self::raw::*;
+
+/// Implemented by types that can be encoded into a byte sink.
+pub trait Encode {
+    /// Encode the type into the given byte sink.
+    fn encode(&self, sink: &mut Vec<u8>);
+}
+
+impl<T: Encode + ?Sized> Encode for &'_ T {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        T::encode(self, sink)
+    }
+}
+
+impl<T: Encode> Encode for [T] {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.len().encode(sink);
+        for item in self {
+            item.encode(sink);
+        }
+    }
+}
+
+impl Encode for [u8] {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.len().encode(sink);
+        sink.extend(self);
+    }
+}
+
+impl Encode for str {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.len().encode(sink);
+        sink.extend_from_slice(self.as_bytes());
+    }
+}
+
+impl Encode for usize {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        assert!(*self <= u32::max_value() as usize);
+        (*self as u32).encode(sink)
+    }
+}
+
+impl Encode for u32 {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        leb128::write::unsigned(sink, (*self).into()).unwrap();
+    }
+}
+
+impl Encode for i32 {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        leb128::write::signed(sink, (*self).into()).unwrap();
+    }
+}
+
+impl Encode for u64 {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        leb128::write::unsigned(sink, *self).unwrap();
+    }
+}
+
+impl Encode for i64 {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        leb128::write::signed(sink, *self).unwrap();
+    }
+}
+
+impl Encode for f32 {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        let bits = self.to_bits();
+        sink.extend(bits.to_le_bytes())
+    }
+}
+
+impl Encode for f64 {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        let bits = self.to_bits();
+        sink.extend(bits.to_le_bytes())
+    }
+}
+
+fn encode_vec<T, V>(elements: V, sink: &mut Vec<u8>)
+where
+    T: Encode,
+    V: IntoIterator<Item = T>,
+    V::IntoIter: ExactSizeIterator,
+{
+    let elements = elements.into_iter();
+    u32::try_from(elements.len()).unwrap().encode(sink);
+    for x in elements {
+        x.encode(sink);
+    }
+}
+
+impl<T> Encode for Option<T>
+where
+    T: Encode,
+{
+    fn encode(&self, sink: &mut Vec<u8>) {
+        match self {
+            Some(v) => {
+                sink.push(0x01);
+                v.encode(sink);
+            }
+            None => sink.push(0x00),
+        }
+    }
+}
+
+fn encoding_size(n: u32) -> usize {
+    let mut buf = [0u8; 5];
+    leb128::write::unsigned(&mut &mut buf[..], n.into()).unwrap()
+}
+
+fn encode_section(sink: &mut Vec<u8>, count: u32, bytes: &[u8]) {
+    (encoding_size(count) + bytes.len()).encode(sink);
+    count.encode(sink);
+    sink.extend(bytes);
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn it_encodes_an_empty_module() {
+        let bytes = Module::new().finish();
+        assert_eq!(bytes, [0x00, b'a', b's', b'm', 0x01, 0x00, 0x00, 0x00]);
+    }
+
+    #[test]
+    fn it_encodes_an_empty_component() {
+        let bytes = Component::new().finish();
+        assert_eq!(bytes, [0x00, b'a', b's', b'm', 0x0d, 0x00, 0x01, 0x00]);
+    }
+}

data/ext/cargo-vendor/wasm-encoder-0.41.2/src/raw.rs

@@ -0,0 +1,30 @@
+use crate::{ComponentSection, Encode, Section};
+
+/// A section made up of uninterpreted, raw bytes.
+///
+/// Allows you to splat any data into a module or component.
+#[derive(Clone, Copy, Debug)]
+pub struct RawSection<'a> {
+    /// The id for this section.
+    pub id: u8,
+    /// The raw data for this section.
+    pub data: &'a [u8],
+}
+
+impl Encode for RawSection<'_> {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.data.encode(sink);
+    }
+}
+
+impl Section for RawSection<'_> {
+    fn id(&self) -> u8 {
+        self.id
+    }
+}
+
+impl ComponentSection for RawSection<'_> {
+    fn id(&self) -> u8 {
+        self.id
+    }
+}

data/ext/cargo-vendor/wasmparser-0.121.2/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"146672ae0d3cd601f6af5f320537d7b04f58e75bedce66ff5addcbb2d697afd9","Cargo.toml":"e57b6a25bb0c56b039e246a5b8752138ae18ff8191dd9bf8980c25233ae45821","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/benchmark.rs":"45ed921b97a85df370298186ff3b2ccea8c39664b12e0b4d475dea0e95f74118","examples/simple.rs":"e9eb076367cc0932e2a32651372defa4a27ef800f47fad28c0ef840ba8ea7e08","src/binary_reader.rs":"f24195a95974d55e3c57e24910dfc4506f9473a448569546c726d6b69324e748","src/lib.rs":"b25b04233baacd6ee1c0ac42210e3bfd8a5258583d5e2fa91ffe32929ae988ea","src/limits.rs":"1630c9390274a0a8f54c49d13af4ddf0f8634eafb6cd6aa1a10a977674dc88db","src/parser.rs":"a9d3acf3dc0fbb6c977f0f2669beb59d739666523c9f7ff6e85130de5de988cc","src/readers.rs":"406bf0cf694ed364c9c53cd25eb27a8e3fa97d099994f3e2a640747c49abf74b","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"72f3339cb452c1b055bd080281fe4923d132c280da112fcd1182594811b87494","src/readers/component/canonicals.rs":"d3b844d177be69c40644d924271588718685511fafcc46ee1d9d0f6942b9dccb","src/readers/component/exports.rs":"177f05b11de2276a26842481b1260a8eface092f03736853a55f30d532994c28","src/readers/component/imports.rs":"032db44269c6c772a62d0ad66fd6b4cfa3bf9a4caa5a0ba62ee4c04abe91e113","src/readers/component/instances.rs":"5f3ef2b8424a3beff2c34d118f1c9f168d1beee589c0e87dabab94ba726a8f1d","src/readers/component/names.rs":"3f5dac9db8668b18cd6721cd780e6aba9b223b404c9d1173d09efe4e6b4d3a8a","src/readers/component/start.rs":"8e1e5d8aa5ece26d42251449cadcce0546c4d995f1641941b8a31ed4bc6ac761","src/readers/component/types.rs":"2a340df55af8ba398cda1acae3a75de16e6d8fe87852a9655b82e048592cb16c","src/readers/core.rs":"7922c74859b4d1d22d6f221ee0f436967d7bea31a0ffab1286e08be23fec0001","src/readers/core/branch_hinting.rs":"05d834d34cae2267712401a2b03d952deb99890d9855bd0c74681825caae382f","src/readers/core/code.rs":"53f49986febb27f4cb67f4495e7b369fc80e2f70908e1e831750698dd15fe37f","src/readers/core/coredumps.rs":"7cde14b700bdf2459fa57e2cbb5a520a4d1d8547f075c1440db74b19ecf74764","src/readers/core/custom.rs":"f80d3a994e8778a912319834228cbb772c65a4b6b1f25b41fe00d220d388831f","src/readers/core/data.rs":"c1fcda7b548b15be40b3dd1f667d97c30c543867f2dc4734b590846beefe3ae3","src/readers/core/dylink0.rs":"6b2cf2f64532e38d7261b69781c7a8f2207f472165cde27de9c692bda1b741b5","src/readers/core/elements.rs":"7f05cbe94402bb2e591c8dd8f0be45309044c80f242568c66c1b2ea0011b7f50","src/readers/core/exports.rs":"50dc1ee51b73f03f24077f7c290bca756966563cedbad9e49d735d60f60c91db","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"d23f99a3adc9593652a5efd4dc81e8f014f57e776b49717dabbdcd0a811a96b1","src/readers/core/imports.rs":"4d247e8cac0b3cef7425d93f7a7f2412b2ae8979da944080d565415499e27e87","src/readers/core/init.rs":"ec6717063b0b7f2e9aa17ae52083019cee52594bf5a8b6858f2d77b10d7a0639","src/readers/core/linking.rs":"1ebc6360e66441918af3a52276fd59d5566c48102675b2d62dad3bc8ac00cf4b","src/readers/core/memories.rs":"351f816d663b7d17546dc3b19ce0e43f406ce743289219a3758f7c837903fa6d","src/readers/core/names.rs":"2691bab8024effdd860e51eed168a0a62110708b54f512e7b0ab29268fec77df","src/readers/core/operators.rs":"14c2ddb1baf9c45e92d976e35b939d5468a09c2e55447e0868371f1e586a607e","src/readers/core/producers.rs":"5b53d0979a68008f9aec0bb9bca64c071e49a6a1879d8459f1114fa666e661c5","src/readers/core/tables.rs":"cbe5b35893bd3929354b4487b344062ce6b540e6a70bde6eddf05a07a68574e9","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"2224781b10285a4bca7fe1ed80d8ae3862e78e86d822699b27ba549e41dd423b","src/readers/core/types/matches.rs":"e41f99482c69ab0a8b620fef2158da0893a0e92214fe95461f38c9ab6812b3d2","src/resources.rs":"d82c5dd9baad869770b42dbebd0ad804d96c13884982f796f5baf061233cd5fc","src/validator.rs":"09c6886fc4c4678901db2acf335cda8b8cf258bb65a85addfff3fa31da5d0ddf","src/validator/component.rs":"c50a00cf2964ff9a96ad7df676930f29a25406cb066740dba1c5920eedc80afc","src/validator/core.rs":"73bb490fd039e94f53b39654f95f002c5c9aa086367c1f5a172f7691567a6095","src/validator/core/canonical.rs":"87b6bc1125768437540ace46f72663797066c946bdda0fe12f0cf30c638a0e0c","src/validator/func.rs":"7f1be2771acfd60d997234e6d65c58e4c1c1381a352a29523763b756d11b099e","src/validator/names.rs":"6ae6e8a97c878ca07b0f5afcdabd01b06c59225342a524c02f2595d6bc49a6bd","src/validator/operators.rs":"935e2de8d9aee495d85dbb35c0af3edc1eb6422ca2d2c8eda16d76683685fe79","src/validator/types.rs":"37c99a0f638232ca0690952d9c3b2dead0e8a2ced85de95656d18ee340075f75","tests/big-module.rs":"2d956dedf1a9f0b1e976dd63c97d3707cd726da10166cad2f16ae33000ed13b3"},"package":"9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"}