wasmtime 19.0.2 → 20.0.0

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

@@ -0,0 +1,303 @@
+//! # 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.0/src/runtime/code_memory.rs

@@ -0,0 +1,335 @@
+//! Memory management for executable code.
+
+use anyhow::{anyhow, bail, Context, Result};
+use object::read::{File, Object, ObjectSection};
+use object::ObjectSymbol;
+use std::mem::ManuallyDrop;
+use std::ops::Range;
+use wasmtime_environ::obj;
+use wasmtime_jit_icache_coherence as icache_coherence;
+use wasmtime_runtime::{libcalls, MmapVec, UnwindRegistration};
+
+/// Management of executable memory within a `MmapVec`
+///
+/// This type consumes ownership of a region of memory and will manage the
+/// executable permissions of the contained JIT code as necessary.
+pub struct CodeMemory {
+    // NB: these are `ManuallyDrop` because `unwind_registration` must be
+    // dropped first since it refers to memory owned by `mmap`.
+    mmap: ManuallyDrop<MmapVec>,
+    unwind_registration: ManuallyDrop<Option<UnwindRegistration>>,
+    published: bool,
+    enable_branch_protection: bool,
+
+    relocations: Vec<(usize, obj::LibCall)>,
+
+    // Ranges within `self.mmap` of where the particular sections lie.
+    text: Range<usize>,
+    unwind: Range<usize>,
+    trap_data: Range<usize>,
+    wasm_data: Range<usize>,
+    address_map_data: Range<usize>,
+    func_name_data: Range<usize>,
+    info_data: Range<usize>,
+    dwarf: Range<usize>,
+}
+
+impl Drop for CodeMemory {
+    fn drop(&mut self) {
+        // Drop `unwind_registration` before `self.mmap`
+        unsafe {
+            ManuallyDrop::drop(&mut self.unwind_registration);
+            ManuallyDrop::drop(&mut self.mmap);
+        }
+    }
+}
+
+fn _assert() {
+    fn _assert_send_sync<T: Send + Sync>() {}
+    _assert_send_sync::<CodeMemory>();
+}
+
+impl CodeMemory {
+    /// Creates a new `CodeMemory` by taking ownership of the provided
+    /// `MmapVec`.
+    ///
+    /// The returned `CodeMemory` manages the internal `MmapVec` and the
+    /// `publish` method is used to actually make the memory executable.
+    pub fn new(mmap: MmapVec) -> Result<Self> {
+        let obj = File::parse(&mmap[..])
+            .with_context(|| "failed to parse internal compilation artifact")?;
+
+        let mut relocations = Vec::new();
+        let mut text = 0..0;
+        let mut unwind = 0..0;
+        let mut enable_branch_protection = None;
+        let mut trap_data = 0..0;
+        let mut wasm_data = 0..0;
+        let mut address_map_data = 0..0;
+        let mut func_name_data = 0..0;
+        let mut info_data = 0..0;
+        let mut dwarf = 0..0;
+        for section in obj.sections() {
+            let data = section.data()?;
+            let name = section.name()?;
+            let range = subslice_range(data, &mmap);
+
+            // Double-check that sections are all aligned properly.
+            if section.align() != 0 && data.len() != 0 {
+                if (data.as_ptr() as u64 - mmap.as_ptr() as u64) % section.align() != 0 {
+                    bail!(
+                        "section `{}` isn't aligned to {:#x}",
+                        section.name().unwrap_or("ERROR"),
+                        section.align()
+                    );
+                }
+            }
+
+            match name {
+                obj::ELF_WASM_BTI => match data.len() {
+                    1 => enable_branch_protection = Some(data[0] != 0),
+                    _ => bail!("invalid `{name}` section"),
+                },
+                ".text" => {
+                    text = range;
+
+                    // The text section might have relocations for things like
+                    // libcalls which need to be applied, so handle those here.
+                    //
+                    // Note that only a small subset of possible relocations are
+                    // handled. Only those required by the compiler side of
+                    // things are processed.
+                    for (offset, reloc) in section.relocations() {
+                        assert_eq!(reloc.kind(), object::RelocationKind::Absolute);
+                        assert_eq!(reloc.encoding(), object::RelocationEncoding::Generic);
+                        assert_eq!(usize::from(reloc.size()), std::mem::size_of::<usize>() * 8);
+                        assert_eq!(reloc.addend(), 0);
+                        let sym = match reloc.target() {
+                            object::RelocationTarget::Symbol(id) => id,
+                            other => panic!("unknown relocation target {other:?}"),
+                        };
+                        let sym = obj.symbol_by_index(sym).unwrap().name().unwrap();
+                        let libcall = obj::LibCall::from_str(sym)
+                            .unwrap_or_else(|| panic!("unknown symbol relocation: {sym}"));
+
+                        let offset = usize::try_from(offset).unwrap();
+                        relocations.push((offset, libcall));
+                    }
+                }
+                UnwindRegistration::SECTION_NAME => unwind = range,
+                obj::ELF_WASM_DATA => wasm_data = range,
+                obj::ELF_WASMTIME_ADDRMAP => address_map_data = range,
+                obj::ELF_WASMTIME_TRAPS => trap_data = range,
+                obj::ELF_NAME_DATA => func_name_data = range,
+                obj::ELF_WASMTIME_INFO => info_data = range,
+                obj::ELF_WASMTIME_DWARF => dwarf = range,
+
+                _ => log::debug!("ignoring section {name}"),
+            }
+        }
+        Ok(Self {
+            mmap: ManuallyDrop::new(mmap),
+            unwind_registration: ManuallyDrop::new(None),
+            published: false,
+            enable_branch_protection: enable_branch_protection
+                .ok_or_else(|| anyhow!("missing `{}` section", obj::ELF_WASM_BTI))?,
+            text,
+            unwind,
+            trap_data,
+            address_map_data,
+            func_name_data,
+            dwarf,
+            info_data,
+            wasm_data,
+            relocations,
+        })
+    }
+
+    /// Returns a reference to the underlying `MmapVec` this memory owns.
+    #[inline]
+    pub fn mmap(&self) -> &MmapVec {
+        &self.mmap
+    }
+
+    /// Returns the contents of the text section of the ELF executable this
+    /// represents.
+    #[inline]
+    pub fn text(&self) -> &[u8] {
+        &self.mmap[self.text.clone()]
+    }
+
+    /// Returns the contents of the `ELF_WASMTIME_DWARF` section.
+    #[inline]
+    pub fn dwarf(&self) -> &[u8] {
+        &self.mmap[self.dwarf.clone()]
+    }
+
+    /// Returns the data in the `ELF_NAME_DATA` section.
+    #[inline]
+    pub fn func_name_data(&self) -> &[u8] {
+        &self.mmap[self.func_name_data.clone()]
+    }
+
+    /// Returns the concatenated list of all data associated with this wasm
+    /// module.
+    ///
+    /// This is used for initialization of memories and all data ranges stored
+    /// in a `Module` are relative to the slice returned here.
+    #[inline]
+    pub fn wasm_data(&self) -> &[u8] {
+        &self.mmap[self.wasm_data.clone()]
+    }
+
+    /// Returns the encoded address map section used to pass to
+    /// `wasmtime_environ::lookup_file_pos`.
+    #[inline]
+    pub fn address_map_data(&self) -> &[u8] {
+        &self.mmap[self.address_map_data.clone()]
+    }
+
+    /// Returns the contents of the `ELF_WASMTIME_INFO` section, or an empty
+    /// slice if it wasn't found.
+    #[inline]
+    pub fn wasmtime_info(&self) -> &[u8] {
+        &self.mmap[self.info_data.clone()]
+    }
+
+    /// Returns the contents of the `ELF_WASMTIME_TRAPS` section, or an empty
+    /// slice if it wasn't found.
+    #[inline]
+    pub fn trap_data(&self) -> &[u8] {
+        &self.mmap[self.trap_data.clone()]
+    }
+
+    /// Publishes the internal ELF image to be ready for execution.
+    ///
+    /// This method can only be called once and will panic if called twice. This
+    /// will parse the ELF image from the original `MmapVec` and do everything
+    /// necessary to get it ready for execution, including:
+    ///
+    /// * Change page protections from read/write to read/execute.
+    /// * Register unwinding information with the OS
+    ///
+    /// After this function executes all JIT code should be ready to execute.
+    pub fn publish(&mut self) -> Result<()> {
+        assert!(!self.published);
+        self.published = true;
+
+        if self.text().is_empty() {
+            return Ok(());
+        }
+
+        // The unsafety here comes from a few things:
+        //
+        // * We're actually updating some page protections to executable memory.
+        //
+        // * We're registering unwinding information which relies on the
+        //   correctness of the information in the first place. This applies to
+        //   both the actual unwinding tables as well as the validity of the
+        //   pointers we pass in itself.
+        unsafe {
+            // First, if necessary, apply relocations. This can happen for
+            // things like libcalls which happen late in the lowering process
+            // that don't go through the Wasm-based libcalls layer that's
+            // indirected through the `VMContext`. Note that most modules won't
+            // have relocations, so this typically doesn't do anything.
+            self.apply_relocations()?;
+
+            // Next freeze the contents of this image by making all of the
+            // memory readonly. Nothing after this point should ever be modified
+            // so commit everything. For a compiled-in-memory image this will
+            // mean IPIs to evict writable mappings from other cores. For
+            // loaded-from-disk images this shouldn't result in IPIs so long as
+            // there weren't any relocations because nothing should have
+            // otherwise written to the image at any point either.
+            self.mmap.make_readonly(0..self.mmap.len())?;
+
+            let text = self.text();
+
+            // Clear the newly allocated code from cache if the processor requires it
+            //
+            // Do this before marking the memory as R+X, technically we should be able to do it after
+            // but there are some CPU's that have had errata about doing this with read only memory.
+            icache_coherence::clear_cache(text.as_ptr().cast(), text.len())
+                .expect("Failed cache clear");
+
+            // Switch the executable portion from readonly to read/execute.
+            self.mmap
+                .make_executable(self.text.clone(), self.enable_branch_protection)
+                .context("unable to make memory executable")?;
+
+            // Flush any in-flight instructions from the pipeline
+            icache_coherence::pipeline_flush_mt().expect("Failed pipeline flush");
+
+            // With all our memory set up use the platform-specific
+            // `UnwindRegistration` implementation to inform the general
+            // runtime that there's unwinding information available for all
+            // our just-published JIT functions.
+            self.register_unwind_info()?;
+        }
+
+        Ok(())
+    }
+
+    unsafe fn apply_relocations(&mut self) -> Result<()> {
+        if self.relocations.is_empty() {
+            return Ok(());
+        }
+
+        for (offset, libcall) in self.relocations.iter() {
+            let offset = self.text.start + offset;
+            let libcall = match libcall {
+                obj::LibCall::FloorF32 => libcalls::relocs::floorf32 as usize,
+                obj::LibCall::FloorF64 => libcalls::relocs::floorf64 as usize,
+                obj::LibCall::NearestF32 => libcalls::relocs::nearestf32 as usize,
+                obj::LibCall::NearestF64 => libcalls::relocs::nearestf64 as usize,
+                obj::LibCall::CeilF32 => libcalls::relocs::ceilf32 as usize,
+                obj::LibCall::CeilF64 => libcalls::relocs::ceilf64 as usize,
+                obj::LibCall::TruncF32 => libcalls::relocs::truncf32 as usize,
+                obj::LibCall::TruncF64 => libcalls::relocs::truncf64 as usize,
+                obj::LibCall::FmaF32 => libcalls::relocs::fmaf32 as usize,
+                obj::LibCall::FmaF64 => libcalls::relocs::fmaf64 as usize,
+                #[cfg(target_arch = "x86_64")]
+                obj::LibCall::X86Pshufb => libcalls::relocs::x86_pshufb as usize,
+                #[cfg(not(target_arch = "x86_64"))]
+                obj::LibCall::X86Pshufb => unreachable!(),
+            };
+            self.mmap
+                .as_mut_ptr()
+                .add(offset)
+                .cast::<usize>()
+                .write_unaligned(libcall);
+        }
+        Ok(())
+    }
+
+    unsafe fn register_unwind_info(&mut self) -> Result<()> {
+        if self.unwind.len() == 0 {
+            return Ok(());
+        }
+        let text = self.text();
+        let unwind_info = &self.mmap[self.unwind.clone()];
+        let registration =
+            UnwindRegistration::new(text.as_ptr(), unwind_info.as_ptr(), unwind_info.len())
+                .context("failed to create unwind info registration")?;
+        *self.unwind_registration = Some(registration);
+        Ok(())
+    }
+}
+
+/// Returns the range of `inner` within `outer`, such that `outer[range]` is the
+/// same as `inner`.
+///
+/// This method requires that `inner` is a sub-slice of `outer`, and if that
+/// isn't true then this method will panic.
+fn subslice_range(inner: &[u8], outer: &[u8]) -> Range<usize> {
+    if inner.len() == 0 {
+        return 0..0;
+    }
+
+    assert!(outer.as_ptr() <= inner.as_ptr());
+    assert!((&inner[inner.len() - 1] as *const _) <= (&outer[outer.len() - 1] as *const _));
+
+    let start = inner.as_ptr() as usize - outer.as_ptr() as usize;
+    start..start + inner.len()
+}