koffi 1.1.3 → 1.1.4

package/src/call.cc

@@ -21,7 +21,7 @@
 namespace RG {
 
 CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem)
-    : env(env), instance(instance), func(func), debug(instance->debug),
+    : env(env), instance(instance), func(func),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
     mem->depth++;
@@ -565,13 +565,11 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *t
                 obj.Set(member.name, value);
             } break;
             case PrimitiveKind::Float32: {
-                float f;
-                memcpy(&f, src, 4);
+                float f = *(float *)src;
                 obj.Set(member.name, Napi::Number::New(env, (double)f));
             } break;
             case PrimitiveKind::Float64: {
-                double d;
-                memcpy(&d, src, 8);
+                double d = *(double *)src;
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
         }
@@ -762,19 +760,6 @@ Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t
     RG_UNREACHABLE();
 }
 
-Napi::Value CallData::Run(const Napi::CallbackInfo &info)
-{
-    if (!RG_UNLIKELY(Prepare(info)))
-        return env.Null();
-
-    if (debug) {
-        DumpDebug();
-    }
-    Execute();
-
-    return Complete();
-}
-
 static void DumpMemory(const char *type, Span<const uint8_t> bytes)
 {
     if (bytes.len) {
@@ -805,6 +790,9 @@ void CallData::DumpDebug() const
     }
     PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
 
+    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
+    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
+
     DumpMemory("Stack", stack);
     DumpMemory("Heap", heap);
 }

package/src/call.hh

@@ -34,16 +34,12 @@ class CallData {
     InstanceData *instance;
     const FunctionInfo *func;
 
-    bool debug;
-
     InstanceMemory *mem;
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
     LocalArray<OutObject, MaxOutParameters> out_objects;
-
-    Span<uint8_t> heap;
-    Span<uint8_t> stack;
+    uint8_t *sp;
 
     union {
         uint32_t u32;
@@ -65,15 +61,13 @@ public:
     void Execute();
     Napi::Value Complete();
 
-    Napi::Value Run(const Napi::CallbackInfo &info);
-
     void DumpDebug() const;
 
 private:
     template <typename T = void>
-    bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
+    bool AllocStack(Size size, Size align, T **out_ptr);
     template <typename T = void>
-    bool AllocHeap(Size size, Size align, T **out_ptr = nullptr);
+    bool AllocHeap(Size size, Size align, T **out_ptr);
 
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
@@ -86,7 +80,7 @@ private:
 };
 
 template <typename T>
-bool CallData::AllocStack(Size size, Size align, T **out_ptr)
+inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 {
     uint8_t *ptr = AlignDown(mem->stack.end() - size, align);
     Size delta = mem->stack.end() - ptr;
@@ -96,20 +90,18 @@ bool CallData::AllocStack(Size size, Size align, T **out_ptr)
         return false;
     }
 
-    if (debug) {
-        memset(ptr, 0, delta);
-    }
+#ifdef RG_DEBUG
+    memset(ptr, 0, delta);
+#endif
 
     mem->stack.len -= delta;
 
-    if (out_ptr) {
-        *out_ptr = (T *)ptr;
-    }
+    *out_ptr = (T *)ptr;
     return true;
 }
 
 template <typename T>
-bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
+inline bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
 {
     uint8_t *ptr = AlignUp(mem->heap.ptr, align);
     Size delta = size + (ptr - mem->heap.ptr);
@@ -119,16 +111,14 @@ bool CallData::AllocHeap(Size size, Size align, T **out_ptr)
         return false;
     }
 
-    if (debug) {
-        memset(mem->heap.ptr, 0, (size_t)delta);
-    }
+#ifdef RG_DEBUG
+    memset(mem->heap.ptr, 0, (size_t)delta);
+#endif
 
     mem->heap.ptr += delta;
     mem->heap.len -= delta;
 
-    if (out_ptr) {
-        *out_ptr = (T *)ptr;
-    }
+    *out_ptr = (T *)ptr;
     return true;
 }
 

package/src/ffi.cc

@@ -106,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
@@ -296,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) {
@@ -427,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)
@@ -487,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 {

package/src/ffi.hh

@@ -141,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
 };
 
@@ -162,7 +167,7 @@ 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)
@@ -176,8 +181,6 @@ struct FunctionInfo {
 };
 
 struct InstanceMemory {
-    LinkedAllocator mem_alloc;
-
     Span<uint8_t> stack;
     Span<uint8_t> heap;
 

package/src/parser.cc

@@ -159,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);
     }

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/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.hh

@@ -94,7 +94,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__)
+#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || __riscv_xlen == 64
     typedef int64_t Size;
     #define RG_SIZE_MAX INT64_MAX
 #elif defined(_WIN32) || defined(__APPLE__) || defined(__unix__)
@@ -116,6 +116,7 @@ extern "C" const char *FelixCompiler;
 #if ULLONG_MAX != 0xFFFFFFFFFFFFFFFFull
     #error This code base is not designed to support non-64-bits long long types
 #endif
+static_assert(sizeof(double) == 8, "This code base is not designed to support single-precision double floats");
 
 #define RG_STRINGIFY_(a) #a
 #define RG_STRINGIFY(a) RG_STRINGIFY_(a)
@@ -196,6 +197,8 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
     #define RG_DEBUG_BREAK() __asm__ __volatile__(".inst 0xd4200000")
 #elif defined(__arm__)
     #define RG_DEBUG_BREAK() __asm__ __volatile__(".inst 0xe7f001f0")
+#elif defined(__riscv)
+    #define RG_DEBUG_BREAK() __asm__ __volatile__("ebreak")
 #endif
 
 #define RG_CRITICAL(Cond, ...) \

package/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

package/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",

package/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