wasmtime 20.0.2 → 21.0.1

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

@@ -1,303 +0,0 @@
-//! # Wasmtime's embedding API
-//!
-//! Wasmtime is a WebAssembly engine for JIT-compiled or ahead-of-time compiled
-//! WebAssembly modules and components. 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] or
-//! [WebAssembly components]. For example you can compile WebAssembly, create
-//! instances, call functions, etc. As an embedder of WebAssembly you can also
-//! provide guests 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).
-//!
-//! [WebAssembly modules]: https://webassembly.github.io/spec
-//! [WebAssembly components]: https://component-model.bytecodealliance.org
-//!
-//! The `wasmtime` crate is designed to be safe, efficient, and ergonomic.
-//! This enables executing WebAssembly without the embedder needing to use
-//! `unsafe` code, meaning that you're guaranteed there is no undefined behavior
-//! or segfaults in either the WebAssembly guest or the host itself.
-//!
-//! The `wasmtime` crate can roughly be thought of as being split into two
-//! halves:
-//!
-//! * One half of the crate is similar to 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) and is
-//!   intended for working with [WebAssembly modules]. This API resides in the
-//!   root of the `wasmtime` crate's namespace, for example
-//!   [`wasmtime::Module`](`Module`).
-//!
-//! * The second half of the crate is for use with the [WebAssembly Component
-//!   Model]. The implementation of the component model is present in
-//!   [`wasmtime::component`](`component`) and roughly mirrors the structure for
-//!   core WebAssembly, for example [`component::Func`] mirrors [`Func`].
-//!
-//! [WebAssembly Component Model]: https://component-model.bytecodealliance.org
-//!
-//! An example of using Wasmtime to run a core WebAssembly module looks like:
-//!
-//! ```
-//! use wasmtime::*;
-//!
-//! fn main() -> wasmtime::Result<()> {
-//!     let engine = Engine::default();
-//!
-//!     // Modules can be compiled through either the text or binary format
-//!     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)?;
-//!
-//!     // Host functionality can be arbitrary Rust functions and is provided
-//!     // to guests through a `Linker`.
-//!     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());
-//!     })?;
-//!
-//!     // 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<u32> = Store::new(&engine, 4);
-//!
-//!     // 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 = linker.instantiate(&mut store, &module)?;
-//!     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 and runtime environment for WebAssembly.
-//!   An [`Engine`] is an object that can be shared concurrently across threads
-//!   and is created with a [`Config`] with many knobs for configuring
-//!   behavior. Compiling or executing any WebAssembly requires first
-//!   configuring and creating an [`Engine`]. All [`Module`]s and
-//!   [`Component`](component::Component)s belong to an [`Engine`], and
-//!   typically there's one [`Engine`] per process.
-//!
-//! * [`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`]. A [`Store`] is cheap to create
-//!   and destroy and does not GC objects such as unused instances internally,
-//!   so it's intended to be short-lived (or no longer than the instances it
-//!   contains).
-//!
-//! * [`Linker`] (or [`component::Linker`]) - host functions are defined within
-//!   a linker to provide them a string-based name which can be looked up when
-//!   instantiating a WebAssembly module or component. Linkers are traditionally
-//!   populated at startup and then reused for all future instantiations of all
-//!   instances, assuming the set of host functions does not change over time.
-//!   Host functions are `Fn(..) + Send + Sync` and typically do not close over
-//!   mutable state. Instead it's recommended to store mutable state in the `T`
-//!   of [`Store<T>`] which is accessed through [`Caller<'_,
-//!   T>`](crate::Caller) provided to host functions.
-//!
-//! * [`Module`] (or [`Component`](component::Component)) - a compiled
-//!   WebAssembly module or component. These structures contain compiled
-//!   executable code from a WebAssembly binary which is ready to execute after
-//!   being instantiated. These are expensive to create as they require
-//!   compilation of the input WebAssembly. Modules and components are safe to
-//!   share across threads, however. Modules and components can additionally be
-//!   [serialized into a list of bytes](crate::Module::serialize) to later be
-//!   [deserialized](crate::Module::deserialize) quickly. This enables JIT-style
-//!   compilation through constructors such as [`Module::new`] and AOT-style
-//!   compilation by having the compilation process use [`Module::serialize`]
-//!   and the execution process use [`Module::deserialize`].
-//!
-//! * [`Instance`] (or [`component::Instance`]) - an instantiated WebAssembly
-//!   module or component. An instance is where you can actually acquire a
-//!   [`Func`] (or [`component::Func`]) from, for example, to call.
-//!
-//! * [`Func`] (or [`component::Func`]) - a WebAssembly 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. Functions also have
-//!   typed views as [`TypedFunc`] or [`component::TypedFunc`] for a more
-//!   efficient calling convention.
-//!
-//! * [`Table`], [`Global`], [`Memory`], [`component::Resource`] - 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.
-//!
-//! ## 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
-//!
-//! ## 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. Wasmtime APIs gated behind a Cargo feature should be indicated as
-//! such in the documentation.
-//!
-//! * `runtime` - Enabled by default, this feature enables executing
-//!   WebAssembly modules and components. If a compiler is not available (such
-//!   as `cranelift`) then [`Module::deserialize`] must be used, for example, to
-//!   provide an ahead-of-time compiled artifact to execute WebAssembly.
-//!
-//! * `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 and components.
-//!
-//! * `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`] and
-//!   [`Component::new`](component::Component::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 in parallel with `rayon`.
-//!
-//! * `async` - Enabled by default, this feature enables APIs and runtime
-//!   support for defining asynchronous host functions and calling WebAssembly
-//!   asynchronously. For more information see [`Config::async_support`].
-//!
-//! * `profiling` - Enabled by default, this feature compiles in support for
-//!   profiling guest code via a number of possible strategies. See
-//!   [`Config::profiler`] for more information.
-//!
-//! * `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. This can be combined with [`Config::target`] to precompile
-//!   modules for a different platform than the host.
-//!
-//! * `pooling-allocator` - Enabled by default, this feature adds support for
-//!   [`PoolingAllocationConfig`] to pass to [`Config::allocation_strategy`].
-//!   The pooling allocator can enable efficient reuse of resources for
-//!   high-concurrency and high-instantiation-count scenarios.
-//!
-//! * `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.
-//!
-//! * `component-model` - Enabled by default, this enables support for the
-//!   [`wasmtime::component`](component) API for working with components.
-//!
-//! * `gc` - Enabled by default, this enables support for a number of
-//!   WebAssembly proposals such as `reference-types`, `function-references`,
-//!   and `gc`. Note that the implementation of the `gc` proposal itself is not
-//!   yet complete at this time.
-//!
-//! * `threads` - Enabled by default, this enables compile-time support for the
-//!   WebAssembly `threads` proposal, notably shared memories.
-//!
-//! 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
-
-#![deny(missing_docs)]
-#![doc(test(attr(deny(warnings))))]
-#![doc(test(attr(allow(dead_code, unused_variables, unused_mut))))]
-#![cfg_attr(docsrs, 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;
-#[cfg(any(feature = "cranelift", feature = "winch"))]
-pub use compile::CodeBuilder;
-
-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`.
-#[doc(no_inline)]
-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-20.0.2/src/profiling_agent/jitdump.rs

@@ -1,66 +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::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-20.0.2/src/profiling_agent/perfmap.rs

@@ -1,47 +0,0 @@
-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-20.0.2/src/profiling_agent/vtune.rs

@@ -1,80 +0,0 @@
-//! 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);
-    }
-}

data/ext/cargo-vendor/wasmtime-20.0.2/src/profiling_agent.rs

@@ -1,105 +0,0 @@
-#[allow(unused)]
-use anyhow::{bail, Result};
-
-cfg_if::cfg_if! {
-    if #[cfg(all(feature = "profiling", target_os = "linux"))] {
-        mod jitdump;
-        pub use jitdump::new as new_jitdump;
-    } else {
-        pub fn new_jitdump() -> Result<Box<dyn ProfilingAgent>> {
-            if cfg!(feature = "profiling") {
-                bail!("jitdump is not supported on this platform");
-            } else {
-                bail!("jitdump support disabled at compile time");
-            }
-        }
-    }
-}
-
-cfg_if::cfg_if! {
-    if #[cfg(unix)] {
-        mod perfmap;
-        pub use perfmap::new as new_perfmap;
-    } else {
-        pub fn new_perfmap() -> Result<Box<dyn ProfilingAgent>> {
-            bail!("perfmap support not supported on this platform");
-        }
-    }
-}
-
-cfg_if::cfg_if! {
-    // Note: VTune support is disabled on windows mingw because the ittapi crate doesn't compile
-    // there; see also https://github.com/bytecodealliance/wasmtime/pull/4003 for rationale.
-    if #[cfg(all(feature = "profiling", target_arch = "x86_64", not(any(target_os = "android", all(target_os = "windows", target_env = "gnu")))))] {
-        mod vtune;
-        pub use vtune::new as new_vtune;
-    } else {
-        pub fn new_vtune() -> Result<Box<dyn ProfilingAgent>> {
-            if cfg!(feature = "profiling") {
-                bail!("VTune is not supported on this platform.");
-            } else {
-                bail!("VTune support disabled at compile time.");
-            }
-        }
-    }
-}
-
-/// Common interface for profiling tools.
-pub trait ProfilingAgent: Send + Sync + 'static {
-    fn register_function(&self, name: &str, addr: *const u8, size: usize);
-
-    fn register_module(&self, code: &[u8], custom_name: &dyn Fn(usize) -> Option<String>) {
-        use object::{File, Object as _, ObjectSection, ObjectSymbol, SectionKind, SymbolKind};
-
-        let image = match File::parse(code) {
-            Ok(image) => image,
-            Err(_) => return,
-        };
-
-        let text_base = match image.sections().find(|s| s.kind() == SectionKind::Text) {
-            Some(section) => match section.data() {
-                Ok(data) => data.as_ptr() as usize,
-                Err(_) => return,
-            },
-            None => return,
-        };
-
-        for sym in image.symbols() {
-            if !sym.is_definition() {
-                continue;
-            }
-            if sym.kind() != SymbolKind::Text {
-                continue;
-            }
-            let address = sym.address();
-            let size = sym.size();
-            if size == 0 {
-                continue;
-            }
-            if let Ok(name) = sym.name() {
-                let addr = text_base + address as usize;
-                let owned;
-                let name = match custom_name(address as usize) {
-                    Some(name) => {
-                        owned = name;
-                        &owned
-                    }
-                    None => name,
-                };
-                self.register_function(name, addr as *const u8, size as usize);
-            }
-        }
-    }
-}
-
-pub fn new_null() -> Box<dyn ProfilingAgent> {
-    Box::new(NullProfilerAgent)
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-struct NullProfilerAgent;
-
-impl ProfilingAgent for NullProfilerAgent {
-    fn register_function(&self, _name: &str, _addr: *const u8, _size: usize) {}
-    fn register_module(&self, _code: &[u8], _custom_name: &dyn Fn(usize) -> Option<String>) {}
-}