mini_racer_rs 1.0.0

data/ext/mini_racer_rs/src/rb_raw.rs

@@ -0,0 +1,368 @@
+use std::ffi::{c_int, c_void};
+
+use magnus::rb_sys::{AsRawId, AsRawValue, FromRawValue, protect};
+use magnus::value::{IntoId, LazyId, ReprValue};
+use magnus::{Error, RArray, RHash, RString, Ruby, Value};
+
+static CALL: LazyId = LazyId::new("call");
+
+use crate::guard::{Panicked, guard};
+
+struct Call<F, R> {
+    work: Option<F>,
+    result: Option<Result<R, Panicked>>,
+}
+
+unsafe extern "C" fn call_without_gvl<F, R>(data: *mut c_void) -> *mut c_void
+where
+    F: FnOnce() -> R,
+{
+    // SAFETY: `data` is the `Call` that `nogvl` keeps alive on its stack for the
+    // whole synchronous rb_nogvl call.
+    let call = unsafe { &mut *data.cast::<Call<F, R>>() };
+    if let Some(work) = call.work.take() {
+        call.result = Some(guard(work));
+    }
+    std::ptr::null_mut()
+}
+
+unsafe extern "C" fn call_unblock<U: Fn()>(data: *mut c_void) {
+    // SAFETY: `data` is the `&U` that `nogvl` borrows for the whole rb_nogvl call;
+    // Ruby only calls the unblock function while that call is in progress.
+    let unblock = unsafe { &*data.cast::<U>() };
+    let _ = guard(unblock);
+}
+
+// RB_NOGVL_INTR_FAIL makes rb_nogvl return instead of raising when an interrupt
+// is pending, so no Ruby exception can unwind through these Rust frames (I6).
+// Returns None when Ruby skipped `work` because an interrupt was already pending.
+pub fn nogvl<F, U, R>(_ruby: &Ruby, work: F, unblock: &U) -> Option<Result<R, Panicked>>
+where
+    F: FnOnce() -> R + Send,
+    R: Send,
+    U: Fn() + Sync,
+{
+    let mut call = Call {
+        work: Some(work),
+        result: None,
+    };
+    let flags = c_int::try_from(rb_sys::RB_NOGVL_INTR_FAIL).unwrap_or(1);
+    // SAFETY: rb_nogvl runs both callbacks synchronously before returning, so
+    // `call` and `unblock` outlive every access through the raw pointers.
+    unsafe {
+        rb_sys::rb_nogvl(
+            Some(call_without_gvl::<F, R>),
+            std::ptr::addr_of_mut!(call).cast::<c_void>(),
+            Some(call_unblock::<U>),
+            std::ptr::from_ref(unblock).cast_mut().cast::<c_void>(),
+            flags,
+        );
+    }
+    call.result
+}
+
+// Runs pending interrupts: signal traps return Ok, while Thread#raise, #kill,
+// Timeout and SIGINT come back as the Err the caller must eventually return.
+pub fn check_ints(_ruby: &Ruby) -> Result<(), Error> {
+    protect(|| {
+        // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and
+        // `protect` catches any non-local exit the interrupt handlers raise.
+        unsafe { rb_sys::rb_thread_check_ints() };
+        rb_sys::Qnil as rb_sys::VALUE
+    })
+    .map(|_| ())
+}
+
+// Mutex#lock releases the GVL while it waits and runs interrupts; magnus wraps
+// it in protect, so a Thread#kill comes back as the Err (I6).
+pub fn mutex_lock(_ruby: &Ruby, mutex: magnus::Mutex) -> Result<(), Error> {
+    mutex.lock()
+}
+
+// Ruby's GC cannot see an isolate's native memory, so it is reported here;
+// without it, contexts left to finalizers pile up between collections.
+pub fn adjust_memory(_ruby: &Ruby, bytes: isize) {
+    // SAFETY: the `&Ruby` argument proves this thread holds the GVL.
+    unsafe { rb_sys::rb_gc_adjust_memory_usage(rb_sys::ssize_t::try_from(bytes).unwrap_or(0)) };
+}
+
+/// For a free function, which runs with the GVL held but no `Ruby` handle.
+/// Only decreases are allowed there, and they never start a collection.
+pub fn release_memory(bytes: usize) {
+    let diff = rb_sys::ssize_t::try_from(bytes).map_or(0, |n| -n);
+    // SAFETY: free functions run during GC with the GVL held, and a negative
+    // adjustment only lowers the malloc counter without triggering GC.
+    unsafe { rb_sys::rb_gc_adjust_memory_usage(diff) };
+}
+
+/// Whether the current fiber has a scheduler that waits for it, so a wait can
+/// park the fiber instead of the thread.
+pub fn fiber_scheduler(_ruby: &Ruby) -> bool {
+    // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and
+    // rb_fiber_scheduler_current only reads the current thread and fiber.
+    let scheduler = unsafe { rb_sys::rb_fiber_scheduler_current() };
+    scheduler != rb_sys::Qnil as rb_sys::VALUE
+}
+
+pub fn dbl2big(_ruby: &Ruby, n: f64) -> Value {
+    // SAFETY: rb_dbl2big allocates a Bignum and requires the GVL, which the
+    // `&Ruby` argument proves this thread holds.
+    let raw = unsafe { rb_sys::rb_dbl2big(n) };
+    // SAFETY: `raw` is the live VALUE rb_dbl2big just returned.
+    unsafe { Value::from_raw(raw) }
+}
+
+// mini_racer checks its String arguments with Check_Type, whose TypeError
+// names the argument's type as Ruby itself does.
+pub fn expect_string(ruby: &Ruby, value: Value) -> Result<RString, Error> {
+    let raw = value.as_raw();
+    protect(|| {
+        // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and
+        // `protect` catches the TypeError rb_check_type raises.
+        unsafe { rb_sys::rb_check_type(raw, rb_sys::ruby_value_type::RUBY_T_STRING as c_int) };
+        raw
+    })?;
+    RString::from_value(value)
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected String"))
+}
+
+/// `digits` is a `BigInt` magnitude as little-endian 64-bit words.
+pub fn integer_unpack(_ruby: &Ruby, digits: &[u8], negative: bool) -> Result<Value, Error> {
+    let words = (digits.len() / 8).try_into().unwrap_or_default();
+    let sign = if negative {
+        rb_sys::INTEGER_PACK_NEGATIVE
+    } else {
+        0
+    };
+    let flags = c_int::try_from(rb_sys::INTEGER_PACK_LITTLE_ENDIAN | sign).unwrap_or(0);
+    let raw = protect(|| {
+        // SAFETY: `digits` holds `words` whole 8-byte words and outlives the
+        // call, which copies them; `protect` catches an allocation failure.
+        unsafe { rb_sys::rb_integer_unpack(digits.as_ptr().cast(), words, 8, 0, flags) }
+    })?;
+    // SAFETY: `raw` is the live Integer rb_integer_unpack just returned.
+    Ok(unsafe { Value::from_raw(raw) })
+}
+
+/// The builtin types `mini_racer`'s encoder tells apart; `Other` carries the
+/// number `TYPE()` gives, which it prints in hex.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RubyType {
+    Object,
+    Float,
+    String,
+    Array,
+    Hash,
+    Bignum,
+    Data,
+    Nil,
+    True,
+    False,
+    Symbol,
+    Fixnum,
+    Other(u32),
+}
+
+pub fn ruby_type(_ruby: &Ruby, value: Value) -> RubyType {
+    use rb_sys::ruby_value_type as T;
+    // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and
+    // `value` is a live VALUE the caller holds.
+    let kind = unsafe { rb_sys::RB_TYPE(value.as_raw()) };
+    match kind {
+        T::RUBY_T_OBJECT => RubyType::Object,
+        T::RUBY_T_FLOAT => RubyType::Float,
+        T::RUBY_T_STRING => RubyType::String,
+        T::RUBY_T_ARRAY => RubyType::Array,
+        T::RUBY_T_HASH => RubyType::Hash,
+        T::RUBY_T_BIGNUM => RubyType::Bignum,
+        T::RUBY_T_DATA => RubyType::Data,
+        T::RUBY_T_NIL => RubyType::Nil,
+        T::RUBY_T_TRUE => RubyType::True,
+        T::RUBY_T_FALSE => RubyType::False,
+        T::RUBY_T_SYMBOL => RubyType::Symbol,
+        T::RUBY_T_FIXNUM => RubyType::Fixnum,
+        other => RubyType::Other(other as u32),
+    }
+}
+
+/// An object's address, the identity `mini_racer`'s encoder keys repeated
+/// containers by; stable only while the object is pinned.
+pub fn identity(value: Value) -> u64 {
+    value.as_raw()
+}
+
+/// `super(*values)`, from the method Ruby is running.
+pub fn call_super(_ruby: &Ruby, values: &[Value]) -> Result<Value, Error> {
+    let raw_values: Vec<rb_sys::VALUE> = values.iter().map(|value| value.as_raw()).collect();
+    let count = c_int::try_from(raw_values.len()).unwrap_or(c_int::MAX);
+    let raw = protect(|| {
+        // SAFETY: the `&Ruby` argument proves this thread holds the GVL, the
+        // caller is a method body Ruby called, `raw_values` holds `count`
+        // values the caller keeps alive on its stack, and `protect` catches
+        // anything super raises or throws.
+        unsafe { rb_sys::rb_call_super(count, raw_values.as_ptr()) }
+    })?;
+    // SAFETY: `raw` is the live value super returned.
+    Ok(unsafe { Value::from_raw(raw) })
+}
+
+/// `receiver.call(*args)`, with Ruby reading the arguments from `args`
+/// itself, so they stay where the GC sees them for the whole call.
+pub fn call_with_array(ruby: &Ruby, receiver: Value, args: RArray) -> Result<Value, Error> {
+    let call = (*CALL).into_id_with(ruby);
+    let raw = protect(|| {
+        // SAFETY: the `&Ruby` argument proves this thread holds the GVL, both
+        // values are live on this stack, and `protect` catches any non-local
+        // exit the call raises.
+        unsafe { rb_sys::rb_apply(receiver.as_raw(), call.as_raw(), args.as_raw()) }
+    })?;
+    // SAFETY: `raw` is the live value the call returned.
+    Ok(unsafe { Value::from_raw(raw) })
+}
+
+/// Stores each key and value as `Hash#[]=` would, under one `rb_protect` for
+/// the whole slice. `pairs` must be where the GC sees them, on the native
+/// stack: storing a key can start a compacting collection.
+// rb_hash_bulk_insert would take the slice in one call, but it rehashes the
+// whole table whenever the hash already has entries.
+pub fn hash_aset_pairs(_ruby: &Ruby, hash: RHash, pairs: &[[Value; 2]]) -> Result<(), Error> {
+    let raw = hash.as_raw();
+    protect(|| {
+        for [key, value] in pairs {
+            // SAFETY: the `&Ruby` argument proves this thread holds the GVL,
+            // the caller keeps `pairs` where the GC sees them, and `protect`
+            // catches anything rb_hash_aset raises.
+            unsafe { rb_sys::rb_hash_aset(raw, key.as_raw(), value.as_raw()) };
+        }
+        raw
+    })?;
+    Ok(())
+}
+
+/// How Ruby's own type errors name `value`: nil, true and false by value,
+/// anything else by its class, never a singleton class, printed with `to_s`
+/// as Ruby prints it, overridden or not.
+pub fn type_name(ruby: &Ruby, value: Value) -> String {
+    if value.is_nil() {
+        return "nil".to_owned();
+    }
+    if value.is_kind_of(ruby.class_true_class()) {
+        return "true".to_owned();
+    }
+    if value.is_kind_of(ruby.class_false_class()) {
+        return "false".to_owned();
+    }
+    // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and
+    // rb_obj_class only reads the value's class.
+    let raw = unsafe { rb_sys::rb_obj_class(value.as_raw()) };
+    // SAFETY: `raw` is the live class rb_obj_class returned.
+    let class = unsafe { Value::from_raw(raw) };
+    class
+        .funcall::<_, _, String>("to_s", ())
+        .unwrap_or_else(|_| class_name(ruby, value))
+}
+
+/// The struct name a typed data object was wrapped under, which Ruby's
+/// typed data check names it by.
+pub fn typed_data_name(ruby: &Ruby, value: Value) -> Option<String> {
+    if !matches!(ruby_type(ruby, value), RubyType::Data) {
+        return None;
+    }
+    // SAFETY: `value` is a live T_DATA object and the GVL is held.
+    if !unsafe { rb_sys::RTYPEDDATA_P(value.as_raw()) } {
+        return None;
+    }
+    // SAFETY: as above; the type of a typed data object is static data.
+    let data_type = unsafe { rb_sys::RTYPEDDATA_TYPE(value.as_raw()) };
+    // SAFETY: `data_type` points at the object's static rb_data_type_t.
+    let name = unsafe { (*data_type).wrap_struct_name };
+    if name.is_null() {
+        return None;
+    }
+    // SAFETY: wrap_struct_name is a NUL-terminated static string.
+    Some(
+        unsafe { std::ffi::CStr::from_ptr(name) }
+            .to_string_lossy()
+            .into_owned(),
+    )
+}
+
+/// `rb_str_dup`: a copy of the same class, without `String#dup`'s instance
+/// variables.
+pub fn str_dup(_ruby: &Ruby, s: RString) -> RString {
+    // SAFETY: the `&Ruby` argument proves this thread holds the GVL; rb_str_dup
+    // returns a new live String.
+    let raw = unsafe { rb_sys::rb_str_dup(s.as_raw()) };
+    // SAFETY: `raw` is the String rb_str_dup returned.
+    RString::from_value(unsafe { Value::from_raw(raw) }).unwrap_or(s)
+}
+
+/// A Symbol's name as a String, without calling `Symbol#to_s`.
+pub fn sym2str(ruby: &Ruby, symbol: Value) -> RString {
+    // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and the
+    // caller passes a Symbol, for which rb_sym2str returns its interned name.
+    let raw = unsafe { rb_sys::rb_sym2str(symbol.as_raw()) };
+    // SAFETY: `raw` is the live String rb_sym2str returned.
+    let name = unsafe { Value::from_raw(raw) };
+    RString::from_value(name).unwrap_or_else(|| ruby.str_new(""))
+}
+
+/// Runs `read` over the string's bytes without copying them; `read` must not
+/// call Ruby, which could change or move the string.
+pub fn with_string_bytes<R>(_ruby: &Ruby, s: RString, read: impl FnOnce(&[u8]) -> R) -> R {
+    // SAFETY: the bytes are only read by `read`, which runs no Ruby code.
+    read(unsafe { s.as_slice() })
+}
+
+/// The magnitude of an Integer as little-endian 64-bit words, and whether it is
+/// negative; `None` past `max_words`.
+pub fn integer_words(
+    _ruby: &Ruby,
+    value: Value,
+    max_words: usize,
+) -> Result<Option<(bool, Vec<u8>)>, Error> {
+    let raw = value.as_raw();
+    let mut count = 0;
+    protect(|| {
+        // SAFETY: the `&Ruby` argument proves this thread holds the GVL, and
+        // `protect` catches what rb_absint_numwords raises for a non-Integer.
+        count = unsafe { rb_sys::rb_absint_numwords(raw, 64, std::ptr::null_mut()) };
+        rb_sys::Qnil as rb_sys::VALUE
+    })?;
+    let Some(words) = usize::try_from(count)
+        .ok()
+        .filter(|&words| words <= max_words)
+    else {
+        return Ok(None);
+    };
+    let mut digits = vec![0u64; words];
+    let flags = c_int::try_from(rb_sys::INTEGER_PACK_LITTLE_ENDIAN).unwrap_or(0);
+    let mut sign = 0;
+    protect(|| {
+        // SAFETY: `digits` holds `words` words, which rb_integer_pack fills.
+        sign =
+            unsafe { rb_sys::rb_integer_pack(raw, digits.as_mut_ptr().cast(), count, 8, 0, flags) };
+        rb_sys::Qnil as rb_sys::VALUE
+    })?;
+    if !(-1..=1).contains(&sign) {
+        return Ok(None);
+    }
+    Ok(Some((
+        sign < 0,
+        digits.iter().flat_map(|word| word.to_le_bytes()).collect(),
+    )))
+}
+
+/// The name `rb_class2name` gives the class of `value`, as `mini_racer` prints it.
+pub fn class_name(_ruby: &Ruby, value: Value) -> String {
+    use magnus::Class as _;
+    use magnus::value::ReprValue as _;
+    let class = value.class();
+    // SAFETY: the name is copied before any Ruby code can run and free it.
+    unsafe { class.name() }.into_owned()
+}
+
+pub fn string_bytes(_ruby: &Ruby, s: RString) -> Vec<u8> {
+    // SAFETY: the slice is copied before any Ruby code can run and move or free it.
+    unsafe { s.as_slice() }.to_vec()
+}

data/ext/mini_racer_rs/src/snapshot.rs

@@ -0,0 +1,149 @@
+use std::cell::RefCell;
+
+use magnus::encoding::EncodingCapable;
+use magnus::gc::Marker;
+use magnus::scan_args::scan_args;
+use magnus::typed_data::Obj;
+use magnus::value::ReprValue;
+use magnus::{
+    Class, DataTypeFunctions, Error, Module, Object, RClass, RModule, RString, Ruby, TryConvert,
+    TypedData, Value,
+};
+use mini_racer_engine::{ContextHandle, InvalidSnapshot, SnapshotBlob, WeakSnapshotBlob};
+
+use crate::gc_root::OwnedRoot;
+use crate::host::RubyHost;
+use crate::{context, errors, export, rb_raw};
+
+#[derive(Default, TypedData)]
+#[magnus(
+    class = "MiniRacer::Snapshot",
+    name = "mini_racer/snapshot",
+    free_immediately,
+    mark,
+    size
+)]
+pub struct Snapshot {
+    blob: OwnedRoot<RString>,
+    // What contexts made from this snapshot start from, reused while one of
+    // them lives and `blob` holds the same bytes: `dump` hands `blob` out, and
+    // a context of mini_racer's starts from whatever it holds then. Held
+    // weakly, so once its contexts are gone a snapshot holds only `blob`, as
+    // mini_racer's does.
+    shared: RefCell<Option<WeakSnapshotBlob>>,
+}
+
+impl DataTypeFunctions for Snapshot {
+    fn mark(&self, marker: &Marker) {
+        self.blob.mark(marker);
+    }
+
+    fn size(&self) -> usize {
+        let blob = Ruby::get().ok().and_then(|ruby| self.blob.get(&ruby));
+        size_of::<Self>().saturating_add(blob.map_or(0, RString::len))
+    }
+}
+
+pub fn init(ruby: &Ruby, racer: RModule) -> Result<(), Error> {
+    let class = racer.define_class("Snapshot", ruby.class_object())?;
+    class.define_alloc_func::<Snapshot>();
+    class.define_method("initialize", export!(method Snapshot::initialize, -1))?;
+    class.define_method("dump", export!(method Snapshot::dump, 0))?;
+    class.define_method("size", export!(method Snapshot::size, 0))?;
+    class.define_method("warmup!", export!(method Snapshot::warmup, 1))?;
+    class.define_singleton_method("load", export!(method Snapshot::load, 1))?;
+    Ok(())
+}
+
+/// The blob a context made from `value`, when it is a `MiniRacer::Snapshot`,
+/// starts from, for `Context.new`.
+pub fn shared_of(ruby: &Ruby, value: Value) -> Option<Result<SnapshotBlob, InvalidSnapshot>> {
+    let snapshot = Obj::<Snapshot>::try_convert(value).ok()?;
+    Some(snapshot.shared(ruby))
+}
+
+// mini_racer raises every failure of a build as a snapshot error, V8's
+// refusal of an odd-length UTF-16LE string included, which it meets before
+// the base blob.
+fn build(ruby: &Ruby, code: RString, base: Option<&Snapshot>) -> Result<RString, Error> {
+    let code = context::js_text(ruby, code)
+        .map_err(|_| errors::snapshot(ruby, "Error: Unable to deserialize cloned data."))?;
+    let base = base
+        .map(|base| base.shared(ruby))
+        .transpose()
+        .map_err(|invalid| errors::engine(ruby, invalid.into()))?;
+    let mut host = RubyHost::new(ruby);
+    let built = ContextHandle::create_snapshot(code, base, &mut host);
+    let blob = host.finish(built)?;
+    Ok(ruby.str_from_slice(&blob))
+}
+
+impl Snapshot {
+    fn shared(&self, ruby: &Ruby) -> Result<SnapshotBlob, InvalidSnapshot> {
+        let blob = self.blob(ruby);
+        let mut shared = self.shared.borrow_mut();
+        let kept = shared.as_ref().and_then(WeakSnapshotBlob::upgrade);
+        let current = rb_raw::with_string_bytes(ruby, blob, |bytes| match kept {
+            Some(kept) if kept.as_bytes() == bytes => Ok(kept),
+            _ => SnapshotBlob::new(bytes),
+        })?;
+        *shared = Some(current.downgrade());
+        Ok(current)
+    }
+
+    fn replace(&self, ruby: &Ruby, blob: RString) {
+        self.blob.set(ruby, blob);
+        self.shared.borrow_mut().take();
+    }
+
+    // mini_racer allocates every snapshot with an empty blob it then hands
+    // out, so `dump` on one never built is that same String.
+    fn blob(&self, ruby: &Ruby) -> RString {
+        self.blob.get(ruby).unwrap_or_else(|| {
+            let empty = ruby.str_from_slice(b"");
+            self.blob.set(ruby, empty);
+            empty
+        })
+    }
+
+    fn initialize(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<(), Error> {
+        let args = scan_args::<(), (Option<Value>,), (), (), (), ()>(args)?;
+        let code = match args.optional.0 {
+            Some(code) if !code.is_nil() => rb_raw::expect_string(ruby, code)?,
+            _ => ruby.str_new(""),
+        };
+        rb_self.replace(ruby, build(ruby, code, None)?);
+        Ok(())
+    }
+
+    fn dump(ruby: &Ruby, rb_self: &Self) -> RString {
+        rb_self.blob(ruby)
+    }
+
+    fn size(ruby: &Ruby, rb_self: &Self) -> usize {
+        rb_self.blob(ruby).len()
+    }
+
+    // The blob is replaced only once the warmed-up one is built, so a failed
+    // warmup leaves the snapshot as it was.
+    fn warmup(ruby: &Ruby, rb_self: Obj<Self>, code: Value) -> Result<Obj<Self>, Error> {
+        let code = rb_raw::expect_string(ruby, code)?;
+        let warmed = build(ruby, code, Some(&rb_self))?;
+        rb_self.replace(ruby, warmed);
+        Ok(rb_self)
+    }
+
+    // mini_racer keeps whatever it is given and aborts when V8 reads a bad
+    // blob; refused here, a stale blob read back from disk can be rescued
+    // and built again.
+    fn load(ruby: &Ruby, class: RClass, blob: Value) -> Result<Obj<Self>, Error> {
+        let blob = rb_raw::expect_string(ruby, blob)?;
+        let copy = rb_raw::str_dup(ruby, blob);
+        copy.enc_associate(ruby.ascii8bit_encindex())?;
+        rb_raw::with_string_bytes(ruby, copy, SnapshotBlob::check)
+            .map_err(|invalid| errors::engine(ruby, invalid.into()))?;
+        let snapshot = ruby.obj_wrap_as(Self::default(), class);
+        snapshot.blob.set(ruby, copy);
+        Ok(snapshot)
+    }
+}

data/ext/mini_racer_rs/v8-archives.sha256

@@ -0,0 +1,8 @@
+a4a5484444ad4b5f10dc7bed141236dd9dbeabf2006d14520f19b935d4db4227  librusty_v8_release_aarch64-apple-darwin.a.gz
+c40196bbf182532e583f65b7daf0196fdbb3354e6fac59b31d0539c20f931f3d  librusty_v8_release_aarch64-unknown-linux-gnu.a.gz
+04cbc1c36c4cd5459c54049775d92889337c69d936fb0b011f9b26f1d454610d  librusty_v8_release_x86_64-apple-darwin.a.gz
+b6683e9afcb77fbd8cb2c3acf45d34d52029ab216b332522c95179c12f0fed3c  librusty_v8_release_x86_64-unknown-linux-gnu.a.gz
+b9d5652ebca515eb2bf4c2ee4a6551b2567117b5aa720f430d2032616dd7e3b5  src_binding_release_aarch64-apple-darwin.rs
+3e4d5fecdbe0f98a6017e69d7ca82519a77fb032c5eb5e4cdbecdd3e2ec519d5  src_binding_release_aarch64-unknown-linux-gnu.rs
+b9d5652ebca515eb2bf4c2ee4a6551b2567117b5aa720f430d2032616dd7e3b5  src_binding_release_x86_64-apple-darwin.rs
+3e4d5fecdbe0f98a6017e69d7ca82519a77fb032c5eb5e4cdbecdd3e2ec519d5  src_binding_release_x86_64-unknown-linux-gnu.rs