wasmtime 28.0.0 → 29.0.0

data/ext/cargo-vendor/wasmtime-28.0.0/src/runtime/module/registry.rs

@@ -1,344 +0,0 @@
-//! Implements a registry of modules for a store.
-
-use crate::code::CodeObject;
-#[cfg(feature = "component-model")]
-use crate::component::Component;
-use crate::prelude::*;
-use crate::runtime::vm::VMWasmCallFunction;
-use crate::sync::{OnceLock, RwLock};
-use crate::{code_memory::CodeMemory, FrameInfo, Module};
-use alloc::collections::btree_map::{BTreeMap, Entry};
-use alloc::sync::Arc;
-use core::ptr::NonNull;
-use wasmtime_environ::VMSharedTypeIndex;
-
-/// Used for registering modules with a store.
-///
-/// Note that the primary reason for this registry is to ensure that everything
-/// in `Module` is kept alive for the duration of a `Store`. At this time we
-/// need "basically everything" within a `Module` to stay alive once it's
-/// instantiated within a store. While there's some smaller portions that could
-/// theoretically be omitted as they're not needed by the store they're
-/// currently small enough to not worry much about.
-#[derive(Default)]
-pub struct ModuleRegistry {
-    // Keyed by the end address of a `CodeObject`.
-    //
-    // The value here is the start address and the information about what's
-    // loaded at that address.
-    loaded_code: BTreeMap<usize, (usize, LoadedCode)>,
-
-    // Preserved for keeping data segments alive or similar
-    modules_without_code: Vec<Module>,
-}
-
-struct LoadedCode {
-    /// Kept alive here in the store to have a strong reference to keep the
-    /// relevant code mapped while the store is alive.
-    _code: Arc<CodeObject>,
-
-    /// Modules found within `self.code`, keyed by start address here of the
-    /// address of the first function in the module.
-    modules: BTreeMap<usize, Module>,
-}
-
-/// An identifier of a module that has previously been inserted into a
-/// `ModuleRegistry`.
-#[derive(Clone, Copy)]
-pub enum RegisteredModuleId {
-    /// Index into `ModuleRegistry::modules_without_code`.
-    WithoutCode(usize),
-    /// Start address of the module's code so that we can get it again via
-    /// `ModuleRegistry::lookup_module`.
-    LoadedCode(usize),
-}
-
-impl ModuleRegistry {
-    /// Get a previously-registered module by id.
-    pub fn lookup_module_by_id(&self, id: RegisteredModuleId) -> Option<&Module> {
-        match id {
-            RegisteredModuleId::WithoutCode(idx) => self.modules_without_code.get(idx),
-            RegisteredModuleId::LoadedCode(pc) => {
-                let (module, _) = self.module_and_offset(pc)?;
-                Some(module)
-            }
-        }
-    }
-
-    /// Fetches a registered module given a program counter value.
-    pub fn lookup_module_by_pc(&self, pc: usize) -> Option<&Module> {
-        let (module, _) = self.module_and_offset(pc)?;
-        Some(module)
-    }
-
-    fn code(&self, pc: usize) -> Option<(&LoadedCode, usize)> {
-        let (end, (start, code)) = self.loaded_code.range(pc..).next()?;
-        if pc < *start || *end < pc {
-            return None;
-        }
-        Some((code, pc - *start))
-    }
-
-    fn module_and_offset(&self, pc: usize) -> Option<(&Module, usize)> {
-        let (code, offset) = self.code(pc)?;
-        Some((code.module(pc)?, offset))
-    }
-
-    /// Gets an iterator over all modules in the registry.
-    pub fn all_modules(&self) -> impl Iterator<Item = &'_ Module> + '_ {
-        self.loaded_code
-            .values()
-            .flat_map(|(_, code)| code.modules.values())
-            .chain(self.modules_without_code.iter())
-    }
-
-    /// Registers a new module with the registry.
-    pub fn register_module(&mut self, module: &Module) -> RegisteredModuleId {
-        self.register(module.code_object(), Some(module)).unwrap()
-    }
-
-    #[cfg(feature = "component-model")]
-    pub fn register_component(&mut self, component: &Component) {
-        self.register(component.code_object(), None);
-    }
-
-    /// Registers a new module with the registry.
-    fn register(
-        &mut self,
-        code: &Arc<CodeObject>,
-        module: Option<&Module>,
-    ) -> Option<RegisteredModuleId> {
-        let text = code.code_memory().text();
-
-        // If there's not actually any functions in this module then we may
-        // still need to preserve it for its data segments. Instances of this
-        // module will hold a pointer to the data stored in the module itself,
-        // and for schemes that perform lazy initialization which could use the
-        // module in the future. For that reason we continue to register empty
-        // modules and retain them.
-        if text.is_empty() {
-            return module.map(|module| {
-                let id = RegisteredModuleId::WithoutCode(self.modules_without_code.len());
-                self.modules_without_code.push(module.clone());
-                id
-            });
-        }
-
-        // The module code range is exclusive for end, so make it inclusive as
-        // it may be a valid PC value
-        let start_addr = text.as_ptr() as usize;
-        let end_addr = start_addr + text.len() - 1;
-        let id = module.map(|_| RegisteredModuleId::LoadedCode(start_addr));
-
-        // If this module is already present in the registry then that means
-        // it's either an overlapping image, for example for two modules
-        // found within a component, or it's a second instantiation of the same
-        // module. Delegate to `push_module` to find out.
-        if let Some((other_start, prev)) = self.loaded_code.get_mut(&end_addr) {
-            assert_eq!(*other_start, start_addr);
-            if let Some(module) = module {
-                prev.push_module(module);
-            }
-            return id;
-        }
-
-        // Assert that this module's code doesn't collide with any other
-        // registered modules
-        if let Some((_, (prev_start, _))) = self.loaded_code.range(start_addr..).next() {
-            assert!(*prev_start > end_addr);
-        }
-        if let Some((prev_end, _)) = self.loaded_code.range(..=start_addr).next_back() {
-            assert!(*prev_end < start_addr);
-        }
-
-        let mut item = LoadedCode {
-            _code: code.clone(),
-            modules: Default::default(),
-        };
-        if let Some(module) = module {
-            item.push_module(module);
-        }
-        let prev = self.loaded_code.insert(end_addr, (start_addr, item));
-        assert!(prev.is_none());
-        id
-    }
-
-    /// Fetches frame information about a program counter in a backtrace.
-    ///
-    /// Returns an object if this `pc` is known to some previously registered
-    /// module, or returns `None` if no information can be found. The first
-    /// boolean returned indicates whether the original module has unparsed
-    /// debug information due to the compiler's configuration. The second
-    /// boolean indicates whether the engine used to compile this module is
-    /// using environment variables to control debuginfo parsing.
-    pub(crate) fn lookup_frame_info(&self, pc: usize) -> Option<(FrameInfo, &Module)> {
-        let (module, offset) = self.module_and_offset(pc)?;
-        let info = FrameInfo::new(module.clone(), offset)?;
-        Some((info, module))
-    }
-
-    pub fn wasm_to_array_trampoline(
-        &self,
-        sig: VMSharedTypeIndex,
-    ) -> Option<NonNull<VMWasmCallFunction>> {
-        // TODO: We are doing a linear search over each module. This is fine for
-        // now because we typically have very few modules per store (almost
-        // always one, in fact). If this linear search ever becomes a
-        // bottleneck, we could avoid it by incrementally and lazily building a
-        // `VMSharedSignatureIndex` to `SignatureIndex` map.
-        //
-        // See also the comment in `ModuleInner::wasm_to_native_trampoline`.
-        for (_, code) in self.loaded_code.values() {
-            for module in code.modules.values() {
-                if let Some(trampoline) = module.wasm_to_array_trampoline(sig) {
-                    return Some(trampoline);
-                }
-            }
-        }
-        None
-    }
-}
-
-impl LoadedCode {
-    fn push_module(&mut self, module: &Module) {
-        let func = match module.compiled_module().finished_functions().next() {
-            Some((_, func)) => func,
-            // There are no compiled functions in this module so there's no
-            // need to push onto `self.modules` which is only used for frame
-            // information lookup for a trap which only symbolicates defined
-            // functions.
-            None => return,
-        };
-        let start = func.as_ptr() as usize;
-
-        match self.modules.entry(start) {
-            // This module is already present, and it should be the same as
-            // `module`.
-            Entry::Occupied(m) => {
-                debug_assert!(Arc::ptr_eq(&module.inner, &m.get().inner));
-            }
-            // This module was not already present, so now it's time to insert.
-            Entry::Vacant(v) => {
-                v.insert(module.clone());
-            }
-        }
-    }
-
-    fn module(&self, pc: usize) -> Option<&Module> {
-        // The `modules` map is keyed on the start address of the first
-        // function in the module, so find the first module whose start address
-        // is less than the `pc`. That may be the wrong module but lookup
-        // within the module should fail in that case.
-        let (_start, module) = self.modules.range(..=pc).next_back()?;
-        Some(module)
-    }
-}
-
-// This is the global code registry that stores information for all loaded code
-// objects that are currently in use by any `Store` in the current process.
-//
-// The purpose of this map is to be called from signal handlers to determine
-// whether a program counter is a wasm trap or not. Specifically macOS has
-// no contextual information about the thread available, hence the necessity
-// for global state rather than using thread local state.
-//
-// This is similar to `ModuleRegistry` except that it has less information and
-// supports removal. Any time anything is registered with a `ModuleRegistry`
-// it is also automatically registered with the singleton global module
-// registry. When a `ModuleRegistry` is destroyed then all of its entries
-// are removed from the global registry.
-fn global_code() -> &'static RwLock<GlobalRegistry> {
-    static GLOBAL_CODE: OnceLock<RwLock<GlobalRegistry>> = OnceLock::new();
-    GLOBAL_CODE.get_or_init(Default::default)
-}
-
-type GlobalRegistry = BTreeMap<usize, (usize, Arc<CodeMemory>)>;
-
-/// Find which registered region of code contains the given program counter, and
-/// what offset that PC is within that module's code.
-#[cfg(all(feature = "signals-based-traps", not(miri)))]
-pub fn lookup_code(pc: usize) -> Option<(Arc<CodeMemory>, usize)> {
-    let all_modules = global_code().read();
-    let (_end, (start, module)) = all_modules.range(pc..).next()?;
-    let text_offset = pc.checked_sub(*start)?;
-    Some((module.clone(), text_offset))
-}
-
-/// Registers a new region of code.
-///
-/// Must not have been previously registered and must be `unregister`'d to
-/// prevent leaking memory.
-///
-/// This is required to enable traps to work correctly since the signal handler
-/// will lookup in the `GLOBAL_CODE` list to determine which a particular pc
-/// is a trap or not.
-pub fn register_code(code: &Arc<CodeMemory>) {
-    let text = code.text();
-    if text.is_empty() {
-        return;
-    }
-    let start = text.as_ptr() as usize;
-    let end = start + text.len() - 1;
-    let prev = global_code().write().insert(end, (start, code.clone()));
-    assert!(prev.is_none());
-}
-
-/// Unregisters a code mmap from the global map.
-///
-/// Must have been previously registered with `register`.
-pub fn unregister_code(code: &Arc<CodeMemory>) {
-    let text = code.text();
-    if text.is_empty() {
-        return;
-    }
-    let end = (text.as_ptr() as usize) + text.len() - 1;
-    let code = global_code().write().remove(&end);
-    assert!(code.is_some());
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn test_frame_info() -> Result<(), anyhow::Error> {
-    use crate::*;
-    let mut store = Store::<()>::default();
-    let module = Module::new(
-        store.engine(),
-        r#"
-            (module
-                (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y)))
-                (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y)))
-                (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y)))
-                (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y)))
-                (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y)))
-                (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y)))
-                (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y)))
-            )
-         "#,
-    )?;
-    // Create an instance to ensure the frame information is registered.
-    Instance::new(&mut store, &module, &[])?;
-
-    for (i, alloc) in module.compiled_module().finished_functions() {
-        let (start, end) = {
-            let ptr = alloc.as_ptr();
-            let len = alloc.len();
-            (ptr as usize, ptr as usize + len)
-        };
-        for pc in start..end {
-            let (frame, _) = store
-                .as_context()
-                .0
-                .modules()
-                .lookup_frame_info(pc)
-                .unwrap();
-            assert!(
-                frame.func_index() == i.as_u32(),
-                "lookup of {:#x} returned {}, expected {}",
-                pc,
-                frame.func_index(),
-                i.as_u32()
-            );
-        }
-    }
-    Ok(())
-}

data/ext/cargo-vendor/wasmtime-28.0.0/src/runtime/profiling.rs

@@ -1,280 +0,0 @@
-use crate::instantiate::CompiledModule;
-use crate::prelude::*;
-use crate::runtime::vm::Backtrace;
-use crate::{AsContext, CallHook, Module};
-use fxprof_processed_profile::debugid::DebugId;
-use fxprof_processed_profile::{
-    CategoryHandle, Frame, FrameFlags, FrameInfo, LibraryInfo, MarkerLocation, MarkerSchema,
-    MarkerTiming, Profile, ProfilerMarker, ReferenceTimestamp, Symbol, SymbolTable, Timestamp,
-};
-use std::ops::Range;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-use wasmtime_environ::demangle_function_name_or_index;
-
-// TODO: collect more data
-// - On non-Windows, measure thread-local CPU usage between events with
-//   rustix::time::clock_gettime(ClockId::ThreadCPUTime)
-// - Report which wasm module, and maybe instance, each frame came from
-
-/// Collects basic profiling data for a single WebAssembly guest.
-///
-/// This profiler can't provide measurements that are as accurate or detailed
-/// as a platform-specific profiler, such as `perf` on Linux. On the other
-/// hand, this profiler works on every platform that Wasmtime supports. Also,
-/// as an embedder you can use this profiler selectively on individual guest
-/// instances rather than profiling the entire process.
-///
-/// To use this, you'll need to arrange to call [`GuestProfiler::sample`] at
-/// regular intervals while the guest is on the stack. The most straightforward
-/// way to do that is to call it from a callback registered with
-/// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
-///
-/// # Accuracy
-///
-/// The data collection granularity is limited by the mechanism you use to
-/// interrupt guest execution and collect a profiling sample.
-///
-/// If you use epoch interruption, then samples will only be collected at
-/// function entry points and loop headers. This introduces some bias to the
-/// results. In addition, samples will only be taken at times when WebAssembly
-/// functions are running, not during host-calls.
-///
-/// It is technically possible to use fuel interruption instead. That
-/// introduces worse bias since samples occur after a certain number of
-/// WebAssembly instructions, which can take different amounts of time.
-///
-/// You may instead be able to use platform-specific methods, such as
-/// `setitimer(ITIMER_VIRTUAL, ...)` on POSIX-compliant systems, to sample on
-/// a more accurate interval. The only current requirement is that the guest
-/// you wish to profile must be on the same stack where you call `sample`,
-/// and executing within the same thread. However, the `GuestProfiler::sample`
-/// method is not currently async-signal-safe, so doing this correctly is not
-/// easy.
-///
-/// # Security
-///
-/// Profiles produced using this profiler do not include any configuration
-/// details from the host, such as virtual memory addresses, or from any
-/// WebAssembly modules that you haven't specifically allowed. So for
-/// example, these profiles should be safe to share with untrusted users
-/// who have provided untrusted code that you are running in a multi-tenancy
-/// environment.
-///
-/// However, the profile does include byte offsets into the text section of
-/// the compiled module, revealing some information about the size of the code
-/// generated for each module. For user-provided modules, the user could get
-/// the same information by compiling the module for themself using a similar
-/// version of Wasmtime on the same target architecture, but for any module
-/// where they don't already have the WebAssembly module binary available this
-/// could theoretically lead to an undesirable information disclosure. So you
-/// should only include user-provided modules in profiles.
-#[derive(Debug)]
-pub struct GuestProfiler {
-    profile: Profile,
-    modules: Modules,
-    process: fxprof_processed_profile::ProcessHandle,
-    thread: fxprof_processed_profile::ThreadHandle,
-    start: Instant,
-}
-
-type Modules = Vec<(Range<usize>, fxprof_processed_profile::LibraryHandle)>;
-
-impl GuestProfiler {
-    /// Begin profiling a new guest. When this function is called, the current
-    /// wall-clock time is recorded as the start time for the guest.
-    ///
-    /// The `module_name` parameter is recorded in the profile to help identify
-    /// where the profile came from.
-    ///
-    /// The `interval` parameter should match the rate at which you intend
-    /// to call `sample`. However, this is used as a hint and not required to
-    /// exactly match the real sample rate.
-    ///
-    /// Only modules which are present in the `modules` vector will appear in
-    /// stack traces in this profile. Any stack frames which were executing
-    /// host code or functions from other modules will be omitted. See the
-    /// "Security" section of the [`GuestProfiler`] documentation for guidance
-    /// on what modules should not be included in this list.
-    pub fn new(module_name: &str, interval: Duration, modules: Vec<(String, Module)>) -> Self {
-        let zero = ReferenceTimestamp::from_millis_since_unix_epoch(0.0);
-        let mut profile = Profile::new(module_name, zero, interval.into());
-
-        let mut modules: Vec<_> = modules
-            .into_iter()
-            .filter_map(|(name, module)| {
-                let compiled = module.compiled_module();
-                let text = compiled.text().as_ptr_range();
-                let address_range = text.start as usize..text.end as usize;
-                module_symbols(name, compiled).map(|lib| (address_range, profile.add_lib(lib)))
-            })
-            .collect();
-
-        modules.sort_unstable_by_key(|(range, _)| range.start);
-
-        profile.set_reference_timestamp(std::time::SystemTime::now().into());
-        let process = profile.add_process(module_name, 0, Timestamp::from_nanos_since_reference(0));
-        let thread = profile.add_thread(process, 0, Timestamp::from_nanos_since_reference(0), true);
-        let start = Instant::now();
-        Self {
-            profile,
-            modules,
-            process,
-            thread,
-            start,
-        }
-    }
-
-    /// Add a sample to the profile. This function collects a backtrace from
-    /// any stack frames for allowed modules on the current stack. It should
-    /// typically be called from a callback registered using
-    /// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
-    ///
-    /// The `delta` parameter is the amount of CPU time that was used by this
-    /// guest since the previous sample. It is allowed to pass `Duration::ZERO`
-    /// here if recording CPU usage information is not needed.
-    pub fn sample(&mut self, store: impl AsContext, delta: Duration) {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-        let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
-        let frames = lookup_frames(&self.modules, &backtrace);
-        self.profile
-            .add_sample(self.thread, now, frames, delta.into(), 1);
-    }
-
-    /// Add a marker for transitions between guest and host to the profile.
-    /// This function should typically be called from a callback registered
-    /// using [`Store::call_hook()`](crate::Store::call_hook), and the `kind`
-    /// parameter should be the value of the same type passed into that hook.
-    pub fn call_hook(&mut self, store: impl AsContext, kind: CallHook) {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-        match kind {
-            CallHook::CallingWasm | CallHook::ReturningFromWasm => {}
-            CallHook::CallingHost => {
-                let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
-                let frames = lookup_frames(&self.modules, &backtrace);
-                self.profile.add_marker_with_stack(
-                    self.thread,
-                    "hostcall",
-                    CallMarker,
-                    MarkerTiming::IntervalStart(now),
-                    frames,
-                );
-            }
-            CallHook::ReturningFromHost => {
-                self.profile.add_marker(
-                    self.thread,
-                    "hostcall",
-                    CallMarker,
-                    MarkerTiming::IntervalEnd(now),
-                );
-            }
-        }
-    }
-
-    /// When the guest finishes running, call this function to write the
-    /// profile to the given `output`. The output is a JSON-formatted object in
-    /// the [Firefox "processed profile format"][fmt]. Files in this format may
-    /// be visualized at <https://profiler.firefox.com/>.
-    ///
-    /// [fmt]: https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md
-    pub fn finish(mut self, output: impl std::io::Write) -> Result<()> {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-        self.profile.set_thread_end_time(self.thread, now);
-        self.profile.set_process_end_time(self.process, now);
-
-        serde_json::to_writer(output, &self.profile)?;
-        Ok(())
-    }
-}
-
-fn module_symbols(name: String, compiled: &CompiledModule) -> Option<LibraryInfo> {
-    let symbols = Vec::from_iter(compiled.finished_functions().map(|(defined_idx, _)| {
-        let loc = compiled.func_loc(defined_idx);
-        let func_idx = compiled.module().func_index(defined_idx);
-        let mut name = String::new();
-        demangle_function_name_or_index(
-            &mut name,
-            compiled.func_name(func_idx),
-            defined_idx.as_u32() as usize,
-        )
-        .unwrap();
-        Symbol {
-            address: loc.start,
-            size: Some(loc.length),
-            name,
-        }
-    }));
-    if symbols.is_empty() {
-        return None;
-    }
-
-    Some(LibraryInfo {
-        name,
-        debug_name: String::new(),
-        path: String::new(),
-        debug_path: String::new(),
-        debug_id: DebugId::nil(),
-        code_id: None,
-        arch: None,
-        symbol_table: Some(Arc::new(SymbolTable::new(symbols))),
-    })
-}
-
-fn lookup_frames<'a>(
-    modules: &'a Modules,
-    backtrace: &'a Backtrace,
-) -> impl Iterator<Item = FrameInfo> + 'a {
-    backtrace
-        .frames()
-        // Samply needs to see the oldest frame first, but we list the newest
-        // first, so iterate in reverse.
-        .rev()
-        .filter_map(|frame| {
-            // Find the first module whose start address includes this PC.
-            let module_idx = modules.partition_point(|(range, _)| range.start > frame.pc());
-            if let Some((range, lib)) = modules.get(module_idx) {
-                if range.contains(&frame.pc()) {
-                    return Some(FrameInfo {
-                        frame: Frame::RelativeAddressFromReturnAddress(
-                            *lib,
-                            u32::try_from(frame.pc() - range.start).unwrap(),
-                        ),
-                        category_pair: CategoryHandle::OTHER.into(),
-                        flags: FrameFlags::empty(),
-                    });
-                }
-            }
-            None
-        })
-}
-
-struct CallMarker;
-
-impl ProfilerMarker for CallMarker {
-    const MARKER_TYPE_NAME: &'static str = "hostcall";
-
-    fn schema() -> MarkerSchema {
-        MarkerSchema {
-            type_name: Self::MARKER_TYPE_NAME,
-            locations: vec![
-                MarkerLocation::MarkerChart,
-                MarkerLocation::MarkerTable,
-                MarkerLocation::TimelineOverview,
-            ],
-            chart_label: None,
-            tooltip_label: None,
-            table_label: None,
-            fields: vec![],
-        }
-    }
-
-    fn json_marker_data(&self) -> serde_json::Value {
-        serde_json::json!({ "type": Self::MARKER_TYPE_NAME })
-    }
-}