wasmtime 14.0.3 → 14.0.4

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

@@ -0,0 +1,263 @@
+use std::borrow::Cow;
+
+use crate::{encode_section, CustomSection, Encode, Section, SectionId};
+
+const VERSION: u32 = 2;
+
+/// An encoder for the [linking custom
+/// section](https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md#linking-metadata-section).
+///
+/// This section is a non-standard convention that is supported by the LLVM
+/// toolchain. It, along with associated "reloc.*" custom sections, allows you
+/// to treat a Wasm module as a low-level object file that can be linked with
+/// other Wasm object files to produce a final, complete Wasm module.
+///
+/// The linking section must come before the reloc sections.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{LinkingSection, Module, SymbolTable};
+///
+/// // Create a new linking section.
+/// let mut linking = LinkingSection::new();
+///
+/// // Define a symbol table.
+/// let mut sym_tab = SymbolTable::new();
+///
+/// // Define a function symbol in the symbol table.
+/// let flags = SymbolTable::WASM_SYM_BINDING_LOCAL | SymbolTable::WASM_SYM_EXPORTED;
+/// let func_index = 42;
+/// let sym_name = "my_exported_func";
+/// sym_tab.function(flags, func_index, Some(sym_name));
+///
+/// // Add the symbol table to our linking section.
+/// linking.symbol_table(&sym_tab);
+///
+/// // Add the linking section to a new Wasm module and get the encoded bytes.
+/// let mut module = Module::new();
+/// module.section(&linking);
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Debug)]
+pub struct LinkingSection {
+    bytes: Vec<u8>,
+}
+
+impl LinkingSection {
+    /// Construct a new encoder for the linking custom section.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    // TODO: `fn segment_info` for the `WASM_SEGMENT_INFO` linking subsection.
+
+    // TODO: `fn init_funcs` for the `WASM_INIT_FUNCS` linking subsection.
+
+    // TODO: `fn comdat_info` for the `WASM_COMDAT_INFO` linking subsection.
+
+    /// Add a symbol table subsection.
+    pub fn symbol_table(&mut self, symbol_table: &SymbolTable) -> &mut Self {
+        symbol_table.encode(&mut self.bytes);
+        self
+    }
+}
+
+impl Default for LinkingSection {
+    fn default() -> Self {
+        let mut bytes = Vec::new();
+        VERSION.encode(&mut bytes);
+        Self { bytes }
+    }
+}
+
+impl Encode for LinkingSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        CustomSection {
+            name: "linking".into(),
+            data: Cow::Borrowed(&self.bytes),
+        }
+        .encode(sink);
+    }
+}
+
+impl Section for LinkingSection {
+    fn id(&self) -> u8 {
+        SectionId::Custom.into()
+    }
+}
+
+#[allow(unused)]
+const WASM_SEGMENT_INFO: u8 = 5;
+#[allow(unused)]
+const WASM_INIT_FUNCS: u8 = 6;
+#[allow(unused)]
+const WASM_COMDAT_INFO: u8 = 7;
+const WASM_SYMBOL_TABLE: u8 = 8;
+
+/// A subsection of the [linking custom section][crate::LinkingSection] that
+/// provides extra information about the symbols present in this Wasm object
+/// file.
+#[derive(Clone, Debug, Default)]
+pub struct SymbolTable {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+const SYMTAB_FUNCTION: u32 = 0;
+const SYMTAB_DATA: u32 = 1;
+const SYMTAB_GLOBAL: u32 = 2;
+#[allow(unused)]
+const SYMTAB_SECTION: u32 = 3;
+#[allow(unused)]
+const SYMTAB_TAG: u32 = 4;
+const SYMTAB_TABLE: u32 = 5;
+
+impl SymbolTable {
+    /// Construct a new symbol table subsection encoder.
+    pub fn new() -> Self {
+        SymbolTable {
+            bytes: vec![],
+            num_added: 0,
+        }
+    }
+
+    /// Define a function symbol in this symbol table.
+    ///
+    /// The `name` must be omitted if `index` references an imported table and
+    /// the `WASM_SYM_EXPLICIT_NAME` flag is not set.
+    pub fn function(&mut self, flags: u32, index: u32, name: Option<&str>) -> &mut Self {
+        SYMTAB_FUNCTION.encode(&mut self.bytes);
+        flags.encode(&mut self.bytes);
+        index.encode(&mut self.bytes);
+        if let Some(name) = name {
+            name.encode(&mut self.bytes);
+        }
+        self.num_added += 1;
+        self
+    }
+
+    /// Define a global symbol in this symbol table.
+    ///
+    /// The `name` must be omitted if `index` references an imported table and
+    /// the `WASM_SYM_EXPLICIT_NAME` flag is not set.
+    pub fn global(&mut self, flags: u32, index: u32, name: Option<&str>) -> &mut Self {
+        SYMTAB_GLOBAL.encode(&mut self.bytes);
+        flags.encode(&mut self.bytes);
+        index.encode(&mut self.bytes);
+        if let Some(name) = name {
+            name.encode(&mut self.bytes);
+        }
+        self.num_added += 1;
+        self
+    }
+
+    // TODO: tags
+
+    /// Define a table symbol in this symbol table.
+    ///
+    /// The `name` must be omitted if `index` references an imported table and
+    /// the `WASM_SYM_EXPLICIT_NAME` flag is not set.
+    pub fn table(&mut self, flags: u32, index: u32, name: Option<&str>) -> &mut Self {
+        SYMTAB_TABLE.encode(&mut self.bytes);
+        flags.encode(&mut self.bytes);
+        index.encode(&mut self.bytes);
+        if let Some(name) = name {
+            name.encode(&mut self.bytes);
+        }
+        self.num_added += 1;
+        self
+    }
+
+    /// Add a data symbol to this symbol table.
+    pub fn data(
+        &mut self,
+        flags: u32,
+        name: &str,
+        definition: Option<DataSymbolDefinition>,
+    ) -> &mut Self {
+        SYMTAB_DATA.encode(&mut self.bytes);
+        flags.encode(&mut self.bytes);
+        name.encode(&mut self.bytes);
+        if let Some(def) = definition {
+            def.index.encode(&mut self.bytes);
+            def.offset.encode(&mut self.bytes);
+            def.size.encode(&mut self.bytes);
+        }
+        self.num_added += 1;
+        self
+    }
+
+    // TODO: sections
+
+    /// This is a weak symbol.
+    ///
+    /// This flag is mutually exclusive with `WASM_SYM_BINDING_LOCAL`.
+    ///
+    /// When linking multiple modules defining the same symbol, all weak
+    /// definitions are discarded if any strong definitions exist; then if
+    /// multiple weak definitions exist all but one (unspecified) are discarded;
+    /// and finally it is an error if more than one definition remains.
+    pub const WASM_SYM_BINDING_WEAK: u32 = 0x1;
+
+    /// This is a local symbol.
+    ///
+    /// This flag is mutually exclusive with `WASM_SYM_BINDING_WEAK`.
+    ///
+    /// Local symbols are not to be exported, or linked to other
+    /// modules/sections. The names of all non-local symbols must be unique, but
+    /// the names of local symbols are not considered for uniqueness. A local
+    /// function or global symbol cannot reference an import.
+    pub const WASM_SYM_BINDING_LOCAL: u32 = 0x02;
+
+    /// This is a hidden symbol.
+    ///
+    /// Hidden symbols are not to be exported when performing the final link,
+    /// but may be linked to other modules.
+    pub const WASM_SYM_VISIBILITY_HIDDEN: u32 = 0x04;
+
+    /// This symbol is not defined.
+    ///
+    /// For non-data symbols, this must match whether the symbol is an import or
+    /// is defined; for data symbols, determines whether a segment is specified.
+    pub const WASM_SYM_UNDEFINED: u32 = 0x10;
+
+    /// This symbol is intended to be exported from the wasm module to the host
+    /// environment.
+    ///
+    /// This differs from the visibility flags in that it effects the static
+    /// linker.
+    pub const WASM_SYM_EXPORTED: u32 = 0x20;
+
+    /// This symbol uses an explicit symbol name, rather than reusing the name
+    /// from a wasm import.
+    ///
+    /// This allows it to remap imports from foreign WebAssembly modules into
+    /// local symbols with different names.
+    pub const WASM_SYM_EXPLICIT_NAME: u32 = 0x40;
+
+    /// This symbol is intended to be included in the linker output, regardless
+    /// of whether it is used by the program.
+    pub const WASM_SYM_NO_STRIP: u32 = 0x80;
+}
+
+impl Encode for SymbolTable {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        sink.push(WASM_SYMBOL_TABLE);
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+/// The definition of a data symbol within a symbol table.
+#[derive(Clone, Debug)]
+pub struct DataSymbolDefinition {
+    /// The index of the data segment that this symbol is in.
+    pub index: u32,
+    /// The offset of this symbol within its segment.
+    pub offset: u32,
+    /// The byte size (which can be zero) of this data symbol.
+    ///
+    /// Note that `offset + size` must be less than or equal to the segment's
+    /// size.
+    pub size: u32,
+}

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

@@ -0,0 +1,111 @@
+use crate::{encode_section, Encode, Section, SectionId};
+
+/// An encoder for the memory section.
+///
+/// Memory sections are only supported for modules.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{Module, MemorySection, MemoryType};
+///
+/// let mut memories = MemorySection::new();
+/// memories.memory(MemoryType {
+///     minimum: 1,
+///     maximum: None,
+///     memory64: false,
+///     shared: false,
+/// });
+///
+/// let mut module = Module::new();
+/// module.section(&memories);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Default, Debug)]
+pub struct MemorySection {
+    bytes: Vec<u8>,
+    num_added: u32,
+}
+
+impl MemorySection {
+    /// Create a new memory section encoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// The number of memories 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 memory.
+    pub fn memory(&mut self, memory_type: MemoryType) -> &mut Self {
+        memory_type.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+}
+
+impl Encode for MemorySection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        encode_section(sink, self.num_added, &self.bytes);
+    }
+}
+
+impl Section for MemorySection {
+    fn id(&self) -> u8 {
+        SectionId::Memory.into()
+    }
+}
+
+/// A memory's type.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct MemoryType {
+    /// Minimum size, in pages, of this memory
+    pub minimum: u64,
+    /// Maximum size, in pages, of this memory
+    pub maximum: Option<u64>,
+    /// Whether or not this is a 64-bit memory.
+    pub memory64: bool,
+    /// Whether or not this memory is shared.
+    pub shared: bool,
+}
+
+impl Encode for MemoryType {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        let mut flags = 0;
+        if self.maximum.is_some() {
+            flags |= 0b001;
+        }
+        if self.shared {
+            flags |= 0b010;
+        }
+        if self.memory64 {
+            flags |= 0b100;
+        }
+
+        sink.push(flags);
+        self.minimum.encode(sink);
+        if let Some(max) = self.maximum {
+            max.encode(sink);
+        }
+    }
+}
+
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::MemoryType> for MemoryType {
+    fn from(memory_ty: wasmparser::MemoryType) -> Self {
+        MemoryType {
+            minimum: memory_ty.initial,
+            maximum: memory_ty.maximum,
+            memory64: memory_ty.memory64,
+            shared: memory_ty.shared,
+        }
+    }
+}

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

@@ -0,0 +1,265 @@
+use std::borrow::Cow;
+
+use crate::{encoding_size, CustomSection, Encode, Section, SectionId};
+
+/// An encoder for the custom `name` section.
+///
+/// # Example
+///
+/// ```
+/// use wasm_encoder::{Module, NameSection, NameMap};
+///
+/// let mut names = NameSection::new();
+/// names.module("the module name");
+///
+/// let mut function_names = NameMap::new();
+/// function_names.append(0, "name of function 0");
+/// function_names.append(1, "a better function");
+/// function_names.append(3, "the best function");
+/// names.functions(&function_names);
+///
+/// let mut module = Module::new();
+/// module.section(&names);
+///
+/// let wasm_bytes = module.finish();
+/// ```
+#[derive(Clone, Debug, Default)]
+pub struct NameSection {
+    bytes: Vec<u8>,
+}
+
+enum Subsection {
+    // Currently specified in the wasm spec's appendix
+    Module = 0,
+    Function = 1,
+    Local = 2,
+
+    // specified as part of the extended name section proposal
+    //
+    // https://github.com/WebAssembly/extended-name-section/blob/main/proposals/extended-name-section/Overview.md
+    Label = 3,
+    Type = 4,
+    Table = 5,
+    Memory = 6,
+    Global = 7,
+    Element = 8,
+    Data = 9,
+}
+
+impl NameSection {
+    /// Creates a new blank `name` custom section.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Appends a module name subsection to this section.
+    ///
+    /// This will indicate that the name of the entire module should be the
+    /// `name` specified. Note that this should be encoded first before other
+    /// subsections.
+    pub fn module(&mut self, name: &str) {
+        let len = encoding_size(u32::try_from(name.len()).unwrap());
+        self.subsection_header(Subsection::Module, len + name.len());
+        name.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all functions in this wasm module.
+    ///
+    /// Function names are declared in the `names` map provided where the index
+    /// in the map corresponds to the wasm index of the function. This section
+    /// should come after the module name subsection (if present) and before the
+    /// locals subsection (if present).
+    pub fn functions(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Function, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of locals within functions in the
+    /// wasm module.
+    ///
+    /// This section should come after the function name subsection (if present)
+    /// and before the labels subsection (if present).
+    pub fn locals(&mut self, names: &IndirectNameMap) {
+        self.subsection_header(Subsection::Local, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of labels within functions in the
+    /// wasm module.
+    ///
+    /// This section should come after the local name subsection (if present)
+    /// and before the type subsection (if present).
+    pub fn labels(&mut self, names: &IndirectNameMap) {
+        self.subsection_header(Subsection::Label, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all types in this wasm module.
+    ///
+    /// This section should come after the label name subsection (if present)
+    /// and before the table subsection (if present).
+    pub fn types(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Type, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all tables in this wasm module.
+    ///
+    /// This section should come after the type name subsection (if present)
+    /// and before the memory subsection (if present).
+    pub fn tables(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Table, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all memories in this wasm module.
+    ///
+    /// This section should come after the table name subsection (if present)
+    /// and before the global subsection (if present).
+    pub fn memories(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Memory, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all globals in this wasm module.
+    ///
+    /// This section should come after the memory name subsection (if present)
+    /// and before the element subsection (if present).
+    pub fn globals(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Global, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all elements in this wasm module.
+    ///
+    /// This section should come after the global name subsection (if present)
+    /// and before the data subsection (if present).
+    pub fn elements(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Element, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    /// Appends a subsection for the names of all data in this wasm module.
+    ///
+    /// This section should come after the element name subsection (if present).
+    pub fn data(&mut self, names: &NameMap) {
+        self.subsection_header(Subsection::Data, names.size());
+        names.encode(&mut self.bytes);
+    }
+
+    fn subsection_header(&mut self, id: Subsection, len: usize) {
+        self.bytes.push(id as u8);
+        len.encode(&mut self.bytes);
+    }
+
+    /// View the encoded section as a CustomSection.
+    pub fn as_custom<'a>(&'a self) -> CustomSection<'a> {
+        CustomSection {
+            name: "name".into(),
+            data: Cow::Borrowed(&self.bytes),
+        }
+    }
+}
+
+impl Encode for NameSection {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.as_custom().encode(sink);
+    }
+}
+
+impl Section for NameSection {
+    fn id(&self) -> u8 {
+        SectionId::Custom.into()
+    }
+}
+
+/// A map used to name items in a wasm module, organized by naming each
+/// individual index.
+///
+/// This is used in conjunction with [`NameSection::functions`] and simlar
+/// methods.
+#[derive(Clone, Debug, Default)]
+pub struct NameMap {
+    bytes: Vec<u8>,
+    count: u32,
+}
+
+impl NameMap {
+    /// Creates a new empty `NameMap`.
+    pub fn new() -> NameMap {
+        NameMap {
+            bytes: vec![],
+            count: 0,
+        }
+    }
+
+    /// Adds a an entry where the item at `idx` has the `name` specified.
+    ///
+    /// Note that indices should be appended in ascending order of the index
+    /// value. Each index may only be named once, but not all indices must be
+    /// named (e.g. `0 foo; 1 bar; 7 qux` is valid but `0 foo; 0 bar` is not).
+    /// Names do not have to be unique (e.g. `0 foo; 1 foo; 2 foo` is valid).
+    pub fn append(&mut self, idx: u32, name: &str) {
+        idx.encode(&mut self.bytes);
+        name.encode(&mut self.bytes);
+        self.count += 1;
+    }
+
+    pub(crate) fn size(&self) -> usize {
+        encoding_size(self.count) + self.bytes.len()
+    }
+
+    /// Returns whether no names have been added to this map.
+    pub fn is_empty(&self) -> bool {
+        self.count == 0
+    }
+}
+
+impl Encode for NameMap {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.count.encode(sink);
+        sink.extend(&self.bytes);
+    }
+}
+
+/// A map used to describe names with two levels of indirection, as opposed to a
+/// [`NameMap`] which has one level of indirection.
+///
+/// This naming map is used with [`NameSection::locals`], for example.
+#[derive(Clone, Debug, Default)]
+pub struct IndirectNameMap {
+    bytes: Vec<u8>,
+    count: u32,
+}
+
+impl IndirectNameMap {
+    /// Creates a new empty name map.
+    pub fn new() -> IndirectNameMap {
+        IndirectNameMap {
+            bytes: vec![],
+            count: 0,
+        }
+    }
+
+    /// Adds a new entry where the item at `idx` has sub-items named within
+    /// `names` as specified.
+    ///
+    /// For example if this is describing local names then `idx` is a function
+    /// index where the indexes within `names` are local indices.
+    pub fn append(&mut self, idx: u32, names: &NameMap) {
+        idx.encode(&mut self.bytes);
+        names.encode(&mut self.bytes);
+        self.count += 1;
+    }
+
+    fn size(&self) -> usize {
+        encoding_size(self.count) + self.bytes.len()
+    }
+}
+
+impl Encode for IndirectNameMap {
+    fn encode(&self, sink: &mut Vec<u8>) {
+        self.count.encode(sink);
+        sink.extend(&self.bytes);
+    }
+}