wasmtime 21.0.1 → 23.0.2

data/ext/cargo-vendor/wast-215.0.0/src/component.rs

@@ -0,0 +1,28 @@
+//! Types and support for parsing the component model text format.
+
+mod alias;
+pub(crate) mod binary;
+mod component;
+mod custom;
+mod expand;
+mod export;
+mod func;
+mod import;
+mod instance;
+mod item_ref;
+mod module;
+mod resolve;
+mod types;
+mod wast;
+
+pub use self::alias::*;
+pub use self::component::*;
+pub use self::custom::*;
+pub use self::export::*;
+pub use self::func::*;
+pub use self::import::*;
+pub use self::instance::*;
+pub use self::item_ref::*;
+pub use self::module::*;
+pub use self::types::*;
+pub use self::wast::*;

data/ext/cargo-vendor/wast-215.0.0/src/core/binary/dwarf.rs

@@ -0,0 +1,610 @@
+//! Implementation of emitting DWARF debugging information for `*.wat` files.
+//!
+//! This is intended to be relatively simple but the goal is to enable emission
+//! of DWARF sections which point back to the original `*.wat` file itself. This
+//! enables debuggers like LLDB to debug `*.wat` files without necessarily
+//! built-in knowledge of WebAssembly itself.
+//!
+//! Overall I was curious on weekend and decided to implement this. It's an
+//! off-by-default crate feature and an off-by-default runtime feature of this
+//! crate. Hopefully doesn't carry too much complexity with it while still being
+//! easy/fun to play around with.
+
+use crate::core::binary::{EncodeOptions, Encoder, GenerateDwarf, Names, RecOrType};
+use crate::core::{InnerTypeKind, Local, ValType};
+use crate::token::Span;
+use gimli::write::{
+    self, Address, AttributeValue, DwarfUnit, Expression, FileId, LineProgram, LineString,
+    Sections, UnitEntryId, Writer,
+};
+use gimli::{Encoding, Format, LineEncoding, LittleEndian};
+use std::cmp::Ordering;
+use std::collections::HashMap;
+use std::path::Path;
+
+pub struct Dwarf<'a> {
+    // Metadata configured at `Dwarf` creation time
+    func_names: HashMap<u32, &'a str>,
+    func_imports: u32,
+    contents: &'a str,
+    file_id: FileId,
+    style: GenerateDwarf,
+    types: &'a [RecOrType<'a>],
+
+    dwarf: DwarfUnit,
+
+    // Next function index when `start_func` is called
+    next_func: u32,
+
+    // Current `DW_TAG_subprogram` that's being built as part of `start_func`.
+    cur_subprogram: Option<UnitEntryId>,
+    cur_subprogram_instrs: usize,
+
+    // Code-section-relative offset of the start of every function. Filled in
+    // as part of `end_func`.
+    sym_offsets: Vec<usize>,
+
+    // Metadata tracking what the line/column information was at the specified
+    // last offset.
+    line: u64,
+    column: u64,
+    last_offset: usize,
+
+    i32_ty: Option<UnitEntryId>,
+    i64_ty: Option<UnitEntryId>,
+    f32_ty: Option<UnitEntryId>,
+    f64_ty: Option<UnitEntryId>,
+}
+
+impl<'a> Dwarf<'a> {
+    /// Creates a new `Dwarf` from the specified configuration.
+    ///
+    /// * `func_imports` - the number of imported functions in this module, or
+    ///   the index of the first defined function.
+    /// * `opts` - encoding options, namely where whether DWARF is to be emitted
+    ///   is configured.
+    /// * `names` - the `name` custom section for this module, used to name
+    ///   functions in DWARF.
+    pub fn new(
+        func_imports: u32,
+        opts: &EncodeOptions<'a>,
+        names: &Names<'a>,
+        types: &'a [RecOrType<'a>],
+    ) -> Option<Dwarf<'a>> {
+        // This is a load-bearing `?` which notably short-circuits all DWARF
+        // machinery entirely if this was not enabled at runtime.
+        let (file, contents, style) = opts.dwarf_info?;
+        let file = file.to_str()?;
+
+        // Configure some initial `gimli::write` context.
+        let encoding = Encoding {
+            address_size: 4,
+            format: Format::Dwarf32,
+            version: 5,
+        };
+        let mut dwarf = DwarfUnit::new(encoding);
+        let (comp_dir, comp_file) = match (
+            Path::new(file).parent().and_then(|s| s.to_str()),
+            Path::new(file).file_name().and_then(|s| s.to_str()),
+        ) {
+            (Some(parent), Some(file_name)) if !parent.is_empty() => (parent, file_name),
+            _ => (".", file),
+        };
+        let comp_dir_ref = dwarf.strings.add(comp_dir);
+        let comp_file_ref = dwarf.strings.add(comp_file);
+        dwarf.unit.line_program = LineProgram::new(
+            encoding,
+            LineEncoding::default(),
+            LineString::StringRef(comp_dir_ref),
+            LineString::StringRef(comp_file_ref),
+            None,
+        );
+        let dir_id = dwarf.unit.line_program.default_directory();
+        let file_id =
+            dwarf
+                .unit
+                .line_program
+                .add_file(LineString::StringRef(comp_file_ref), dir_id, None);
+
+        // Configure a single compilation unit which encompasses the entire code
+        // section. The code section isn't fully known at this point so only a
+        // "low pc" is emitted here.
+        let root = dwarf.unit.root();
+        let cu = dwarf.unit.get_mut(root);
+        cu.set(
+            gimli::DW_AT_producer,
+            AttributeValue::String(format!("wast {}", env!("CARGO_PKG_VERSION")).into_bytes()),
+        );
+        cu.set(
+            gimli::DW_AT_language,
+            // Technically this should be something like wasm or wat but that
+            // doesn't exist so fill in something here.
+            AttributeValue::Language(gimli::DW_LANG_C),
+        );
+        cu.set(gimli::DW_AT_name, AttributeValue::StringRef(comp_file_ref));
+        cu.set(
+            gimli::DW_AT_comp_dir,
+            AttributeValue::StringRef(comp_dir_ref),
+        );
+        cu.set(gimli::DW_AT_low_pc, AttributeValue::Data4(0));
+
+        // Build a lookup table for defined function index to its name.
+        let mut func_names = HashMap::new();
+        for (idx, name) in names.funcs.iter() {
+            func_names.insert(*idx, *name);
+        }
+
+        // Offsets pointing to newlines are considered internally as the 0th
+        // column of the next line, so handle the case that the contents start
+        // with a newline.
+        let (line, column) = if contents.starts_with("\n") {
+            (2, 0)
+        } else {
+            (1, 1)
+        };
+        Some(Dwarf {
+            dwarf,
+            style,
+            next_func: func_imports,
+            func_imports,
+            sym_offsets: Vec::new(),
+            contents,
+            line,
+            column,
+            last_offset: 0,
+            file_id,
+            cur_subprogram: None,
+            cur_subprogram_instrs: 0,
+            func_names,
+            i32_ty: None,
+            i64_ty: None,
+            f32_ty: None,
+            f64_ty: None,
+            types,
+        })
+    }
+
+    /// Start emitting a new function defined at `span`.
+    ///
+    /// This will start a new line program for this function and additionally
+    /// configure a new `DW_TAG_subprogram` for this new function.
+    pub fn start_func(&mut self, span: Span, ty: u32, locals: &[Local<'_>]) {
+        self.change_linecol(span);
+        let addr = Address::Symbol {
+            symbol: (self.next_func - self.func_imports) as usize,
+            addend: 0,
+        };
+        self.dwarf.unit.line_program.begin_sequence(Some(addr));
+
+        let root = self.dwarf.unit.root();
+        let subprogram = self.dwarf.unit.add(root, gimli::DW_TAG_subprogram);
+        let entry = self.dwarf.unit.get_mut(subprogram);
+        let fallback = format!("wasm-function[{}]", self.next_func);
+        let func_name = self
+            .func_names
+            .get(&self.next_func)
+            .copied()
+            .unwrap_or(&fallback);
+        entry.set(gimli::DW_AT_name, AttributeValue::String(func_name.into()));
+        entry.set(
+            gimli::DW_AT_decl_file,
+            AttributeValue::FileIndex(Some(self.file_id)),
+        );
+        entry.set(gimli::DW_AT_decl_line, AttributeValue::Udata(self.line));
+        entry.set(gimli::DW_AT_decl_column, AttributeValue::Udata(self.column));
+        entry.set(gimli::DW_AT_external, AttributeValue::FlagPresent);
+        entry.set(gimli::DW_AT_low_pc, AttributeValue::Address(addr));
+
+        if let GenerateDwarf::Full = self.style {
+            self.add_func_params_and_locals(subprogram, ty, locals);
+        }
+
+        self.cur_subprogram = Some(subprogram);
+        self.cur_subprogram_instrs = 0;
+        self.next_func += 1;
+    }
+
+    /// Adds `DW_TAG_formal_parameter` and `DW_TAG_variable` for all locals
+    /// (which are both params and function-defined locals).
+    ///
+    /// This is pretty simple in that the expression for the location of
+    /// these variables is constant, it's just "it's the local", and it spans
+    /// the entire function.
+    fn add_func_params_and_locals(
+        &mut self,
+        subprogram: UnitEntryId,
+        ty: u32,
+        locals: &[Local<'_>],
+    ) {
+        // Iterate through `self.types` which is what was encoded into the
+        // module and find the function type which gives access to the
+        // parameters which gives access to their types.
+        let ty = self
+            .types
+            .iter()
+            .flat_map(|t| match t {
+                RecOrType::Type(t) => std::slice::from_ref(*t),
+                RecOrType::Rec(r) => &r.types,
+            })
+            .nth(ty as usize);
+        let ty = match ty.map(|t| &t.def.kind) {
+            Some(InnerTypeKind::Func(ty)) => ty,
+            _ => return,
+        };
+
+        let mut local_idx = 0;
+        for (_, _, ty) in ty.params.iter() {
+            self.local(local_idx, subprogram, gimli::DW_TAG_formal_parameter, ty);
+            local_idx += 1;
+        }
+
+        for local in locals {
+            self.local(local_idx, subprogram, gimli::DW_TAG_variable, &local.ty);
+            local_idx += 1;
+        }
+    }
+
+    /// Attempts to define a local variable within `subprogram` with the `ty`
+    /// given.
+    ///
+    /// This does nothing if `ty` can't be represented in DWARF.
+    fn local(&mut self, local: u32, subprogram: UnitEntryId, tag: gimli::DwTag, ty: &ValType<'_>) {
+        let ty = match self.val_type_to_dwarf_type(ty) {
+            Some(ty) => ty,
+            None => return,
+        };
+
+        let param = self.dwarf.unit.add(subprogram, tag);
+        let entry = self.dwarf.unit.get_mut(param);
+        entry.set(
+            gimli::DW_AT_name,
+            AttributeValue::String(format!("local{local}").into()),
+        );
+
+        let mut loc = Expression::new();
+        loc.op_wasm_local(local);
+        loc.op(gimli::DW_OP_stack_value);
+        entry.set(gimli::DW_AT_location, AttributeValue::Exprloc(loc));
+        entry.set(gimli::DW_AT_type, AttributeValue::UnitRef(ty));
+    }
+
+    fn val_type_to_dwarf_type(&mut self, ty: &ValType<'_>) -> Option<UnitEntryId> {
+        match ty {
+            ValType::I32 => Some(self.i32_ty()),
+            ValType::I64 => Some(self.i64_ty()),
+            ValType::F32 => Some(self.f32_ty()),
+            ValType::F64 => Some(self.f64_ty()),
+            // TODO: make a C union of sorts or something like that to
+            // represent v128 as an array-of-lanes or u128 or something like
+            // that.
+            ValType::V128 => None,
+            // Not much that can be done about reference types without actually
+            // knowing what the engine does, this probably needs an addition to
+            // DWARF itself to represent this.
+            ValType::Ref(_) => None,
+        }
+    }
+
+    /// Emit an instruction which starts at `offset` and is defined at `span`.
+    ///
+    /// Note that `offset` is code-section-relative.
+    pub fn instr(&mut self, offset: usize, span: Span) {
+        self.change_linecol(span);
+        let offset = u64::try_from(offset).unwrap();
+
+        let mut changed = false;
+        let row = self.dwarf.unit.line_program.row();
+        set(&mut row.address_offset, offset, &mut changed);
+        set(&mut row.line, self.line, &mut changed);
+        set(&mut row.column, self.column, &mut changed);
+        set(&mut row.file, self.file_id, &mut changed);
+        set(&mut row.is_statement, true, &mut changed);
+        set(
+            &mut row.prologue_end,
+            self.cur_subprogram_instrs == 0,
+            &mut changed,
+        );
+
+        if changed {
+            self.dwarf.unit.line_program.generate_row();
+        }
+        self.cur_subprogram_instrs += 1;
+
+        fn set<T: PartialEq>(slot: &mut T, val: T, changed: &mut bool) {
+            if *slot != val {
+                *slot = val;
+                *changed = true;
+            }
+        }
+    }
+
+    /// Change `self.line` and `self.column` to be appropriate for the offset
+    /// in `span`.
+    ///
+    /// This will incrementally move from `self.last_offset` to `span.offset()`
+    /// and update line/column information as we go. It's assumed that this is
+    /// more efficient than a precalculate-all-the-positions-for-each-byte
+    /// approach since that would require a great deal of memory to store a
+    /// line/col for all bytes in the input string. It's also assumed that most
+    /// `span` adjustments are minor as it's between instructions in a function
+    /// which are frequently close together. Whether or not this assumption
+    /// pans out is yet to be seen.
+    fn change_linecol(&mut self, span: Span) {
+        let offset = span.offset();
+
+        loop {
+            match self.last_offset.cmp(&offset) {
+                Ordering::Less => {
+                    let haystack = self.contents[self.last_offset + 1..].as_bytes();
+                    let next_newline = match memchr::memchr_iter(b'\n', haystack).next() {
+                        Some(pos) => pos + self.last_offset + 1,
+                        None => break,
+                    };
+                    if next_newline > offset {
+                        break;
+                    } else {
+                        self.line += 1;
+                        self.column = 0;
+                        self.last_offset = next_newline;
+                    }
+                }
+                Ordering::Greater => {
+                    let haystack = self.contents[..self.last_offset].as_bytes();
+                    match memchr::memchr_iter(b'\n', haystack).next_back() {
+                        Some(prev_newline) => {
+                            if self.column == 0 {
+                                self.line -= 1;
+                            }
+                            self.column = 0;
+                            self.last_offset = prev_newline;
+                        }
+                        None => {
+                            self.line = 1;
+                            self.column = 1;
+                            self.last_offset = 0;
+                        }
+                    }
+                }
+                Ordering::Equal => break,
+            }
+        }
+
+        match self.last_offset.cmp(&offset) {
+            Ordering::Less => {
+                self.column += (offset - self.last_offset) as u64;
+            }
+            Ordering::Greater => {
+                self.column -= (self.last_offset - offset) as u64;
+            }
+            Ordering::Equal => {}
+        }
+        self.last_offset = offset;
+    }
+
+    /// Completes emission of the latest function.
+    ///
+    /// The latest function took `func_size` bytes to encode and the current end
+    /// of the code section, after the function was appended, is
+    /// `code_section_end`.
+    pub fn end_func(&mut self, func_size: usize, code_section_end: usize) {
+        // Add a final row corresponding to the final `end` instruction in the
+        // function to ensure there's something for all bytecodes.
+        let row = self.dwarf.unit.line_program.row();
+        row.address_offset = (func_size - 1) as u64;
+        self.dwarf.unit.line_program.generate_row();
+
+        // This function's symbol is relative to the start of the function
+        // itself. Functions are encoded as a leb-size-of-function then the
+        // function itself, so to account for the size of the
+        // leb-size-of-function we calculate the function start as the current
+        // end of the code section minus the size of the function's bytes.
+        self.sym_offsets.push(code_section_end - func_size);
+
+        // The line program is relative to the start address, so only the
+        // function's size is used here.
+        self.dwarf
+            .unit
+            .line_program
+            .end_sequence(u64::try_from(func_size).unwrap());
+
+        // The high PC value here is relative to `DW_AT_low_pc`, so it's the
+        // size of the function.
+        let entry = self.dwarf.unit.get_mut(self.cur_subprogram.take().unwrap());
+        entry.set(
+            gimli::DW_AT_high_pc,
+            AttributeValue::Data4(func_size as u32),
+        );
+    }
+
+    pub fn set_code_section_size(&mut self, size: usize) {
+        let root = self.dwarf.unit.root();
+        let entry = self.dwarf.unit.get_mut(root);
+        entry.set(gimli::DW_AT_high_pc, AttributeValue::Data4(size as u32));
+    }
+
+    pub fn emit(&mut self, dst: &mut Encoder<'_>) {
+        let mut sections = Sections::new(DwarfWriter {
+            sym_offsets: &self.sym_offsets,
+            bytes: Vec::new(),
+        });
+        self.dwarf.write(&mut sections).unwrap();
+
+        sections
+            .for_each(|id, writer| {
+                if !writer.bytes.is_empty() {
+                    dst.custom_section(id.name(), &writer.bytes);
+                }
+                Ok::<_, std::convert::Infallible>(())
+            })
+            .unwrap();
+    }
+
+    fn i32_ty(&mut self) -> UnitEntryId {
+        if self.i32_ty.is_none() {
+            self.i32_ty = Some(self.mk_primitive("i32", 4, gimli::DW_ATE_signed));
+        }
+        self.i32_ty.unwrap()
+    }
+
+    fn i64_ty(&mut self) -> UnitEntryId {
+        if self.i64_ty.is_none() {
+            self.i64_ty = Some(self.mk_primitive("i64", 8, gimli::DW_ATE_signed));
+        }
+        self.i64_ty.unwrap()
+    }
+
+    fn f32_ty(&mut self) -> UnitEntryId {
+        if self.f32_ty.is_none() {
+            self.f32_ty = Some(self.mk_primitive("f32", 4, gimli::DW_ATE_float));
+        }
+        self.f32_ty.unwrap()
+    }
+
+    fn f64_ty(&mut self) -> UnitEntryId {
+        if self.f64_ty.is_none() {
+            self.f64_ty = Some(self.mk_primitive("f64", 8, gimli::DW_ATE_float));
+        }
+        self.f64_ty.unwrap()
+    }
+
+    fn mk_primitive(&mut self, name: &str, byte_size: u8, encoding: gimli::DwAte) -> UnitEntryId {
+        let name = self.dwarf.strings.add(name);
+        let root = self.dwarf.unit.root();
+        let ty = self.dwarf.unit.add(root, gimli::DW_TAG_base_type);
+        let entry = self.dwarf.unit.get_mut(ty);
+        entry.set(gimli::DW_AT_name, AttributeValue::StringRef(name));
+        entry.set(gimli::DW_AT_byte_size, AttributeValue::Data1(byte_size));
+        entry.set(gimli::DW_AT_encoding, AttributeValue::Encoding(encoding));
+        ty
+    }
+}
+
+#[derive(Clone)]
+struct DwarfWriter<'a> {
+    sym_offsets: &'a [usize],
+    bytes: Vec<u8>,
+}
+
+impl Writer for DwarfWriter<'_> {
+    type Endian = LittleEndian;
+
+    fn endian(&self) -> Self::Endian {
+        LittleEndian
+    }
+    fn len(&self) -> usize {
+        self.bytes.len()
+    }
+    fn write(&mut self, bytes: &[u8]) -> write::Result<()> {
+        self.bytes.extend_from_slice(bytes);
+        Ok(())
+    }
+    fn write_at(&mut self, offset: usize, bytes: &[u8]) -> write::Result<()> {
+        self.bytes[offset..][..bytes.len()].copy_from_slice(bytes);
+        Ok(())
+    }
+    fn write_address(&mut self, address: Address, size: u8) -> write::Result<()> {
+        match address {
+            Address::Constant(val) => self.write_udata(val, size),
+            Address::Symbol { symbol, addend } => {
+                assert_eq!(addend, 0);
+                let offset = self.sym_offsets[symbol];
+                self.write_udata(offset as u64, size)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Dwarf, EncodeOptions, GenerateDwarf};
+    use crate::token::Span;
+    use rand::rngs::SmallRng;
+    use rand::{Rng, SeedableRng};
+
+    fn linecol_test(contents: &str) {
+        let mut dwarf = Dwarf::new(
+            0,
+            EncodeOptions::default().dwarf("foo.wat".as_ref(), contents, GenerateDwarf::Lines),
+            &Default::default(),
+            &[],
+        )
+        .unwrap();
+
+        // Print some debugging information in case someone's debugging this
+        // test
+        let mut offset = 0;
+        for (i, line) in contents.lines().enumerate() {
+            println!(
+                "line {:2} is at {:2} .. {:2}",
+                i + 1,
+                offset,
+                offset + line.len()
+            );
+            offset += line.len() + 1;
+        }
+        println!("");
+
+        // Precalculate (line, col) for all characters, assumed to all be one
+        // byte here.
+        let mut precalculated_linecols = Vec::new();
+        let mut line = 1;
+        let mut col = 1;
+        for c in contents.chars() {
+            if c == '\n' {
+                line += 1;
+                col = 0;
+            }
+            precalculated_linecols.push((line, col));
+            col += 1;
+        }
+
+        // Traverse randomly throughout this string and assert that the
+        // incremental update matches the precalculated position.
+        let mut rand = SmallRng::seed_from_u64(102);
+        for _ in 0..1000 {
+            let pos = rand.gen_range(0..contents.len());
+            dwarf.change_linecol(Span::from_offset(pos));
+            let (line, col) = precalculated_linecols[pos];
+
+            assert_eq!(dwarf.line, line, "line mismatch");
+            assert_eq!(dwarf.column, col, "column mismatch");
+        }
+    }
+
+    #[test]
+    fn linecol_simple() {
+        linecol_test(
+            "a
+
+        b
+        c (; ... ;)
+        d
+         e
+
+
+         f
+
+         fg",
+        );
+    }
+
+    #[test]
+    fn linecol_empty() {
+        linecol_test("x");
+    }
+
+    #[test]
+    fn linecol_start_newline() {
+        linecol_test("\nx ab\nyyy \ncc");
+    }
+
+    #[test]
+    fn linecol_lots_of_newlines() {
+        linecol_test("\n\n\n\n");
+    }
+
+    #[test]
+    fn linecol_interspersed() {
+        linecol_test("\na\nb\nc\n");
+    }
+}

data/ext/cargo-vendor/wast-215.0.0/src/core/binary/dwarf_disabled.rs

@@ -0,0 +1,41 @@
+//! Dummy version of dwarf emission that does nothing when the compile-time
+//! feature is disabled.
+
+use crate::core::binary::{EncodeOptions, Encoder, Names, RecOrType};
+use crate::core::Local;
+use crate::token::Span;
+
+pub struct Dwarf<'a> {
+    uninhabited: &'a std::convert::Infallible,
+}
+
+impl<'a> Dwarf<'a> {
+    pub fn new(
+        _func_imports: u32,
+        _opts: &EncodeOptions<'a>,
+        _names: &Names<'a>,
+        _types: &'a [RecOrType<'a>],
+    ) -> Option<Dwarf<'a>> {
+        None
+    }
+
+    pub fn start_func(&mut self, _span: Span, _ty: u32, _locals: &[Local<'_>]) {
+        match *self.uninhabited {}
+    }
+
+    pub fn instr(&mut self, _offset: usize, _span: Span) {
+        match *self.uninhabited {}
+    }
+
+    pub fn end_func(&mut self, _: usize, _: usize) {
+        match *self.uninhabited {}
+    }
+
+    pub fn set_code_section_size(&mut self, _size: usize) {
+        match *self.uninhabited {}
+    }
+
+    pub fn emit(&mut self, _dst: &mut Encoder<'_>) {
+        match *self.uninhabited {}
+    }
+}