Experiment: Add buffer type and inline pointer

docs/api/ffi.md

@@ -110,6 +110,7 @@ The following `FFIType` values are supported.
 
 | `FFIType`  | C Type         | Aliases                     |
 | ---------- | -------------- | --------------------------- |
+| buffer     | `char*`        |                             |
 | cstring    | `char*`        |                             |
 | function   | `(void*)(*)()` | `fn`, `callback`            |
 | ptr        | `void*`        | `pointer`, `void*`, `char*` |
@@ -130,6 +131,8 @@ The following `FFIType` values are supported.
 | napi_env   | `napi_env`     |                             |
 | napi_value | `napi_value`   |                             |
 
+Note: `buffer` arguments must be a `TypedArray` or `DataView`.
+
 ## Strings
 
 JavaScript strings and C-like strings are different, and that complicates using strings with native libraries.

packages/bun-types/ffi.d.ts

@@ -340,6 +340,7 @@ declare module "bun:ffi" {
 
     napi_env = 18,
     napi_value = 19,
+    buffer = 20,
   }
 
   type Pointer = number & { __pointer__: null };
@@ -377,6 +378,7 @@ declare module "bun:ffi" {
     [FFIType.function]: Pointer | JSCallback; // cannot be null
     [FFIType.napi_env]: unknown;
     [FFIType.napi_value]: unknown;
+    [FFIType.buffer]: NodeJS.TypedArray | DataView;
   }
   interface FFITypeToReturnsType {
     [FFIType.char]: number;
@@ -411,6 +413,7 @@ declare module "bun:ffi" {
     [FFIType.function]: Pointer | null;
     [FFIType.napi_env]: unknown;
     [FFIType.napi_value]: unknown;
+    [FFIType.buffer]: NodeJS.TypedArray | DataView;
   }
   interface FFITypeStringToType {
     ["char"]: FFIType.char;
@@ -445,6 +448,7 @@ declare module "bun:ffi" {
     ["callback"]: FFIType.pointer; // for now
     ["napi_env"]: never;
     ["napi_value"]: unknown;
+    ["buffer"]: FFIType.buffer;
   }
 
   type FFITypeOrString = FFIType | keyof FFITypeStringToType;

src/bun.js/api/FFI.h

@@ -35,7 +35,7 @@ typedef _Bool bool;
 
 #ifndef SRC_JS_NATIVE_API_TYPES_H_
 typedef struct napi_env__ *napi_env;
-typedef struct napi_value__ *napi_value;
+typedef int64_t napi_value;
 typedef enum {
   napi_ok,
   napi_invalid_arg,
@@ -74,14 +74,14 @@ void NapiHandleScope__pop(void* jsGlobalObject, void* handleScope);
 // begin with a 15-bit pattern within the range 0x0002..0xFFFC.
 #define DoubleEncodeOffsetBit 49
 #define DoubleEncodeOffset    (1ll << DoubleEncodeOffsetBit)
-#define OtherTag              0x2
-#define BoolTag               0x4
-#define UndefinedTag          0x8
+#define OtherTag              0x2ll
+#define BoolTag               0x4ll
+#define UndefinedTag          0x8ll
 #define TagValueFalse            (OtherTag | BoolTag | false)
 #define TagValueTrue             (OtherTag | BoolTag | true)
 #define TagValueUndefined        (OtherTag | UndefinedTag)
 #define TagValueNull             (OtherTag)
-#define NotCellMask  NumberTag | OtherTag
+#define NotCellMask  (int64_t)(NumberTag | OtherTag)
 
 #define MAX_INT32 2147483648
 #define MAX_INT52 9007199254740991
@@ -171,6 +171,11 @@ static int32_t JSVALUE_TO_INT32(EncodedJSValue val) __attribute__((__always_inli
 static float JSVALUE_TO_FLOAT(EncodedJSValue val) __attribute__((__always_inline__));
 static double JSVALUE_TO_DOUBLE(EncodedJSValue val) __attribute__((__always_inline__));
 static bool JSVALUE_TO_BOOL(EncodedJSValue val) __attribute__((__always_inline__));
+static uint8_t GET_JSTYPE(EncodedJSValue val) __attribute__((__always_inline__));
+static bool JSTYPE_IS_TYPED_ARRAY(uint8_t type) __attribute__((__always_inline__));
+static bool JSCELL_IS_TYPED_ARRAY(EncodedJSValue val) __attribute__((__always_inline__));
+static void* JSVALUE_TO_TYPED_ARRAY_VECTOR(EncodedJSValue val) __attribute__((__always_inline__));
+static uint64_t JSVALUE_TO_TYPED_ARRAY_LENGTH(EncodedJSValue val) __attribute__((__always_inline__));
 
 static bool JSVALUE_IS_CELL(EncodedJSValue val) {
   return !(val.asInt64 & NotCellMask);
@@ -184,6 +189,25 @@ static bool JSVALUE_IS_NUMBER(EncodedJSValue val) {
   return val.asInt64 & NumberTag;
 }
 
+static uint8_t GET_JSTYPE(EncodedJSValue val) {
+  return *(uint8_t*)((uint8_t*)val.asPtr + JSCell__offsetOfType);
+}
+
+static bool JSTYPE_IS_TYPED_ARRAY(uint8_t type) {
+  return type >= JSTypeArrayBufferViewMin && type <= JSTypeArrayBufferViewMax;
+}
+
+static bool JSCELL_IS_TYPED_ARRAY(EncodedJSValue val) {
+  return JSVALUE_IS_CELL(val) && JSTYPE_IS_TYPED_ARRAY(GET_JSTYPE(val));
+}
+
+static void* JSVALUE_TO_TYPED_ARRAY_VECTOR(EncodedJSValue val) {
+  return *(void**)((char*)val.asPtr + JSArrayBufferView__offsetOfVector);
+}
+
+static uint64_t JSVALUE_TO_TYPED_ARRAY_LENGTH(EncodedJSValue val) {
+  return *(uint64_t*)((char*)val.asPtr + JSArrayBufferView__offsetOfLength);
+}
 
 // JSValue numbers-as-pointers are represented as a 52-bit integer
 // Previously, the pointer was stored at the end of the 64-bit value
@@ -193,6 +217,11 @@ static bool JSVALUE_IS_NUMBER(EncodedJSValue val) {
 static void* JSVALUE_TO_PTR(EncodedJSValue val) {
   if (val.asInt64 == TagValueNull)
     return 0;
+
+  if (JSCELL_IS_TYPED_ARRAY(val)) {
+      return JSVALUE_TO_TYPED_ARRAY_VECTOR(val);
+  }
+
   val.asInt64 -= DoubleEncodeOffset;
   size_t ptr = (size_t)val.asDouble;
   return (void*)ptr;
@@ -275,6 +304,10 @@ static uint64_t JSVALUE_TO_UINT64(EncodedJSValue value) {
     return (uint64_t)JSVALUE_TO_DOUBLE(value);
   }
 
+  if (JSCELL_IS_TYPED_ARRAY(value)) {
+    return (uint64_t)JSVALUE_TO_TYPED_ARRAY_LENGTH(value);
+  }
+
   return JSVALUE_TO_UINT64_SLOW(value);
 }
 static int64_t JSVALUE_TO_INT64(EncodedJSValue value) {

src/bun.js/api/ffi.zig

@@ -76,6 +76,24 @@ const IOTask = JSC.IOTask;
 const TCC = @import("../../tcc.zig");
 extern fn pthread_jit_write_protect_np(enable: bool) callconv(.C) void;
 
+const Offsets = extern struct {
+    JSArrayBufferView__offsetOfLength: u32,
+    JSArrayBufferView__offsetOfByteOffset: u32,
+    JSArrayBufferView__offsetOfVector: u32,
+    JSCell__offsetOfType: u32,
+
+    extern "C" var Bun__FFI__offsets: Offsets;
+    extern "C" fn Bun__FFI__ensureOffsetsAreLoaded() void;
+    fn loadOnce() void {
+        Bun__FFI__ensureOffsetsAreLoaded();
+    }
+    var once = std.once(loadOnce);
+    pub fn get() *const Offsets {
+        once.call();
+        return &Bun__FFI__offsets;
+    }
+};
+
 pub const FFI = struct {
     dylib: ?std.DynLib = null,
     relocated_bytes_to_free: ?[]u8 = null,
@@ -1361,6 +1379,11 @@ pub const FFI = struct {
             return ZigString.static("Cannot return napi_env to JavaScript").toErrorInstance(global);
         }
 
+        if (return_type == .buffer) {
+            abi_types.clearAndFree(allocator);
+            return ZigString.static("Cannot return a buffer to JavaScript (since byteLength and byteOffset are unknown)").toErrorInstance(global);
+        }
+
         if (function.threadsafe and return_type != ABIType.void) {
             abi_types.clearAndFree(allocator);
             return ZigString.static("Threadsafe functions must return void").toErrorInstance(global);
@@ -1542,14 +1565,7 @@ pub const FFI = struct {
             }
 
             _ = TCC.tcc_set_output_type(state, TCC.TCC_OUTPUT_MEMORY);
-            const Sizes = @import("../bindings/sizes.zig");
 
-            var symbol_buf: [256]u8 = undefined;
-            TCC.tcc_define_symbol(
-                state,
-                "Bun_FFI_PointerOffsetToArgumentsList",
-                std.fmt.bufPrintZ(&symbol_buf, "{d}", .{Sizes.Bun_FFI_PointerOffsetToArgumentsList}) catch unreachable,
-            );
             CompilerRT.define(state);
 
             // TCC.tcc_define_symbol(
@@ -2064,7 +2080,7 @@ pub const FFI = struct {
         function = 17,
         napi_env = 18,
         napi_value = 19,
-
+        buffer = 20,
         pub const max = @intFromEnum(ABIType.napi_value);
 
         /// Types that we can directly pass through as an `int64_t`
@@ -2104,6 +2120,8 @@ pub const FFI = struct {
             .{ "uint64_t", ABIType.uint64_t },
             .{ "uint8_t", ABIType.uint8_t },
             .{ "usize", ABIType.uint64_t },
+            .{ "size_t", ABIType.uint64_t },
+            .{ "buffer", ABIType.buffer },
             .{ "void*", ABIType.ptr },
             .{ "ptr", ABIType.ptr },
             .{ "pointer", ABIType.ptr },
@@ -2219,6 +2237,9 @@ pub const FFI = struct {
                         try writer.writeAll(".asNapiValue");
                         return;
                     },
+                    .buffer => {
+                        try writer.writeAll("JSVALUE_TO_TYPED_ARRAY_VECTOR(");
+                    },
                 }
                 // if (self.fromi64) {
                 //     try writer.writeAll("EncodedJSValue{ ");
@@ -2274,6 +2295,9 @@ pub const FFI = struct {
                     .napi_value => {
                         try writer.print("((EncodedJSValue) {{.asNapiValue = {s} }} )", .{self.symbol});
                     },
+                    .buffer => {
+                        try writer.writeAll("0");
+                    },
                 }
             }
         };
@@ -2302,7 +2326,7 @@ pub const FFI = struct {
 
         pub fn typenameLabel(this: ABIType) []const u8 {
             return switch (this) {
-                .function, .cstring, .ptr => "void*",
+                .buffer, .function, .cstring, .ptr => "void*",
                 .bool => "bool",
                 .int8_t => "int8_t",
                 .uint8_t => "uint8_t",
@@ -2345,6 +2369,7 @@ pub const FFI = struct {
                 .void => "void",
                 .napi_env => "napi_env",
                 .napi_value => "napi_value",
+                .buffer => "buffer",
             };
         }
     };
@@ -2423,6 +2448,40 @@ const CompilerRT = struct {
             // there
             _ = TCC.tcc_compile_string(state, @embedFile(("libtcc1.c")));
         }
+
+        const Sizes = @import("../bindings/sizes.zig");
+        var symbol_buf: [256]u8 = undefined;
+        TCC.tcc_define_symbol(
+            state,
+            "Bun_FFI_PointerOffsetToArgumentsList",
+            std.fmt.bufPrintZ(&symbol_buf, "{d}", .{Sizes.Bun_FFI_PointerOffsetToArgumentsList}) catch unreachable,
+        );
+        const offsets = Offsets.get();
+        TCC.tcc_define_symbol(
+            state,
+            "JSArrayBufferView__offsetOfLength",
+            std.fmt.bufPrintZ(&symbol_buf, "{d}", .{offsets.JSArrayBufferView__offsetOfLength}) catch unreachable,
+        );
+        TCC.tcc_define_symbol(
+            state,
+            "JSArrayBufferView__offsetOfVector",
+            std.fmt.bufPrintZ(&symbol_buf, "{d}", .{offsets.JSArrayBufferView__offsetOfVector}) catch unreachable,
+        );
+        TCC.tcc_define_symbol(
+            state,
+            "JSCell__offsetOfType",
+            std.fmt.bufPrintZ(&symbol_buf, "{d}", .{offsets.JSCell__offsetOfType}) catch unreachable,
+        );
+        TCC.tcc_define_symbol(
+            state,
+            "JSTypeArrayBufferViewMin",
+            std.fmt.bufPrintZ(&symbol_buf, "{d}", .{@intFromEnum(JSC.JSValue.JSType.min_typed_array)}) catch unreachable,
+        );
+        TCC.tcc_define_symbol(
+            state,
+            "JSTypeArrayBufferViewMax",
+            std.fmt.bufPrintZ(&symbol_buf, "{d}", .{@intFromEnum(JSC.JSValue.JSType.max_typed_array)}) catch unreachable,
+        );
     }
 
     pub fn inject(state: *TCC.TCCState) void {

src/bun.js/bindings/bindings.zig

@@ -3676,6 +3676,9 @@ pub const JSValue = enum(JSValueReprInt) {
         JSAsJSONType = 0b11110000 | 1,
         _,
 
+        pub const min_typed_array: JSType = .Int8Array;
+        pub const max_typed_array: JSType = .DataView;
+
         pub fn canGet(this: JSType) bool {
             return switch (this) {
                 .Array,

src/bun.js/bindings/ffi.cpp

@@ -0,0 +1,17 @@
+#include "root.h"
+
+typedef struct FFIFields {
+    uint32_t JSArrayBufferView__offsetOfLength;
+    uint32_t JSArrayBufferView__offsetOfByteOffset;
+    uint32_t JSArrayBufferView__offsetOfVector;
+    uint32_t JSCell__offsetOfType;
+} FFIFields;
+extern "C" FFIFields Bun__FFI__offsets = { 0 };
+
+extern "C" void Bun__FFI__ensureOffsetsAreLoaded()
+{
+    Bun__FFI__offsets.JSArrayBufferView__offsetOfLength = JSC::JSArrayBufferView::offsetOfLength();
+    Bun__FFI__offsets.JSArrayBufferView__offsetOfByteOffset = JSC::JSArrayBufferView::offsetOfByteOffset();
+    Bun__FFI__offsets.JSArrayBufferView__offsetOfVector = JSC::JSArrayBufferView::offsetOfVector();
+    Bun__FFI__offsets.JSCell__offsetOfType = JSC::JSCell::typeInfoTypeOffset();
+}

src/js/bun/ffi.ts

@@ -57,6 +57,7 @@ const FFIType = {
   fn: 17,
   napi_env: 18,
   napi_value: 19,
+  buffer: 20,
 };
 
 const suffix = process.platform === "win32" ? "dll" : process.platform === "darwin" ? "dylib" : "so";
@@ -155,7 +156,7 @@ Object.defineProperty(globalThis, "__GlobalBunCString", {
   configurable: false,
 });
 
-const ffiWrappers = new Array(20);
+const ffiWrappers = new Array(21);
 
 var char = "val|0";
 ffiWrappers.fill(char);
@@ -281,14 +282,25 @@ Object.defineProperty(globalThis, "__GlobalBunFFIPtrFunctionForWrapper", {
   enumerable: false,
   configurable: true,
 });
+Object.defineProperty(globalThis, "__GlobalBunFFIPtrArrayBufferViewFn", {
+  value: function isTypedArrayView(val) {
+    return $isTypedArrayView(val);
+  },
+  enumerable: false,
+  configurable: true,
+});
 
 ffiWrappers[FFIType.cstring] = ffiWrappers[FFIType.pointer] = `{
   if (typeof val === "number") return val;
   if (!val) {
     return null;
   }
 
-  if (ArrayBuffer.isView(val) || val instanceof ArrayBuffer) {
+  if (__GlobalBunFFIPtrArrayBufferViewFn(val)) {
+    return val;
+  }
+
+  if (val instanceof ArrayBuffer) {
     return __GlobalBunFFIPtrFunctionForWrapper(val);
   }
 
@@ -299,6 +311,14 @@ ffiWrappers[FFIType.cstring] = ffiWrappers[FFIType.pointer] = `{
   throw new TypeError(\`Unable to convert \${ val } to a pointer\`);
 }`;
 
+ffiWrappers[FFIType.buffer] = `{
+  if (!__GlobalBunFFIPtrArrayBufferViewFn(val)) {
+    throw new TypeError("Expected a TypedArray");
+  }
+
+  return val;
+}`;
+
 ffiWrappers[FFIType.function] = `{
   if (typeof val === "number") {
     return val;