koffi 0.9.33 → 0.9.36

package/CMakeLists.txt

@@ -30,6 +30,7 @@ set(KOFFI_SRC
     src/call_x64_win.cc
     src/call_x86.cc
     src/ffi.cc
+    src/parser.cc
     src/util.cc
     vendor/libcc/libcc.cc
 )
@@ -54,7 +55,7 @@ endif()
 add_node_addon(NAME koffi SOURCES ${KOFFI_SRC})
 target_include_directories(koffi PRIVATE . vendor/node-addon-api)
 
-target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS)
+target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=8)
 if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)

package/README.md

@@ -1,14 +1,14 @@
 # Table of contents
 
 - [Introduction](#introduction)
+- [Benchmarks](#benchmarks)
+  * [atoi results](#atoi-results)
+  * [Raylib results](#raylib-results)
 - [Installation](#installation)
   * [Windows](#windows)
   * [Other platforms](#other-platforms)
 - [Get started](#get-started)
 - [Tests](#tests)
-- [Benchmarks](#benchmarks)
-  * [atoi results](#atoi-results)
-  * [Raylib results](#raylib-results)
 
 # Introduction
 
@@ -27,12 +27,13 @@ The following platforms __are officially supported and tested__ at the moment:
 * FreeBSD ARM64 Little Endian
 * macOS x86_64
 
-The following platforms will __soon be officially supported__:
+The following platforms will __soon be officially supported__, when I can get my hand on a machine...:
 
 * macOS ARM64
 
 The following platforms __may be supported__ but are not tested:
 
+* Linux ARM32 (full software FP) Little Endian
 * NetBSD x86_64
 * NetBSD ARM64
 * OpenBSD x86_64
@@ -40,6 +41,65 @@ The following platforms __may be supported__ but are not tested:
 
 This is still in development, bugs are to expected. More tests will come in the near future.
 
+# Benchmarks
+
+In order to run it, go to `koffi/benchmark` and run `../../cnoke/cnoke.js` (or `node ..\..\cnoke\cnoke.js` on Windows) before doing anything else.
+
+Once this is done, you can execute each implementation, e.g. `build/atoi_cc` or `./atoi_koffi.js`. You can optionally define a custom number of iterations, e.g. `./atoi_koffi.js 10000000`.
+
+## atoi results
+
+This test is based around repeated calls to a simple standard C function atoi, and has three implementations:
+- the first one is the reference, it calls atoi through an N-API module, and is close to the theoretical limit of a perfect (no overhead) Node.js > C FFI implementation.
+- the second one calls atoi through Koffi
+- the third one uses the official Node.js FFI implementation, node-ffi-napi
+
+Because atoi is a small call, the FFI overhead is clearly visible.
+
+### Linux
+
+The results below were measured on my x86_64 Linux machine (AMD® Ryzen™ 7 5800H 16G):
+
+Benchmark     | Iterations | Total time  | Overhead
+------------- | ---------- | ----------- | ----------
+atoi_napi     | 20000000   | 1.10s       | (baseline)
+atoi_koffi    | 20000000   | 1.91s       | x1.73
+atoi_node_ffi | 20000000   | 640.49s     | x582
+
+### Windows
+
+The results below were measured on my x86_64 Windows machine (AMD® Ryzen™ 7 5800H 16G):
+
+Benchmark     | Iterations | Total time  | Overhead
+------------- | ---------- | ----------- | ----------
+atoi_napi     | 20000000   | 1.94s       | (baseline)
+atoi_koffi    | 20000000   | 3.15s       | x1.62
+atoi_node_ffi | 20000000   | 640.49s     | x242
+
+## Raylib results
+
+This benchmark uses the CPU-based image drawing functions in Raylib. The calls are much heavier than in the atoi benchmark, thus the FFI overhead is reduced. In this implemenetation, the baseline is a full C++ version of the code.
+
+### Linux
+
+The results below were measured on my x86_64 Linux machine (AMD® Ryzen™ 7 5800H 16G):
+
+Benchmark       | Iterations | Total time  | Overhead
+--------------- | ---------- | ----------- | ----------
+raylib_cc       | 100        | 4.14s       | (baseline)
+raylib_koffi    | 100        | 6.25s       | x1.51
+raylib_node_ffi | 100        | 27.13s      | x6.55
+
+### Windows
+
+The results below were measured on my x86_64 Windows machine (AMD® Ryzen™ 7 5800H 16G):
+
+Benchmark       | Iterations | Total time  | Overhead
+--------------- | ---------- | ----------- | ----------
+raylib_cc       | 100        | 8.39s       | (baseline)
+raylib_koffi    | 100        | 11.51s      | x1.37
+raylib_node_ffi | 100        | 31.47s      | x3.8
+
 # Installation
 
 ## Windows
@@ -136,17 +196,20 @@ const Font = koffi.struct('Font', {
 // Fix the path to Raylib DLL if needed
 let lib = koffi.load('build/raylib' + koffi.extension);
 
-const InitWindow = lib.cdecl('InitWindow', 'void', ['int', 'int', 'string']);
-const SetTargetFPS = lib.cdecl('SetTargetFPS', 'void', ['int']);
-const GetScreenWidth = lib.cdecl('GetScreenWidth', 'int', []);
-const GetScreenHeight = lib.cdecl('GetScreenHeight', 'int', []);
-const ClearBackground = lib.cdecl('ClearBackground', 'void', [Color]);
-const BeginDrawing = lib.cdecl('BeginDrawing', 'void', []);
-const EndDrawing = lib.cdecl('EndDrawing', 'void', []);
-const WindowShouldClose = lib.cdecl('WindowShouldClose', 'bool', []);
-const GetFontDefault = lib.cdecl('GetFontDefault', Font, []);
-const MeasureTextEx = lib.cdecl('MeasureTextEx', Vector2, [Font, 'string', 'float', 'float']);
-const DrawTextEx = lib.cdecl('DrawTextEx', 'void', [Font, 'string', Vector2, 'float', 'float', Color]);
+// Classic function declaration
+const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'string']);
+const SetTargetFPS = lib.func('SetTargetFPS', 'void', ['int']);
+const GetScreenWidth = lib.func('GetScreenWidth', 'int', []);
+const GetScreenHeight = lib.func('GetScreenHeight', 'int', []);
+const ClearBackground = lib.func('ClearBackground', 'void', [Color]);
+
+// Prototype parser
+const BeginDrawing = lib.func('void BeginDrawing()');
+const EndDrawing = lib.func('void EndDrawing()');
+const WindowShouldClose = lib.func('void WindowShouldClose(bool)');
+const GetFontDefault = lib.func('Font GetFontDefault()');
+const MeasureTextEx = lib.func('Vector2 MeasureTextEx(Font, const char *, float, float)');
+const DrawTextEx = lib.func('void DrawTextEx(Font font, const char *text, Vector2 pos, float size, float spacing, Color tint)');
 
 InitWindow(800, 600, 'Test Raylib');
 SetTargetFPS(60);
@@ -200,13 +263,13 @@ MessageBoxA(null, 'Hello', 'Foobar', MB_ICONINFORMATION);
 
 Koffi is tested on multiple architectures using emulated (accelerated when possible) QEMU machines. First, you need to install qemu packages, such as `qemu-system` (or even `qemu-system-gui`) on Ubuntu.
 
-These machines are not included directly in this repository (for license and size reasons), but they are available here: https://koromix.dev/files/koffi/
+These machines are not included directly in this repository (for license and size reasons), but they are available here: https://koromix.dev/files/koffi/machines/
 
 For example, if you want to run the tests on Debian ARM64, run the following commands:
 
 ```sh
 cd luigi/koffi/test/
-wget -q -O- https://koromix.dev/files/koffi/qemu_debian_arm64.tar.zst | zstd -d | tar xv
+wget -q -O- https://koromix.dev/files/koffi/machines/qemu_debian_arm64.tar.zst | zstd -d | tar xv
 sha256sum -c --ignore-missing registry/sha256sum.txt
 ```
 
@@ -251,94 +314,4 @@ Each machine is configured to run a VNC server available locally, which you can
 
 ```sh
 node test.js info debian_x64
-```
-
-# Benchmarks
-
-At this stage, two benchmarks are implemented:
-* The first one is based around repeated calls to atoi, and has four implementations: one in C++, one calling atoi through an NAPI module, one using Koffi, and one with node-ffi-napi. This is a simple function, thus the JS and FFI overhead is clearly visible.
-* The second one is based around Raylib, and will execute much more heavier functions repeatdly. Also in three versions: Koffi, node-ffi-napi and C code.
-
-In order to run it, go to `koffi/benchmark` and run `../../cnoke/cnoke.js` (or `node ..\..\cnoke\cnoke.js` on Windows) before doing anything else.
-
-Once this is done, you can execute each implementation, e.g. `build/atoi_cc` or `./atoi_koffi.js`. You can optionally define a custom number of iterations, e.g. `./atoi_koffi.js 10000000`.
-
-## atoi results
-
-Here are some results from 2022-04-24 on Linux on my machine (AMD® Ryzen™ 7 5800H 16G):
-
-```sh
-$ build/atoi_cc
-Iterations: 20000000
-Time: 0.24s
-
-$ ./atoi_napi.js
-Iterations: 20000000
-Time: 1.10s
-
-$ ./atoi_koffi.js
-Iterations: 20000000
-Time: 1.91s
-
-# Note: the Node-FFI version does a few setTimeout calls to force the GC to run (around 20
-# for the example below), without which Node will consume all memory because the GC never appears
-# to run, or not enough. It's not ideal but on the other hand it counts as another limitation
-# to Node-FFI performance.
-$ ./atoi_node_ffi.js
-Iterations: 20000000
-Time: 640.49s
-```
-
-And on Windows on the same machine (AMD® Ryzen™ 7 5800H 16G):
-
-```sh
-$ build\atoi_cc.exe
-Iterations: 20000000
-Time: 0.25s
-
-$ node atoi_napi.js
-Iterations: 20000000
-Time: 1.94s
-
-$ node atoi_koffi.js
-Iterations: 20000000
-Time: 3.15s
-
-$ node atoi_node_ffi.js
-Iterations: 20000000
-Time: 267.20s
-```
-
-## Raylib results
-
-Here are some results from 2022-04-24 on Linux on my machine (AMD® Ryzen™ 7 5800H 16G):
-
-```sh
-$ build/raylib_cc
-Iterations: 100
-Time: 4.14s
-
-$ ./raylib_koffi.js
-Iterations: 100
-Time: 6.25s
-
-$ ./raylib_node_ffi.js
-Iterations: 100
-Time: 27.13s
-```
-
-And on Windows on the same machine (AMD® Ryzen™ 7 5800H 16G):
-
-```sh
-$ build\raylib_cc.exe
-Iterations: 100
-Time: 8.39s
-
-$ node raylib_koffi.js
-Iterations: 100
-Time: 11.51s
-
-$ node raylib_node_ffi.js
-Iterations: 100
-Time: 32.47s
-```
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "0.9.33",
+  "version": "0.9.36",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -18,12 +18,12 @@
   "author": "Niels Martignène <niels.martignene@protonmail.com>",
   "main": "src/index.js",
   "scripts": {
-    "install": "cnoke",
+    "install": "cnoke --prebuild https://koromix.dev/files/koffi/builds/{{version}}/koffi_{{platform}}_{{arch}}.tar.gz",
     "test": "node test/test.js"
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cnoke": "^1.0.1"
+    "cnoke": "^1.0.2"
   },
   "devDependencies": {
     "chalk": "^4.1.2",
@@ -31,7 +31,8 @@
     "minimatch": "^5.0.1",
     "node-ssh": "^12.0.3",
     "ref-napi": "^3.0.3",
-    "ref-struct-di": "^1.1.1"
+    "ref-struct-di": "^1.1.1",
+    "tar": "^6.1.11"
   },
   "files": [
     "src",

package/src/call_arm32.cc

@@ -39,6 +39,7 @@ extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
 
 static bool IsHFA(const TypeInfo *type)
 {
+#ifdef __ARM_PCS_VFP
     if (type->primitive != PrimitiveKind::Record)
         return false;
 
@@ -54,6 +55,9 @@ static bool IsHFA(const TypeInfo *type)
     }
 
     return true;
+#else
+    return false;
+#endif
 }
 
 bool AnalyseFunction(InstanceData *, FunctionInfo *func)
@@ -107,17 +111,23 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
             case PrimitiveKind::Float64: {
                 Size need = param.type->size / 4;
 
-                if (param.variadic) {
-                    if (need <= gpr_avail) {
-                        param.gpr_count = need;
-                        gpr_avail -= need;
+#ifdef __ARM_PCS_VFP
+                bool vfp = !param.variadic;
+#else
+                bool vfp = false;
+#endif
+
+                if (vfp) {
+                    if (need <= vec_avail) {
+                        param.vec_count = need;
+                        vec_avail -= need;
                     } else {
                         started_stack = true;
                     }
                 } else {
-                    if (need <= vec_avail) {
-                        param.vec_count = need;
-                        vec_avail -= need;
+                    if (need <= gpr_avail) {
+                        param.gpr_count = need;
+                        gpr_avail -= need;
                     } else {
                         started_stack = true;
                     }
@@ -136,7 +146,7 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                         vec_avail = 0;
                         started_stack = true;
                     }
-                } else if (param.type->size) {
+                } else {
                     int gpr_count = (param.type->size + 3) / 4;
 
                     if (gpr_count <= gpr_avail) {
@@ -384,8 +394,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_arm64.cc

@@ -353,8 +353,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_x64_sysv.cc

@@ -323,8 +323,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_x64_win.cc

@@ -157,8 +157,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_x86.cc

@@ -65,7 +65,7 @@ bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
     func->args_size = params_size + 4 * !func->ret.trivial;
 
     switch (func->convention) {
-        case CallConvention::Default: {
+        case CallConvention::Cdecl: {
             func->decorated_name = Fmt(&instance->str_alloc, "_%1", func->name).ptr;
         } break;
         case CallConvention::Stdcall: {
@@ -201,8 +201,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/ffi.cc

@@ -14,6 +14,7 @@
 #include "vendor/libcc/libcc.hh"
 #include "ffi.hh"
 #include "call.hh"
+#include "parser.hh"
 #include "util.hh"
 
 #ifdef _WIN32
@@ -182,23 +183,8 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
     if (!ref)
         return env.Null();
 
-    char name_buf[256];
-    Fmt(name_buf, "%1%2*", ref->name, ref->primitive == PrimitiveKind::Pointer ? "" : " ");
-
-    TypeInfo *type = instance->types_map.FindValue(name_buf, nullptr);
-
-    if (!type) {
-        type = instance->types.AppendDefault();
-
-        type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
-
-        type->primitive = PrimitiveKind::Pointer;
-        type->size = RG_SIZE(void *);
-        type->align = RG_SIZE(void *);
-        type->ref = ref;
-
-        instance->types_map.Set(type);
-    }
+    TypeInfo *type = (TypeInfo *)GetPointerType(instance, ref);
+    RG_ASSERT(type);
 
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
     SetValueTag(instance, external, &TypeInfoMarker);
@@ -284,7 +270,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    for (Size i = func.parameters.len; i < info.Length(); i += 2) {
+    for (Size i = func.parameters.len; i < (Size)info.Length(); i += 2) {
         ParameterInfo param = {};
 
         param.type = ResolveType(instance, info[i], &param.directions);
@@ -316,38 +302,33 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     return TranslateCall(instance, &func, info);
 }
 
-static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention, bool variadic)
+static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
+                                 Napi::Array parameters, FunctionInfo *func)
 {
-    Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-    LibraryHolder *lib = (LibraryHolder *)info.Data();
 
-    if (info.Length() < 3) {
-        ThrowError<Napi::TypeError>(env, "Expected 3 or 4 arguments, not %1", info.Length());
-        return env.Null();
+#ifdef _WIN32
+    if (!name.IsString() && !name.IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
+        return false;
     }
-    if (!info[0].IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for filename, expected string", GetValueType(instance, info[0]));
-        return env.Null();
+#else
+    if (!name.IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, name));
+        return false;
     }
+#endif
 
-    FunctionInfo *func = new FunctionInfo();
-    RG_DEFER_N(func_guard) { delete func; };
-
-    std::string name = ((Napi::Value)info[0u]).As<Napi::String>();
-    func->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
-    func->lib = lib->Ref();
-    func->convention = convention;
+    func->name = DuplicateString(std::string(name).c_str(), &instance->str_alloc).ptr;
 
-    func->ret.type = ResolveType(instance, info[1u]);
+    func->ret.type = ResolveType(instance, ret);
     if (!func->ret.type)
-        return env.Null();
-    if (!((Napi::Value)info[2u]).IsArray()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, (Napi::Value)info[1u]), func->name);
-        return env.Null();
+        return false;
+    if (!parameters.IsArray()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), func->name);
+        return false;
     }
 
-    Napi::Array parameters = ((Napi::Value)info[2u]).As<Napi::Array>();
     Size parameters_len = parameters.Length();
 
     if (parameters_len) {
@@ -357,11 +338,6 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
             func->variadic = true;
             parameters_len--;
         }
-
-        if (!variadic && func->variadic) {
-            LogError("Call convention '%1' does not support variadic functions, ignoring");
-            func->convention = CallConvention::Default;
-        }
     }
 
     for (uint32_t j = 0; j < parameters_len; j++) {
@@ -369,19 +345,19 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
 
         param.type = ResolveType(instance, parameters[j], &param.directions);
         if (!param.type)
-            return env.Null();
+            return false;
         if (param.type->primitive == PrimitiveKind::Void) {
             ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
-            return env.Null();
+            return false;
         }
 
         if (func->parameters.len >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
-            return env.Null();
+            return false;
         }
         if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
-            return env.Null();
+            return false;
         }
 
         param.offset = j;
@@ -389,6 +365,40 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         func->parameters.Append(param);
     }
 
+    return true;
+}
+
+static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    LibraryHolder *lib = (LibraryHolder *)info.Data();
+
+    FunctionInfo *func = new FunctionInfo();
+    RG_DEFER_N(func_guard) { delete func; };
+
+    func->lib = lib->Ref();
+    func->convention = convention;
+
+    if (info.Length() >= 3) {
+        if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
+            return env.Null();
+    } else if (info.Length() >= 1) {
+        PrototypeParser parser(env);
+
+        if (!parser.Parse(info[0u].As<Napi::String>(), func))
+            return env.Null();
+    } else {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
+        return env.Null();
+    }
+
+    if (func->convention != CallConvention::Cdecl && func->variadic) {
+        LogError("Call convention '%1' does not support variadic functions, ignoring",
+                 CallConventionNames[(int)func->convention]);
+        func->convention = CallConvention::Cdecl;
+    }
+
     if (!AnalyseFunction(instance, func))
         return env.Null();
     if (func->variadic) {
@@ -397,11 +407,18 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
 #ifdef _WIN32
-    if (func->decorated_name) {
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
-    }
-    if (!func->func) {
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, func->name);
+    if (info[0].IsString()) {
+        if (func->decorated_name) {
+            func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
+        }
+        if (!func->func) {
+            func->func = (void *)GetProcAddress((HMODULE)lib->module, func->name);
+        }
+    } else {
+        uint16_t ordinal = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
+
+        func->decorated_name = nullptr;
+        func->func = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)ordinal);
     }
 #else
     if (func->decorated_name) {
@@ -417,7 +434,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
     Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
-    Napi::Function wrapper = Napi::Function::New(env, call, name.c_str(), (void *)func);
+    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func);
     wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
     func_guard.Disable();
 
@@ -481,17 +498,18 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     Napi::Object obj = Napi::Object::New(env);
 
-#define ADD_CONVENTION(Name, Value, Variadic) \
+#define ADD_CONVENTION(Name, Value) \
         do { \
-            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value), (Variadic)); }; \
+            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value)); }; \
             Napi::Function func = Napi::Function::New(env, wrapper, (Name), (void *)lib->Ref()); \
             func.AddFinalizer([](Napi::Env, LibraryHolder *lib) { lib->Unref(); }, lib); \
             obj.Set((Name), func); \
         } while (false)
 
-    ADD_CONVENTION("cdecl", CallConvention::Default, true);
-    ADD_CONVENTION("stdcall", CallConvention::Stdcall, false);
-    ADD_CONVENTION("fastcall", CallConvention::Fastcall, false);
+    ADD_CONVENTION("func", CallConvention::Cdecl);
+    ADD_CONVENTION("cdecl", CallConvention::Cdecl);
+    ADD_CONVENTION("stdcall", CallConvention::Stdcall);
+    ADD_CONVENTION("fastcall", CallConvention::Fastcall);
 
 #undef ADD_CONVENTION
 
@@ -585,7 +603,6 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4, alignof(float));
     RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
     RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
-    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {