koffi 2.7.3 → 2.7.4

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Koffi 2.7
 
+#### Koffi 2.7.4 (2024-02-04)
+
+- Support callbacks happening on main thread but outside JS call (such as during event loop)
+- Improve stability after `koffi.reset()`
+- Expose internal Node/NAPI `env` pointer
+- Name main Koffi API functions
+
 #### Koffi 2.7.3 (2024-01-26)
 
 - Support decoding NULL terminated arrays

package/index.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.3",
-      stable: "2.7.3",
+      version: "2.7.4",
+      stable: "2.7.4",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/indirect.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.3",
-      stable: "2.7.3",
+      version: "2.7.4",
+      stable: "2.7.4",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/package.json

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

package/src/cnoke/assets/FindCNoke.cmake

@@ -30,12 +30,16 @@ function(add_node_addon)
     cmake_parse_arguments(ARG "" "NAME" "SOURCES" ${ARGN})
 
     add_library(${ARG_NAME} SHARED ${ARG_SOURCES} ${NODE_JS_SOURCES})
+    target_link_node(${ARG_NAME})
     set_target_properties(${ARG_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
-    target_include_directories(${ARG_NAME} PRIVATE ${NODE_JS_INCLUDE_DIRS})
-    target_link_libraries(${ARG_NAME} PRIVATE ${NODE_JS_LIBRARIES})
-    target_compile_options(${ARG_NAME} PRIVATE ${NODE_JS_COMPILE_FLAGS})
+endfunction()
+
+function(target_link_node TARGET)
+    target_include_directories(${TARGET} PRIVATE ${NODE_JS_INCLUDE_DIRS})
+    target_link_libraries(${TARGET} PRIVATE ${NODE_JS_LIBRARIES})
+    target_compile_options(${TARGET} PRIVATE ${NODE_JS_COMPILE_FLAGS})
     if (NODE_JS_LINK_FLAGS)
-        target_link_options(${ARG_NAME} PRIVATE ${NODE_JS_LINK_FLAGS})
+        target_link_options(${TARGET} PRIVATE ${NODE_JS_LINK_FLAGS})
     endif()
 endfunction()
 

package/src/core/libcc/libcc.hh

@@ -3142,10 +3142,10 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args...
 #ifdef RG_DEBUG
     const char *DebugLogContext(const char *filename, int line);
 
-    #define LogDebug(...) Log(LogLevel::Debug, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
-    #define LogInfo(...) Log(LogLevel::Info, nullptr __VA_OPT__(,) __VA_ARGS__)
-    #define LogWarning(...) Log(LogLevel::Warning, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
-    #define LogError(...) Log(LogLevel::Error, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
+    #define LogDebug(...) Log(LogLevel::Debug, DebugLogContext(__FILE__, __LINE__),  __VA_ARGS__)
+    #define LogInfo(...) Log(LogLevel::Info, nullptr, __VA_ARGS__)
+    #define LogWarning(...) Log(LogLevel::Warning, DebugLogContext(__FILE__, __LINE__), __VA_ARGS__)
+    #define LogError(...) Log(LogLevel::Error, DebugLogContext(__FILE__, __LINE__), __VA_ARGS__)
 #else
     template <typename... Args>
     static inline void LogDebug(Args...) {}

package/src/koffi/CMakeLists.txt

@@ -21,13 +21,12 @@
 
 cmake_minimum_required(VERSION 3.6)
 cmake_policy(SET CMP0091 NEW)
-
 project(koffi C CXX ASM)
 
-include(CheckCXXCompilerFlag)
-
 find_package(CNoke)
 
+include(CheckCXXCompilerFlag)
+
 set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)

package/src/koffi/src/abi_arm32.cc

@@ -564,7 +564,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg)
 {
     if (env.IsExceptionPending()) [[unlikely]]
         return;
@@ -827,11 +827,11 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     // Make the call
     napi_value ret;
-    if (async) {
-        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
-    } else {
+    if (switch_stack) {
         ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
                               [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    } else {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
     }
     Napi::Value value(env, ret);
 

package/src/koffi/src/abi_arm64.cc

@@ -709,7 +709,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg)
 {
     if (env.IsExceptionPending()) [[unlikely]]
         return;
@@ -1143,11 +1143,11 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     // Make the call
     napi_value ret;
-    if (async) {
-        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
-    } else {
+    if (switch_stack) {
         ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
                               [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    } else {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
     }
     Napi::Value value(env, ret);
 

package/src/koffi/src/abi_riscv64.cc

@@ -506,7 +506,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg)
 {
     if (env.IsExceptionPending()) [[unlikely]]
         return;
@@ -740,11 +740,11 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     // Make the call
     napi_value ret;
-    if (async) {
-        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
-    } else {
+    if (switch_stack) {
         ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
                               [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    } else {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
     }
     Napi::Value value(env, ret);
 

package/src/koffi/src/abi_x64_sysv.cc

@@ -541,7 +541,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg)
 {
     if (env.IsExceptionPending()) [[unlikely]]
         return;
@@ -764,11 +764,11 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     // Make the call
     napi_value ret;
-    if (async) {
-        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
-    } else {
+    if (switch_stack) {
         ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
                               [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    } else {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
     }
     Napi::Value value(env, ret);
 

package/src/koffi/src/abi_x64_win.cc

@@ -350,7 +350,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg)
 {
     if (env.IsExceptionPending()) [[unlikely]]
         return;
@@ -587,11 +587,11 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async,
 
     // Make the call
     napi_value ret;
-    if (async) {
-        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
-    } else {
+    if (switch_stack) {
         ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
                               [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    } else {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
     }
     Napi::Value value(env, ret);
 

package/src/koffi/src/abi_x86.cc

@@ -464,7 +464,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
     RG_UNREACHABLE();
 }
 
-void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRegisters *out_reg)
+void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg)
 {
     if (env.IsExceptionPending()) [[unlikely]]
         return;
@@ -700,11 +700,11 @@ void CallData::Relay(Size idx, uint8_t *, uint8_t *caller_sp, bool async, BackRe
 
     // Make the call
     napi_value ret;
-    if (async) {
-        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
-    } else {
+    if (switch_stack) {
         ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
                               [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    } else {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
     }
     Napi::Value value(env, ret);
 

package/src/koffi/src/call.cc

@@ -101,7 +101,7 @@ void CallData::Dispose()
     instance = nullptr;
 }
 
-void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool dispose_call, BackRegisters *out_reg)
+void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool outside_call, BackRegisters *out_reg)
 {
     if (std::this_thread::get_id() != instance->main_thread_id) {
         // JS/V8 is single-threaded, and runs on main_thread_id. Forward the call
@@ -110,7 +110,7 @@ void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool dis
         RelayContext ctx;
 
         ctx.call = this;
-        ctx.dispose_call = dispose_call;
+        ctx.dispose_call = outside_call;
         ctx.idx = idx;
         ctx.own_sp = own_sp;
         ctx.caller_sp = caller_sp;
@@ -124,8 +124,8 @@ void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool dis
             ctx.cv.wait(lock);
         }
     } else {
-        RG_ASSERT(!dispose_call);
-        Relay(idx, own_sp, caller_sp, false, out_reg);
+        Napi::HandleScope scope(env);
+        Relay(idx, own_sp, caller_sp, !outside_call, out_reg);
     }
 }
 
@@ -133,7 +133,7 @@ void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
 {
     RelayContext *ctx = (RelayContext *)udata;
 
-    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, true, ctx->out_reg);
+    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, false, ctx->out_reg);
 
     if (ctx->dispose_call) {
         ctx->call->Dispose();

package/src/koffi/src/call.hh

@@ -107,8 +107,8 @@ public:
 
 #undef INLINE_IF_UNITY
 
-    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool async, BackRegisters *out_reg);
-    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool dispose_call, BackRegisters *out_reg);
+    void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_stack, BackRegisters *out_reg);
+    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool outside_call, BackRegisters *out_reg);
     static void RelayAsync(napi_env, napi_value, void *, void *udata);
 
     void DumpForward(const FunctionInfo *func) const;

package/src/koffi/src/ffi.cc

@@ -48,10 +48,6 @@
 #endif
 
 #include <napi.h>
-#if NODE_WANT_INTERNALS
-    #include <env-inl.h>
-    #include <js_native_api_v8.h>
-#endif
 
 namespace RG {
 
@@ -2001,6 +1997,40 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
+static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (instance->broker) {
+        napi_release_threadsafe_function(instance->broker, napi_tsfn_abort);
+        instance->broker = nullptr;
+    }
+
+    instance->types.RemoveFrom(instance->base_types_len);
+
+    {
+        HashSet<const void *> base_types;
+        HashMap<const char *, const TypeInfo *> new_map;
+
+        for (const TypeInfo &type: instance->types) {
+            base_types.Set(&type);
+        }
+
+        for (const auto &bucket: instance->types_map.table) {
+            if (base_types.Find(bucket.value)) {
+                new_map.Set(bucket.key, bucket.value);
+            }
+        }
+
+        std::swap(instance->types_map, new_map);
+    }
+
+    instance->callbacks.Clear();
+
+    return env.Undefined();
+}
+
 void LibraryHolder::Unload()
 {
 #ifdef _WIN32
@@ -2084,11 +2114,6 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
     return true;
 }
 
-CallData *GetThreadCall()
-{
-    return exec_call;
-}
-
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
@@ -2162,83 +2187,6 @@ static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 #endif
 }
 
-static Napi::Object InitBaseTypes(Napi::Env env)
-{
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    Napi::Object types = Napi::Object::New(env);
-
-    RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
-    RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
-    RegisterPrimitiveType(env, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(env, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
-    RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
-    RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(env, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
-    RegisterPrimitiveType(env, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
-    RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(env, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
-    RegisterPrimitiveType(env, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
-    RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(env, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
-    RegisterPrimitiveType(env, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
-    RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(RG_SIZE(size_t), false), RG_SIZE(size_t), alignof(size_t));
-    RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
-    RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
-    RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
-    RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
-    RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
-
-    instance->void_type = instance->types_map.FindValue("void", nullptr);
-    instance->char_type = instance->types_map.FindValue("char", nullptr);
-    instance->char16_type = instance->types_map.FindValue("char16", nullptr);
-
-    instance->active_symbol = Napi::Symbol::New(env, "active");
-
-    types.Freeze();
-
-    return types;
-}
-
-static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
-{
-    Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    if (instance->broker) {
-        napi_release_threadsafe_function(instance->broker, napi_tsfn_abort);
-        instance->broker = nullptr;
-    }
-
-    instance->types.Clear();
-    instance->types_map.Clear();
-    instance->callbacks.Clear();
-
-    InitBaseTypes(env);
-
-    return env.Undefined();
-}
-
 static InstanceData *CreateInstance()
 {
     InstanceData *instance = new InstanceData();
@@ -2267,52 +2215,52 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
     env.SetInstanceData(instance);
 
-    exports.Set("config", Napi::Function::New(env, GetSetConfig));
-    exports.Set("stats", Napi::Function::New(env, GetStats));
+    exports.Set("config", Napi::Function::New(env, GetSetConfig, "config"));
+    exports.Set("stats", Napi::Function::New(env, GetStats, "stats"));
 
-    exports.Set("struct", Napi::Function::New(env, CreatePaddedStructType));
-    exports.Set("pack", Napi::Function::New(env, CreatePackedStructType));
-    exports.Set("union", Napi::Function::New(env, CreateUnionType));
-    exports.Set("Union", Napi::Function::New(env, InstantiateUnion));
-    exports.Set("opaque", Napi::Function::New(env, CreateOpaqueType));
-    exports.Set("pointer", Napi::Function::New(env, CreatePointerType));
-    exports.Set("array", Napi::Function::New(env, CreateArrayType));
-    exports.Set("proto", Napi::Function::New(env, CreateFunctionType));
-    exports.Set("alias", Napi::Function::New(env, CreateTypeAlias));
+    exports.Set("struct", Napi::Function::New(env, CreatePaddedStructType, "struct"));
+    exports.Set("pack", Napi::Function::New(env, CreatePackedStructType, "pack"));
+    exports.Set("union", Napi::Function::New(env, CreateUnionType, "union"));
+    exports.Set("Union", Napi::Function::New(env, InstantiateUnion, "Union"));
+    exports.Set("opaque", Napi::Function::New(env, CreateOpaqueType, "opaque"));
+    exports.Set("pointer", Napi::Function::New(env, CreatePointerType, "pointer"));
+    exports.Set("array", Napi::Function::New(env, CreateArrayType, "array"));
+    exports.Set("proto", Napi::Function::New(env, CreateFunctionType, "proto"));
+    exports.Set("alias", Napi::Function::New(env, CreateTypeAlias, "alias"));
 
-    exports.Set("sizeof", Napi::Function::New(env, GetTypeSize));
-    exports.Set("alignof", Napi::Function::New(env, GetTypeAlign));
-    exports.Set("offsetof", Napi::Function::New(env, GetMemberOffset));
-    exports.Set("resolve", Napi::Function::New(env, GetResolvedType));
-    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition));
+    exports.Set("sizeof", Napi::Function::New(env, GetTypeSize, "sizeof"));
+    exports.Set("alignof", Napi::Function::New(env, GetTypeAlign, "alignof"));
+    exports.Set("offsetof", Napi::Function::New(env, GetMemberOffset, "offsetof"));
+    exports.Set("resolve", Napi::Function::New(env, GetResolvedType, "resolve"));
+    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition, "introspect"));
 
-    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary));
+    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary, "load"));
 
-    exports.Set("in", Napi::Function::New(env, MarkIn));
-    exports.Set("out", Napi::Function::New(env, MarkOut));
-    exports.Set("inout", Napi::Function::New(env, MarkInOut));
+    exports.Set("in", Napi::Function::New(env, MarkIn, "in"));
+    exports.Set("out", Napi::Function::New(env, MarkOut, "out"));
+    exports.Set("inout", Napi::Function::New(env, MarkInOut, "inout"));
 
-    exports.Set("disposable", Napi::Function::New(env, CreateDisposableType));
-    exports.Set("free", Napi::Function::New(env, CallFree));
+    exports.Set("disposable", Napi::Function::New(env, CreateDisposableType, "disposable"));
+    exports.Set("free", Napi::Function::New(env, CallFree, "free"));
 
-    exports.Set("register", Napi::Function::New(env, RegisterCallback));
-    exports.Set("unregister", Napi::Function::New(env, UnregisterCallback));
+    exports.Set("register", Napi::Function::New(env, RegisterCallback, "register"));
+    exports.Set("unregister", Napi::Function::New(env, UnregisterCallback, "unregister"));
 
-    exports.Set("as", Napi::Function::New(env, CastValue));
-    exports.Set("decode", Napi::Function::New(env, DecodeValue));
-    exports.Set("address", Napi::Function::New(env, GetPointerAddress));
-    exports.Set("call", Napi::Function::New(env, CallPointerSync));
-    exports.Set("encode", Napi::Function::New(env, EncodeValue));
+    exports.Set("as", Napi::Function::New(env, CastValue, "as"));
+    exports.Set("decode", Napi::Function::New(env, DecodeValue, "decode"));
+    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("reset", Napi::Function::New(env, ResetKoffi));
+    exports.Set("reset", Napi::Function::New(env, ResetKoffi, "reset"));
 
-    exports.Set("errno", Napi::Function::New(env, GetOrSetErrNo));
+    exports.Set("errno", Napi::Function::New(env, GetOrSetErrNo, "errno"));
 
-    Napi::Object os = Napi::Object::New(env);
-    exports.Set("os", os);
-
-    // Init constants mapping
+    // Export useful OS info
     {
+        Napi::Object os = Napi::Object::New(env);
+        exports.Set("os", os);
+
         Napi::Object codes = Napi::Object::New(env);
 
         for (const ErrnoCodeInfo &info: ErrnoCodes) {
@@ -2330,8 +2278,71 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     exports.Set("extension", Napi::String::New(env, ".so"));
 #endif
 
-    Napi::Object types = InitBaseTypes(env);
-    exports.Set("types", types);
+    // Init base types
+    {
+        Napi::Object types = Napi::Object::New(env);
+        exports.Set("types", types);
+
+        RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
+        RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
+        RegisterPrimitiveType(env, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
+        RegisterPrimitiveType(env, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
+        RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
+        RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
+        RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+        RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+        RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
+        RegisterPrimitiveType(env, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+        RegisterPrimitiveType(env, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+        RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
+        RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
+        RegisterPrimitiveType(env, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+        RegisterPrimitiveType(env, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+        RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
+        RegisterPrimitiveType(env, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+        RegisterPrimitiveType(env, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+        RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
+        RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
+        RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(RG_SIZE(size_t), false), RG_SIZE(size_t), alignof(size_t));
+        RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
+        RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
+        RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
+        RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
+        RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
+        RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
+        RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
+
+        instance->void_type = instance->types_map.FindValue("void", nullptr);
+        instance->char_type = instance->types_map.FindValue("char", nullptr);
+        instance->char16_type = instance->types_map.FindValue("char16", nullptr);
+
+        instance->active_symbol = Napi::Symbol::New(env, "active");
+
+        instance->base_types_len = instance->types.len;
+    }
+
+    // Expose internal Node stuff
+    {
+        Napi::Object node = Napi::Object::New(env);
+        exports.Set("node", node);
+
+        Napi::External<void> external = Napi::External<void>::New(env, (napi_env)env);
+        SetValueTag(instance, external, instance->void_type);
+
+        node.Set("env", external);
+    }
 
     exports.Set("version", Napi::String::New(env, RG_STRINGIFY(VERSION)));
 

package/src/koffi/src/ffi.hh

@@ -269,6 +269,7 @@ struct InstanceData {
     BucketArray<TypeInfo> types;
     HashMap<const char *, const TypeInfo *> types_map;
     BucketArray<FunctionInfo> callbacks;
+    Size base_types_len;
 
     bool debug;
     uint64_t tag_lower;
@@ -352,6 +353,5 @@ Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info);
 Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info);
 
 bool InitAsyncBroker(Napi::Env env, InstanceData *instance);
-CallData *GetThreadCall();
 
 }