wasmtime 17.0.1 → 18.0.3

data/ext/cargo-vendor/wasmtime-18.0.3/src/lib.rs

@@ -0,0 +1,444 @@
+//! Wasmtime's embedding API
+//!
+//! Wasmtime is a WebAssembly engine for JIT-compiled or ahead-of-time compiled
+//! WebAssembly modules. More information about the Wasmtime project as a whole
+//! can be found [in the documentation book](https://docs.wasmtime.dev) whereas
+//! this documentation mostly focuses on the API reference of the `wasmtime`
+//! crate itself.
+//!
+//! This crate contains an API used to interact with WebAssembly modules. For
+//! example you can compile modules, instantiate them, call them, etc. As an
+//! embedder of WebAssembly you can also provide WebAssembly modules
+//! functionality from the host by creating host-defined functions, memories,
+//! globals, etc, which can do things that WebAssembly cannot (such as print to
+//! the screen).
+//!
+//! The `wasmtime` crate has similar concepts to the
+//! the [JS WebAssembly
+//! API](https://developer.mozilla.org/en-US/docs/WebAssembly) as well as the
+//! [proposed C API](https://github.com/webassembly/wasm-c-api), but the Rust
+//! API is designed for efficiency, ergonomics, and expressivity in Rust. As
+//! with all other Rust code you're guaranteed that programs will be safe (not
+//! have undefined behavior or segfault) so long as you don't use `unsafe` in
+//! your own program. With `wasmtime` you can easily and conveniently embed a
+//! WebAssembly runtime with confidence that the WebAssembly is safely
+//! sandboxed.
+//!
+//! An example of using Wasmtime looks like:
+//!
+//! ```
+//! use wasmtime::*;
+//!
+//! fn main() -> wasmtime::Result<()> {
+//!     // Modules can be compiled through either the text or binary format
+//!     let engine = Engine::default();
+//!     let wat = r#"
+//!         (module
+//!             (import "host" "host_func" (func $host_hello (param i32)))
+//!
+//!             (func (export "hello")
+//!                 i32.const 3
+//!                 call $host_hello)
+//!         )
+//!     "#;
+//!     let module = Module::new(&engine, wat)?;
+//!
+//!     // All wasm objects operate within the context of a "store". Each
+//!     // `Store` has a type parameter to store host-specific data, which in
+//!     // this case we're using `4` for.
+//!     let mut store = Store::new(&engine, 4);
+//!     let host_func = Func::wrap(&mut store, |caller: Caller<'_, u32>, param: i32| {
+//!         println!("Got {} from WebAssembly", param);
+//!         println!("my host state is: {}", caller.data());
+//!     });
+//!
+//!     // Instantiation of a module requires specifying its imports and then
+//!     // afterwards we can fetch exports by name, as well as asserting the
+//!     // type signature of the function with `get_typed_func`.
+//!     let instance = Instance::new(&mut store, &module, &[host_func.into()])?;
+//!     let hello = instance.get_typed_func::<(), ()>(&mut store, "hello")?;
+//!
+//!     // And finally we can call the wasm!
+//!     hello.call(&mut store, ())?;
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ## Core Concepts
+//!
+//! There are a number of core types and concepts that are important to be aware
+//! of when using the `wasmtime` crate:
+//!
+//! * [`Engine`] - a global compilation environment for WebAssembly. An
+//!   [`Engine`] is an object that can be shared concurrently across threads and
+//!   is created with a [`Config`] to tweak various settings. Compilation of any
+//!   WebAssembly requires first configuring and creating an [`Engine`].
+//!
+//! * [`Module`] - a compiled WebAssembly module. This structure represents
+//!   in-memory JIT code which is ready to execute after being instantiated.
+//!   It's often important to cache instances of a [`Module`] because creation
+//!   (compilation) can be expensive. Note that [`Module`] is safe to share
+//!   across threads, and can be created from a WebAssembly binary and an
+//!   [`Engine`] with [`Module::new`]. Caching can either happen with
+//!   [`Engine::precompile_module`] or [`Module::serialize`], feeding those
+//!   bytes back into [`Module::deserialize`].
+//!
+//! * [`Store`] - container for all information related to WebAssembly objects
+//!   such as functions, instances, memories, etc. A [`Store<T>`][`Store`]
+//!   allows customization of the `T` to store arbitrary host data within a
+//!   [`Store`]. This host data can be accessed through host functions via the
+//!   [`Caller`] function parameter in host-defined functions. A [`Store`] is
+//!   required for all WebAssembly operations, such as calling a wasm function.
+//!   The [`Store`] is passed in as a "context" to methods like [`Func::call`].
+//!   Dropping a [`Store`] will deallocate all memory associated with
+//!   WebAssembly objects within the [`Store`].
+//!
+//! * [`Instance`] - an instantiated WebAssembly module. An instance is where
+//!   you can actually acquire a [`Func`] from, for example, to call.
+//!
+//! * [`Func`] - a WebAssembly (or host) function. This can be acquired as the
+//!   export of an [`Instance`] to call WebAssembly functions, or it can be
+//!   created via functions like [`Func::wrap`] to wrap host-defined
+//!   functionality and give it to WebAssembly.
+//!
+//! * [`Table`], [`Global`], [`Memory`] - other WebAssembly objects which can
+//!   either be defined on the host or in wasm itself (via instances). These all
+//!   have various ways of being interacted with like [`Func`].
+//!
+//! All "store-connected" types such as [`Func`], [`Memory`], etc, require the
+//! store to be passed in as a context to each method. Methods in wasmtime
+//! frequently have their first parameter as either [`impl
+//! AsContext`][`AsContext`] or [`impl AsContextMut`][`AsContextMut`]. These
+//! traits are implemented for a variety of types, allowing you to, for example,
+//! pass the following types into methods:
+//!
+//! * `&Store<T>`
+//! * `&mut Store<T>`
+//! * `&Caller<'_, T>`
+//! * `&mut Caller<'_, T>`
+//! * `StoreContext<'_, T>`
+//! * `StoreContextMut<'_, T>`
+//!
+//! A [`Store`] is the sole owner of all WebAssembly internals. Types like
+//! [`Func`] point within the [`Store`] and require the [`Store`] to be provided
+//! to actually access the internals of the WebAssembly function, for instance.
+//!
+//! ## Linking
+//!
+//! WebAssembly modules almost always require functionality from the host to
+//! perform I/O-like tasks. They might refer to quite a few pieces of host
+//! functionality, WASI, or maybe even a number of other wasm modules. To assist
+//! with managing this a [`Linker`] type is provided to instantiate modules.
+//!
+//! A [`Linker`] performs name-based resolution of the imports of a WebAssembly
+//! module so the [`Linker::instantiate`] method does not take an `imports`
+//! argument like [`Instance::new`] does. Methods like [`Linker::define`] or
+//! [`Linker::func_wrap`] can be used to define names within a [`Linker`] to
+//! later be used for instantiation.
+//!
+//! For example we can reimplement the above example with a `Linker`:
+//!
+//! ```
+//! use wasmtime::*;
+//!
+//! fn main() -> wasmtime::Result<()> {
+//!     let engine = Engine::default();
+//!     let wat = r#"
+//!         (module
+//!             (import "host" "host_func" (func $host_hello (param i32)))
+//!
+//!             (func (export "hello")
+//!                 i32.const 3
+//!                 call $host_hello)
+//!         )
+//!     "#;
+//!     let module = Module::new(&engine, wat)?;
+//!
+//!     // Create a `Linker` and define our host function in it:
+//!     let mut linker = Linker::new(&engine);
+//!     linker.func_wrap("host", "host_func", |caller: Caller<'_, u32>, param: i32| {
+//!         println!("Got {} from WebAssembly", param);
+//!         println!("my host state is: {}", caller.data());
+//!     })?;
+//!
+//!     // Use the `linker` to instantiate the module, which will automatically
+//!     // resolve the imports of the module using name-based resolution.
+//!     let mut store = Store::new(&engine, 0);
+//!     let instance = linker.instantiate(&mut store, &module)?;
+//!     let hello = instance.get_typed_func::<(), ()>(&mut store, "hello")?;
+//!     hello.call(&mut store, ())?;
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! The [`Linker`] type also transparently handles Commands and Reactors
+//! as defined by WASI.
+//!
+//! ## Example Architecture
+//!
+//! To better understand how Wasmtime types interact with each other let's walk
+//! through, at a high-level, an example of how you might use WebAssembly. In
+//! our use case let's say we have a web server where we'd like to run some
+//! custom WebAssembly on each request. To ensure requests are entirely isolated
+//! from each other, though, we'll be creating a new [`Store`] for each
+//! request.
+//!
+//! When the server starts, we'll start off by creating an [`Engine`] (and maybe
+//! tweaking [`Config`] settings if necessary). This [`Engine`] will be the only
+//! engine for the lifetime of the server itself. Next, we can compile our
+//! WebAssembly. You'd create a [`Module`] through the [`Module::new`] API.
+//! This will generate JIT code and perform expensive compilation tasks
+//! up-front. Finally the last step of initialization would be to create a
+//! [`Linker`] which will later be used to instantiate modules, adding
+//! functionality like WASI to the linker too.
+//!
+//! After that setup, the server starts up as usual and is ready to receive
+//! requests. Upon receiving a request you'd then create a [`Store`] with
+//! [`Store::new`] referring to the original [`Engine`]. Using your [`Module`]
+//! and [`Linker`] from before you'd then call [`Linker::instantiate`] to
+//! instantiate our module for the request. Both of these operations are
+//! designed to be as cheap as possible.
+//!
+//! With an [`Instance`] you can then invoke various exports and interact with
+//! the WebAssembly module. Once the request is finished, the [`Store`]
+//! is dropped and everything will be deallocated. Note that if the same
+//! [`Store`] were used for every request then that would have all requests
+//! sharing resources and nothing would ever get deallocated, causing memory
+//! usage to baloon and would achive less isolation between requests.
+//!
+//! ## WASI
+//!
+//! The `wasmtime` crate does not natively provide support for WASI, but you can
+//! use the [`wasmtime-wasi`] crate for that purpose. With [`wasmtime-wasi`] all
+//! WASI functions can be added to a [`Linker`] and then used to instantiate
+//! WASI-using modules. For more information see the [WASI example in the
+//! documentation](https://docs.wasmtime.dev/examples-rust-wasi.html).
+//!
+//! [`wasmtime-wasi`]: https://crates.io/crates/wasmtime-wasi
+//!
+//! ## Cross-store usage of items
+//!
+//! In `wasmtime` wasm items such as [`Global`] and [`Memory`] "belong" to a
+//! [`Store`]. The store they belong to is the one they were created with
+//! (passed in as a parameter) or instantiated with. This store is the only
+//! store that can be used to interact with wasm items after they're created.
+//!
+//! The `wasmtime` crate will panic if the [`Store`] argument passed in to these
+//! operations is incorrect. In other words it's considered a programmer error
+//! rather than a recoverable error for the wrong [`Store`] to be used when
+//! calling APIs.
+//!
+//! ## Crate Features
+//!
+//! The `wasmtime` crate comes with a number of compile-time features that can
+//! be used to customize what features it supports. Some of these features are
+//! just internal details, but some affect the public API of the `wasmtime`
+//! crate. Be sure to check the API you're using to see if any crate features
+//! are enabled.
+//!
+//! * `runtime` - Enabled by default, this feature enables executing
+//!   WebAssembly modules. If modules are only compiled, however, this feature
+//!   can be disabled.
+//!
+//! * `cranelift` - Enabled by default, this features enables using Cranelift at
+//!   runtime to compile a WebAssembly module to native code. This feature is
+//!   required to process and compile new WebAssembly modules. If this feature
+//!   is disabled then the only way to create a [`Module`] is to use the
+//!   [`Module::deserialize`] function with a precompiled artifact (typically
+//!   compiled with the same version of Wasmtime, just somewhere else).
+//!
+//! * `cache` - Enabled by default, this feature adds support for wasmtime to
+//!   perform internal caching of modules in a global location. This must still
+//!   be enabled explicitly through [`Config::cache_config_load`] or
+//!   [`Config::cache_config_load_default`].
+//!
+//! * `wat` - Enabled by default, this feature adds support for accepting the
+//!   text format of WebAssembly in [`Module::new`]. The text format will be
+//!   automatically recognized and translated to binary when compiling a
+//!   module.
+//!
+//! * `parallel-compilation` - Enabled by default, this feature enables support
+//!   for compiling functions of a module in parallel with `rayon`.
+//!
+//! * `async` - Enabled by default, this feature enables APIs and runtime
+//!   support for defining asynchronous host functions and calling WebAssembly
+//!   asynchronously.
+//!
+//! * `jitdump` - Enabled by default, this feature compiles in support for the
+//!   jitdump runtime profiling format. The profiler can be selected with
+//!   [`Config::profiler`].
+//!
+//! * `vtune` - Enabled by default, this feature compiles in support for VTune
+//!   profiling of JIT code.
+//!
+//! * `all-arch` - Not enabled by default. This feature compiles in support for
+//!   all architectures for both the JIT compiler and the `wasmtime compile` CLI
+//!   command.
+//!
+//! * `pooling-allocator` - Enabled by default, this feature adds support for
+//!   the pooling allocation strategy enabled via
+//!   [`Config::allocation_strategy`]. The pooling allocator can enable more
+//!   efficient reuse of resources for high-concurrency and
+//!   high-instantiation-count scenarios.
+//!
+//! * `memory-init-cow` - Enabled by default, this feature builds in support
+//!   for, on supported platforms, initializing wasm linear memories with
+//!   copy-on-write heap mappings. This makes instantiation much faster by
+//!   `mmap`-ing the initial memory image into place instead of copying memory
+//!   into place, allowing sharing pages that end up only getting read. Note
+//!   that this is simply compile-time support and this must also be enabled at
+//!   run-time via [`Config::memory_init_cow`] (which is also enabled by
+//!   default).
+//!
+//! * `demangle` - Enabled by default, this will affect how backtraces are
+//!   printed and whether symbol names from WebAssembly are attempted to be
+//!   demangled. Rust and C++ demanglings are currently supported.
+//!
+//! * `coredump` - Enabled by default, this will provide support for generating
+//!   a core dump when a trap happens. This can be configured via
+//!   [`Config::coredump_on_trap`].
+//!
+//! * `addr2line` - Enabled by default, this feature configures whether traps
+//!   will attempt to parse DWARF debug information and convert WebAssembly
+//!   addresses to source filenames and line numbers.
+//!
+//! * `debug-builtins` - Enabled by default, this feature includes some built-in
+//!   debugging utilities and symbols for native debuggers such as GDB and LLDB
+//!   to attach to the process Wasmtime is used within. The intrinsics provided
+//!   will enable debugging guest code compiled to WebAssembly. This must also
+//!   be enabled via [`Config::debug_info`] as well for guests.
+//!
+//! More crate features can be found in the [manifest] of Wasmtime itself for
+//! seeing what can be enabled and disabled.
+//!
+//! [manifest]: https://github.com/bytecodealliance/wasmtime/blob/main/crates/wasmtime/Cargo.toml
+//!
+//! ## Examples
+//!
+//! In addition to the examples below be sure to check out the [online embedding
+//! documentation][rustdocs] as well as the [online list of examples][examples]
+//!
+//! [rustdocs]: https://bytecodealliance.github.io/wasmtime/lang-rust.html
+//! [examples]: https://bytecodealliance.github.io/wasmtime/examples-rust-embed.html
+//!
+//! An example of using WASI looks like:
+//!
+//! ```no_run
+//! # use wasmtime::*;
+//! use wasi_common::sync::WasiCtxBuilder;
+//!
+//! # fn main() -> wasmtime::Result<()> {
+//! // Compile our module and create a `Linker` which has WASI functions defined
+//! // within it.
+//! let engine = Engine::default();
+//! let module = Module::from_file(&engine, "foo.wasm")?;
+//! let mut linker = Linker::new(&engine);
+//! wasi_common::sync::add_to_linker(&mut linker, |cx| cx)?;
+//!
+//! // Configure and create a `WasiCtx`, which WASI functions need access to
+//! // through the host state of the store (which in this case is the host state
+//! // of the store)
+//! let wasi_ctx = WasiCtxBuilder::new().inherit_stdio().build();
+//! let mut store = Store::new(&engine, wasi_ctx);
+//!
+//! // Instantiate our module with the imports we've created, and run it.
+//! let instance = linker.instantiate(&mut store, &module)?;
+//! // ...
+//!
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! An example of reading a string from a wasm module:
+//!
+//! ```
+//! use std::str;
+//!
+//! # use wasmtime::*;
+//! # fn main() -> wasmtime::Result<()> {
+//! let mut store = Store::default();
+//! let log_str = Func::wrap(&mut store, |mut caller: Caller<'_, ()>, ptr: i32, len: i32| {
+//!     // Use our `caller` context to learn about the memory export of the
+//!     // module which called this host function.
+//!     let mem = match caller.get_export("memory") {
+//!         Some(Extern::Memory(mem)) => mem,
+//!         _ => anyhow::bail!("failed to find host memory"),
+//!     };
+//!
+//!     // Use the `ptr` and `len` values to get a subslice of the wasm-memory
+//!     // which we'll attempt to interpret as utf-8.
+//!     let data = mem.data(&caller)
+//!         .get(ptr as u32 as usize..)
+//!         .and_then(|arr| arr.get(..len as u32 as usize));
+//!     let string = match data {
+//!         Some(data) => match str::from_utf8(data) {
+//!             Ok(s) => s,
+//!             Err(_) => anyhow::bail!("invalid utf-8"),
+//!         },
+//!         None => anyhow::bail!("pointer/length out of bounds"),
+//!     };
+//!     assert_eq!(string, "Hello, world!");
+//!     println!("{}", string);
+//!     Ok(())
+//! });
+//! let module = Module::new(
+//!     store.engine(),
+//!     r#"
+//!         (module
+//!             (import "" "" (func $log_str (param i32 i32)))
+//!             (func (export "foo")
+//!                 i32.const 4   ;; ptr
+//!                 i32.const 13  ;; len
+//!                 call $log_str)
+//!             (memory (export "memory") 1)
+//!             (data (i32.const 4) "Hello, world!"))
+//!     "#,
+//! )?;
+//! let instance = Instance::new(&mut store, &module, &[log_str.into()])?;
+//! let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
+//! foo.call(&mut store, ())?;
+//! # Ok(())
+//! # }
+//! ```
+
+#![deny(missing_docs)]
+#![doc(test(attr(deny(warnings))))]
+#![doc(test(attr(allow(dead_code, unused_variables, unused_mut))))]
+#![cfg_attr(nightlydoc, feature(doc_cfg))]
+#![cfg_attr(not(feature = "default"), allow(dead_code, unused_imports))]
+// Allow broken links when the default features is disabled because most of our
+// documentation is written for the "one build" of the `main` branch which has
+// most features enabled. This will present warnings in stripped-down doc builds
+// and will prevent the doc build from failing.
+#![cfg_attr(feature = "default", deny(rustdoc::broken_intra_doc_links))]
+
+#[cfg(feature = "runtime")]
+mod runtime;
+#[cfg(feature = "runtime")]
+pub use runtime::*;
+
+#[cfg(any(feature = "cranelift", feature = "winch"))]
+mod compile;
+
+mod config;
+mod engine;
+mod profiling_agent;
+
+pub use crate::config::*;
+pub use crate::engine::*;
+
+/// A convenience wrapper for `Result<T, anyhow::Error>`.
+///
+/// This type can be used to interact with `wasmtimes`'s extensive use
+/// of `anyhow::Error` while still not directly depending on `anyhow`.
+/// This type alias is identical to `anyhow::Result`.
+pub use anyhow::{Error, Result};
+
+fn _assert_send_and_sync<T: Send + Sync>() {}
+
+fn _assertions_lib() {
+    _assert_send_and_sync::<Engine>();
+    _assert_send_and_sync::<Config>();
+}

data/ext/cargo-vendor/wasmtime-18.0.3/src/profiling_agent/jitdump.rs

@@ -0,0 +1,66 @@
+//! 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::profiling_agent::ProfilingAgent;
+use anyhow::Result;
+use std::process;
+use std::sync::Mutex;
+use target_lexicon::Architecture;
+use wasmtime_jit_debug::perf_jitdump::*;
+
+use object::elf;
+
+/// Interface for driving the creation of jitdump files
+struct JitDumpAgent {
+    pid: u32,
+}
+
+/// 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);
+
+/// Intialize a JitDumpAgent and write out the header.
+pub fn new() -> Result<Box<dyn ProfilingAgent>> {
+    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(Box::new(JitDumpAgent {
+        pid: std::process::id(),
+    }))
+}
+
+impl ProfilingAgent for JitDumpAgent {
+    fn register_function(&self, name: &str, addr: *const u8, size: usize) {
+        let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
+        let jitdump_file = jitdump_file.as_mut().unwrap();
+        let timestamp = jitdump_file.get_time_stamp();
+        #[allow(trivial_numeric_casts)]
+        let tid = rustix::thread::gettid().as_raw_nonzero().get() as u32;
+        if let Err(err) =
+            jitdump_file.dump_code_load_record(&name, addr, size, timestamp, self.pid, tid)
+        {
+            println!("Jitdump: write_code_load_failed_record failed: {:?}\n", err);
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-18.0.3/src/profiling_agent/perfmap.rs

@@ -0,0 +1,47 @@
+use crate::profiling_agent::ProfilingAgent;
+use anyhow::Result;
+use std::io::{self, BufWriter, Write};
+use std::process;
+use std::{fs::File, sync::Mutex};
+
+/// Process-wide perf map file. Perf only reads a unique file per process.
+static PERFMAP_FILE: Mutex<Option<BufWriter<File>>> = Mutex::new(None);
+
+/// Interface for driving the creation of jitdump files
+struct PerfMapAgent;
+
+/// Intialize a JitDumpAgent and write out the header.
+pub fn new() -> Result<Box<dyn ProfilingAgent>> {
+    let mut file = PERFMAP_FILE.lock().unwrap();
+    if file.is_none() {
+        let filename = format!("/tmp/perf-{}.map", process::id());
+        *file = Some(BufWriter::new(File::create(filename)?));
+    }
+    Ok(Box::new(PerfMapAgent))
+}
+
+impl 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)?;
+        writer.flush()?;
+        Ok(())
+    }
+}
+
+impl ProfilingAgent for PerfMapAgent {
+    fn register_function(&self, name: &str, addr: *const u8, size: usize) {
+        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}");
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-18.0.3/src/profiling_agent/vtune.rs

@@ -0,0 +1,80 @@
+//! Adds support for profiling JIT-ed code using VTune. By default, VTune
+//! support is built in to Wasmtime (configure with the `vtune` feature flag).
+//! To enable it at runtime, use the `--profile=vtune` CLI flag.
+//!
+//! ### Profile
+//!
+//! ```ignore
+//! vtune -run-pass-thru=--no-altstack -v -collect hotspots target/debug/wasmtime --profile=vtune test.wasm
+//! ```
+//!
+//! Note: `vtune` is a command-line tool for VTune which must [be
+//! installed](https://www.intel.com/content/www/us/en/developer/tools/oneapi/vtune-profiler.html#standalone)
+//! for this to work.
+
+use crate::profiling_agent::ProfilingAgent;
+use anyhow::Result;
+use ittapi::jit::MethodLoadBuilder;
+use std::sync::Mutex;
+
+/// Interface for driving the ittapi for VTune support
+struct VTuneAgent {
+    // Note that we use a mutex internally to serialize state updates since multiple threads may be
+    // sharing this agent.
+    state: Mutex<State>,
+}
+
+/// Interface for driving vtune
+#[derive(Default)]
+struct State {
+    vtune: ittapi::jit::Jit,
+}
+
+/// Initialize a VTuneAgent.
+pub fn new() -> Result<Box<dyn ProfilingAgent>> {
+    Ok(Box::new(VTuneAgent {
+        state: Mutex::new(State {
+            vtune: Default::default(),
+        }),
+    }))
+}
+
+impl Drop for VTuneAgent {
+    fn drop(&mut self) {
+        self.state.lock().unwrap().event_shutdown();
+    }
+}
+
+impl State {
+    /// Notify vtune about a newly tracked code region.
+    fn notify_code(&mut self, module_name: &str, method_name: &str, addr: *const u8, len: usize) {
+        self.vtune
+            .load_method(
+                MethodLoadBuilder::new(method_name.to_owned(), addr, len)
+                    .class_file_name(module_name.to_owned())
+                    .source_file_name("<unknown wasm filename>".to_owned()),
+            )
+            .unwrap();
+    }
+
+    /// Shutdown module
+    fn event_shutdown(&mut self) {
+        // Ignore if something went wrong.
+        let _ = self.vtune.shutdown();
+    }
+}
+
+impl ProfilingAgent for VTuneAgent {
+    fn register_function(&self, name: &str, addr: *const u8, size: usize) {
+        self.state
+            .lock()
+            .unwrap()
+            .register_function(name, addr, size);
+    }
+}
+
+impl State {
+    fn register_function(&mut self, name: &str, addr: *const u8, size: usize) {
+        self.notify_code("wasmtime", name, addr, size);
+    }
+}