wasmtime 19.0.2 → 20.0.0

data/ext/cargo-vendor/wasmtime-cranelift-20.0.0/src/obj.rs

@@ -0,0 +1,545 @@
+//! Object file builder.
+//!
+//! Creates ELF image based on `Compilation` information. The ELF contains
+//! functions and trampolines in the ".text" section. It also contains all
+//! relocation records for the linking stage. If DWARF sections exist, their
+//! content will be written as well.
+//!
+//! The object file has symbols for each function and trampoline, as well as
+//! symbols that refer to libcalls.
+//!
+//! The function symbol names have format "_wasm_function_N", where N is
+//! `FuncIndex`. The defined wasm function symbols refer to a JIT compiled
+//! function body, the imported wasm function do not. The trampolines symbol
+//! names have format "_trampoline_N", where N is `SignatureIndex`.
+
+use crate::{CompiledFunction, RelocationTarget};
+use anyhow::Result;
+use cranelift_codegen::binemit::Reloc;
+use cranelift_codegen::isa::unwind::{systemv, UnwindInfo};
+use cranelift_codegen::TextSectionBuilder;
+use cranelift_control::ControlPlane;
+use gimli::write::{Address, EhFrame, EndianVec, FrameTable, Writer};
+use gimli::RunTimeEndian;
+use object::write::{Object, SectionId, StandardSegment, Symbol, SymbolId, SymbolSection};
+use object::{Architecture, SectionKind, SymbolFlags, SymbolKind, SymbolScope};
+use std::collections::HashMap;
+use std::ops::Range;
+use wasmtime_environ::obj::LibCall;
+use wasmtime_environ::Compiler;
+
+const TEXT_SECTION_NAME: &[u8] = b".text";
+
+/// A helper structure used to assemble the final text section of an exectuable,
+/// plus unwinding information and other related details.
+///
+/// This builder relies on Cranelift-specific internals but assembles into a
+/// generic `Object` which will get further appended to in a compiler-agnostic
+/// fashion later.
+pub struct ModuleTextBuilder<'a> {
+    /// The target that we're compiling for, used to query target-specific
+    /// information as necessary.
+    compiler: &'a dyn Compiler,
+
+    /// The object file that we're generating code into.
+    obj: &'a mut Object<'static>,
+
+    /// The WebAssembly module we're generating code for.
+    text_section: SectionId,
+
+    unwind_info: UnwindInfoBuilder<'a>,
+
+    /// In-progress text section that we're using cranelift's `MachBuffer` to
+    /// build to resolve relocations (calls) between functions.
+    text: Box<dyn TextSectionBuilder>,
+
+    /// Symbols defined in the object for libcalls that relocations are applied
+    /// against.
+    ///
+    /// Note that this isn't typically used. It's only used for SSE-disabled
+    /// builds without SIMD on x86_64 right now.
+    libcall_symbols: HashMap<LibCall, SymbolId>,
+
+    ctrl_plane: ControlPlane,
+}
+
+impl<'a> ModuleTextBuilder<'a> {
+    /// Creates a new builder for the text section of an executable.
+    ///
+    /// The `.text` section will be appended to the specified `obj` along with
+    /// any unwinding or such information as necessary. The `num_funcs`
+    /// parameter indicates the number of times the `append_func` function will
+    /// be called. The `finish` function will panic if this contract is not met.
+    pub fn new(
+        obj: &'a mut Object<'static>,
+        compiler: &'a dyn Compiler,
+        text: Box<dyn TextSectionBuilder>,
+    ) -> Self {
+        // Entire code (functions and trampolines) will be placed
+        // in the ".text" section.
+        let text_section = obj.add_section(
+            obj.segment_name(StandardSegment::Text).to_vec(),
+            TEXT_SECTION_NAME.to_vec(),
+            SectionKind::Text,
+        );
+
+        Self {
+            compiler,
+            obj,
+            text_section,
+            unwind_info: Default::default(),
+            text,
+            libcall_symbols: HashMap::default(),
+            ctrl_plane: ControlPlane::default(),
+        }
+    }
+
+    /// Appends the `func` specified named `name` to this object.
+    ///
+    /// The `resolve_reloc_target` closure is used to resolve a relocation
+    /// target to an adjacent function which has already been added or will be
+    /// added to this object. The argument is the relocation target specified
+    /// within `CompiledFunction` and the return value must be an index where
+    /// the target will be defined by the `n`th call to `append_func`.
+    ///
+    /// Returns the symbol associated with the function as well as the range
+    /// that the function resides within the text section.
+    pub fn append_func(
+        &mut self,
+        name: &str,
+        compiled_func: &'a CompiledFunction,
+        resolve_reloc_target: impl Fn(wasmtime_environ::RelocationTarget) -> usize,
+    ) -> (SymbolId, Range<u64>) {
+        let body = compiled_func.buffer.data();
+        let alignment = compiled_func.alignment;
+        let body_len = body.len() as u64;
+        let off = self
+            .text
+            .append(true, &body, alignment, &mut self.ctrl_plane);
+
+        let symbol_id = self.obj.add_symbol(Symbol {
+            name: name.as_bytes().to_vec(),
+            value: off,
+            size: body_len,
+            kind: SymbolKind::Text,
+            scope: SymbolScope::Compilation,
+            weak: false,
+            section: SymbolSection::Section(self.text_section),
+            flags: SymbolFlags::None,
+        });
+
+        if let Some(info) = compiled_func.unwind_info() {
+            self.unwind_info.push(off, body_len, info);
+        }
+
+        for r in compiled_func.relocations() {
+            match r.reloc_target {
+                // Relocations against user-defined functions means that this is
+                // a relocation against a module-local function, typically a
+                // call between functions. The `text` field is given priority to
+                // resolve this relocation before we actually emit an object
+                // file, but if it can't handle it then we pass through the
+                // relocation.
+                RelocationTarget::Wasm(_) | RelocationTarget::Builtin(_) => {
+                    let target = resolve_reloc_target(r.reloc_target);
+                    if self
+                        .text
+                        .resolve_reloc(off + u64::from(r.offset), r.reloc, r.addend, target)
+                    {
+                        continue;
+                    }
+
+                    // At this time it's expected that all relocations are
+                    // handled by `text.resolve_reloc`, and anything that isn't
+                    // handled is a bug in `text.resolve_reloc` or something
+                    // transitively there. If truly necessary, though, then this
+                    // loop could also be updated to forward the relocation to
+                    // the final object file as well.
+                    panic!(
+                        "unresolved relocation could not be processed against \
+                         {:?}: {r:?}",
+                        r.reloc_target,
+                    );
+                }
+
+                // Relocations against libcalls are not common at this time and
+                // are only used in non-default configurations that disable wasm
+                // SIMD, disable SSE features, and for wasm modules that still
+                // use floating point operations.
+                //
+                // Currently these relocations are all expected to be absolute
+                // 8-byte relocations so that's asserted here and then encoded
+                // directly into the object as a normal object relocation. This
+                // is processed at module load time to resolve the relocations.
+                RelocationTarget::HostLibcall(call) => {
+                    let symbol = *self.libcall_symbols.entry(call).or_insert_with(|| {
+                        self.obj.add_symbol(Symbol {
+                            name: call.symbol().as_bytes().to_vec(),
+                            value: 0,
+                            size: 0,
+                            kind: SymbolKind::Text,
+                            scope: SymbolScope::Linkage,
+                            weak: false,
+                            section: SymbolSection::Undefined,
+                            flags: SymbolFlags::None,
+                        })
+                    });
+                    let flags = match r.reloc {
+                        Reloc::Abs8 => object::RelocationFlags::Generic {
+                            encoding: object::RelocationEncoding::Generic,
+                            kind: object::RelocationKind::Absolute,
+                            size: 64,
+                        },
+                        other => unimplemented!("unimplemented relocation kind {other:?}"),
+                    };
+                    self.obj
+                        .add_relocation(
+                            self.text_section,
+                            object::write::Relocation {
+                                symbol,
+                                flags,
+                                offset: off + u64::from(r.offset),
+                                addend: r.addend,
+                            },
+                        )
+                        .unwrap();
+                }
+            };
+        }
+        (symbol_id, off..off + body_len)
+    }
+
+    /// Forces "veneers" to be used for inter-function calls in the text
+    /// section which means that in-bounds optimized addresses are never used.
+    ///
+    /// This is only useful for debugging cranelift itself and typically this
+    /// option is disabled.
+    pub fn force_veneers(&mut self) {
+        self.text.force_veneers();
+    }
+
+    /// Appends the specified amount of bytes of padding into the text section.
+    ///
+    /// This is only useful when fuzzing and/or debugging cranelift itself and
+    /// for production scenarios `padding` is 0 and this function does nothing.
+    pub fn append_padding(&mut self, padding: usize) {
+        if padding == 0 {
+            return;
+        }
+        self.text
+            .append(false, &vec![0; padding], 1, &mut self.ctrl_plane);
+    }
+
+    /// Indicates that the text section has been written completely and this
+    /// will finish appending it to the original object.
+    ///
+    /// Note that this will also write out the unwind information sections if
+    /// necessary.
+    pub fn finish(mut self) {
+        // Finish up the text section now that we're done adding functions.
+        let text = self.text.finish(&mut self.ctrl_plane);
+        self.obj
+            .section_mut(self.text_section)
+            .set_data(text, self.compiler.page_size_align());
+
+        // Append the unwind information for all our functions, if necessary.
+        self.unwind_info
+            .append_section(self.compiler, self.obj, self.text_section);
+    }
+}
+
+/// Builder used to create unwind information for a set of functions added to a
+/// text section.
+#[derive(Default)]
+struct UnwindInfoBuilder<'a> {
+    windows_xdata: Vec<u8>,
+    windows_pdata: Vec<RUNTIME_FUNCTION>,
+    systemv_unwind_info: Vec<(u64, &'a systemv::UnwindInfo)>,
+}
+
+// This is a mirror of `RUNTIME_FUNCTION` in the Windows API, but defined here
+// to ensure everything is always `u32` and to have it available on all
+// platforms. Note that all of these specifiers here are relative to a "base
+// address" which we define as the base of where the text section is eventually
+// loaded.
+#[allow(non_camel_case_types)]
+struct RUNTIME_FUNCTION {
+    begin: u32,
+    end: u32,
+    unwind_address: u32,
+}
+
+impl<'a> UnwindInfoBuilder<'a> {
+    /// Pushes the unwind information for a function into this builder.
+    ///
+    /// The function being described must be located at `function_offset` within
+    /// the text section itself, and the function's size is specified by
+    /// `function_len`.
+    ///
+    /// The `info` should come from Cranelift. and is handled here depending on
+    /// its flavor.
+    fn push(&mut self, function_offset: u64, function_len: u64, info: &'a UnwindInfo) {
+        match info {
+            // Windows unwind information is stored in two locations:
+            //
+            // * First is the actual unwinding information which is stored
+            //   in the `.xdata` section. This is where `info`'s emitted
+            //   information will go into.
+            // * Second are pointers to connect all this unwind information,
+            //   stored in the `.pdata` section. The `.pdata` section is an
+            //   array of `RUNTIME_FUNCTION` structures.
+            //
+            // Due to how these will be loaded at runtime the `.pdata` isn't
+            // actually assembled byte-wise here. Instead that's deferred to
+            // happen later during `write_windows_unwind_info` which will apply
+            // a further offset to `unwind_address`.
+            UnwindInfo::WindowsX64(info) => {
+                let unwind_size = info.emit_size();
+                let mut unwind_info = vec![0; unwind_size];
+                info.emit(&mut unwind_info);
+
+                // `.xdata` entries are always 4-byte aligned
+                //
+                // FIXME: in theory we could "intern" the `unwind_info` value
+                // here within the `.xdata` section. Most of our unwind
+                // information for functions is probably pretty similar in which
+                // case the `.xdata` could be quite small and `.pdata` could
+                // have multiple functions point to the same unwinding
+                // information.
+                while self.windows_xdata.len() % 4 != 0 {
+                    self.windows_xdata.push(0x00);
+                }
+                let unwind_address = self.windows_xdata.len();
+                self.windows_xdata.extend_from_slice(&unwind_info);
+
+                // Record a `RUNTIME_FUNCTION` which this will point to.
+                self.windows_pdata.push(RUNTIME_FUNCTION {
+                    begin: u32::try_from(function_offset).unwrap(),
+                    end: u32::try_from(function_offset + function_len).unwrap(),
+                    unwind_address: u32::try_from(unwind_address).unwrap(),
+                });
+            }
+
+            // System-V is different enough that we just record the unwinding
+            // information to get processed at a later time.
+            UnwindInfo::SystemV(info) => {
+                self.systemv_unwind_info.push((function_offset, info));
+            }
+
+            _ => panic!("some unwind info isn't handled here"),
+        }
+    }
+
+    /// Appends the unwind information section, if any, to the `obj` specified.
+    ///
+    /// This function must be called immediately after the text section was
+    /// added to a builder. The unwind information section must trail the text
+    /// section immediately.
+    ///
+    /// The `text_section`'s section identifier is passed into this function.
+    fn append_section(
+        &self,
+        compiler: &dyn Compiler,
+        obj: &mut Object<'_>,
+        text_section: SectionId,
+    ) {
+        // This write will align the text section to a page boundary and then
+        // return the offset at that point. This gives us the full size of the
+        // text section at that point, after alignment.
+        let text_section_size =
+            obj.append_section_data(text_section, &[], compiler.page_size_align());
+
+        if self.windows_xdata.len() > 0 {
+            assert!(self.systemv_unwind_info.len() == 0);
+            // The `.xdata` section must come first to be just-after the `.text`
+            // section for the reasons documented in `write_windows_unwind_info`
+            // below.
+            let segment = obj.segment_name(StandardSegment::Data).to_vec();
+            let xdata_id = obj.add_section(segment, b".xdata".to_vec(), SectionKind::ReadOnlyData);
+            let segment = obj.segment_name(StandardSegment::Data).to_vec();
+            let pdata_id = obj.add_section(segment, b".pdata".to_vec(), SectionKind::ReadOnlyData);
+            self.write_windows_unwind_info(obj, xdata_id, pdata_id, text_section_size);
+        }
+
+        if self.systemv_unwind_info.len() > 0 {
+            let segment = obj.segment_name(StandardSegment::Data).to_vec();
+            let section_id =
+                obj.add_section(segment, b".eh_frame".to_vec(), SectionKind::ReadOnlyData);
+            self.write_systemv_unwind_info(compiler, obj, section_id, text_section_size)
+        }
+    }
+
+    /// This function appends a nonstandard section to the object which is only
+    /// used during `CodeMemory::publish`.
+    ///
+    /// This custom section effectively stores a `[RUNTIME_FUNCTION; N]` into
+    /// the object file itself. This way registration of unwind info can simply
+    /// pass this slice to the OS itself and there's no need to recalculate
+    /// anything on the other end of loading a module from a precompiled object.
+    ///
+    /// Support for reading this is in `crates/jit/src/unwind/winx64.rs`.
+    fn write_windows_unwind_info(
+        &self,
+        obj: &mut Object<'_>,
+        xdata_id: SectionId,
+        pdata_id: SectionId,
+        text_section_size: u64,
+    ) {
+        // Currently the binary format supported here only supports
+        // little-endian for x86_64, or at least that's all where it's tested.
+        // This may need updates for other platforms.
+        assert_eq!(obj.architecture(), Architecture::X86_64);
+
+        // Append the `.xdata` section, or the actual unwinding information
+        // codes and such which were built as we found unwind information for
+        // functions.
+        obj.append_section_data(xdata_id, &self.windows_xdata, 4);
+
+        // Next append the `.pdata` section, or the array of `RUNTIME_FUNCTION`
+        // structures stored in the binary.
+        //
+        // This memory will be passed at runtime to `RtlAddFunctionTable` which
+        // takes a "base address" and the entries within `RUNTIME_FUNCTION` are
+        // all relative to this base address. The base address we pass is the
+        // address of the text section itself so all the pointers here must be
+        // text-section-relative. The `begin` and `end` fields for the function
+        // it describes are already text-section-relative, but the
+        // `unwind_address` field needs to be updated here since the value
+        // stored right now is `xdata`-section-relative. We know that the
+        // `xdata` section follows the `.text` section so the
+        // `text_section_size` is added in to calculate the final
+        // `.text`-section-relative address of the unwind information.
+        let mut pdata = Vec::with_capacity(self.windows_pdata.len() * 3 * 4);
+        for info in self.windows_pdata.iter() {
+            pdata.extend_from_slice(&info.begin.to_le_bytes());
+            pdata.extend_from_slice(&info.end.to_le_bytes());
+            let address = text_section_size + u64::from(info.unwind_address);
+            let address = u32::try_from(address).unwrap();
+            pdata.extend_from_slice(&address.to_le_bytes());
+        }
+        obj.append_section_data(pdata_id, &pdata, 4);
+    }
+
+    /// This function appends a nonstandard section to the object which is only
+    /// used during `CodeMemory::publish`.
+    ///
+    /// This will generate a `.eh_frame` section, but not one that can be
+    /// naively loaded. The goal of this section is that we can create the
+    /// section once here and never again does it need to change. To describe
+    /// dynamically loaded functions though each individual FDE needs to talk
+    /// about the function's absolute address that it's referencing. Naturally
+    /// we don't actually know the function's absolute address when we're
+    /// creating an object here.
+    ///
+    /// To solve this problem the FDE address encoding mode is set to
+    /// `DW_EH_PE_pcrel`. This means that the actual effective address that the
+    /// FDE describes is a relative to the address of the FDE itself. By
+    /// leveraging this relative-ness we can assume that the relative distance
+    /// between the FDE and the function it describes is constant, which should
+    /// allow us to generate an FDE ahead-of-time here.
+    ///
+    /// For now this assumes that all the code of functions will start at a
+    /// page-aligned address when loaded into memory. The eh_frame encoded here
+    /// then assumes that the text section is itself page aligned to its size
+    /// and the eh_frame will follow just after the text section. This means
+    /// that the relative offsets we're using here is the FDE going backwards
+    /// into the text section itself.
+    ///
+    /// Note that the library we're using to create the FDEs, `gimli`, doesn't
+    /// actually encode addresses relative to the FDE itself. Instead the
+    /// addresses are encoded relative to the start of the `.eh_frame` section.
+    /// This makes it much easier for us where we provide the relative offset
+    /// from the start of `.eh_frame` to the function in the text section, which
+    /// given our layout basically means the offset of the function in the text
+    /// section from the end of the text section.
+    ///
+    /// A final note is that the reason we page-align the text section's size is
+    /// so the .eh_frame lives on a separate page from the text section itself.
+    /// This allows `.eh_frame` to have different virtual memory permissions,
+    /// such as being purely read-only instead of read/execute like the code
+    /// bits.
+    fn write_systemv_unwind_info(
+        &self,
+        compiler: &dyn Compiler,
+        obj: &mut Object<'_>,
+        section_id: SectionId,
+        text_section_size: u64,
+    ) {
+        let mut cie = match compiler.create_systemv_cie() {
+            Some(cie) => cie,
+            None => return,
+        };
+        let mut table = FrameTable::default();
+        cie.fde_address_encoding = gimli::constants::DW_EH_PE_pcrel;
+        let cie_id = table.add_cie(cie);
+
+        for (text_section_off, unwind_info) in self.systemv_unwind_info.iter() {
+            let backwards_off = text_section_size - text_section_off;
+            let actual_offset = -i64::try_from(backwards_off).unwrap();
+            // Note that gimli wants an unsigned 64-bit integer here, but
+            // unwinders just use this constant for a relative addition with the
+            // address of the FDE, which means that the sign doesn't actually
+            // matter.
+            let fde = unwind_info.to_fde(Address::Constant(actual_offset as u64));
+            table.add_fde(cie_id, fde);
+        }
+        let endian = match compiler.triple().endianness().unwrap() {
+            target_lexicon::Endianness::Little => RunTimeEndian::Little,
+            target_lexicon::Endianness::Big => RunTimeEndian::Big,
+        };
+        let mut eh_frame = EhFrame(MyVec(EndianVec::new(endian)));
+        table.write_eh_frame(&mut eh_frame).unwrap();
+
+        // Some unwinding implementations expect a terminating "empty" length so
+        // a 0 is written at the end of the table for those implementations.
+        let mut endian_vec = (eh_frame.0).0;
+        endian_vec.write_u32(0).unwrap();
+        obj.append_section_data(section_id, endian_vec.slice(), 1);
+
+        use gimli::constants;
+        use gimli::write::Error;
+
+        struct MyVec(EndianVec<RunTimeEndian>);
+
+        impl Writer for MyVec {
+            type Endian = RunTimeEndian;
+
+            fn endian(&self) -> RunTimeEndian {
+                self.0.endian()
+            }
+
+            fn len(&self) -> usize {
+                self.0.len()
+            }
+
+            fn write(&mut self, buf: &[u8]) -> Result<(), Error> {
+                self.0.write(buf)
+            }
+
+            fn write_at(&mut self, pos: usize, buf: &[u8]) -> Result<(), Error> {
+                self.0.write_at(pos, buf)
+            }
+
+            // FIXME(gimli-rs/gimli#576) this is the definition we want for
+            // `write_eh_pointer` but the default implementation, at the time
+            // of this writing, uses `offset - val` instead of `val - offset`.
+            // A PR has been merged to fix this but until that's published we
+            // can't use it.
+            fn write_eh_pointer(
+                &mut self,
+                address: Address,
+                eh_pe: constants::DwEhPe,
+                size: u8,
+            ) -> Result<(), Error> {
+                let val = match address {
+                    Address::Constant(val) => val,
+                    Address::Symbol { .. } => unreachable!(),
+                };
+                assert_eq!(eh_pe.application(), constants::DW_EH_PE_pcrel);
+                let offset = self.len() as u64;
+                let val = val.wrapping_sub(offset);
+                self.write_eh_pointer_data(val, eh_pe.format(), size)
+            }
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-environ-20.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"35f889fb86559c7163fe6bc6668e458aac2fe269b83f97088ded4f179e039973","Cargo.toml":"99ea220975bdf53a49e55e25e8a788eb9fdbe3df2e1d2dc100ebd51e4d45a34d","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","examples/factc.rs":"014e9efa802f089162e8aea2ef0a1e578d03595599daab66308bf983c744a451","src/address_map.rs":"ef9b5e98b9cc1aacb9f7579193576f93996e7d5bb6a6b1e361fd3073eebe1843","src/builtin.rs":"6d853fd48ccf4dfb7a89258fa2fc4026980bdbe048892182e7faf96454546fcb","src/compile/address_map.rs":"f527f8d218607d2b19c474761ae60bfb434c33b69811e7d15baf8aec166ff715","src/compile/mod.rs":"bc26c629187dc2e4116b0450bfb3a5376a9cd728f86ae639c342e645c6239ec0","src/compile/module_artifacts.rs":"6a6ef3e54c7e77ab6a732ad1799f56f2d49557d54ea5704e65ac14e901aa1ad2","src/compile/trap_encoding.rs":"1dd555f4d6de46494e62e694eea6f134166662c0c0c0b9e2d7abbd5a8052cd57","src/component.rs":"127bf58d73d90a6694e36cb2475ef7d586c2658b8e74861cbee02260b5acd3e2","src/component/artifacts.rs":"90c8971d7dd4fff7456558a4a822e51cfd0963046da3c19f89beab724d3abcc7","src/component/compiler.rs":"9cd748e3a8819c09e6c8127c916fd0ccd63546984d85ef0f6958fe2163e93486","src/component/dfg.rs":"78e2ad6edcf012e6e4023c55f3b356e85103ca8575f94f5442999732858aeebe","src/component/info.rs":"eb7dcbd79b4c17952f2186c7bd8fb31e886b8632021d7be60deff6bff1148d1a","src/component/translate.rs":"c0c8431fc697fe3f7eb68578363db478ef7c7f413f08cfa4b6d77626c21f5848","src/component/translate/adapt.rs":"ac30dda384e0cc275a543a9239ea96ce0b501ea41198d6b931fecb61fa46d793","src/component/translate/inline.rs":"cbc46b1255802b5a97c7380c2d9d22f60d648cd185a205d1177c17b7029b6dbf","src/component/types.rs":"55867014de5085159a4b320d7e95c9718f7576aa9758fc6223c9113864799e61","src/component/types/resources.rs":"3d3f1cb1b49e2b89e44332066027cd13ec4b44aaa85d9425446de73627a6ab20","src/component/vmcomponent_offsets.rs":"0ee57772c220392f3f8206d8229e377034e290fb78862097e75620eeed305a41","src/demangling.rs":"4a8b68490baa91bb2dfad48b6ed413f9b7f452028b625726f5445bad28424260","src/fact.rs":"ecd0dffdf958fe6c3732a45e20e625a05bdf0e471548845f592aa2f265958689","src/fact/core_types.rs":"bf2c66cfec482f1bbb03a9da23987935de3d6e59afa96027fa0383f75b0fa9dd","src/fact/signature.rs":"cf3486a7d7797ba0683d46a32fee05e75c21a849257d530710c9abdc0706cff6","src/fact/trampoline.rs":"5b6cc0c99ec7b54afd07dc83ed3a81d017e9582a77b18f17ab9f261c05a07f73","src/fact/transcode.rs":"87657d6e2d1388babf5acd2f240700e7550830535c0059f7d13b0f054c40b9a7","src/fact/traps.rs":"bbd45a334104ad7f39c518c01434dba0a6b0bd24c24e1dba505fa0c4cd348cf1","src/gc.rs":"2d6326c4d7a2cc2f4ff7555e860300d179936483b53a14ab9c7b597c8356b6a5","src/lib.rs":"fc2e9c81add20b14f9f3d803607538bc33db81beb37b8922ab142a135277f661","src/module.rs":"36d89c6f18730eef86239b5eb4a7faaa540cbc14c7728e85bfa7d98e41c9f5a8","src/module_artifacts.rs":"dd7d6b5bddb9bd0362755b26954bfed997ff3edb9d29c76cca239b0f2b716295","src/module_environ.rs":"b85e2e971bb17d322f478d39b8b22216e7c3c139e557cb66622c4e4db834f039","src/module_types.rs":"f5a1b32fce8fa3865608e427088c357166d921d48bec0527715d7b6b4ea11bfe","src/obj.rs":"93df78ad7e0088be17d14464e2cded37e3995091ef8dfd680aa06e54b014a2c2","src/ref_bits.rs":"45d1aabb7667bc3de741a35c7d00ce9f97053d97451bba7947bd5e7bb3719942","src/scopevec.rs":"7c6f28f2c22721097d51bc54f6e381c3617b3f3d314f346db636597993568284","src/stack_map.rs":"a8aaf1a81f3ff7a74885d2d86b2d3008a1efce281c520008703862f550b47ef3","src/trap_encoding.rs":"538be2eaaed5db255b303689d2422c97b6e86286dd38964e5b85b7ed1545d3e8","src/tunables.rs":"e19b10fc99021df73e9b7fed0d32697c8f2f464fbc4f99549bc63c0b88f37dde","src/vmoffsets.rs":"9938882f73b57eca16a80270b54f28f7bbcbceeefe7c5a6518aec9917246b23f"},"package":"64ffc1613db69ee47c96738861534f9a405e422a5aa00224fbf5d410b03fb445"}