koffi 2.10.1 → 2.12.0

package/doc/pages/pointers.md

@@ -248,6 +248,81 @@ Disposable types can only be created from pointer or string types.
 > [!WARNING]
 > Be careful on Windows: if your shared library uses a different CRT (such as msvcrt), the memory could have been allocated by a different malloc/free implementation or heap, resulting in undefined behavior if you use `koffi.free()`.
 
+# External buffers (views)
+
+*New in Koffi 2.11.0*
+
+You can access unmanaged memory with `koffi.view(ptr, len)`. This function takes a pointer and a length, and creates an ArrayBuffer through which you can access the underlying memory without copy.
+
+> [!NOTE]
+> Some runtimes (such as Electron) forbid the use of external buffers. In this case, trying to create a view will trigger an exception.
+
+The following Linux example writes the string "Hello World!" to a file named "hello.txt" through mmaped memory, to demontrate the use of `koffi.view()`:
+
+```js
+// ES6 syntax: import koffi from 'koffi';
+const koffi = require('koffi');
+
+const libc = koffi.load('libc.so.6');
+
+const mode_t = koffi.alias('mode_t', 'uint32_t');
+const off_t = koffi.alias('off_t', 'int64_t');
+
+// These values are used on Linux and may differ on other systems
+const O_RDONLY = 00000000;
+const O_WRONLY = 00000001;
+const O_RDWR = 00000002;
+const O_CREAT = 00000100;
+const O_EXCL = 00000200;
+const O_CLOEXEC = 02000000;
+
+// These values are used on Linux and may differ on other systems
+const PROT_READ = 0x01;
+const PROT_WRITE = 0x02;
+const PROT_EXEC = 0x04;
+const MAP_SHARED = 0x01;
+const MAP_PRIVATE = 0x02;
+
+const open = libc.func('int open(const char *path, int flags, uint32_t mode)');
+const close = libc.func('int close(int fd)');
+const ftruncate = libc.func('int ftruncate(int fd, off_t length)');
+const mmap = libc.func('void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)');
+const munmap = libc.func('int munmap(void *addr, size_t length)');
+const strerror = libc.func('const char *strerror(int errnum)');
+
+write('hello.txt', 'Hello World!');
+
+function write(filename, str) {
+    let fd = -1;
+    let ptr = null;
+
+    // Work with encoded string
+    str = Buffer.from(str);
+
+    try {
+        fd = open(filename, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, 0644);
+        if (fd < 0)
+            throw new Error(`Failed to create '${filename}': ` + strerror(koffi.errno()));
+
+        if (ftruncate(fd, str.length) < 0)
+            throw new Error(`Failed to resize '${filename}': ` + strerror(koffi.errno()));
+
+        ptr = mmap(null, str.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (ptr == null)
+            throw new Error(`Failed to map '${filename}' to memory: ` + strerror(koffi.errno()));
+
+        let ab = koffi.view(ptr, str.length);
+        let view = new Uint8Array(ab);
+
+        str.copy(view);
+     } finally {
+        if (ptr != null)
+            munmap(ptr, str.length);
+        close(fd);
+    }
+}
+```
+
 # Unwrap pointers
 
 You can use `koffi.address(ptr)` on a pointer to get the numeric value as a [BigInt object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt).

package/doc/static/koffi.css

@@ -13,9 +13,10 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>. */
 
-@import url('../flaat/flaat.css');
+@import url('../flat/flat.css');
 @import url('../../../vendor/highlight.js/styles/base16/tomorrow.css');
 
 html {
-    --primary_color: #ec7400;
+    --top_color: #ec7400;
+    --anchor_color: #ec7400;
 }

package/index.js

@@ -4,9 +4,9 @@ var __commonJS = (cb, mod3) => function __require() {
   return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
-// ../../bin/Koffi/package/src/cnoke/src/tools.js
+// package/src/cnoke/src/tools.js
 var require_tools = __commonJS({
-  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+  "package/src/cnoke/src/tools.js"(exports2, module2) {
     "use strict";
     var crypto = require("crypto");
     var fs2 = require("fs");
@@ -278,6 +278,22 @@ var require_tools = __commonJS({
             }
           }
           break;
+        case 248:
+          {
+            switch (buf[4]) {
+              case 1:
+                {
+                  header.e_machine = "loong32";
+                }
+                break;
+              case 2:
+                {
+                  header.e_machine = "loong64";
+                }
+                break;
+            }
+          }
+          break;
         default:
           throw new Error("Unknown ELF machine type");
       }
@@ -358,13 +374,13 @@ var require_tools = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/package.json
+// package/src/koffi/package.json
 var require_package = __commonJS({
-  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+  "package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.10.1",
-      stable: "2.10.1",
+      version: "2.12.0",
+      stable: "2.12.0",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -408,9 +424,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/src/init.js
+// package/src/koffi/src/init.js
 var require_init = __commonJS({
-  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+  "package/src/koffi/src/init.js"(exports, module) {
     var fs = require("fs");
     var path = require("path");
     var util = require("util");
@@ -493,7 +509,7 @@ var require_init = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/index.js
+// package/src/koffi/index.js
 var { detect: detect2, init: init2 } = require_init();
 var triplet2 = detect2();
 var native2 = null;
@@ -539,6 +555,11 @@ try {
         native2 = require("./build/koffi/linux_ia32/koffi.node");
       }
       break;
+    case "linux_loong64":
+      {
+        native2 = require("./build/koffi/linux_loong64/koffi.node");
+      }
+      break;
     case "linux_riscv64d":
       {
         native2 = require("./build/koffi/linux_riscv64d/koffi.node");
@@ -593,6 +614,11 @@ try {
           native2 = require("./build/koffi/musl_ia32/koffi.node");
         }
         break;
+      case "linux_loong64":
+        {
+          native2 = require("./build/koffi/musl_loong64/koffi.node");
+        }
+        break;
       case "linux_riscv64d":
         {
           native2 = require("./build/koffi/musl_riscv64d/koffi.node");

package/indirect.js

@@ -4,9 +4,9 @@ var __commonJS = (cb, mod3) => function __require() {
   return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
-// ../../bin/Koffi/package/src/cnoke/src/tools.js
+// package/src/cnoke/src/tools.js
 var require_tools = __commonJS({
-  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+  "package/src/cnoke/src/tools.js"(exports2, module2) {
     "use strict";
     var crypto = require("crypto");
     var fs2 = require("fs");
@@ -278,6 +278,22 @@ var require_tools = __commonJS({
             }
           }
           break;
+        case 248:
+          {
+            switch (buf[4]) {
+              case 1:
+                {
+                  header.e_machine = "loong32";
+                }
+                break;
+              case 2:
+                {
+                  header.e_machine = "loong64";
+                }
+                break;
+            }
+          }
+          break;
         default:
           throw new Error("Unknown ELF machine type");
       }
@@ -358,13 +374,13 @@ var require_tools = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/package.json
+// package/src/koffi/package.json
 var require_package = __commonJS({
-  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+  "package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.10.1",
-      stable: "2.10.1",
+      version: "2.12.0",
+      stable: "2.12.0",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -408,9 +424,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/src/init.js
+// package/src/koffi/src/init.js
 var require_init = __commonJS({
-  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+  "package/src/koffi/src/init.js"(exports, module) {
     var fs = require("fs");
     var path = require("path");
     var util = require("util");
@@ -493,7 +509,7 @@ var require_init = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/indirect.js
+// package/src/koffi/indirect.js
 var { detect: detect2, init: init2 } = require_init();
 var triplet2 = detect2();
 var mod2 = init2(triplet2, null);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.10.1",
-    "stable": "2.10.1",
+    "version": "2.12.0",
+    "stable": "2.12.0",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/cnoke/src/tools.js

@@ -304,6 +304,12 @@ function decode_elf_header(buf) {
                 case 2: { header.e_machine = 'riscv64'; } break;
             }
         } break;
+        case 248: {
+            switch (buf[4]) {
+                case 1: { header.e_machine = 'loong32'; } break;
+                case 2: { header.e_machine = 'loong64'; } break;
+            }
+        } break;
         default: throw new Error('Unknown ELF machine type');
     }
 

package/src/core/libcc/libcc.hh

@@ -105,7 +105,7 @@ extern "C" const char *FelixTarget;
 extern "C" const char *FelixVersion;
 extern "C" const char *FelixCompiler;
 
-#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64) || __riscv_xlen == 64
+#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64) || __riscv_xlen == 64 || defined(__loongarch64)
     typedef int64_t Size;
     #define RG_SIZE_MAX INT64_MAX
 #elif defined(_WIN32) || defined(__APPLE__) || defined(__unix__)
@@ -211,6 +211,8 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
     #define RG_DEBUG_BREAK() __asm__ __volatile__(".inst 0xe7f001f0")
 #elif defined(__riscv)
     #define RG_DEBUG_BREAK() __asm__ __volatile__("ebreak")
+#elif defined(__loongarch64)
+    #define RG_DEBUG_BREAK() __asm__ __volatile__("break 1")
 #endif
 
 #define RG_CRITICAL(Cond, ...) \

package/src/koffi/CMakeLists.txt

@@ -110,6 +110,8 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
         endif()
     elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv")
         list(APPEND KOFFI_SRC src/abi_riscv64.cc src/abi_riscv64_asm.S)
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
+        list(APPEND KOFFI_SRC src/abi_riscv64.cc src/abi_loong64_asm.S)
     else()
         if(WIN32)
             list(APPEND KOFFI_SRC src/abi_x64_win.cc src/abi_x64_win_asm.asm)

package/src/koffi/src/abi_loong64.cc

@@ -0,0 +1,23 @@
+// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the “Software”), to deal in
+// the Software without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+// Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+// There's nothing to see here, this architecture uses the ABI code in abi_riscv64.cc!
+// This file only exists to avoid leaving abi_loong64_asm.S alone :)

package/src/koffi/src/abi_loong64_asm.S

@@ -0,0 +1,240 @@
+# Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the “Software”), to deal in 
+# the Software without restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+# Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+#define SYMBOL(Symbol) Symbol
+
+# Forward
+# ----------------------------
+
+# These three are the same, but they differ (in the C side) by their return type.
+# Unlike the three next functions, these ones don't forward FA argument registers.
+.global ForwardCallGG
+.global ForwardCallF
+.global ForwardCallDG
+.global ForwardCallGD
+.global ForwardCallDD
+
+# The X variants are slightly slower, and are used when FA arguments must be forwarded.
+.global ForwardCallXGG
+.global ForwardCallXF
+.global ForwardCallXDG
+.global ForwardCallXGD
+.global ForwardCallXDD
+
+# Copy function pointer to t7, in order to save it through argument forwarding.
+# Also make a copy of the SP to CallData::old_sp because the callback system might need it.
+# Save SP in FP, and use carefully assembled stack provided by caller.
+.macro prologue
+    addi.d $sp, $sp, -16
+    st.d $ra, $sp, 0
+    st.d $fp, $sp, 8
+    move $fp, $sp
+    st.d $fp, $a2, 0
+    move $t7, $a0
+    addi.d $sp, $a1, 128
+.endm
+
+# Call native function.
+# Once done, restore normal stack pointer and return.
+# The return value is passed untouched through registers.
+.macro epilogue
+    jirl $ra, $t7,0
+    move $sp, $fp
+    ld.d $ra, $sp, 0
+    ld.d $fp, $sp, 8
+    addi.d $sp, $sp, 16
+    jr $ra
+.endm
+
+# Prepare general purpose argument registers from array passed by caller.
+.macro forward_gpr
+    ld.d $a7, $a1, 120
+    ld.d $a6, $a1, 112
+    ld.d $a5, $a1, 104
+    ld.d $a4, $a1, 96
+    ld.d $a3, $a1, 88
+    ld.d $a2, $a1, 80
+    ld.d $a0, $a1, 64
+    ld.d $a1, $a1, 72
+.endm
+
+# Prepare vector argument registers from array passed by caller.
+.macro forward_vec
+    fld.d $fa7, $a1, 56
+    fld.d $fa6, $a1, 48
+    fld.d $fa5, $a1, 40
+    fld.d $fa4, $a1, 32
+    fld.d $fa3, $a1, 24
+    fld.d $fa2, $a1, 16
+    fld.d $fa1, $a1, 8
+    fld.d $fa0, $a1, 0
+.endm
+
+ForwardCallGG:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallF:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallDG:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallGD:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallDD:
+    prologue
+    forward_gpr
+    epilogue
+
+ForwardCallXGG:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXF:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXDG:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXGD:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+ForwardCallXDD:
+    prologue
+    forward_vec
+    forward_gpr
+    epilogue
+
+# Callbacks
+# ----------------------------
+
+.global RelayCallback
+.global CallSwitchStack
+
+# First, make a copy of the GPR argument registers (a0 to a7).
+# Then call the C function RelayCallback with the following arguments:
+# static trampoline ID, a pointer to the saved GPR array, a pointer to the stack
+# arguments of this call, and a pointer to a struct that will contain the result registers.
+# After the call, simply load these registers from the output struct.
+.macro trampoline id
+    addi.d $sp, $sp, -176
+    st.d $ra, $sp, 0
+    st.d $a0, $sp, 8
+    st.d $a1, $sp, 16
+    st.d $a2, $sp, 24
+    st.d $a3, $sp, 32
+    st.d $a4, $sp, 40
+    st.d $a5, $sp, 48
+    st.d $a6, $sp, 56
+    st.d $a7, $sp, 64
+    li.d $a0, \id
+    addi.d $a1, $sp, 8
+    addi.d $a2, $sp, 176
+    addi.d $a3, $sp, 136
+    bl RelayCallback
+    ld.d $ra, $sp, 0
+    ld.d $a0, $sp, 136
+    ld.d $a1, $sp, 144
+    addi.d $sp, $sp, 176
+    jr $ra
+.endm
+
+# Same thing, but also forwards the floating-point argument registers and loads them at the end.
+.macro trampoline_vec id
+    addi.d $sp, $sp, -176
+    st.d $ra, $sp, 0
+    st.d $a0, $sp, 8
+    st.d $a1, $sp, 16
+    st.d $a2, $sp, 24
+    st.d $a3, $sp, 32
+    st.d $a4, $sp, 40
+    st.d $a5, $sp, 48
+    st.d $a6, $sp, 56
+    st.d $a7, $sp, 64
+    fst.d $fa0, $sp, 72
+    fst.d $fa1, $sp, 80
+    fst.d $fa2, $sp, 88
+    fst.d $fa3, $sp, 96
+    fst.d $fa4, $sp, 104
+    fst.d $fa5, $sp, 112
+    fst.d $fa6, $sp, 120
+    fst.d $fa7, $sp, 128
+    li.d $a0, \id
+    addi.d $a1, $sp, 8
+    addi.d $a2, $sp, 176
+    addi.d $a3, $sp, 136
+    bl RelayCallback
+    ld.d $ra, $sp, 0
+    ld.d $a0, $sp, 136
+    ld.d $a1, $sp, 144
+    fld.d $fa0, $sp, 152
+    fld.d $fa1, $sp, 160
+    addi.d $sp, $sp, 176
+    jr $ra
+.endm
+
+# When a callback is relayed, Koffi will call into Node.js and V8 to execute Javascript.
+# The problem is that we're still running on the separate Koffi stack, and V8 will
+# probably misdetect this as a "stack overflow". We have to restore the old
+# stack pointer, call Node.js/V8 and go back to ours.
+# The first three parameters (a0, a1, a2) are passed through untouched.
+CallSwitchStack:
+    addi.d $sp, $sp, -16
+    st.d $ra, $sp, 0
+    st.d $fp, $sp, 8
+    move $fp, $sp
+    ld.d $t0, $a4, 0
+    sub.d $t0, $sp, $t0
+    li.d $t1, -16
+    and $t0, $t0, $t1
+    st.d $t0, $a4, 8
+    move $sp, $a3
+    jirl $ra, $a5, 0
+    move $sp, $fp
+    ld.d $ra, $sp, 0
+    ld.d $fp, $sp, 8
+    addi.d $sp, $sp, 16
+    jr $ra
+
+# Trampolines
+# ----------------------------
+
+#include "trampolines/gnu.inc"

package/src/koffi/src/abi_riscv64.cc

@@ -19,7 +19,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 
-#if __riscv_xlen == 64
+#if __riscv_xlen == 64 || defined(__loongarch64)
 
 #include "src/core/libcc/libcc.hh"
 #include "ffi.hh"
@@ -97,7 +97,7 @@ static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
     gpr_avail = std::min(2, gpr_avail);
     vec_avail = std::min(2, vec_avail);
 
-#if defined(__riscv_float_abi_double)
+#if defined(__riscv_float_abi_double) || defined(__loongarch64)
     if (param->type->primitive != PrimitiveKind::Union) {
         int gpr_count = 0;
         int vec_count = 0;

package/src/koffi/src/ffi.cc

@@ -2107,6 +2107,44 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
+static Napi::Value CreateView(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[1].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    void *ptr = nullptr;
+    if (!GetExternalPointer(env, info[0], &ptr))
+        return env.Null();
+    Size len = (Size)info[1].As<Napi::Number>().Int64Value();
+
+    if (len < 0) {
+        ThrowError<Napi::TypeError>(env, "Array length must be positive and non-zero");
+        return env.Null();
+    }
+
+    if (len) {
+        Napi::ArrayBuffer view = Napi::ArrayBuffer::New(env, ptr, (size_t)len);
+
+        if (!view.ByteLength()) {
+            ThrowError<Napi::Error>(env, "This runtime does not support external buffers");
+            return env.Null();
+        }
+
+        return view;
+    } else {
+        return Napi::ArrayBuffer::New(env, 0);
+    }
+}
+
 static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -2364,6 +2402,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     exports.Set("address", Napi::Function::New(env, GetPointerAddress, "address"));
     exports.Set("call", Napi::Function::New(env, CallPointerSync, "call"));
     exports.Set("encode", Napi::Function::New(env, EncodeValue, "encode"));
+    exports.Set("view", Napi::Function::New(env, CreateView, "view"));
 
     exports.Set("reset", Napi::Function::New(env, ResetKoffi, "reset"));
 

package/src/koffi/src/ffi.hh

@@ -209,7 +209,7 @@ struct ParameterInfo {
 #elif defined(__i386__) || defined(_M_IX86)
     bool trivial; // Only matters for return value
     int8_t fast;
-#elif __riscv_xlen == 64
+#elif __riscv_xlen == 64 || defined(__loongarch64)
     bool use_memory;
     int8_t gpr_count;
     int8_t vec_count;