wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-environ-20.0.2/src/compile/mod.rs

@@ -1,389 +0,0 @@
-//! A `Compilation` contains the compiled function bodies for a WebAssembly
-//! module.
-
-use crate::{obj, Tunables};
-use crate::{
-    BuiltinFunctionIndex, DefinedFuncIndex, FlagValue, FuncIndex, FunctionBodyData, FunctionLoc,
-    ModuleTranslation, ModuleTypesBuilder, ObjectKind, PrimaryMap, WasmError, WasmFuncType,
-    WasmFunctionInfo,
-};
-use anyhow::Result;
-use object::write::{Object, SymbolId};
-use object::{Architecture, BinaryFormat, FileFlags};
-use std::any::Any;
-use std::borrow::Cow;
-use std::fmt;
-use std::path;
-use std::sync::Arc;
-use thiserror::Error;
-
-mod address_map;
-mod module_artifacts;
-mod trap_encoding;
-
-pub use self::address_map::*;
-pub use self::module_artifacts::*;
-pub use self::trap_encoding::*;
-
-/// An error while compiling WebAssembly to machine code.
-#[derive(Error, Debug)]
-pub enum CompileError {
-    /// A wasm translation error occured.
-    #[error("WebAssembly translation error")]
-    Wasm(#[from] WasmError),
-
-    /// A compilation error occured.
-    #[error("Compilation error: {0}")]
-    Codegen(String),
-
-    /// A compilation error occured.
-    #[error("Debug info is not supported with this configuration")]
-    DebugInfoNotSupported,
-}
-
-/// What relocations can be applied against.
-///
-/// Each wasm function may refer to various other `RelocationTarget` entries.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum RelocationTarget {
-    /// This is a reference to another defined wasm function in the same module.
-    Wasm(FuncIndex),
-    /// This is a reference to a trampoline for a builtin function.
-    Builtin(BuiltinFunctionIndex),
-    /// A compiler-generated libcall.
-    HostLibcall(obj::LibCall),
-}
-
-/// Implementation of an incremental compilation's key/value cache store.
-///
-/// In theory, this could just be Cranelift's `CacheKvStore` trait, but it is not as we want to
-/// make sure that wasmtime isn't too tied to Cranelift internals (and as a matter of fact, we
-/// can't depend on the Cranelift trait here).
-pub trait CacheStore: Send + Sync + std::fmt::Debug {
-    /// Try to retrieve an arbitrary cache key entry, and returns a reference to bytes that were
-    /// inserted via `Self::insert` before.
-    fn get(&self, key: &[u8]) -> Option<Cow<[u8]>>;
-
-    /// Given an arbitrary key and bytes, stores them in the cache.
-    ///
-    /// Returns false when insertion in the cache failed.
-    fn insert(&self, key: &[u8], value: Vec<u8>) -> bool;
-}
-
-/// Abstract trait representing the ability to create a `Compiler` below.
-///
-/// This is used in Wasmtime to separate compiler implementations, currently
-/// mostly used to separate Cranelift from Wasmtime itself.
-pub trait CompilerBuilder: Send + Sync + fmt::Debug {
-    /// Sets the target of compilation to the target specified.
-    fn target(&mut self, target: target_lexicon::Triple) -> Result<()>;
-
-    /// Enables clif output in the directory specified.
-    fn clif_dir(&mut self, _path: &path::Path) -> Result<()> {
-        anyhow::bail!("clif output not supported");
-    }
-
-    /// Returns the currently configured target triple that compilation will
-    /// produce artifacts for.
-    fn triple(&self) -> &target_lexicon::Triple;
-
-    /// Compiler-specific method to configure various settings in the compiler
-    /// itself.
-    ///
-    /// This is expected to be defined per-compiler. Compilers should return
-    /// errors for unknown names/values.
-    fn set(&mut self, name: &str, val: &str) -> Result<()>;
-
-    /// Compiler-specific method for configuring settings.
-    ///
-    /// Same as [`CompilerBuilder::set`] except for enabling boolean flags.
-    /// Currently cranelift uses this to sometimes enable a family of settings.
-    fn enable(&mut self, name: &str) -> Result<()>;
-
-    /// Returns a list of all possible settings that can be configured with
-    /// [`CompilerBuilder::set`] and [`CompilerBuilder::enable`].
-    fn settings(&self) -> Vec<Setting>;
-
-    /// Enables Cranelift's incremental compilation cache, using the given `CacheStore`
-    /// implementation.
-    ///
-    /// This will return an error if the compiler does not support incremental compilation.
-    fn enable_incremental_compilation(&mut self, cache_store: Arc<dyn CacheStore>) -> Result<()>;
-
-    /// Set the tunables for this compiler.
-    fn set_tunables(&mut self, tunables: Tunables) -> Result<()>;
-
-    /// Builds a new [`Compiler`] object from this configuration.
-    fn build(&self) -> Result<Box<dyn Compiler>>;
-
-    /// Enables or disables wmemcheck during runtime according to the wmemcheck CLI flag.
-    fn wmemcheck(&mut self, _enable: bool) {}
-}
-
-/// Description of compiler settings returned by [`CompilerBuilder::settings`].
-#[derive(Clone, Copy, Debug)]
-pub struct Setting {
-    /// The name of the setting.
-    pub name: &'static str,
-    /// The description of the setting.
-    pub description: &'static str,
-    /// The kind of the setting.
-    pub kind: SettingKind,
-    /// The supported values of the setting (for enum values).
-    pub values: Option<&'static [&'static str]>,
-}
-
-/// Different kinds of [`Setting`] values that can be configured in a
-/// [`CompilerBuilder`]
-#[derive(Clone, Copy, Debug)]
-pub enum SettingKind {
-    /// The setting is an enumeration, meaning it's one of a set of values.
-    Enum,
-    /// The setting is a number.
-    Num,
-    /// The setting is a boolean.
-    Bool,
-    /// The setting is a preset.
-    Preset,
-}
-
-/// An implementation of a compiler which can compile WebAssembly functions to
-/// machine code and perform other miscellaneous tasks needed by the JIT runtime.
-pub trait Compiler: Send + Sync {
-    /// Compiles the function `index` within `translation`.
-    ///
-    /// The body of the function is available in `data` and configuration
-    /// values are also passed in via `tunables`. Type information in
-    /// `translation` is all relative to `types`.
-    ///
-    /// This function returns a tuple:
-    ///
-    /// 1. Metadata about the wasm function itself.
-    /// 2. The function itself, as an `Any` to get downcasted later when passed
-    ///    to `append_code`.
-    fn compile_function(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        index: DefinedFuncIndex,
-        data: FunctionBodyData<'_>,
-        types: &ModuleTypesBuilder,
-    ) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError>;
-
-    /// Compile a trampoline for an array-call host function caller calling the
-    /// `index`th Wasm function.
-    ///
-    /// The trampoline should save the necessary state to record the
-    /// host-to-Wasm transition (e.g. registers used for fast stack walking).
-    fn compile_array_to_wasm_trampoline(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        types: &ModuleTypesBuilder,
-        index: DefinedFuncIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Compile a trampoline for a native-call host function caller calling the
-    /// `index`th Wasm function.
-    ///
-    /// The trampoline should save the necessary state to record the
-    /// host-to-Wasm transition (e.g. registers used for fast stack walking).
-    fn compile_native_to_wasm_trampoline(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        types: &ModuleTypesBuilder,
-        index: DefinedFuncIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Compile a trampoline for a Wasm caller calling a native callee with the
-    /// given signature.
-    ///
-    /// The trampoline should save the necessary state to record the
-    /// Wasm-to-host transition (e.g. registers used for fast stack walking).
-    fn compile_wasm_to_native_trampoline(
-        &self,
-        wasm_func_ty: &WasmFuncType,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Creates a tramopline that can be used to call Wasmtime's implementation
-    /// of the builtin function specified by `index`.
-    ///
-    /// The trampoline created can technically have any ABI but currently has
-    /// the native ABI. This will then perform all the necessary duties of an
-    /// exit trampoline from wasm and then perform the actual dispatch to the
-    /// builtin function. Builtin functions in Wasmtime are stored in an array
-    /// in all `VMContext` pointers, so the call to the host is an indirect
-    /// call.
-    fn compile_wasm_to_builtin(
-        &self,
-        index: BuiltinFunctionIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Returns the list of relocations required for a function from one of the
-    /// previous `compile_*` functions above.
-    fn compiled_function_relocation_targets<'a>(
-        &'a self,
-        func: &'a dyn Any,
-    ) -> Box<dyn Iterator<Item = RelocationTarget> + 'a>;
-
-    /// Appends a list of compiled functions to an in-memory object.
-    ///
-    /// This function will receive the same `Box<dyn Any>` produced as part of
-    /// compilation from functions like `compile_function`,
-    /// `compile_host_to_wasm_trampoline`, and other component-related shims.
-    /// Internally this will take all of these functions and add information to
-    /// the object such as:
-    ///
-    /// * Compiled code in a `.text` section
-    /// * Unwind information in Wasmtime-specific sections
-    /// * Relocations, if necessary, for the text section
-    ///
-    /// Each function is accompanied with its desired symbol name and the return
-    /// value of this function is the symbol for each function as well as where
-    /// each function was placed within the object.
-    ///
-    /// The `resolve_reloc` argument is intended to resolving relocations
-    /// between function, chiefly resolving intra-module calls within one core
-    /// wasm module. The closure here takes two arguments:
-    ///
-    /// 1. First, the index within `funcs` that is being resolved,
-    ///
-    /// 2. and next the `RelocationTarget` which is the relocation target to
-    /// resolve.
-    ///
-    /// The return value is an index within `funcs` that the relocation points
-    /// to.
-    fn append_code(
-        &self,
-        obj: &mut Object<'static>,
-        funcs: &[(String, Box<dyn Any + Send>)],
-        resolve_reloc: &dyn Fn(usize, RelocationTarget) -> usize,
-    ) -> Result<Vec<(SymbolId, FunctionLoc)>>;
-
-    /// Inserts two trampolines into `obj` for a array-call host function:
-    ///
-    /// 1. A wasm-call trampoline: A trampoline that takes arguments in their
-    ///    wasm-call locations, moves them to their array-call locations, calls
-    ///    the array-call host function, and finally moves the return values
-    ///    from the array-call locations to the wasm-call return
-    ///    locations. Additionally, this trampoline manages the wasm-to-host
-    ///    state transition for the runtime.
-    ///
-    /// 2. A native-call trampoline: A trampoline that takes arguments in their
-    ///    native-call locations, moves them to their array-call locations,
-    ///    calls the array-call host function, and finally moves the return
-    ///    values from the array-call locations to the native-call return
-    ///    locations. Does not need to manage any wasm/host state transitions,
-    ///    since both caller and callee are on the host side.
-    ///
-    /// This will configure the same sections as `append_code`, but will likely
-    /// be much smaller.
-    ///
-    /// The two returned `FunctionLoc` structures describe where to find these
-    /// trampolines in the text section, respectively.
-    ///
-    /// These trampolines are only valid for in-process JIT usage. They bake in
-    /// the function pointer to the host code.
-    fn emit_trampolines_for_array_call_host_func(
-        &self,
-        ty: &WasmFuncType,
-        // Actually `host_fn: VMArrayCallFunction` but that type is not
-        // available in `wasmtime-environ`.
-        host_fn: usize,
-        obj: &mut Object<'static>,
-    ) -> Result<(FunctionLoc, FunctionLoc)>;
-
-    /// Creates a new `Object` file which is used to build the results of a
-    /// compilation into.
-    ///
-    /// The returned object file will have an appropriate
-    /// architecture/endianness for `self.triple()`, but at this time it is
-    /// always an ELF file, regardless of target platform.
-    fn object(&self, kind: ObjectKind) -> Result<Object<'static>> {
-        use target_lexicon::Architecture::*;
-
-        let triple = self.triple();
-        let mut obj = Object::new(
-            BinaryFormat::Elf,
-            match triple.architecture {
-                X86_32(_) => Architecture::I386,
-                X86_64 => Architecture::X86_64,
-                Arm(_) => Architecture::Arm,
-                Aarch64(_) => Architecture::Aarch64,
-                S390x => Architecture::S390x,
-                Riscv64(_) => Architecture::Riscv64,
-                architecture => {
-                    anyhow::bail!("target architecture {:?} is unsupported", architecture,);
-                }
-            },
-            match triple.endianness().unwrap() {
-                target_lexicon::Endianness::Little => object::Endianness::Little,
-                target_lexicon::Endianness::Big => object::Endianness::Big,
-            },
-        );
-        obj.flags = FileFlags::Elf {
-            os_abi: obj::ELFOSABI_WASMTIME,
-            e_flags: match kind {
-                ObjectKind::Module => obj::EF_WASMTIME_MODULE,
-                ObjectKind::Component => obj::EF_WASMTIME_COMPONENT,
-            },
-            abi_version: 0,
-        };
-        Ok(obj)
-    }
-
-    /// Returns the target triple that this compiler is compiling for.
-    fn triple(&self) -> &target_lexicon::Triple;
-
-    /// Returns the alignment necessary to align values to the page size of the
-    /// compilation target. Note that this may be an upper-bound where the
-    /// alignment is larger than necessary for some platforms since it may
-    /// depend on the platform's runtime configuration.
-    fn page_size_align(&self) -> u64 {
-        use target_lexicon::*;
-        match (self.triple().operating_system, self.triple().architecture) {
-            (
-                OperatingSystem::MacOSX { .. }
-                | OperatingSystem::Darwin
-                | OperatingSystem::Ios
-                | OperatingSystem::Tvos,
-                Architecture::Aarch64(..),
-            ) => 0x4000,
-            // 64 KB is the maximal page size (i.e. memory translation granule size)
-            // supported by the architecture and is used on some platforms.
-            (_, Architecture::Aarch64(..)) => 0x10000,
-            _ => 0x1000,
-        }
-    }
-
-    /// Returns a list of configured settings for this compiler.
-    fn flags(&self) -> Vec<(&'static str, FlagValue<'static>)>;
-
-    /// Same as [`Compiler::flags`], but ISA-specific (a cranelift-ism)
-    fn isa_flags(&self) -> Vec<(&'static str, FlagValue<'static>)>;
-
-    /// Get a flag indicating whether branch protection is enabled.
-    fn is_branch_protection_enabled(&self) -> bool;
-
-    /// Returns a suitable compiler usable for component-related compliations.
-    ///
-    /// Note that the `ComponentCompiler` trait can also be implemented for
-    /// `Self` in which case this function would simply return `self`.
-    #[cfg(feature = "component-model")]
-    fn component_compiler(&self) -> &dyn crate::component::ComponentCompiler;
-
-    /// Appends generated DWARF sections to the `obj` specified for the compiled
-    /// functions.
-    fn append_dwarf(
-        &self,
-        obj: &mut Object<'_>,
-        translation: &ModuleTranslation<'_>,
-        funcs: &PrimaryMap<DefinedFuncIndex, (SymbolId, &(dyn Any + Send))>,
-    ) -> Result<()>;
-
-    /// Creates a new System V Common Information Entry for the ISA.
-    ///
-    /// Returns `None` if the ISA does not support System V unwind information.
-    fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
-        // By default, an ISA cannot create a System V CIE.
-        None
-    }
-}

data/ext/cargo-vendor/wasmtime-environ-20.0.2/src/compile/module_artifacts.rs

@@ -1,300 +0,0 @@
-//! Definitions of runtime structures and metadata which are serialized into ELF
-//! with `bincode` as part of a module's compilation process.
-
-use crate::{
-    obj, CompiledFunctionInfo, CompiledModuleInfo, DefinedFuncIndex, FunctionLoc, FunctionName,
-    MemoryInitialization, Metadata, ModuleTranslation, PrimaryMap, Tunables,
-};
-use anyhow::{bail, Result};
-use object::write::{Object, SectionId, StandardSegment, WritableBuffer};
-use object::SectionKind;
-use std::ops::Range;
-use wasmtime_types::ModuleInternedTypeIndex;
-
-/// Helper structure to create an ELF file as a compilation artifact.
-///
-/// This structure exposes the process which Wasmtime will encode a core wasm
-/// module into an ELF file, notably managing data sections and all that good
-/// business going into the final file.
-pub struct ObjectBuilder<'a> {
-    /// The `object`-crate-defined ELF file write we're using.
-    obj: Object<'a>,
-
-    /// General compilation configuration.
-    tunables: &'a Tunables,
-
-    /// The section identifier for "rodata" which is where wasm data segments
-    /// will go.
-    data: SectionId,
-
-    /// The section identifier for function name information, or otherwise where
-    /// the `name` custom section of wasm is copied into.
-    ///
-    /// This is optional and lazily created on demand.
-    names: Option<SectionId>,
-
-    /// The section identifier for dwarf information copied from the original
-    /// wasm files.
-    ///
-    /// This is optional and lazily created on demand.
-    dwarf: Option<SectionId>,
-}
-
-impl<'a> ObjectBuilder<'a> {
-    /// Creates a new builder for the `obj` specified.
-    pub fn new(mut obj: Object<'a>, tunables: &'a Tunables) -> ObjectBuilder<'a> {
-        let data = obj.add_section(
-            obj.segment_name(StandardSegment::Data).to_vec(),
-            obj::ELF_WASM_DATA.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-        ObjectBuilder {
-            obj,
-            tunables,
-            data,
-            names: None,
-            dwarf: None,
-        }
-    }
-
-    /// Completes compilation of the `translation` specified, inserting
-    /// everything necessary into the `Object` being built.
-    ///
-    /// This function will consume the final results of compiling a wasm module
-    /// and finish the ELF image in-progress as part of `self.obj` by appending
-    /// any compiler-agnostic sections.
-    ///
-    /// The auxiliary `CompiledModuleInfo` structure returned here has also been
-    /// serialized into the object returned, but if the caller will quickly
-    /// turn-around and invoke `CompiledModule::from_artifacts` after this then
-    /// the information can be passed to that method to avoid extra
-    /// deserialization. This is done to avoid a serialize-then-deserialize for
-    /// API calls like `Module::new` where the compiled module is immediately
-    /// going to be used.
-    ///
-    /// The various arguments here are:
-    ///
-    /// * `translation` - the core wasm translation that's being completed.
-    ///
-    /// * `funcs` - compilation metadata about functions within the translation
-    ///   as well as where the functions are located in the text section and any
-    ///   associated trampolines.
-    ///
-    /// * `wasm_to_native_trampolines` - list of all trampolines necessary for
-    ///   Wasm callers calling native callees (e.g. `Func::wrap`). One for each
-    ///   function signature in the module. Must be sorted by `SignatureIndex`.
-    ///
-    /// Returns the `CompiledModuleInfo` corresponding to this core Wasm module
-    /// as a result of this append operation. This is then serialized into the
-    /// final artifact by the caller.
-    pub fn append(
-        &mut self,
-        translation: ModuleTranslation<'_>,
-        funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
-        wasm_to_native_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
-    ) -> Result<CompiledModuleInfo> {
-        let ModuleTranslation {
-            mut module,
-            debuginfo,
-            has_unparsed_debuginfo,
-            data,
-            data_align,
-            passive_data,
-            ..
-        } = translation;
-
-        // Place all data from the wasm module into a section which will the
-        // source of the data later at runtime. This additionally keeps track of
-        // the offset of
-        let mut total_data_len = 0;
-        let data_offset = self
-            .obj
-            .append_section_data(self.data, &[], data_align.unwrap_or(1));
-        for (i, data) in data.iter().enumerate() {
-            // The first data segment has its alignment specified as the alignment
-            // for the entire section, but everything afterwards is adjacent so it
-            // has alignment of 1.
-            let align = if i == 0 { data_align.unwrap_or(1) } else { 1 };
-            self.obj.append_section_data(self.data, data, align);
-            total_data_len += data.len();
-        }
-        for data in passive_data.iter() {
-            self.obj.append_section_data(self.data, data, 1);
-        }
-
-        // If any names are present in the module then the `ELF_NAME_DATA` section
-        // is create and appended.
-        let mut func_names = Vec::new();
-        if debuginfo.name_section.func_names.len() > 0 {
-            let name_id = *self.names.get_or_insert_with(|| {
-                self.obj.add_section(
-                    self.obj.segment_name(StandardSegment::Data).to_vec(),
-                    obj::ELF_NAME_DATA.as_bytes().to_vec(),
-                    SectionKind::ReadOnlyData,
-                )
-            });
-            let mut sorted_names = debuginfo.name_section.func_names.iter().collect::<Vec<_>>();
-            sorted_names.sort_by_key(|(idx, _name)| *idx);
-            for (idx, name) in sorted_names {
-                let offset = self.obj.append_section_data(name_id, name.as_bytes(), 1);
-                let offset = match u32::try_from(offset) {
-                    Ok(offset) => offset,
-                    Err(_) => bail!("name section too large (> 4gb)"),
-                };
-                let len = u32::try_from(name.len()).unwrap();
-                func_names.push(FunctionName {
-                    idx: *idx,
-                    offset,
-                    len,
-                });
-            }
-        }
-
-        // Data offsets in `MemoryInitialization` are offsets within the
-        // `translation.data` list concatenated which is now present in the data
-        // segment that's appended to the object. Increase the offsets by
-        // `self.data_size` to account for any previously added module.
-        let data_offset = u32::try_from(data_offset).unwrap();
-        match &mut module.memory_initialization {
-            MemoryInitialization::Segmented(list) => {
-                for segment in list {
-                    segment.data.start = segment.data.start.checked_add(data_offset).unwrap();
-                    segment.data.end = segment.data.end.checked_add(data_offset).unwrap();
-                }
-            }
-            MemoryInitialization::Static { map } => {
-                for (_, segment) in map {
-                    if let Some(segment) = segment {
-                        segment.data.start = segment.data.start.checked_add(data_offset).unwrap();
-                        segment.data.end = segment.data.end.checked_add(data_offset).unwrap();
-                    }
-                }
-            }
-        }
-
-        // Data offsets for passive data are relative to the start of
-        // `translation.passive_data` which was appended to the data segment
-        // of this object, after active data in `translation.data`. Update the
-        // offsets to account prior modules added in addition to active data.
-        let data_offset = data_offset + u32::try_from(total_data_len).unwrap();
-        for (_, range) in module.passive_data_map.iter_mut() {
-            range.start = range.start.checked_add(data_offset).unwrap();
-            range.end = range.end.checked_add(data_offset).unwrap();
-        }
-
-        // Insert the wasm raw wasm-based debuginfo into the output, if
-        // requested. Note that this is distinct from the native debuginfo
-        // possibly generated by the native compiler, hence these sections
-        // getting wasm-specific names.
-        let mut dwarf = Vec::new();
-        if self.tunables.parse_wasm_debuginfo {
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_abbrev);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_addr);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_aranges);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_info);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_line);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_line_str);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_str);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_str_offsets);
-            self.push_debug(&mut dwarf, &debuginfo.debug_ranges);
-            self.push_debug(&mut dwarf, &debuginfo.debug_rnglists);
-        }
-        // Sort this for binary-search-lookup later in `symbolize_context`.
-        dwarf.sort_by_key(|(id, _)| *id);
-
-        Ok(CompiledModuleInfo {
-            module,
-            funcs,
-            wasm_to_native_trampolines,
-            func_names,
-            meta: Metadata {
-                native_debug_info_present: self.tunables.generate_native_debuginfo,
-                has_unparsed_debuginfo,
-                code_section_offset: debuginfo.wasm_file.code_section_offset,
-                has_wasm_debuginfo: self.tunables.parse_wasm_debuginfo,
-                dwarf,
-            },
-        })
-    }
-
-    fn push_debug<'b, T>(&mut self, dwarf: &mut Vec<(u8, Range<u64>)>, section: &T)
-    where
-        T: gimli::Section<gimli::EndianSlice<'b, gimli::LittleEndian>>,
-    {
-        let data = section.reader().slice();
-        if data.is_empty() {
-            return;
-        }
-        let section_id = *self.dwarf.get_or_insert_with(|| {
-            self.obj.add_section(
-                self.obj.segment_name(StandardSegment::Debug).to_vec(),
-                obj::ELF_WASMTIME_DWARF.as_bytes().to_vec(),
-                SectionKind::Debug,
-            )
-        });
-        let offset = self.obj.append_section_data(section_id, data, 1);
-        dwarf.push((T::id() as u8, offset..offset + data.len() as u64));
-    }
-
-    /// Creates the `ELF_WASMTIME_INFO` section from the given serializable data
-    /// structure.
-    pub fn serialize_info<T>(&mut self, info: &T)
-    where
-        T: serde::Serialize,
-    {
-        let section = self.obj.add_section(
-            self.obj.segment_name(StandardSegment::Data).to_vec(),
-            obj::ELF_WASMTIME_INFO.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-        let data = bincode::serialize(info).unwrap();
-        self.obj.set_section_data(section, data, 1);
-    }
-
-    /// Serializes `self` into a buffer. This can be used for execution as well
-    /// as serialization.
-    pub fn finish<T: WritableBuffer>(self, t: &mut T) -> Result<()> {
-        self.obj.emit(t).map_err(|e| e.into())
-    }
-}
-
-/// A type which can be the result of serializing an object.
-pub trait FinishedObject: Sized {
-    /// Emit the object as `Self`.
-    fn finish_object(obj: ObjectBuilder<'_>) -> Result<Self>;
-}
-
-impl FinishedObject for Vec<u8> {
-    fn finish_object(obj: ObjectBuilder<'_>) -> Result<Self> {
-        let mut result = ObjectVec::default();
-        obj.finish(&mut result)?;
-        return Ok(result.0);
-
-        #[derive(Default)]
-        struct ObjectVec(Vec<u8>);
-
-        impl WritableBuffer for ObjectVec {
-            fn len(&self) -> usize {
-                self.0.len()
-            }
-
-            fn reserve(&mut self, additional: usize) -> Result<(), ()> {
-                assert_eq!(self.0.len(), 0, "cannot reserve twice");
-                self.0 = Vec::with_capacity(additional);
-                Ok(())
-            }
-
-            fn resize(&mut self, new_len: usize) {
-                if new_len <= self.0.len() {
-                    self.0.truncate(new_len)
-                } else {
-                    self.0.extend(vec![0; new_len - self.0.len()])
-                }
-            }
-
-            fn write_bytes(&mut self, val: &[u8]) {
-                self.0.extend(val);
-            }
-        }
-    }
-}