deps: add cranelift crate

Signed-off-by: Paolo Insogna <paolo@cowtech.it>
Assisted-By: OpenAI:GPT-5.5 <openai/gpt-5.5>

Author: ShogunPanda

deps/crates/src/node_fast_ffi.rs

@@ -0,0 +1,349 @@
+use cranelift::codegen::ir::UserFuncName;
+use cranelift::prelude::*;
+use std::ffi::c_void;
+
+#[repr(C)]
+pub struct FastFFIFunction {
+    pub code: *const c_void,
+    pub handle: *mut c_void,
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+#[repr(u8)]
+enum FastFFIType {
+    Void = 0,
+    I8 = 1,
+    U8 = 2,
+    I16 = 3,
+    U16 = 4,
+    I32 = 5,
+    U32 = 6,
+    I64 = 7,
+    U64 = 8,
+    F32 = 9,
+    F64 = 10,
+    Pointer = 11,
+    Buffer = 12,
+}
+
+impl FastFFIType {
+    fn from_raw(raw: u8) -> Option<Self> {
+        match raw {
+            0 => Some(Self::Void),
+            1 => Some(Self::I8),
+            2 => Some(Self::U8),
+            3 => Some(Self::I16),
+            4 => Some(Self::U16),
+            5 => Some(Self::I32),
+            6 => Some(Self::U32),
+            7 => Some(Self::I64),
+            8 => Some(Self::U64),
+            9 => Some(Self::F32),
+            10 => Some(Self::F64),
+            11 => Some(Self::Pointer),
+            12 => Some(Self::Buffer),
+            _ => None,
+        }
+    }
+}
+
+fn convert(ty: FastFFIType, wrapper: bool, isize_ty: Type) -> AbiParam {
+    match ty {
+        FastFFIType::Void => AbiParam::new(types::INVALID),
+        FastFFIType::I8 => {
+            if wrapper {
+                AbiParam::new(types::I32)
+            } else {
+                AbiParam::new(types::I8).sext()
+            }
+        }
+        FastFFIType::U8 => {
+            if wrapper {
+                AbiParam::new(types::I32)
+            } else {
+                AbiParam::new(types::I8).uext()
+            }
+        }
+        FastFFIType::I16 => {
+            if wrapper {
+                AbiParam::new(types::I32)
+            } else {
+                AbiParam::new(types::I16).sext()
+            }
+        }
+        FastFFIType::U16 => {
+            if wrapper {
+                AbiParam::new(types::I32)
+            } else {
+                AbiParam::new(types::I16).uext()
+            }
+        }
+        FastFFIType::I32 | FastFFIType::U32 => AbiParam::new(types::I32),
+        FastFFIType::I64 | FastFFIType::U64 => AbiParam::new(types::I64),
+        FastFFIType::F32 => AbiParam::new(types::F32),
+        FastFFIType::F64 => AbiParam::new(types::F64),
+        FastFFIType::Pointer => AbiParam::new(isize_ty),
+        FastFFIType::Buffer => {
+            if wrapper {
+                AbiParam::new(isize_ty)
+            } else {
+                AbiParam::new(isize_ty)
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn node_fast_ffi_compile(
+    target_slot: *const c_void,
+    result_type: u8,
+    parameter_types: *const u8,
+    parameter_count: usize,
+    buffer_data: *const c_void,
+    raise_invalid_buffer: *const c_void,
+    raise_library_closed: *const c_void,
+    out: *mut FastFFIFunction,
+) -> bool {
+    if target_slot.is_null() || out.is_null() || parameter_types.is_null() {
+        return false;
+    }
+
+    let result_type = match FastFFIType::from_raw(result_type) {
+        Some(value) => value,
+        None => return false,
+    };
+
+    let parameter_types = unsafe { std::slice::from_raw_parts(parameter_types, parameter_count) };
+    let mut params = Vec::with_capacity(parameter_count);
+    for raw in parameter_types {
+        let Some(param) = FastFFIType::from_raw(*raw) else {
+            return false;
+        };
+        params.push(param);
+    }
+
+    let Ok(compiled) = compile(
+        target_slot,
+        result_type,
+        &params,
+        buffer_data,
+        raise_invalid_buffer,
+        raise_library_closed,
+    ) else {
+        return false;
+    };
+
+    unsafe {
+        *out = compiled;
+    }
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn node_fast_ffi_free(handle: *mut c_void) {
+    if handle.is_null() {
+        return;
+    }
+    unsafe {
+        drop(Box::from_raw(handle as *mut memmap2::Mmap));
+    }
+}
+
+fn compile(
+    target_slot: *const c_void,
+    result_type: FastFFIType,
+    parameter_types: &[FastFFIType],
+    buffer_data: *const c_void,
+    raise_invalid_buffer: *const c_void,
+    raise_library_closed: *const c_void,
+) -> Result<FastFFIFunction, Box<dyn std::error::Error>> {
+    let mut flag_builder = settings::builder();
+    flag_builder.set("is_pic", "true")?;
+    flag_builder.set("opt_level", "speed_and_size")?;
+    let flags = settings::Flags::new(flag_builder);
+    let isa = cranelift_native::builder()
+        .map_err(|err| format!("Cranelift native ISA error: {err}"))?
+        .finish(flags)?;
+
+    #[cfg(target_pointer_width = "32")]
+    let isize_ty = types::I32;
+    #[cfg(target_pointer_width = "64")]
+    let isize_ty = types::I64;
+
+    let mut wrapper_sig = cranelift::codegen::ir::Signature::new(isa.default_call_conv());
+    let mut target_sig = cranelift::codegen::ir::Signature::new(isa.default_call_conv());
+    let mut buffer_sig = cranelift::codegen::ir::Signature::new(isa.default_call_conv());
+    let mut raise_sig = cranelift::codegen::ir::Signature::new(isa.default_call_conv());
+    let mut raise_closed_sig = cranelift::codegen::ir::Signature::new(isa.default_call_conv());
+
+    // V8 receiver.
+    wrapper_sig.params.push(AbiParam::new(isize_ty));
+    for param in parameter_types {
+        wrapper_sig.params.push(convert(*param, true, isize_ty));
+        target_sig.params.push(convert(*param, false, isize_ty));
+    }
+    // FastApiCallbackOptions&.
+    wrapper_sig.params.push(AbiParam::new(isize_ty));
+
+    if result_type != FastFFIType::Void {
+        wrapper_sig
+            .returns
+            .push(convert(result_type, true, isize_ty));
+        target_sig
+            .returns
+            .push(convert(result_type, false, isize_ty));
+    }
+
+    buffer_sig.params.push(AbiParam::new(isize_ty));
+    buffer_sig.returns.push(AbiParam::new(isize_ty));
+
+    raise_sig.params.push(AbiParam::new(isize_ty));
+    raise_sig.params.push(AbiParam::new(types::I32));
+
+    raise_closed_sig.params.push(AbiParam::new(isize_ty));
+
+    let mut ctx = cranelift::codegen::Context::new();
+    let mut fn_builder_ctx = FunctionBuilderContext::new();
+    ctx.func = cranelift::codegen::ir::Function::with_name_signature(
+        UserFuncName::testcase("node_fast_ffi_wrapper".to_string()),
+        wrapper_sig,
+    );
+
+    let mut f = FunctionBuilder::new(&mut ctx.func, &mut fn_builder_ctx);
+    let target_sig = f.import_signature(target_sig);
+    let buffer_sig = f.import_signature(buffer_sig);
+    let raise_sig = f.import_signature(raise_sig);
+    let raise_closed_sig = f.import_signature(raise_closed_sig);
+
+    let entry = f.create_block();
+    let error = f.create_block();
+    let closed_error = f.create_block();
+    f.append_block_param(error, types::I32);
+    f.set_cold_block(error);
+    f.set_cold_block(closed_error);
+    f.append_block_params_for_function_params(entry);
+    f.switch_to_block(entry);
+    f.seal_block(entry);
+
+    let wrapper_args = f.block_params(entry).to_owned();
+    let options = wrapper_args[parameter_types.len() + 1];
+    let mut native_args = Vec::with_capacity(parameter_types.len());
+    let mut next = f.create_block();
+
+    for (index, param) in parameter_types.iter().enumerate() {
+        let arg = wrapper_args[index + 1];
+        match param {
+            FastFFIType::I8 | FastFFIType::U8 => {
+                native_args.push(f.ins().ireduce(types::I8, arg));
+            }
+            FastFFIType::I16 | FastFFIType::U16 => {
+                native_args.push(f.ins().ireduce(types::I16, arg));
+            }
+            FastFFIType::Buffer => {
+                if buffer_data.is_null() {
+                    return Err("missing buffer helper".into());
+                }
+                let callee = f.ins().iconst(isize_ty, buffer_data as i64);
+                let call = f.ins().call_indirect(buffer_sig, callee, &[arg]);
+                let ptr = f.inst_results(call)[0];
+                native_args.push(ptr);
+
+                let sentinel = f.ins().iconst(isize_ty, -1);
+                let invalid = f.ins().icmp(IntCC::Equal, ptr, sentinel);
+                let index = f.ins().iconst(types::I32, index as i64);
+                f.ins().brif(invalid, error, &[index], next, &[]);
+                f.switch_to_block(next);
+                f.seal_block(next);
+                next = f.create_block();
+            }
+            _ => native_args.push(arg),
+        }
+    }
+
+    let target_slot = f.ins().iconst(isize_ty, target_slot as i64);
+    let callee = f.ins().load(isize_ty, MemFlags::trusted(), target_slot, 0);
+    let null = f.ins().iconst(isize_ty, 0);
+    let is_closed = f.ins().icmp(IntCC::Equal, callee, null);
+    let call_target = f.create_block();
+    f.ins().brif(is_closed, closed_error, &[], call_target, &[]);
+    f.switch_to_block(call_target);
+    f.seal_block(call_target);
+
+    let call = f.ins().call_indirect(target_sig, callee, &native_args);
+    let mut results = f.inst_results(call).to_owned();
+    match result_type {
+        FastFFIType::I8 | FastFFIType::I16 => {
+            results[0] = f.ins().sextend(types::I32, results[0]);
+        }
+        FastFFIType::U8 | FastFFIType::U16 => {
+            results[0] = f.ins().uextend(types::I32, results[0]);
+        }
+        _ => {}
+    }
+    f.ins().return_(&results);
+
+    f.switch_to_block(closed_error);
+    f.seal_block(closed_error);
+    if !raise_library_closed.is_null() {
+        let callee = f.ins().iconst(isize_ty, raise_library_closed as i64);
+        f.ins().call_indirect(raise_closed_sig, callee, &[options]);
+    }
+    if result_type == FastFFIType::Void {
+        f.ins().return_(&[]);
+    } else {
+        let ret = convert(result_type, true, isize_ty).value_type;
+        let zero = if ret == types::F32 {
+            f.ins().f32const(0.0)
+        } else if ret == types::F64 {
+            f.ins().f64const(0.0)
+        } else {
+            f.ins().iconst(ret, 0)
+        };
+        f.ins().return_(&[zero]);
+    }
+
+    f.switch_to_block(error);
+    f.seal_block(error);
+    let error_index = f.block_params(error)[0];
+    if result_type == FastFFIType::Void {
+        if !raise_invalid_buffer.is_null() {
+            let callee = f.ins().iconst(isize_ty, raise_invalid_buffer as i64);
+            f.ins()
+                .call_indirect(raise_sig, callee, &[options, error_index]);
+        }
+        f.ins().return_(&[]);
+    } else {
+        if !raise_invalid_buffer.is_null() {
+            let callee = f.ins().iconst(isize_ty, raise_invalid_buffer as i64);
+            f.ins()
+                .call_indirect(raise_sig, callee, &[options, error_index]);
+        }
+        let ret = convert(result_type, true, isize_ty).value_type;
+        let zero = if ret == types::F32 {
+            f.ins().f32const(0.0)
+        } else if ret == types::F64 {
+            f.ins().f64const(0.0)
+        } else {
+            f.ins().iconst(ret, 0)
+        };
+        f.ins().return_(&[zero]);
+    }
+
+    f.finalize();
+
+    cranelift::codegen::verifier::verify_function(&ctx.func, isa.flags())?;
+    let mut ctrl_plane = Default::default();
+    ctx.optimize(&*isa, &mut ctrl_plane)?;
+    let code_info = ctx
+        .compile(&*isa, &mut ctrl_plane)
+        .map_err(|err| format!("Cranelift compile error: {err:?}"))?;
+
+    let data = code_info.buffer.data();
+    let mut mutable = memmap2::MmapMut::map_anon(data.len())?;
+    mutable.copy_from_slice(data);
+    let executable = mutable.make_exec()?;
+    let code = executable.as_ptr() as *const c_void;
+    let handle = Box::into_raw(Box::new(executable)) as *mut c_void;
+
+    Ok(FastFFIFunction { code, handle })
+}

deps/crates/vendor/allocator-api2/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"f44a14175e1995bd4b75ea0c74654a53b7073fedcb37c92c41841126e6f40f17","CHANGELOG.md":"886f8c688db0c22d24b650df0dc30a39d05d54d0e562c00d9574bf31cbf73251","Cargo.toml":"ddaa434cc54a30a33bbe0096e72479d71ba5deffa2ad9bee39419d4e50b75275","Cargo.toml.orig":"c1688fbd2be36f529a6eebbbf62fcf612c86b6f824738a44f6caa8875f57279b","LICENSE-APACHE":"20fe7b00e904ed690e3b9fd6073784d3fc428141dbd10b81c01fd143d0797f58","LICENSE-MIT":"36516aefdc84c5d5a1e7485425913a22dbda69eb1930c5e84d6ae4972b5194b9","README.md":"8b8c45a89f9d61688fd32516ca24ea11cc6be4994757bd01bd9d02d96cd49337","src/lib.rs":"56a7344026bf5be503ca8b3fe208b74550956e82be7806a229951e80ebb3c249","src/nightly.rs":"c12152b6721216174c9a3cec90e612d5571a5d2c0a94ad54900cb814414519c3","src/stable/alloc/global.rs":"14836ad7d73a364474fc153b24a1f17ad0e60a69b90a8721dc1059eada8bf869","src/stable/alloc/mod.rs":"866dafd3984dd246e381d8ad1c2b3e02a60c3421b598ca493aa83f9b6422608d","src/stable/alloc/system.rs":"db5d5bf088eecac3fc5ff1281e1bf26ca36dd38f13cd52c49d95ff1bab064254","src/stable/boxed.rs":"fb664ab68a599b7fc5acbae1c634c2007ba2bda9a24fea2212b8202bb537f7a0","src/stable/macros.rs":"74490796a766338d0163f40a37612cd9ea2de58ae3d8e9abf6c7bcf81d9be4a6","src/stable/mod.rs":"474dce5f150456a98fa7c4debc24f03ec2db4ebf0d54011ae19c8b575feb5712","src/stable/raw_vec.rs":"9a56ce1bab4562000285e80837da7b7bd2bbbc63850c83ab5d8df9888b65f5db","src/stable/slice.rs":"089263b058e6c185467bad7ad14908479e5675408fc70a8291e5dddaef36035a","src/stable/unique.rs":"6ed3678beed7fa6bd18b694f7357e638d83e3f1f895f9988a465dc5afebfbac9","src/stable/vec/drain.rs":"740cd2e0f31eeb0146bbd0f645a14fe12bacd3912f003db433ddc6b3a178461f","src/stable/vec/into_iter.rs":"da72ce52344ea2e263ddf7776356cc012bbafc51f48499955c1771729448754d","src/stable/vec/mod.rs":"dd3ddca02747686ed2064397dd17068b64f28c6f42b55e9e2ce129cd573fe44c","src/stable/vec/partial_eq.rs":"9f1b18605164a62b58d9e17914d573698735de31c51ceb8bd3666e83d32df370","src/stable/vec/set_len_on_drop.rs":"561342e22a194e515cc25c9a1bcd827ca24c4db033e9e2c4266fbdd2fb16e5bc","src/stable/vec/splice.rs":"95a460b3a7b4af60fdc9ba04d3a719b61a0c11786cd2d8823d022e22c397f9c9"},"package":"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"}

deps/crates/vendor/allocator-api2/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "63cd7fcc2f8854b5821c7054d026e8a4647acde1"
+  },
+  "path_in_vcs": ""
+}

deps/crates/vendor/allocator-api2/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]