wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-jit-9.0.4/src/lib.rs

@@ -1,39 +0,0 @@
-//! JIT-style runtime for WebAssembly using Cranelift.
-
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))]
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(clippy::new_without_default, clippy::new_without_default)
-)]
-#![cfg_attr(
-    feature = "cargo-clippy",
-    warn(
-        clippy::float_arithmetic,
-        clippy::mut_mut,
-        clippy::nonminimal_bool,
-        clippy::map_unwrap_or,
-        clippy::clippy::print_stdout,
-        clippy::unicode_not_nfc,
-        clippy::use_self
-    )
-)]
-
-mod code_memory;
-mod debug;
-mod demangling;
-mod instantiate;
-mod profiling;
-mod unwind;
-
-pub use crate::code_memory::CodeMemory;
-pub use crate::instantiate::{
-    subslice_range, CompiledFunctionInfo, CompiledModule, CompiledModuleInfo, ObjectBuilder,
-    SymbolizeContext,
-};
-pub use demangling::*;
-pub use profiling::*;
-
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");

data/ext/cargo-vendor/wasmtime-jit-9.0.4/src/profiling/jitdump_disabled.rs

@@ -1,32 +0,0 @@
-use crate::{CompiledModule, ProfilingAgent};
-use anyhow::{bail, Result};
-
-/// Interface for driving the creation of jitdump files
-#[derive(Debug)]
-pub struct JitDumpAgent {
-    _private: (),
-}
-
-impl JitDumpAgent {
-    /// Intialize a dummy JitDumpAgent that will fail upon instantiation.
-    pub fn new() -> Result<Self> {
-        if cfg!(feature = "jitdump") {
-            bail!("jitdump is not supported on this platform");
-        } else {
-            bail!("jitdump support disabled at compile time");
-        }
-    }
-}
-
-impl ProfilingAgent for JitDumpAgent {
-    fn module_load(&self, _module: &CompiledModule, _dbg_image: Option<&[u8]>) {}
-    fn load_single_trampoline(
-        &self,
-        _name: &str,
-        _addr: *const u8,
-        _size: usize,
-        __pid: u32,
-        _tid: u32,
-    ) {
-    }
-}

data/ext/cargo-vendor/wasmtime-jit-9.0.4/src/profiling/jitdump_linux.rs

@@ -1,444 +0,0 @@
-//! Support for jitdump files which can be used by perf for profiling jitted code.
-//! Spec definitions for the output format is as described here:
-//! <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/perf/Documentation/jitdump-specification.txt>
-//!
-//! Usage Example:
-//!     Record
-//!         sudo perf record -k 1 -e instructions:u target/debug/wasmtime -g --profile=jitdump test.wasm
-//!     Combine
-//!         sudo perf inject -v -j -i perf.data -o perf.jit.data
-//!     Report
-//!         sudo perf report -i perf.jit.data -F+period,srcline
-//! Note: For descriptive results, the WASM file being executed should contain dwarf debug data
-
-use crate::{CompiledModule, ProfilingAgent};
-use anyhow::Result;
-use object::{Object, ObjectSection};
-use std::sync::Mutex;
-use std::{borrow, mem, process};
-use target_lexicon::Architecture;
-use wasmtime_environ::EntityRef;
-use wasmtime_jit_debug::perf_jitdump::*;
-
-use object::elf;
-
-/// Interface for driving the creation of jitdump files
-pub struct JitDumpAgent {
-    /// Flag for experimenting with dumping code load record
-    /// after each function (true) or after each module. This
-    /// flag is currently set to true.
-    dump_funcs: bool,
-}
-
-/// Process-wide JIT dump file. Perf only accepts a unique file per process, in the injection step.
-static JITDUMP_FILE: Mutex<Option<JitDumpFile>> = Mutex::new(None);
-
-impl JitDumpAgent {
-    /// Intialize a JitDumpAgent and write out the header.
-    pub fn new() -> Result<Self> {
-        let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
-
-        if jitdump_file.is_none() {
-            let filename = format!("./jit-{}.dump", process::id());
-            let e_machine = match target_lexicon::HOST.architecture {
-                Architecture::X86_64 => elf::EM_X86_64 as u32,
-                Architecture::X86_32(_) => elf::EM_386 as u32,
-                Architecture::Arm(_) => elf::EM_ARM as u32,
-                Architecture::Aarch64(_) => elf::EM_AARCH64 as u32,
-                Architecture::S390x => elf::EM_S390 as u32,
-                _ => unimplemented!("unrecognized architecture"),
-            };
-            *jitdump_file = Some(JitDumpFile::new(filename, e_machine)?);
-        }
-
-        Ok(JitDumpAgent { dump_funcs: true })
-    }
-}
-
-impl ProfilingAgent for JitDumpAgent {
-    /// Sent when a method is compiled and loaded into memory by the VM.
-    fn module_load(&self, module: &CompiledModule, dbg_image: Option<&[u8]>) {
-        let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
-        let jitdump_file = jitdump_file.as_mut().unwrap();
-
-        let pid = process::id();
-        let tid = pid; // ThreadId does appear to track underlying thread. Using PID.
-
-        for (idx, func) in module.finished_functions() {
-            let addr = func.as_ptr();
-            let len = func.len();
-            if let Some(img) = &dbg_image {
-                if let Err(err) =
-                    self.dump_from_debug_image(jitdump_file, img, "wasm", addr, len, pid, tid)
-                {
-                    println!(
-                        "Jitdump: module_load failed dumping from debug image: {:?}\n",
-                        err
-                    );
-                }
-            } else {
-                let timestamp = jitdump_file.get_time_stamp();
-                let name = super::debug_name(module, idx);
-                if let Err(err) =
-                    jitdump_file.dump_code_load_record(&name, addr, len, timestamp, pid, tid)
-                {
-                    println!("Jitdump: write_code_load_failed_record failed: {:?}\n", err);
-                }
-            }
-        }
-
-        // Note: these are the trampolines into exported functions.
-        for (name, body) in module
-            .array_to_wasm_trampolines()
-            .map(|(i, body)| {
-                (
-                    format!("wasm::array_to_wasm_trampoline[{}]", i.index()),
-                    body,
-                )
-            })
-            .chain(module.native_to_wasm_trampolines().map(|(i, body)| {
-                (
-                    format!("wasm::native_to_wasm_trampoline[{}]", i.index()),
-                    body,
-                )
-            }))
-            .chain(module.wasm_to_native_trampolines().map(|(i, body)| {
-                (
-                    format!("wasm::wasm_to_native_trampolines[{}]", i.index()),
-                    body,
-                )
-            }))
-        {
-            let addr = body.as_ptr();
-            let len = body.len();
-            let timestamp = jitdump_file.get_time_stamp();
-            if let Err(err) =
-                jitdump_file.dump_code_load_record(&name, addr, len, timestamp, pid, tid)
-            {
-                println!("Jitdump: write_code_load_failed_record failed: {:?}\n", err);
-            }
-        }
-    }
-
-    fn load_single_trampoline(&self, name: &str, addr: *const u8, size: usize, pid: u32, tid: u32) {
-        let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
-        let jitdump_file = jitdump_file.as_mut().unwrap();
-
-        let timestamp = jitdump_file.get_time_stamp();
-        if let Err(err) = jitdump_file.dump_code_load_record(&name, addr, size, timestamp, pid, tid)
-        {
-            println!("Jitdump: write_code_load_failed_record failed: {:?}\n", err);
-        }
-    }
-}
-
-impl JitDumpAgent {
-    /// Attempts to dump debuginfo data structures, adding method and line level
-    /// for the jitted function.
-    pub fn dump_from_debug_image(
-        &self,
-        jitdump_file: &mut JitDumpFile,
-        dbg_image: &[u8],
-        module_name: &str,
-        addr: *const u8,
-        len: usize,
-        pid: u32,
-        tid: u32,
-    ) -> Result<()> {
-        let file = object::File::parse(dbg_image).unwrap();
-        let endian = if file.is_little_endian() {
-            gimli::RunTimeEndian::Little
-        } else {
-            gimli::RunTimeEndian::Big
-        };
-
-        let load_section = |id: gimli::SectionId| -> Result<borrow::Cow<[u8]>> {
-            if let Some(section) = file.section_by_name(id.name()) {
-                Ok(section.data()?.into())
-            } else {
-                Ok((&[] as &[u8]).into())
-            }
-        };
-
-        let dwarf_cow = gimli::Dwarf::load(&load_section)?;
-        let borrow_section: &dyn for<'a> Fn(
-            &'a borrow::Cow<[u8]>,
-        )
-            -> gimli::EndianSlice<'a, gimli::RunTimeEndian> =
-            &|section| gimli::EndianSlice::new(&*section, endian);
-
-        let dwarf = dwarf_cow.borrow(&borrow_section);
-
-        let mut iter = dwarf.units();
-        while let Some(header) = iter.next()? {
-            let unit = match dwarf.unit(header) {
-                Ok(unit) => unit,
-                Err(_err) => {
-                    return Ok(());
-                }
-            };
-            self.dump_entries(jitdump_file, unit, &dwarf, module_name, addr, len, pid, tid)?;
-            // TODO: Temp exit to avoid duplicate addresses being covered by only
-            // processing the top unit
-            break;
-        }
-        if !self.dump_funcs {
-            let timestamp = jitdump_file.get_time_stamp();
-            if let Err(err) =
-                jitdump_file.dump_code_load_record(module_name, addr, len, timestamp, pid, tid)
-            {
-                println!("Jitdump: write_code_load_failed_record failed: {:?}\n", err);
-            }
-        }
-        Ok(())
-    }
-
-    fn dump_entries<R: Reader>(
-        &self,
-        jitdump_file: &mut JitDumpFile,
-        unit: gimli::Unit<R>,
-        dwarf: &gimli::Dwarf<R>,
-        module_name: &str,
-        addr: *const u8,
-        len: usize,
-        pid: u32,
-        tid: u32,
-    ) -> Result<()> {
-        let mut depth = 0;
-        let mut entries = unit.entries();
-        while let Some((delta_depth, entry)) = entries.next_dfs()? {
-            if self.dump_funcs {
-                let record_header = RecordHeader {
-                    id: RecordId::JitCodeLoad as u32,
-                    record_size: 0,
-                    timestamp: 0,
-                };
-
-                let mut clr = CodeLoadRecord {
-                    header: record_header,
-                    pid,
-                    tid,
-                    virtual_address: 0,
-                    address: 0,
-                    size: 0,
-                    index: 0,
-                };
-                let mut clr_name: String = String::from(module_name);
-                let mut get_debug_entry = false;
-                depth += delta_depth;
-                assert!(depth >= 0);
-
-                if entry.tag() == gimli::constants::DW_TAG_subprogram {
-                    get_debug_entry = true;
-
-                    let mut attrs = entry.attrs();
-                    while let Some(attr) = attrs.next()? {
-                        if let Some(n) = attr.name().static_string() {
-                            if n == "DW_AT_low_pc" {
-                                clr.address = match attr.value() {
-                                    gimli::AttributeValue::Addr(address) => address,
-                                    _ => 0,
-                                };
-                                clr.virtual_address = clr.address;
-                            } else if n == "DW_AT_high_pc" {
-                                clr.size = match attr.value() {
-                                    gimli::AttributeValue::Udata(data) => data,
-                                    _ => 0,
-                                };
-                            } else if n == "DW_AT_name" {
-                                clr_name = match attr.value() {
-                                    gimli::AttributeValue::DebugStrRef(offset) => {
-                                        if let Ok(s) = dwarf.debug_str.get_str(offset) {
-                                            clr_name.push_str("::");
-                                            clr_name.push_str(&s.to_string_lossy()?);
-                                            clr_name
-                                        } else {
-                                            clr_name.push_str("::");
-                                            clr_name.push_str("?");
-                                            clr_name
-                                        }
-                                    }
-                                    _ => {
-                                        clr_name.push_str("??");
-                                        clr_name
-                                    }
-                                };
-                            }
-                        }
-                    }
-                }
-                if get_debug_entry {
-                    //  TODO: Temp check to make sure well only formed data is processed.
-                    if clr.address == 0 {
-                        continue;
-                    }
-                    //  TODO: Temp check to make sure well only formed data is processed.
-                    if clr_name == "?" {
-                        continue;
-                    }
-                    if clr.address == 0 || clr.size == 0 {
-                        clr.address = addr as u64;
-                        clr.virtual_address = addr as u64;
-                        clr.size = len as u64;
-                    }
-                    clr.header.record_size = mem::size_of::<CodeLoadRecord>() as u32
-                        + (clr_name.len() + 1) as u32
-                        + clr.size as u32;
-                    clr.index = jitdump_file.next_code_index();
-                    self.dump_debug_info(jitdump_file, &unit, &dwarf, clr.address, clr.size, None)?;
-
-                    clr.header.timestamp = jitdump_file.get_time_stamp();
-
-                    unsafe {
-                        let code_buffer: &[u8] =
-                            std::slice::from_raw_parts(clr.address as *const u8, clr.size as usize);
-                        let _ = jitdump_file.write_code_load_record(&clr_name, clr, code_buffer);
-                    }
-                }
-            } else {
-                let mut func_name: String = String::from("?");
-                let mut func_addr = 0;
-                let mut func_size = 0;
-
-                let mut get_debug_entry = false;
-                depth += delta_depth;
-                assert!(depth >= 0);
-                if entry.tag() == gimli::constants::DW_TAG_subprogram {
-                    get_debug_entry = true;
-
-                    let mut attrs = entry.attrs();
-                    while let Some(attr) = attrs.next()? {
-                        if let Some(n) = attr.name().static_string() {
-                            if n == "DW_AT_low_pc" {
-                                func_addr = match attr.value() {
-                                    gimli::AttributeValue::Addr(address) => address,
-                                    _ => 0,
-                                };
-                            } else if n == "DW_AT_high_pc" {
-                                func_size = match attr.value() {
-                                    gimli::AttributeValue::Udata(data) => data,
-                                    _ => 0,
-                                };
-                            } else if n == "DW_AT_name" {
-                                func_name = match attr.value() {
-                                    gimli::AttributeValue::DebugStrRef(offset) => {
-                                        if let Ok(s) = dwarf.debug_str.get_str(offset) {
-                                            func_name.clear();
-                                            func_name.push_str(&s.to_string_lossy()?);
-                                            func_name
-                                        } else {
-                                            func_name.push_str("?");
-                                            func_name
-                                        }
-                                    }
-                                    _ => {
-                                        func_name.push_str("??");
-                                        func_name
-                                    }
-                                };
-                            }
-                        }
-                    }
-                }
-                if get_debug_entry {
-                    //  TODO: Temp check to make sure well only formed data is processed.
-                    if func_addr == 0 {
-                        continue;
-                    }
-                    //  TODO: Temp check to make sure well only formed data is processed.
-                    if func_name == "?" {
-                        continue;
-                    }
-                    self.dump_debug_info(
-                        jitdump_file,
-                        &unit,
-                        &dwarf,
-                        func_addr,
-                        func_size,
-                        Some(func_name.as_str()),
-                    )?;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn dump_debug_info<R: Reader>(
-        &self,
-        jitdump_file: &mut JitDumpFile,
-        unit: &gimli::Unit<R>,
-        dwarf: &gimli::Dwarf<R>,
-        address: u64,
-        size: u64,
-        file_suffix: Option<&str>,
-    ) -> Result<()> {
-        let timestamp = jitdump_file.get_time_stamp();
-        if let Some(program) = unit.line_program.clone() {
-            let mut debug_info_record = DebugInfoRecord {
-                header: RecordHeader {
-                    id: RecordId::JitCodeDebugInfo as u32,
-                    record_size: 0,
-                    timestamp,
-                },
-                address,
-                count: 0,
-            };
-
-            let mut debug_entries = Vec::new();
-            let mut debug_entries_total_filenames_len = 0;
-            let mut rows = program.rows();
-            while let Some((header, row)) = rows.next_row()? {
-                let row_file_index = row.file_index() - 1;
-                let myfile = dwarf
-                    .attr_string(
-                        &unit,
-                        header.file_names()[row_file_index as usize].path_name(),
-                    )
-                    .unwrap();
-                let filename = myfile.to_string_lossy()?;
-                let line = row.line().map(|nonzero| nonzero.get()).unwrap_or(0);
-                let column = match row.column() {
-                    gimli::ColumnType::Column(column) => column.get(),
-                    gimli::ColumnType::LeftEdge => 0,
-                };
-
-                if (row.address() < address) || (row.address() > (address + size)) {
-                    continue;
-                }
-                let mut debug_entry = DebugEntry {
-                    address: row.address(),
-                    line: line as u32,
-                    discriminator: column as u32,
-                    filename: filename.to_string(),
-                };
-
-                if let Some(suffix) = file_suffix {
-                    debug_entry.filename.push_str("::");
-                    debug_entry.filename.push_str(suffix);
-                }
-
-                debug_entries_total_filenames_len += debug_entry.filename.len() + 1;
-                debug_entries.push(debug_entry);
-            }
-
-            debug_info_record.count = debug_entries.len() as u64;
-
-            let debug_entries_size = (debug_info_record.count
-                * (mem::size_of::<DebugEntry>() as u64 - mem::size_of::<String>() as u64))
-                + debug_entries_total_filenames_len as u64;
-            debug_info_record.header.record_size =
-                mem::size_of::<DebugInfoRecord>() as u32 + debug_entries_size as u32;
-
-            let _ = jitdump_file.write_debug_info_record(debug_info_record);
-            let _ = jitdump_file.write_debug_info_entries(debug_entries);
-        }
-        Ok(())
-    }
-}
-
-trait Reader: gimli::Reader<Offset = usize> + Send + Sync {}
-
-impl<'input, Endian> Reader for gimli::EndianSlice<'input, Endian> where
-    Endian: gimli::Endianity + Send + Sync
-{
-}

data/ext/cargo-vendor/wasmtime-jit-9.0.4/src/profiling/perfmap_disabled.rs

@@ -1,28 +0,0 @@
-use crate::{CompiledModule, ProfilingAgent};
-use anyhow::{bail, Result};
-
-/// Interface for driving the creation of jitdump files
-#[derive(Debug)]
-pub struct PerfMapAgent {
-    _private: (),
-}
-
-impl PerfMapAgent {
-    /// Intialize a dummy PerfMapAgent that will fail upon instantiation.
-    pub fn new() -> Result<Self> {
-        bail!("perfmap support not supported on this platform");
-    }
-}
-
-impl ProfilingAgent for PerfMapAgent {
-    fn module_load(&self, _module: &CompiledModule, _dbg_image: Option<&[u8]>) {}
-    fn load_single_trampoline(
-        &self,
-        _name: &str,
-        _addr: *const u8,
-        _size: usize,
-        __pid: u32,
-        _tid: u32,
-    ) {
-    }
-}

data/ext/cargo-vendor/wasmtime-jit-9.0.4/src/profiling/perfmap_linux.rs

@@ -1,104 +0,0 @@
-use crate::{CompiledModule, ProfilingAgent};
-use anyhow::Result;
-use std::io::{self, BufWriter, Write};
-use std::process;
-use std::{fs::File, sync::Mutex};
-use wasmtime_environ::EntityRef as _;
-
-/// Process-wide perf map file. Perf only reads a unique file per process.
-static PERFMAP_FILE: Mutex<Option<File>> = Mutex::new(None);
-
-/// Interface for driving the creation of jitdump files
-pub struct PerfMapAgent;
-
-impl PerfMapAgent {
-    /// Intialize a JitDumpAgent and write out the header.
-    pub fn new() -> Result<Self> {
-        let mut file = PERFMAP_FILE.lock().unwrap();
-        if file.is_none() {
-            let filename = format!("/tmp/perf-{}.map", process::id());
-            *file = Some(File::create(filename)?);
-        }
-        Ok(PerfMapAgent)
-    }
-
-    fn make_line(
-        writer: &mut dyn Write,
-        name: &str,
-        addr: *const u8,
-        len: usize,
-    ) -> io::Result<()> {
-        // Format is documented here: https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/jit-interface.txt
-        // Try our best to sanitize the name, since wasm allows for any utf8 string in there.
-        let sanitized_name = name.replace('\n', "_").replace('\r', "_");
-        write!(writer, "{:x} {:x} {}\n", addr as usize, len, sanitized_name)?;
-        Ok(())
-    }
-}
-
-impl ProfilingAgent for PerfMapAgent {
-    /// Sent when a method is compiled and loaded into memory by the VM.
-    fn module_load(&self, module: &CompiledModule, _dbg_image: Option<&[u8]>) {
-        let mut file = PERFMAP_FILE.lock().unwrap();
-        let file = file.as_mut().unwrap();
-        let mut file = BufWriter::new(file);
-
-        for (idx, func) in module.finished_functions() {
-            let addr = func.as_ptr();
-            let len = func.len();
-            let name = super::debug_name(module, idx);
-            if let Err(err) = Self::make_line(&mut file, &name, addr, len) {
-                eprintln!("Error when writing function info to the perf map file: {err}");
-                return;
-            }
-        }
-
-        // Note: these are the trampolines into exported functions.
-        for (name, body) in module
-            .array_to_wasm_trampolines()
-            .map(|(i, body)| {
-                (
-                    format!("wasm::array_to_wasm_trampoline[{}]", i.index()),
-                    body,
-                )
-            })
-            .chain(module.native_to_wasm_trampolines().map(|(i, body)| {
-                (
-                    format!("wasm::native_to_wasm_trampoline[{}]", i.index()),
-                    body,
-                )
-            }))
-            .chain(module.wasm_to_native_trampolines().map(|(i, body)| {
-                (
-                    format!("wasm::wasm_to_native_trampolines[{}]", i.index()),
-                    body,
-                )
-            }))
-        {
-            let (addr, len) = (body.as_ptr(), body.len());
-            if let Err(err) = Self::make_line(&mut file, &name, addr, len) {
-                eprintln!("Error when writing export trampoline info to the perf map file: {err}");
-                return;
-            }
-        }
-
-        if let Err(err) = file.flush() {
-            eprintln!("Error when flushing the perf map file buffer: {err}");
-        }
-    }
-
-    fn load_single_trampoline(
-        &self,
-        name: &str,
-        addr: *const u8,
-        size: usize,
-        _pid: u32,
-        _tid: u32,
-    ) {
-        let mut file = PERFMAP_FILE.lock().unwrap();
-        let file = file.as_mut().unwrap();
-        if let Err(err) = Self::make_line(file, name, addr, size) {
-            eprintln!("Error when writing import trampoline info to the perf map file: {err}");
-        }
-    }
-}