koffi 1.3.2 → 1.3.5

package/doc/functions.md

@@ -2,16 +2,16 @@
 
 ## Function definitions
 
-To declare functions, start by loading the shared library with `koffi.load()`.
+To declare functions, start by loading the shared library with `koffi.load(filename)`.
 
 ```js
 const koffi = require('koffi');
 const lib = koffi.load('/path/to/shared/library'); // File extension depends on platforms: .so, .dll, .dylib, etc.
 ```
 
-You can use the returned object to load C functions from the library. Koffi supports two syntaxes:
+You can use the returned object to load C functions from the library. To do so, you can use two syntaxes:
 
-- Classic syntax, inspired by node-ffi
+- The classic syntax, inspired by node-ffi
 - C-like prototypes
 
 ### Classic syntax
@@ -27,18 +27,20 @@ Koffi automatically tries mangled names for non-standard x86 calling conventions
 
 ### C-like prototypes
 
-You can declare functions using simple C-like prototype strings, as shown below:
+If you prefer, you can declare functions using simple C-like prototype strings, as shown below:
 
 ```js
 const printf = lib.func('int printf(const char *fmt, ...)');
 const atoi = lib.func('int atoi(string)'); // The parameter name is not used by Koffi, and optional
 ```
 
+You can use `()` or `(void)` for functions that take no argument.
+
 ## Synchronous calls
 
 By default, calling a C function happens synchronously.
 
-Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi support several standards:
+Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi supports several x86 conventions:
 
  Convention   | Classic form                  | Prototype form | Description
 ------------- | ----------------------------- | -------------- | -------------------------------------------------------------------
@@ -49,7 +51,7 @@ Most architectures only support one procedure call standard per process. The 32-
 
 You can safely use these on non-x86 platforms, they are simply ignored.
 
-Below you can find a small example showing how to use a non-default calling convention:
+Below you can find a small example showing how to use a non-default calling convention, with the two syntaxes:
 
 ```js
 const koffi = require('koffi');
@@ -75,9 +77,13 @@ atoi.async('1257', (err, res) => {
 })
 console.log('Hello World!');
 
-// This program will print "Hello World!", and then "Result: 1257"
+// This program will print:
+//   Hello World!
+//   Result: 1257
 ```
 
+These calls are executed by worker threads. It is **your responsibility to deal with data sharing issues** in the native code that may be caused by multi-threading.
+
 You can easily convert this callback-style async function to a promise-based version with `util.promisify()` from the Node.js standard library.
 
 Variadic functions cannot be called asynchronously.
@@ -101,7 +107,7 @@ On x86 platforms, only the Cdecl convention can be used for variadic functions.
 
 By default, Koffi will only forward arguments from Javascript to C. However, many C functions use pointer arguments for output values, or input/output values.
 
-For simplicy, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:
+For simplicity, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:
 
 - [Structs](types.md#struct-types) (to/from JS objects)
 - [Opaque handles](types.md#opaque-handles)
@@ -166,8 +172,6 @@ sqlite3_close_v2(db);
 
 ## Javascript callbacks
 
-### Using callbacks
-
 In order to pass a JS function to a C function expecting a callback, you must first create a callback type with the expected return type and parameters. The syntax is similar to the one used to load functions from a shared library.
 
 ```js
@@ -180,7 +184,7 @@ const ExampleCallback = koffi.callback('ExampleCallback', 'void', ['int']);
 const AddDoubleFloat = koffi.callback('double AddDoubleFloat(double d, float f)');
 ```
 
-Once your callback type is declared, you can use them in struct definitions, or as function parameter and/or return type.
+Once your callback type is declared, you can use it in struct definitions, or as function parameter and/or return type.
 
 Here is a small example with the C part and the JS part.
 
@@ -217,8 +221,8 @@ console.log(ret);
 
 On x86 platforms, only Cdecl and Stdcall callbacks are supported.
 
-### Thread safety
+## Thread safety
 
-The callback must be called from the main thread, or more precisely from the same thread as the V8 intepreter.
+Asynchronous functions run on worker threads. You need to deal with thread safety issues if you share data between threads.
 
-Calling the callback from another thread is undefined behavior, and will likely lead to a mess.
+Callbacks must be called from the main thread, or more precisely from the same thread as the V8 intepreter. Calling a callback from another thread is undefined behavior, and will likely lead to a crash or a big mess. You've been warned!

package/doc/index.rst

@@ -6,7 +6,7 @@ Overview
 
 Koffi is a **fast and easy-to-use C FFI module for Node.js**, featuring:
 
-* Low-overhead and fast performance (see :ref:`Benchmarks`)
+* Low-overhead and fast performance (see :ref:`benchmarks<Benchmarks>`)
 * Support for primitive and aggregate data types (structs and fixed-size arrays), both by reference (pointer) and by value
 * Javascript functions can be used as C callbacks (since 1.2.0)
 * Well-tested code base for :ref:`popular OS/architecture combinations<Supported platforms>`
@@ -24,6 +24,7 @@ Table of contents
    memory
    benchmarks
    contribute
+   changes
 
 License
 -------

package/doc/memory.md

@@ -4,7 +4,7 @@
 
 For synchronous/normal calls, Koffi uses two preallocated memory blocks:
 
-- One to construct to assign the C stack, subsequently used by the platform-specific assembly code (1 MiB by default)
+- One to construct the C stack and assign registers, subsequently used by the platform-specific assembly code (1 MiB by default)
 - One to allocate strings and big objects/structs (2 MiB by default)
 
 Unless very big strings or objects (at least more than one page of memory) are used, no extra allocation ever happens during calls or callbacks.
@@ -18,12 +18,15 @@ console.log(config);
 
 The same is true for asynchronous calls. When an asynchronous call is made, Koffi will allocate new blocks unless there is an unused (resident) set of blocks still available. Once the asynchronous call is finished, these blocks are freed if there are more than `resident_async_pools` sets of blocks left around.
 
+There cannot be more than `max_async_calls` running at the same time.
+
 ## Default settings
 
 Setting              | Default | Description
 -------------------- | ------- | -----------------------------------------------
 sync_stack_size      | 1 MiB   | Stack size for synchronous calls
 sync_heap_size       | 2 MiB   | Heap size for synchronous calls
-async_stack_size     | 512 kiB | Stack size for asynchronous calls
-async_heap_size      | 1 MiB   | Heap size for asynchronous calls
+async_stack_size     | 256 kiB | Stack size for asynchronous calls
+async_heap_size      | 512 kiB | Heap size for asynchronous calls
 resident_async_pools | 2       | Number of resident pools for asynchronous calls
+max_async_calls      | 64      | Maximum number of ongoing asynchronous calls

package/doc/platforms.md

@@ -12,6 +12,8 @@ RISC-V 64 [^3]     | ⬜️ *N/A*    | ✅ Yes   | ⬜️ *N/A*    | 🟨 Probab
 
 For all fully supported platforms (green check marks), a prebuilt binary is included in the NPM package which means you can install Koffi without a C++ compiler.
 
+Node 12 or later is required, earlier versions are not supported. Use [NVM](https://github.com/nvm-sh/nvm) to install recent Node versions on older Linux distributions.
+
 [^1]: The following call conventions are supported for forward calls: cdecl, stdcall, MS fastcall, thiscall. Only cdecl and stdcall can be used for C to JS callbacks.
 [^2]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
 [^3]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source (untested), the LP64F ABI is not supported.

package/doc/start.md

@@ -19,7 +19,7 @@ Below you can find three examples:
 
 ## Small Linux example
 
-This is a small example for Linux systems, which uses `gettimeofday()` and `printf()` to print the current time and the timezone.
+This is a small example for Linux systems, which uses `gettimeofday()`, `localtime_r()` and `printf()` to print the current time.
 
 It illustrates the use of output parameters.
 
@@ -69,7 +69,7 @@ printf('Local time: %02d:%02d:%02d\n', 'int', now.tm_hour, 'int', now.tm_min, 'i
 
 ## Small Windows example
 
-This is a small example targeting the Win32 API, using `MessageBox()` to show a Hello message to the user.
+This is a small example targeting the Win32 API, using `MessageBox()` to show a *Hello World!* message to the user.
 
 It illustrates the use of the x86 stdcall calling convention.
 
@@ -85,5 +85,5 @@ const MB_ICONINFORMATION = 0x40;
 // Find functions
 const MessageBoxA = lib.stdcall('MessageBoxA', 'int', ['void *', 'string', 'string', 'uint']);
 
-MessageBoxA(null, 'Hello', 'Foobar', MB_ICONINFORMATION);
+MessageBoxA(null, 'Hello World!', 'Koffi', MB_ICONINFORMATION);
 ```

package/doc/types.md

@@ -42,6 +42,8 @@ Number (float)    | float64            | 8     |            |
 Number (float)    | float              | 4     |            |
 Number (float)    | double             | 8     |            |
 
+Koffi also accepts BigInt values when converting from JS to C integers. If the value exceeds the range of the C type, Koffi will convert the number to an undefined value. In the reverse direction, BigInt values are automatically used when needed for big 64-bit integers.
+
 Koffi defines a few more types that can change size depending on the OS and the architecture:
 
 JS type          | C type        | Signedness | Note
@@ -95,7 +97,7 @@ const A = koffi.struct('A', {
 
 Koffi follows the C and ABI rules regarding struct alignment and padding.
 
-Once a struct is declared, you can use it by name (with a string, like you can do for primitive types) or the through the value returned by the call to `koffi.struct()`. Only the latter is possible when declaring an anonymous struct.
+Once a struct is declared, you can use it by name (with a string, like you can do for primitive types) or through the value returned by the call to `koffi.struct()`. Only the latter is possible when declaring an anonymous struct.
 
 ```js
 // The following two function declarations are equivalent, and declare a function taking an A value and returning A
@@ -107,9 +109,9 @@ const Function2 = lib.func('Function', A, [A]);
 
 In C, pointer arguments are used for differenty purposes. It is important to distinguish these use cases because Koffi provides different ways to deal with each of them:
 
-- **Struct pointers**: Use of struct pointers by C libraries fall in two cases: avoid (potentially) expensive copies, and to let the function change struct contents (output or input/output argument).
-- **Opaque handles**: the library does not expose the contents of the structs, and only provides you with a pointer to it (e.g. `sqlite3_stmt`). Only the functions provided by the library can do something with this pointer, in Koffi we call this a handle. This is usually done for ABI-stability reason, and to prevent library users from messing directly with library internals.
-- **Arrays**: in C, you dynamically-sized arrays are usually passed to functions with pointers, either NULL-terminated or with an additional length argument.
+- **Struct pointers**: Use of struct pointers by C libraries fall in two cases: avoid (potentially) expensive copies, and to let the function change struct contents (output or input/output arguments).
+- **Opaque handles**: the library does not expose the contents of the structs, and only provides you with a pointer to it (e.g. `FILE *`). Only the functions provided by the library can do something with this pointer, in Koffi we call this a handle. This is usually done for ABI-stability reason, and to prevent library users from messing directly with library internals.
+- **Arrays**: in C, you dynamically-sized arrays are usually passed to functions with pointers, either NULL-terminated (or any other sentinel value) or with an additional length argument.
 - **Pointers to primitive types**: This is more rare, and generally used for output or input/output arguments. The Win32 API has a lot of these.
 
 ### Struct pointers
@@ -351,7 +353,7 @@ const ComputeTotalLength = lib.func('int64_t ComputeTotalLength(const char **str
 let strings = ['Get', 'Total', 'Length', null];
 let total = ComputeTotalLength(strings);
 
-console.log(total); // Prints 14n (big int)
+console.log(total); // Prints 14
 ```
 
 By default, just like for objects, array arguments are copied from JS to C but not vice-versa. You can however change the direction as documented in the section on [output parameters](functions.md#output-parameters).
@@ -423,7 +425,7 @@ console.log(filenames);
 
 In javascript, it is not possible to pass a primitive value by reference to another function. This means that you cannot call a function and expect it to modify the value of one of its number or string parameter.
 
-However, arrays and objects (among others) are reference type values. Assigning an array or an object from one variable to another does not invole any copy. Instead, as the following example illustrates, the new variable references the same list as the first:
+However, arrays and objects (among others) are reference type values. Assigning an array or an object from one variable to another does not invole any copy. Instead, as the following example illustrates, the new variable references the same array as the first:
 
 ```js
 let list1 = [1, 2];
@@ -436,7 +438,7 @@ console.log(list1); // Prints [1, 42]
 
 All of this means that C functions that are expected to modify their primitive output values (such as an `int *` parameter) cannot be used directly. However, thanks to Koffi's transparent array support, you can use Javascript arrays to approximate reference semantics with single-element arrays.
 
-Below, you can find an example of an addition function where the result is stored in an `int *` output parameter and how to use this function from Koffi.
+Below, you can find an example of an addition function where the result is stored in an `int *` input/output parameter and how to use this function from Koffi.
 
 ```c
 void AddInt(int *dest, int add)
@@ -445,7 +447,7 @@ void AddInt(int *dest, int add)
 }
 ```
 
-You can simply pass a single-element array as the third argument:
+You can simply pass a single-element array as the first argument:
 
 ```js
 const AddInt = lib.func('void AddInt(_Inout_ int *dest, int add)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.3.2",
+  "version": "1.3.5",
   "description": "Fast and simple C FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -25,7 +25,7 @@
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cnoke": "^2.0.3"
+    "cnoke": "^2.0.4"
   },
   "devDependencies": {
     "chalk": "^4.1.2",

package/qemu/qemu.js

@@ -352,6 +352,7 @@ async function pack() {
                     console.error(str);
                 }
 
+                ignore.add(machine);
                 success = false;
             }
         }));

package/qemu/registry/machines.json

@@ -392,6 +392,12 @@
                 "arch": "x64",
                 "directory": "/Users/macos/luigi",
                 "build": "PATH=/usr/local/bin:/usr/bin:/bin SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.3.sdk node ../cnoke/cnoke.js"
+            },
+
+            "macOS ARM64": {
+                "arch": "arm64",
+                "directory": "/Users/macos/luigi_arm64",
+                "build": "PATH=/usr/local/bin:/usr/bin:/bin SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.3.sdk node ../cnoke/cnoke.js --arch arm64"
             }
         },
 
@@ -538,16 +544,5 @@
                 }
             }
         }
-    },
-
-    "macos_arm64": {
-        "name": "macOS ARM64",
-        "platform": "darwin",
-
-        "builds": {
-            "macOS ARM64": {
-                "arch": "arm64"
-            }
-        }
     }
 }

package/src/abi_arm32.cc

@@ -497,14 +497,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -603,7 +603,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 int64_t v = *(int64_t *)(param.gpr_count ? gpr_ptr : args_ptr);
                 (param.gpr_count ? gpr_ptr : args_ptr) += 2;
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
@@ -612,7 +612,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 uint64_t v = *(uint64_t *)(param.gpr_count ? gpr_ptr : args_ptr);
                 (param.gpr_count ? gpr_ptr : args_ptr) += 2;
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_arm64.cc

@@ -518,14 +518,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -703,7 +703,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
                 int64_t v = *(int64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
@@ -713,7 +713,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
                 uint64_t v = *(uint64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_riscv64.cc

@@ -433,14 +433,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -541,13 +541,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             case PrimitiveKind::Int64: {
                 int64_t v = *(int64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_x64_sysv.cc

@@ -489,14 +489,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -592,13 +592,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             case PrimitiveKind::Int64: {
                 int64_t v = *(int64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_x64_win.cc

@@ -299,14 +299,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -409,14 +409,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 int64_t v = *(int64_t *)(j < 4 ? gpr_ptr + j : args_ptr);
                 args_ptr += (j >= 4);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)(j < 4 ? gpr_ptr + j : args_ptr);
                 args_ptr += (j >= 4);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_x86.cc

@@ -373,14 +373,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -485,14 +485,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 int64_t v = *(int64_t *)args_ptr;
                 args_ptr += 2;
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)args_ptr;
                 args_ptr += 2;
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/call.cc

@@ -40,8 +40,9 @@ CallData::~CallData()
     mem->heap = old_heap_mem;
 
     instance->free_trampolines |= used_trampolines;
+    instance->temporaries -= mem->temporary;
 
-    if (--mem->depth && mem->temporary) {
+    if (!--mem->depth && mem->temporary) {
         delete mem;
     }
 }
@@ -801,11 +802,11 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
             } break;
             case PrimitiveKind::Int64: {
                 int64_t v = *(int64_t *)src;
-                obj.Set(member.name, Napi::BigInt::New(env, v));
+                obj.Set(member.name, NewBigInt(env, v));
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)src;
-                obj.Set(member.name, Napi::BigInt::New(env, v));
+                obj.Set(member.name, NewBigInt(env, v));
             } break;
             case PrimitiveKind::String: {
                 const char *str = *(const char **)src;
@@ -914,13 +915,13 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
         case PrimitiveKind::Int64: {
             POP_ARRAY({
                 int64_t v = *(int64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::UInt64: {
             POP_ARRAY({
                 uint64_t v = *(uint64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::String: {
@@ -1078,13 +1079,13 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
         case PrimitiveKind::Int64: {
             POP_ARRAY({
                 int64_t v = *(int64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::UInt64: {
             POP_ARRAY({
                 uint64_t v = *(uint64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::String: {

package/src/call.hh

@@ -50,7 +50,13 @@ class alignas(8) CallData {
     uint8_t *old_sp;
 
     union {
+        int8_t i8;
+        uint8_t u8;
+        int16_t i16;
+        uint16_t u16;
+        int32_t i32;
         uint32_t u32;
+        int64_t i64;
         uint64_t u64;
         float f;
         double d;