wasmtime 17.0.1 → 18.0.3

data/ext/cargo-vendor/cranelift-wasm-0.105.3/src/sections_translator.rs

@@ -0,0 +1,409 @@
+//! Helper functions to gather information for each of the non-function sections of a
+//! WebAssembly module.
+//!
+//! The code of these helper functions is straightforward since they only read metadata
+//! about linear memories, tables, globals, etc. and store them for later use.
+//!
+//! The special case of the initialize expressions for table elements offsets or global variables
+//! is handled, according to the semantics of WebAssembly, to only specific expressions that are
+//! interpreted on the fly.
+use crate::environ::ModuleEnvironment;
+use crate::wasm_unsupported;
+use crate::{
+    DataIndex, ElemIndex, FuncIndex, GlobalIndex, GlobalInit, Memory, MemoryIndex, TableIndex, Tag,
+    TagIndex, TypeIndex, WasmError, WasmResult,
+};
+use cranelift_entity::packed_option::ReservedValue;
+use cranelift_entity::EntityRef;
+use std::boxed::Box;
+use std::vec::Vec;
+use wasmparser::{
+    self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind,
+    ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
+    GlobalSectionReader, ImportSectionReader, MemorySectionReader, MemoryType, NameSectionReader,
+    Naming, Operator, TableSectionReader, TagSectionReader, TagType, TypeRef, TypeSectionReader,
+};
+
+fn memory(ty: MemoryType) -> Memory {
+    Memory {
+        minimum: ty.initial,
+        maximum: ty.maximum,
+        shared: ty.shared,
+        memory64: ty.memory64,
+    }
+}
+
+fn tag(e: TagType) -> Tag {
+    match e.kind {
+        wasmparser::TagKind::Exception => Tag {
+            ty: TypeIndex::from_u32(e.func_type_idx),
+        },
+    }
+}
+
+/// Parses the Type section of the wasm module.
+pub fn parse_type_section<'a>(
+    types: TypeSectionReader<'a>,
+    environ: &mut dyn ModuleEnvironment<'a>,
+) -> WasmResult<()> {
+    let count = types.count();
+    environ.reserve_types(count)?;
+
+    for ty in types.into_iter_err_on_gc_types() {
+        let ty = environ.convert_func_type(&ty?);
+        environ.declare_type_func(ty)?;
+    }
+    Ok(())
+}
+
+/// Parses the Import section of the wasm module.
+pub fn parse_import_section<'data>(
+    imports: ImportSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_imports(imports.count())?;
+
+    for entry in imports {
+        let import = entry?;
+        match import.ty {
+            TypeRef::Func(sig) => {
+                environ.declare_func_import(
+                    TypeIndex::from_u32(sig),
+                    import.module,
+                    import.name,
+                )?;
+            }
+            TypeRef::Memory(ty) => {
+                environ.declare_memory_import(memory(ty), import.module, import.name)?;
+            }
+            TypeRef::Tag(e) => {
+                environ.declare_tag_import(tag(e), import.module, import.name)?;
+            }
+            TypeRef::Global(ty) => {
+                let ty = environ.convert_global_type(&ty);
+                environ.declare_global_import(ty, import.module, import.name)?;
+            }
+            TypeRef::Table(ty) => {
+                let ty = environ.convert_table_type(&ty);
+                environ.declare_table_import(ty, import.module, import.name)?;
+            }
+        }
+    }
+
+    environ.finish_imports()?;
+    Ok(())
+}
+
+/// Parses the Function section of the wasm module.
+pub fn parse_function_section(
+    functions: FunctionSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    let num_functions = functions.count();
+    if num_functions == std::u32::MAX {
+        // We reserve `u32::MAX` for our own use in cranelift-entity.
+        return Err(WasmError::ImplLimitExceeded);
+    }
+
+    environ.reserve_func_types(num_functions)?;
+
+    for entry in functions {
+        let sigindex = entry?;
+        environ.declare_func_type(TypeIndex::from_u32(sigindex))?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Table section of the wasm module.
+pub fn parse_table_section(
+    tables: TableSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tables(tables.count())?;
+
+    for entry in tables {
+        let ty = environ.convert_table_type(&entry?.ty);
+        environ.declare_table(ty)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Memory section of the wasm module.
+pub fn parse_memory_section(
+    memories: MemorySectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_memories(memories.count())?;
+
+    for entry in memories {
+        let memory = memory(entry?);
+        environ.declare_memory(memory)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Tag section of the wasm module.
+pub fn parse_tag_section(
+    tags: TagSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tags(tags.count())?;
+
+    for entry in tags {
+        let tag = tag(entry?);
+        environ.declare_tag(tag)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Global section of the wasm module.
+pub fn parse_global_section(
+    globals: GlobalSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_globals(globals.count())?;
+
+    for entry in globals {
+        let wasmparser::Global { ty, init_expr } = entry?;
+        let mut init_expr_reader = init_expr.get_binary_reader();
+        let initializer = match init_expr_reader.read_operator()? {
+            Operator::I32Const { value } => GlobalInit::I32Const(value),
+            Operator::I64Const { value } => GlobalInit::I64Const(value),
+            Operator::F32Const { value } => GlobalInit::F32Const(value.bits()),
+            Operator::F64Const { value } => GlobalInit::F64Const(value.bits()),
+            Operator::V128Const { value } => {
+                GlobalInit::V128Const(u128::from_le_bytes(*value.bytes()))
+            }
+            Operator::RefNull { hty: _ } => GlobalInit::RefNullConst,
+            Operator::RefFunc { function_index } => {
+                GlobalInit::RefFunc(FuncIndex::from_u32(function_index))
+            }
+            Operator::GlobalGet { global_index } => {
+                GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index))
+            }
+            ref s => {
+                return Err(wasm_unsupported!(
+                    "unsupported init expr in global section: {:?}",
+                    s
+                ));
+            }
+        };
+        let ty = environ.convert_global_type(&ty);
+        environ.declare_global(ty, initializer)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Export section of the wasm module.
+pub fn parse_export_section<'data>(
+    exports: ExportSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_exports(exports.count())?;
+
+    for entry in exports {
+        let Export {
+            name,
+            ref kind,
+            index,
+        } = entry?;
+
+        // The input has already been validated, so we should be able to
+        // assume valid UTF-8 and use `from_utf8_unchecked` if performance
+        // becomes a concern here.
+        let index = index as usize;
+        match *kind {
+            ExternalKind::Func => environ.declare_func_export(FuncIndex::new(index), name)?,
+            ExternalKind::Table => environ.declare_table_export(TableIndex::new(index), name)?,
+            ExternalKind::Memory => environ.declare_memory_export(MemoryIndex::new(index), name)?,
+            ExternalKind::Tag => environ.declare_tag_export(TagIndex::new(index), name)?,
+            ExternalKind::Global => environ.declare_global_export(GlobalIndex::new(index), name)?,
+        }
+    }
+
+    environ.finish_exports()?;
+    Ok(())
+}
+
+/// Parses the Start section of the wasm module.
+pub fn parse_start_section(index: u32, environ: &mut dyn ModuleEnvironment) -> WasmResult<()> {
+    environ.declare_start_func(FuncIndex::from_u32(index))?;
+    Ok(())
+}
+
+fn read_elems(items: &ElementItems) -> WasmResult<Box<[FuncIndex]>> {
+    let mut elems = Vec::new();
+    match items {
+        ElementItems::Functions(funcs) => {
+            for func in funcs.clone() {
+                elems.push(FuncIndex::from_u32(func?));
+            }
+        }
+        ElementItems::Expressions(_ty, funcs) => {
+            for func in funcs.clone() {
+                let idx = match func?.get_binary_reader().read_operator()? {
+                    Operator::RefNull { .. } => FuncIndex::reserved_value(),
+                    Operator::RefFunc { function_index } => FuncIndex::from_u32(function_index),
+                    s => {
+                        return Err(WasmError::Unsupported(format!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        )));
+                    }
+                };
+                elems.push(idx);
+            }
+        }
+    }
+    Ok(elems.into_boxed_slice())
+}
+
+/// Parses the Element section of the wasm module.
+pub fn parse_element_section<'data>(
+    elements: ElementSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_table_elements(elements.count())?;
+
+    for (index, entry) in elements.into_iter().enumerate() {
+        let Element {
+            kind,
+            items,
+            range: _,
+        } = entry?;
+        let segments = read_elems(&items)?;
+        match kind {
+            ElementKind::Active {
+                table_index,
+                offset_expr,
+            } => {
+                let mut offset_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match offset_expr_reader.read_operator()? {
+                    Operator::I32Const { value } => (None, value as u32),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        ));
+                    }
+                };
+                environ.declare_table_elements(
+                    TableIndex::from_u32(table_index.unwrap_or(0)),
+                    base,
+                    offset,
+                    segments,
+                )?
+            }
+            ElementKind::Passive => {
+                let index = ElemIndex::from_u32(index as u32);
+                environ.declare_passive_element(index, segments)?;
+            }
+            ElementKind::Declared => {
+                environ.declare_elements(segments)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Data section of the wasm module.
+pub fn parse_data_section<'data>(
+    data: DataSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_data_initializers(data.count())?;
+
+    for (index, entry) in data.into_iter().enumerate() {
+        let Data {
+            kind,
+            data,
+            range: _,
+        } = entry?;
+        match kind {
+            DataKind::Active {
+                memory_index,
+                offset_expr,
+            } => {
+                let mut offset_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match offset_expr_reader.read_operator()? {
+                    Operator::I32Const { value } => (None, value as u64),
+                    Operator::I64Const { value } => (None, value as u64),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in data section: {:?}",
+                            s
+                        ))
+                    }
+                };
+                environ.declare_data_initialization(
+                    MemoryIndex::from_u32(memory_index),
+                    base,
+                    offset,
+                    data,
+                )?;
+            }
+            DataKind::Passive => {
+                let index = DataIndex::from_u32(index as u32);
+                environ.declare_passive_data(index, data)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Parses the Name section of the wasm module.
+pub fn parse_name_section<'data>(
+    names: NameSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    for subsection in names {
+        match subsection? {
+            wasmparser::Name::Function(names) => {
+                for name in names {
+                    let Naming { index, name } = name?;
+                    // We reserve `u32::MAX` for our own use in cranelift-entity.
+                    if index != u32::max_value() {
+                        environ.declare_func_name(FuncIndex::from_u32(index), name);
+                    }
+                }
+            }
+            wasmparser::Name::Module { name, .. } => {
+                environ.declare_module_name(name);
+            }
+            wasmparser::Name::Local(reader) => {
+                for f in reader {
+                    let f = f?;
+                    if f.index == u32::max_value() {
+                        continue;
+                    }
+                    for name in f.names {
+                        let Naming { index, name } = name?;
+                        environ.declare_local_name(FuncIndex::from_u32(f.index), index, name)
+                    }
+                }
+            }
+            wasmparser::Name::Label(_)
+            | wasmparser::Name::Type(_)
+            | wasmparser::Name::Table(_)
+            | wasmparser::Name::Global(_)
+            | wasmparser::Name::Memory(_)
+            | wasmparser::Name::Element(_)
+            | wasmparser::Name::Data(_)
+            | wasmparser::Name::Tag(_)
+            | wasmparser::Name::Unknown { .. } => {}
+        }
+    }
+    Ok(())
+}

data/ext/cargo-vendor/cranelift-wasm-0.105.3/src/translation_utils.rs

@@ -0,0 +1,91 @@
+//! Helper functions and structures for the translation.
+use crate::environ::TargetEnvironment;
+use crate::WasmResult;
+use core::u32;
+use cranelift_codegen::ir;
+use cranelift_frontend::FunctionBuilder;
+use wasmparser::{FuncValidator, WasmModuleResources};
+
+/// Get the parameter and result types for the given Wasm blocktype.
+pub fn blocktype_params_results<'a, T>(
+    validator: &'a FuncValidator<T>,
+    ty: wasmparser::BlockType,
+) -> WasmResult<(
+    impl ExactSizeIterator<Item = wasmparser::ValType> + Clone + 'a,
+    impl ExactSizeIterator<Item = wasmparser::ValType> + Clone + 'a,
+)>
+where
+    T: WasmModuleResources,
+{
+    return Ok(match ty {
+        wasmparser::BlockType::Empty => (
+            itertools::Either::Left(std::iter::empty()),
+            itertools::Either::Left(None.into_iter()),
+        ),
+        wasmparser::BlockType::Type(ty) => (
+            itertools::Either::Left(std::iter::empty()),
+            itertools::Either::Left(Some(ty).into_iter()),
+        ),
+        wasmparser::BlockType::FuncType(ty_index) => {
+            let ty = validator
+                .resources()
+                .sub_type_at(ty_index)
+                .expect("should be valid")
+                .unwrap_func();
+
+            (
+                itertools::Either::Right(ty.params().iter().copied()),
+                itertools::Either::Right(ty.results().iter().copied()),
+            )
+        }
+    });
+}
+
+/// Create a `Block` with the given Wasm parameters.
+pub fn block_with_params<PE: TargetEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    params: impl IntoIterator<Item = wasmparser::ValType>,
+    environ: &PE,
+) -> WasmResult<ir::Block> {
+    let block = builder.create_block();
+    for ty in params {
+        match ty {
+            wasmparser::ValType::I32 => {
+                builder.append_block_param(block, ir::types::I32);
+            }
+            wasmparser::ValType::I64 => {
+                builder.append_block_param(block, ir::types::I64);
+            }
+            wasmparser::ValType::F32 => {
+                builder.append_block_param(block, ir::types::F32);
+            }
+            wasmparser::ValType::F64 => {
+                builder.append_block_param(block, ir::types::F64);
+            }
+            wasmparser::ValType::Ref(rt) => {
+                let hty = environ.convert_heap_type(rt.heap_type());
+                builder.append_block_param(block, environ.reference_type(hty));
+            }
+            wasmparser::ValType::V128 => {
+                builder.append_block_param(block, ir::types::I8X16);
+            }
+        }
+    }
+    Ok(block)
+}
+
+/// Turns a `wasmparser` `f32` into a `Cranelift` one.
+pub fn f32_translation(x: wasmparser::Ieee32) -> ir::immediates::Ieee32 {
+    ir::immediates::Ieee32::with_bits(x.bits())
+}
+
+/// Turns a `wasmparser` `f64` into a `Cranelift` one.
+pub fn f64_translation(x: wasmparser::Ieee64) -> ir::immediates::Ieee64 {
+    ir::immediates::Ieee64::with_bits(x.bits())
+}
+
+/// Special VMContext value label. It is tracked as 0xffff_fffe label.
+pub fn get_vmctx_value_label() -> ir::ValueLabel {
+    const VMCTX_LABEL: u32 = 0xffff_fffe;
+    ir::ValueLabel::from_u32(VMCTX_LABEL)
+}

data/ext/cargo-vendor/cranelift-wasm-0.105.3/wasmtests/icall-simd.wat

@@ -0,0 +1,7 @@
+(module
+  (type $ft (func (param v128) (result v128)))
+  (func $foo (export "foo") (param i32) (param v128) (result v128)
+    (call_indirect (type $ft) (local.get 1) (local.get 0))
+  )
+  (table (;0;) 23 23 funcref)
+)

data/ext/cargo-vendor/cranelift-wasm-0.105.3/wasmtests/icall.wat

@@ -0,0 +1,7 @@
+(module
+  (type $ft (func (param f32) (result i32)))
+  (func $foo (export "foo") (param i32 f32) (result i32)
+    (call_indirect (type $ft) (local.get 1) (local.get 0))
+  )
+  (table (;0;) 23 23 funcref)
+)

data/ext/cargo-vendor/cranelift-wasm-0.105.3/wasmtests/unreachable_code.wat

@@ -0,0 +1,77 @@
+(module
+  (type (;0;) (func (param i32 i64 f64) (result f64)))
+  (type (;1;) (func))
+  (type (;2;) (func (result f32)))
+  (type (;3;) (func (result f64)))
+  (type (;4;) (func (param f64 f64) (result f64)))
+  (type (;5;) (func (result i32)))
+  (func (result i32)
+      block (result i32)
+        unreachable
+      end
+      block
+      end
+      i32.clz
+  )
+  (func (result i32)
+      loop (result i32)
+        unreachable
+      end
+      block
+      end
+      i32.clz
+  )
+  (func (;0;) (type 5) (result i32)
+    nop
+    block (result i32)  ;; label = @1
+      block  ;; label = @2
+        block  ;; label = @3
+          nop
+          block  ;; label = @4
+            i32.const 1
+            if  ;; label = @5
+              nop
+              block  ;; label = @6
+                nop
+                nop
+                loop (result i32)  ;; label = @7
+                  nop
+                  block (result i32)  ;; label = @8
+                    nop
+                    nop
+                    block (result i32)  ;; label = @9
+                      nop
+                      unreachable
+                    end
+                  end
+                end
+                block (result i32)  ;; label = @7
+                  block  ;; label = @8
+                    nop
+                  end
+                  i32.const 0
+                end
+                br_if 5 (;@1;)
+                drop
+              end
+            else
+              nop
+            end
+            nop
+          end
+        end
+      end
+      unreachable
+    end)
+  (func
+    block (result i32)
+      block (result i32)
+        i32.const 1
+        br 1
+      end
+    end
+    drop
+  )
+  (table (;0;) 16 funcref)
+  (elem (i32.const 0))
+)

data/ext/cargo-vendor/deterministic-wasi-ctx-0.1.19/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"3d61899f07e16d7d2a157af210c34ed14503caed4bd233a17ac2a6a9550c2fa1","README.md":"42cbd7351f25fd5d7d4134f9e8f669d9353ef53b82b186d6363b2f702a3559f1","src/clocks.rs":"2ebb359e0f7b7b2b0be6d0f9bc2c8383604a64596f00ea624d58175af31b93ce","src/lib.rs":"7c57a068c9f34d8d5a0ed6f4e4b5f31ab70af97bfe2193a326a7251c6dd4c281","src/noop_scheduler.rs":"4919984f5f20cfdf123cbeead22f74219521dac2af5968f3ea494c0bd1f11035","tests/clocks.rs":"e15d13d3e1040640922f7a18870581f4449c76af90e40873076f47653542e5b2","tests/common/mod.rs":"cd5eecbb8e9176fb18f65dbb0115ccfe2b5725493ad9a81485a858b40d44f5b4","tests/random.rs":"3ba63e4ba945826d67799e3650b542fbf1be128530a7ea76904d86fba448b978","tests/scheduler.rs":"f337576ba8f7886fe3974c53eaabdebf3f6ba79aa4c0e42bed5a3e7dc30d4e27"},"package":"f29124412317a866d85be05583f518d4f23e16607a19344a2be29b44ee294552"}

data/ext/cargo-vendor/deterministic-wasi-ctx-0.1.19/Cargo.toml

@@ -0,0 +1,49 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "deterministic-wasi-ctx"
+version = "0.1.19"
+description = "A wasi-common WasiCtx implementation that is fully deterministic"
+homepage = "https://github.com/Shopify/deterministic-wasi-ctx"
+readme = "README.md"
+keywords = ["wasi"]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+resolver = "1"
+
+[dependencies.anyhow]
+version = "1.0.56"
+
+[dependencies.async-trait]
+version = "0.1.53"
+
+[dependencies.cap-primitives]
+version = "2.0.0"
+
+[dependencies.rand_core]
+version = "0.6.3"
+
+[dependencies.rand_pcg]
+version = "0.3.1"
+
+[dependencies.wasi-common]
+version = ">= 8.0.0, < 19.0.0"
+
+[dev-dependencies.more-asserts]
+version = "0.3.1"
+
+[dev-dependencies.wasmtime]
+version = "18.0.0"
+
+[dev-dependencies.wasmtime-wasi]
+version = "18.0.0"

data/ext/cargo-vendor/rb-sys-0.9.89/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"5f4c51f8c98e62134b1f92f20669124ef29470973ecee1335c5ce2ed6ef6993a","LICENSE-APACHE":"110a4b771805962e964448aed69e868cc3e9aec91e89c88b8598f8bd726d1d6a","LICENSE-MIT":"3edf6db4f22b0da400397c3ffe917b3330f6cff051753ba02de9b40b4b8ccb24","bin/release.sh":"13e6ec69a0f03cbc9886802ddd6c41837e6211808bd2cb9d9b65dc5bfd0b5502","build/features.rs":"64771d14419fb8cec74d1c2ce1e55ed08d213ed7da63e2707a3f63267c081460","build/main.rs":"d0df7106702bf66f54310adf1c0794fb3b7210657c4ef21d75e632b3dd58bd55","build/stable_api_config.rs":"438275149a37998f1cc1c9a9f485644894f0f38098af9353c813fd6d7ac88d37","build/version.rs":"5aa269dfe31b723f3ebfc7ecf95f5ab210f97ccffc37ae80b780d1d7c3092066","readme.md":"231c3861b3536ad03e6078456663d87267b09a84d5d332883c8bd7ea16cf9522","src/bindings.rs":"e1416b9e81136c00d26e86d0cfc8fe025a054631d388b87d25185379666b4db0","src/hidden.rs":"d504f494f08eb23dc459a58a6f48dfcc342ed48b307b6d2e6d951cb3e603f090","src/lib.rs":"e2688b6f61f5d3013a4ff70603c7516bc50a2d3dd1a9f116f3f1bf8a4d871bdf","src/macros.rs":"efb0a9f8bc52e21f24edc9a353cb6e8621c020a75900bbd883649de78aba27da","src/memory.rs":"d09435cc62db3d155cefe124e78d965b36c73ce4f75eb041a0a6b1ce2488a0ed","src/ruby_abi_version.rs":"bdc3b36f81cabf11902e7124cfd7b5555e811ca9bda0315c73dc9596002af86b","src/special_consts.rs":"115c1ff7cf681e52755df5ac14e109cbc641c9a6cdb8e57ddb915fc33b5eb745","src/stable_api.rs":"254602abff584068be428f83d58d55f340e60453048282358fb394a56cb2a9c2","src/stable_api/compiled.c":"42793803ad072d333fad4f76d90ab0fa666a0e95940077d4bc4eeb04495245a1","src/stable_api/compiled.rs":"6579184bfa8d454f6281d62e80fe911062ffa2e72464f4538c3a727633983c01","src/stable_api/ruby_2_6.rs":"1e44889355c0b581126ef4d112966c1f9587c652d21d1058fda6b5752dce4a6f","src/stable_api/ruby_2_7.rs":"c6cc59ec2e9a4989174f87c108af4555ee633a7cceff0b4bf3a116e99d60a487","src/stable_api/ruby_3_0.rs":"8bd8bfe9d96a810838e1e39f2eecd7d994384002ff98b7b14b4ffa2dfaf16d61","src/stable_api/ruby_3_1.rs":"9654491e22d50f3e475c8e447ca049ae79218392c6c9fc1732f1ec772a0a099e","src/stable_api/ruby_3_2.rs":"ce298b347f04f6d9ff30cd293a3a1fcabdc7a0a1b05faae458cfd9f30e844ced","src/stable_api/ruby_3_3.rs":"ac99b81de0d7df6e2e2b1209c8ceb0beb5b27a3765e18d5c18674bebb17df07d","src/symbol.rs":"0b9eda6442a5cd2279cefcdacc1ae327c3c72254d703364f99ed1ff27a6b94b8","src/tracking_allocator.rs":"e07aa507d098bb7cc196a44419c72457d650903d92186e3523552e5d43f676af","src/utils.rs":"3a0629bf39377316a07927ee280f29c48635aaa4d7e22fbd2bb49e3a067ee8b6","src/value_type.rs":"dce790c49d3864f960c2fb93a8d906cfad0f48de258718177ceaa9fbf304b2eb"},"package":"0d197f2c03751ef006f29d593d22aa9068c9c358e04ca503afea0329c366147c"}