koffi 1.1.2 → 1.1.5

package/src/ffi.cc

@@ -29,6 +29,7 @@
 #else
     #include <dlfcn.h>
     #include <unistd.h>
+    #include <sys/mman.h>
 #endif
 
 #include <napi.h>
@@ -39,6 +40,11 @@
 
 namespace RG {
 
+const Size SyncStackSize = Mebibytes(2);
+const Size SyncHeapSize = Mebibytes(4);
+const Size AsyncStackSize = Mebibytes(1);
+const Size AsyncHeapSize = Mebibytes(2);
+
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
 
@@ -100,6 +106,11 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type->members.Append(member);
     }
 
+    if (!type->size) {
+        ThrowError<Napi::TypeError>(env, "Empty struct '%1' is not allowed in C", type->name);
+        return env.Null();
+    }
+
     type->size = (int16_t)AlignLen(type->size, type->align);
 
     // If the insert succeeds, we cannot fail anymore
@@ -290,7 +301,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     if (!ref)
         return env.Null();
     if (len <= 0) {
-        ThrowError<Napi::TypeError>(env, "Array length must be non-zero positive");
+        ThrowError<Napi::TypeError>(env, "Array length must be positive and non-zero");
         return env.Null();
     }
     if (len > INT16_MAX / ref->size) {
@@ -369,21 +380,6 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
     return type->defn.Value();
 }
 
-static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
-{
-    RG_ASSERT(AlignLen(size, 16) == size);
-    RG_ASSERT(size >= Kibibytes(1));
-
-    // Account for allocator overhead
-    size -= 256;
-
-    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
-    uint8_t *aligned = AlignUp(ptr, 16);
-    Size delta = AlignLen(aligned - ptr, 16);
-
-    return MakeSpan(aligned, size - delta);
-}
-
 static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 {
     for (Size i = 1; i < instance->memories.len; i++) {
@@ -395,8 +391,23 @@ static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(1));
-    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+    mem->stack.len = AsyncStackSize;
+#if defined(_WIN32)
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif defined(__APPLE__)
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+#endif
+    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+
+    mem->heap.len = AsyncHeapSize;
+#ifdef _WIN32
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     if (instance->memories.Available()) {
         instance->memories.Append(mem);
@@ -421,7 +432,15 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, func, mem);
 
-    return call.Run(info);
+    if (!RG_UNLIKELY(call.Prepare(info)))
+        return env.Null();
+
+    if (instance->debug) {
+        call.DumpDebug();
+    }
+    call.Execute();
+
+    return call.Complete();
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -430,7 +449,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     FunctionInfo func;
-    memcpy(&func, info.Data(), RG_SIZE(FunctionInfo));
+    memcpy((void *)&func, info.Data(), RG_SIZE(FunctionInfo));
     func.lib = nullptr;
 
     // This makes variadic calls non-reentrant
@@ -481,7 +500,15 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, &func, mem);
 
-    return call.Run(info);
+    if (!RG_UNLIKELY(call.Prepare(info)))
+        return env.Null();
+
+    if (instance->debug) {
+        call.DumpDebug();
+    }
+    call.Execute();
+
+    return call.Complete();
 }
 
 class AsyncCall: public Napi::AsyncWorker {
@@ -597,10 +624,10 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         return false;
     }
 
-    Size parameters_len = parameters.Length();
+    uint32_t parameters_len = parameters.Length();
 
     if (parameters_len) {
-        Napi::String str = ((Napi::Value)parameters[(uint32_t)(parameters_len - 1)]).As<Napi::String>();
+        Napi::String str = ((Napi::Value)parameters[parameters_len - 1]).As<Napi::String>();
 
         if (str.IsString() && str.Utf8Value() == "...") {
             func->variadic = true;
@@ -788,6 +815,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     ADD_CONVENTION("cdecl", CallConvention::Cdecl);
     ADD_CONVENTION("stdcall", CallConvention::Stdcall);
     ADD_CONVENTION("fastcall", CallConvention::Fastcall);
+    ADD_CONVENTION("thiscall", CallConvention::Thiscall);
 
 #undef ADD_CONVENTION
 
@@ -928,12 +956,46 @@ void FunctionInfo::Unref() const
     }
 }
 
+InstanceMemory::~InstanceMemory()
+{
+#ifdef _WIN32
+    if (stack.ptr) {
+        VirtualFree(stack.ptr, 0, MEM_RELEASE);
+    }
+    if (heap.ptr) {
+        VirtualFree(heap.ptr, 0, MEM_RELEASE);
+    }
+#else
+    if (stack.ptr) {
+        munmap(stack.ptr, stack.len);
+    }
+    if (heap.ptr) {
+        munmap(heap.ptr, heap.len);
+    }
+#endif
+}
+
 InstanceData::InstanceData()
 {
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
-    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(4));
+    mem->stack.len = SyncStackSize;
+#if defined(_WIN32)
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif defined(__APPLE__)
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+#endif
+    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+
+    mem->heap.len = SyncHeapSize;
+#ifdef _WIN32
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     memories.Append(mem);
 }

package/src/ffi.hh

@@ -109,12 +109,14 @@ struct LibraryHolder {
 enum class CallConvention {
     Cdecl,
     Stdcall,
-    Fastcall
+    Fastcall,
+    Thiscall
 };
 static const char *const CallConventionNames[] = {
     "Cdecl",
     "Stdcall",
-    "Fastcall"
+    "Fastcall",
+    "Thiscall"
 };
 
 struct ParameterInfo {
@@ -139,6 +141,11 @@ struct ParameterInfo {
 #elif defined(__i386__) || defined(_M_IX86)
     bool trivial; // Only matters for return value
     bool fast;
+#elif __riscv_xlen == 64
+    bool use_memory;
+    int8_t gpr_count;
+    int8_t vec_count;
+    bool gpr_first; // Only for structs
 #endif
 };
 
@@ -160,9 +167,12 @@ struct FunctionInfo {
     // ABI-specific part
 
     Size args_size;
-#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
+#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64) || defined(__riscv)
     bool forward_fp;
 #endif
+#if defined(__i386__) || defined(_M_IX86)
+    bool fast;
+#endif
 
     ~FunctionInfo();
 
@@ -171,7 +181,7 @@ struct FunctionInfo {
 };
 
 struct InstanceMemory {
-    LinkedAllocator mem_alloc;
+    ~InstanceMemory();
 
     Span<uint8_t> stack;
     Span<uint8_t> heap;

package/src/parser.cc

@@ -38,6 +38,8 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
         out_func->convention = CallConvention::Stdcall;
     } else if (Match("__fastcall")) {
         out_func->convention = CallConvention::Fastcall;
+    } else if (Match("__thiscall")) {
+        out_func->convention = CallConvention::Thiscall;
     }
     out_func->name = ParseIdentifier();
 
@@ -157,9 +159,9 @@ const TypeInfo *PrototypeParser::ParseType()
     }
     if (offset == start) {
         if (offset < tokens.len) {
-            MarkError("Unexpected token '%1', expected identifier", tokens[offset]);
+            MarkError("Unexpected token '%1', expected type", tokens[offset]);
         } else {
-            MarkError("Unexpected end of prototype, expected identifier");
+            MarkError("Unexpected end of prototype, expected type");
         }
         return instance->types_map.FindValue("void", nullptr);
     }
@@ -169,11 +171,21 @@ const TypeInfo *PrototypeParser::ParseType()
     }
     buf.ptr[--buf.len] = 0;
 
-    if (TestStr(buf, "char") && indirect) {
-        buf.RemoveFrom(0);
-        Fmt(&buf, "string");
+    if (indirect) {
+        const TypeInfo *type = instance->types_map.FindValue(buf.ptr, nullptr);
+        PrimitiveKind primitive = type ? type->primitive : PrimitiveKind::Void;
+
+        if (primitive == PrimitiveKind::Int8 || primitive == PrimitiveKind::UInt8) {
+            buf.RemoveFrom(0);
+            Fmt(&buf, "string");
 
-        indirect--;
+            indirect--;
+        } else if (primitive == PrimitiveKind::Int16 || primitive == PrimitiveKind::UInt16) {
+            buf.RemoveFrom(0);
+            Fmt(&buf, "string16");
+
+            indirect--;
+        }
     }
 
     while (buf.len) {

package/src/util.cc

@@ -126,76 +126,45 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
     return match;
 }
 
-class HfaAnalyser {
-    uint32_t primitives;
-    Size count;
-
-public:
-    bool Analyse(const TypeInfo *type, int min, int max);
-
-private:
-    void AnalyseStruct(const TypeInfo *type);
-    void AnalyseArray(const TypeInfo *type);
-};
-
-bool HfaAnalyser::Analyse(const TypeInfo *type, int min, int max)
+static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
-    primitives = 0;
-    count = 0;
-
     if (type->primitive == PrimitiveKind::Record) {
-        AnalyseStruct(type);
+        for (int i = 0; i < count; i++) {
+            for (const RecordMember &member: type->members) {
+                offset = AnalyseFlatRec(member.type, offset, 1, func);
+            }
+        }
     } else if (type->primitive == PrimitiveKind::Array) {
-        AnalyseArray(type);
+        count *= type->size / type->ref->size;
+        offset = AnalyseFlatRec(type->ref, offset, count, func);
     } else {
-        return false;
+        func(type, offset, count);
+        offset += count;
     }
 
-    bool hfa = (count >= min && count <= max && PopCount(primitives) == 1);
-    return hfa;
+    return offset;
 }
 
-void HfaAnalyser::AnalyseStruct(const TypeInfo *type)
+int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-
-    for (const RecordMember &member: type->members) {
-        if (member.type->primitive == PrimitiveKind::Record) {
-            AnalyseStruct(member.type);
-        } else if (member.type->primitive == PrimitiveKind::Array) {
-            AnalyseArray(member.type);
-        } else if (member.type->primitive == PrimitiveKind::Float32 ||
-                   member.type->primitive == PrimitiveKind::Float64) {
-            primitives |= 1u << (int)member.type->primitive;
-            count++;
-        } else {
-            primitives = UINT_MAX;
-            return;
-        }
-    }
+    return AnalyseFlatRec(type, 0, 1, func);
 }
 
-void HfaAnalyser::AnalyseArray(const TypeInfo *type)
+int IsHFA(const TypeInfo *type, int min, int max)
 {
-    RG_ASSERT(type->primitive == PrimitiveKind::Array);
-
-    if (type->ref->primitive == PrimitiveKind::Record) {
-        AnalyseStruct(type->ref);
-    } else if (type->ref->primitive == PrimitiveKind::Array) {
-        AnalyseArray(type->ref);
-    } else if (type->ref->primitive == PrimitiveKind::Float32 ||
-               type->ref->primitive == PrimitiveKind::Float64) {
-        primitives |= 1u << (int)type->ref->primitive;
-        count += type->size / type->ref->size;;
-    } else {
-        primitives = UINT_MAX;
-    }
-}
+    uint32_t primitives = 0;
+    int count = 0;
 
-bool IsHFA(const TypeInfo *type, int min, int max)
-{
-    HfaAnalyser analyser;
-    return analyser.Analyse(type, min, max);
+    count = AnalyseFlat(type, [&](const TypeInfo *type, int, int) {
+        if (IsFloat(type)) {
+            primitives |= 1u << (int)type->primitive;
+        } else {
+            primitives = UINT32_MAX;
+        }
+    });
+
+    bool hfa = (count >= min && count <= max && PopCount(primitives) == 1);
+    return hfa ? count : 0;
 }
 
 }

package/src/util.hh

@@ -53,6 +53,20 @@ static inline T *AlignDown(T *ptr, Size align)
     return (T *)aligned;
 }
 
+static inline bool IsInteger(const TypeInfo *type)
+{
+    bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&
+                    (int)type->primitive <= (int)PrimitiveKind::UInt64);
+    return integer;
+}
+
+static inline bool IsFloat(const TypeInfo *type)
+{
+    bool fp = (type->primitive == PrimitiveKind::Float32 ||
+               type->primitive == PrimitiveKind::Float64);
+    return fp;
+}
+
 const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions = nullptr);
 const TypeInfo *GetPointerType(InstanceData *instance, const TypeInfo *type);
 
@@ -89,6 +103,8 @@ T CopyNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
-bool IsHFA(const TypeInfo *type, int min, int max);
+int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
+
+int IsHFA(const TypeInfo *type, int min, int max);
 
 }

package/test/CMakeLists.txt

@@ -12,7 +12,7 @@
 # along with this program. If not, see https://www.gnu.org/licenses/.
 
 cmake_minimum_required(VERSION 3.12)
-project(koffi C CXX)
+project(koffi_test C CXX)
 
 if(NOT TARGET koffi)
     add_subdirectory(.. koffi)
@@ -42,6 +42,9 @@ else()
                                           -Wno-unused-function -Wno-missing-field-initializers
                                           -Wno-unused-value -Wno-implicit-fallthrough -Wno-stringop-overflow
                                           -Wno-unused-result)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(raylib PRIVATE -Wno-unknown-warning-option)
+    endif()
 endif()
 
 if(WIN32)

package/test/misc.c

@@ -75,6 +75,15 @@ typedef struct Double3 {
     } s;
 } Double3;
 
+typedef struct FloatInt {
+    float f;
+    int i;
+} FloatInt;
+typedef struct IntFloat {
+    int i;
+    float f;
+} IntFloat;
+
 typedef struct IJK1 { int8_t i; int8_t j; int8_t k; } IJK1;
 typedef struct IJK4 { int32_t i; int32_t j; int32_t k; } IJK4;
 typedef struct IJK8 { int64_t i; int64_t j; int64_t k; } IJK8;
@@ -188,6 +197,11 @@ EXPORT Float2 PackFloat2(float a, float b, Float2 *out)
     return ret;
 }
 
+EXPORT Float2 ThroughFloat2(Float2 f2)
+{
+    return f2;
+}
+
 EXPORT Float3 PackFloat3(float a, float b, float c, Float3 *out)
 {
     Float3 ret;
@@ -228,6 +242,26 @@ EXPORT Double3 PackDouble3(double a, double b, double c, Double3 *out)
     return ret;
 }
 
+EXPORT IntFloat ReverseFloatInt(FloatInt sfi)
+{
+    IntFloat sif;
+
+    sif.i = (int)sfi.f;
+    sif.f = (float)sfi.i;
+
+    return sif;
+}
+
+EXPORT FloatInt ReverseIntFloat(IntFloat sif)
+{
+    FloatInt sfi;
+
+    sfi.i = (int)sif.f;
+    sfi.f = (float)sif.i;
+
+    return sfi;
+}
+
 EXPORT int64_t ConcatenateToInt1(int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f,
                                  int8_t g, int8_t h, int8_t i, int8_t j, int8_t k, int8_t l)
 {

package/vendor/_patches/glfw_001_fix_openbsd_xlib_soname.patch

@@ -0,0 +1,145 @@
+diff --git a/koffi/vendor/raylib/src/external/glfw/src/egl_context.c b/koffi/vendor/raylib/src/external/glfw/src/egl_context.c
+index 975c67be..4edd3dac 100644
+--- a/koffi/vendor/raylib/src/external/glfw/src/egl_context.c
++++ b/koffi/vendor/raylib/src/external/glfw/src/egl_context.c
+@@ -316,6 +316,8 @@ GLFWbool _glfwInitEGL(void)
+         "libEGL.dylib",
+ #elif defined(__CYGWIN__)
+         "libEGL-1.so",
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++        "libEGL.so",
+ #else
+         "libEGL.so.1",
+ #endif
+@@ -686,6 +688,8 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
+             "libGLES_CM.dll",
+ #elif defined(_GLFW_COCOA)
+             "libGLESv1_CM.dylib",
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++            "libGLESv1_CM.so",
+ #else
+             "libGLESv1_CM.so.1",
+             "libGLES_CM.so.1",
+@@ -703,6 +707,8 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
+             "libGLESv2.dylib",
+ #elif defined(__CYGWIN__)
+             "libGLESv2-2.so",
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++            "libGLESv2.so",
+ #else
+             "libGLESv2.so.2",
+ #endif
+diff --git a/koffi/vendor/raylib/src/external/glfw/src/osmesa_context.c b/koffi/vendor/raylib/src/external/glfw/src/osmesa_context.c
+index 70e8675b..62c31678 100644
+--- a/koffi/vendor/raylib/src/external/glfw/src/osmesa_context.c
++++ b/koffi/vendor/raylib/src/external/glfw/src/osmesa_context.c
+@@ -124,6 +124,8 @@ GLFWbool _glfwInitOSMesa(void)
+         "libOSMesa.8.dylib",
+ #elif defined(__CYGWIN__)
+         "libOSMesa-8.so",
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++        "libOSMesa.so",
+ #else
+         "libOSMesa.so.8",
+         "libOSMesa.so.6",
+diff --git a/koffi/vendor/raylib/src/external/glfw/src/vulkan.c b/koffi/vendor/raylib/src/external/glfw/src/vulkan.c
+index b5340520..7eb4fdf0 100644
+--- a/koffi/vendor/raylib/src/external/glfw/src/vulkan.c
++++ b/koffi/vendor/raylib/src/external/glfw/src/vulkan.c
+@@ -59,6 +59,8 @@ GLFWbool _glfwInitVulkan(int mode)
+     _glfw.vk.handle = _glfw_dlopen("libvulkan.1.dylib");
+     if (!_glfw.vk.handle)
+         _glfw.vk.handle = _glfwLoadLocalVulkanLoaderNS();
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.vk.handle = _glfw_dlopen("libvulkan.so");
+ #else
+     _glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
+ #endif
+diff --git a/koffi/vendor/raylib/src/external/glfw/src/x11_init.c b/koffi/vendor/raylib/src/external/glfw/src/x11_init.c
+index fc9ac427..c2233f56 100644
+--- a/koffi/vendor/raylib/src/external/glfw/src/x11_init.c
++++ b/koffi/vendor/raylib/src/external/glfw/src/x11_init.c
+@@ -601,7 +601,11 @@ static void detectEWMH(void)
+ //
+ static GLFWbool initExtensions(void)
+ {
++#if defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.vidmode.handle = _glfw_dlopen("libXxf86vm.so");
++#else
+     _glfw.x11.vidmode.handle = _glfw_dlopen("libXxf86vm.so.1");
++#endif
+     if (_glfw.x11.vidmode.handle)
+     {
+         _glfw.x11.vidmode.QueryExtension = (PFN_XF86VidModeQueryExtension)
+@@ -621,6 +625,8 @@ static GLFWbool initExtensions(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.xi.handle = _glfw_dlopen("libXi-6.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.xi.handle = _glfw_dlopen("libXi.so");
+ #else
+     _glfw.x11.xi.handle = _glfw_dlopen("libXi.so.6");
+ #endif
+@@ -651,6 +657,8 @@ static GLFWbool initExtensions(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.randr.handle = _glfw_dlopen("libXrandr-2.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.randr.handle = _glfw_dlopen("libXrandr.so");
+ #else
+     _glfw.x11.randr.handle = _glfw_dlopen("libXrandr.so.2");
+ #endif
+@@ -743,6 +751,8 @@ static GLFWbool initExtensions(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor-1.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor.so");
+ #else
+     _glfw.x11.xcursor.handle = _glfw_dlopen("libXcursor.so.1");
+ #endif
+@@ -764,6 +774,8 @@ static GLFWbool initExtensions(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama-1.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama.so");
+ #else
+     _glfw.x11.xinerama.handle = _glfw_dlopen("libXinerama.so.1");
+ #endif
+@@ -817,6 +829,8 @@ static GLFWbool initExtensions(void)
+     {
+ #if defined(__CYGWIN__)
+         _glfw.x11.x11xcb.handle = _glfw_dlopen("libX11-xcb-1.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++        _glfw.x11.x11xcb.handle = _glfw_dlopen("libX11-xcb.so");
+ #else
+         _glfw.x11.x11xcb.handle = _glfw_dlopen("libX11-xcb.so.1");
+ #endif
+@@ -830,6 +844,8 @@ static GLFWbool initExtensions(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.xrender.handle = _glfw_dlopen("libXrender-1.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.xrender.handle = _glfw_dlopen("libXrender.so");
+ #else
+     _glfw.x11.xrender.handle = _glfw_dlopen("libXrender.so.1");
+ #endif
+@@ -857,6 +873,8 @@ static GLFWbool initExtensions(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.xshape.handle = _glfw_dlopen("libXext-6.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.xshape.handle = _glfw_dlopen("libXext.so");
+ #else
+     _glfw.x11.xshape.handle = _glfw_dlopen("libXext.so.6");
+ #endif
+@@ -1120,6 +1138,8 @@ int _glfwPlatformInit(void)
+ 
+ #if defined(__CYGWIN__)
+     _glfw.x11.xlib.handle = _glfw_dlopen("libX11-6.so");
++#elif defined(__OpenBSD__) || defined(__NetBSD__)
++    _glfw.x11.xlib.handle = _glfw_dlopen("libX11.so");
+ #else
+     _glfw.x11.xlib.handle = _glfw_dlopen("libX11.so.6");
+ #endif

package/vendor/libcc/libcc.cc

@@ -3745,7 +3745,7 @@ static std::atomic_bool flag_interrupt = false;
 static std::atomic_bool explicit_interrupt = false;
 static int interrupt_pfd[2] = {-1, -1};
 
-static void SetSignalHandler(int signal, struct sigaction *prev, void (*func)(int))
+void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev)
 {
     struct sigaction action = {};
 
@@ -3786,10 +3786,10 @@ RG_INIT(SetupDefaultHandlers)
     int ret = setpgid(0, 0);
     RG_ASSERT(!ret);
 
-    SetSignalHandler(SIGINT, nullptr, DefaultSignalHandler);
-    SetSignalHandler(SIGTERM, nullptr, DefaultSignalHandler);
-    SetSignalHandler(SIGHUP, nullptr, DefaultSignalHandler);
-    SetSignalHandler(SIGPIPE, nullptr, [](int) {});
+    SetSignalHandler(SIGINT, DefaultSignalHandler);
+    SetSignalHandler(SIGTERM, DefaultSignalHandler);
+    SetSignalHandler(SIGHUP, DefaultSignalHandler);
+    SetSignalHandler(SIGPIPE, [](int) {});
 }
 
 RG_EXIT(TerminateChildren)
@@ -3797,7 +3797,7 @@ RG_EXIT(TerminateChildren)
     pid_t pid = getpid();
     RG_ASSERT(pid > 1);
 
-    SetSignalHandler(SIGTERM, nullptr, [](int) {});
+    SetSignalHandler(SIGTERM, [](int) {});
     kill(-pid, SIGTERM);
 }
 
@@ -4168,7 +4168,7 @@ WaitForResult WaitForInterrupt(int64_t timeout)
     static std::atomic_bool message = false;
 
     flag_interrupt = true;
-    SetSignalHandler(SIGUSR1, nullptr, [](int) { message = true; });
+    SetSignalHandler(SIGUSR1, [](int) { message = true; });
 
     if (timeout >= 0) {
         struct timespec ts;