koffi 0.9.20 → 0.9.23

package/CMakeLists.txt

@@ -11,7 +11,7 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see https://www.gnu.org/licenses/.
 
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.12)
 project(koffi C CXX ASM)
 
 find_package(CNoke)
@@ -65,59 +65,3 @@ else()
     target_compile_options(koffi PRIVATE -fno-exceptions -Wno-missing-field-initializers
                                          -fno-strict-aliasing)
 endif()
-
-# ---- Raylib ----
-
-add_library(raylib SHARED
-    vendor/raylib/src/rcore.c
-    vendor/raylib/src/rshapes.c
-    vendor/raylib/src/rtextures.c
-    vendor/raylib/src/rtext.c
-    vendor/raylib/src/rmodels.c
-    vendor/raylib/src/utils.c
-    vendor/raylib/src/rglfw.c
-    vendor/raylib/src/raudio.c
-)
-set_target_properties(raylib PROPERTIES PREFIX "")
-target_include_directories(raylib PRIVATE vendor/raylib/src/external/glfw/include)
-target_compile_definitions(raylib PRIVATE PLATFORM_DESKTOP GRAPHICS_API_OPENGL_21
-                                          BUILD_LIBTYPE_SHARED NDEBUG)
-
-if(MSVC)
-    target_compile_options(raylib PRIVATE /wd4244 /wd4305)
-else()
-    target_compile_options(raylib PRIVATE -Wno-sign-compare -Wno-old-style-declaration
-                                          -Wno-unused-function -Wno-missing-field-initializers
-                                          -Wno-unused-value -Wno-implicit-fallthrough -Wno-stringop-overflow
-                                          -Wno-unused-result)
-endif()
-
-if(WIN32)
-    target_compile_definitions(raylib PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
-    target_link_libraries(raylib PRIVATE winmm)
-endif()
-
-if(CMAKE_SYSTEM_NAME MATCHES "BSD")
-    target_include_directories(raylib PRIVATE /usr/local/include)
-endif()
-
-if(APPLE)
-    target_compile_options(raylib PRIVATE -Wno-unknown-warning-option -Wno-macro-redefined)
-    target_compile_definitions(raylib PRIVATE GL_SILENCE_DEPRECATION)
-    set_source_files_properties(vendor/raylib/src/rglfw.c PROPERTIES COMPILE_FLAGS "-x objective-c")
-    target_link_libraries(raylib PRIVATE "-framework Cocoa" "-framework IOKit" "-framework CoreFoundation" "-framework OpenGL")
-endif()
-
-# ---- SQLite ----
-
-add_library(sqlite3 SHARED vendor/sqlite3/sqlite3.c)
-set_target_properties(sqlite3 PROPERTIES PREFIX "")
-
-if(WIN32)
-    target_compile_definitions(sqlite3 PRIVATE SQLITE_API=__declspec\(dllexport\))
-endif()
-
-# ---- Misc ----
-
-add_library(misc SHARED test/tests/misc.c)
-set_target_properties(misc PROPERTIES PREFIX "")

package/README.md

@@ -6,6 +6,7 @@
   * [Other platforms](#other-platforms)
 - [Get started](#get-started)
 - [Tests](#tests)
+- [Benchmarks](#benchmarks)
 
 # Introduction
 
@@ -264,16 +265,16 @@ Here are some results from 2022-04-15 on my machine (AMD Ryzen™ 7 5800H 16G):
 $ time ./raylib_c 200
 Iterations: 200
 
-real    0m9,206s
-user    0m9,152s
-sys     0m0,040s
+real    0m8,871s
+user    0m8,792s
+sys     0m0,016s
 
 $ time ./raylib_koffi.js 200
 Iterations: 200
 
-real    0m13,790s
-user    0m13,699s
-sys     0m0,044s
+real    0m13,011s
+user    0m12,923s
+sys     0m0,032s
 
 $ time ./raylib_node_ffi.js 200
 Iterations: 200

package/benchmark/build.sh

@@ -0,0 +1,13 @@
+#!/bin/sh -e
+
+cd $(dirname $0)/..
+
+echo "Install all dependencies..."
+npm install
+
+echo "Building dependencies..."
+node ../cnoke/cnoke.js
+node ../cnoke/cnoke.js -C test
+
+echo "Building raylib_c..."
+gcc -O2 -std=gnu99 -Wall -Wl,-rpath,$(realpath $(pwd)/test/build) -fPIC benchmark/raylib_c.c -o benchmark/raylib_c test/build/raylib.so -lm -pthread -ldl

package/benchmark/raylib_c.c

@@ -0,0 +1,83 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include "../vendor/raylib/src/raylib.h"
+
+#define STRINGIFY(Value) # Value
+
+static int ParseInt(const char *str)
+{
+    char *end;
+    long long value = strtoll(str, &end, 10);
+
+    if (end == str || *end) {
+        fprintf(stderr, "Not a valid integer number\n");
+        return -1;
+    }
+    if (value < 1 || value == LLONG_MAX) {
+        fprintf(stderr, "Value must be between 1 and " STRINGIFY(LLONG_MAX) "\n");
+        return -1;
+    }
+
+    return (int)value;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2) {
+        fprintf(stderr, "Missing number of iterations\n");
+        return 1;
+    }
+
+    int iterations = ParseInt(argv[1]);
+    if (iterations < 0)
+        return 1;
+    printf("Iterations: %d\n", iterations);
+
+    // We need to call InitWindow before using anything else (such as fonts)
+    SetTraceLogLevel(4); // Warnings
+    SetWindowState(0x80); // Hidden
+    InitWindow(640, 480, "Raylib Test");
+
+    Image img = GenImageColor(800, 600, (Color){ .r = 0, .g = 0, .b = 0, .a = 255 });
+    Font font = GetFontDefault();
+
+    for (int i = 0; i < iterations; i++) {
+        ImageClearBackground(&img, (Color){ .r = 0, .g = 0, .b = 0, .a = 255 });
+
+        for (int j = 0; j < 3600; j++) {
+            const char *text = "Hello World!";
+            int text_width = MeasureTextEx(font, text, 10, 1).x;
+
+            double angle = (j * 7) * PI / 180;
+            Color color = {
+                .r = 127.5 + 127.5 * sin(angle),
+                .g = 127.5 + 127.5 * sin(angle + PI / 2),
+                .b = 127.5 + 127.5 * sin(angle + PI),
+                .a = 255
+            };
+            Vector2 pos = {
+                .x = (img.width / 2 - text_width / 2) + j * 0.1 * cos(angle - PI / 2),
+                .y = (img.height / 2 - 16) + j * 0.1 * sin(angle - PI / 2)
+            };
+
+            ImageDrawTextEx(&img, font, text, pos, 10, 1, color);
+        }
+    }
+
+    return 0;
+}

package/benchmark/raylib_koffi.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const koffi = require('../build/koffi.node');
+const path = require('path');
+
+const Color = koffi.struct('Color', {
+    r: 'uchar',
+    g: 'uchar',
+    b: 'uchar',
+    a: 'uchar'
+});
+
+const Image = koffi.struct('Image', {
+    data: koffi.pointer('void'),
+    width: 'int',
+    height: 'int',
+    mipmaps: 'int',
+    format: 'int'
+});
+
+const GlyphInfo = koffi.struct('GlyphInfo', {
+    value: 'int',
+    offsetX: 'int',
+    offsetY: 'int',
+    advanceX: 'int',
+    image: Image
+});
+
+const Vector2 = koffi.struct('Vector2', {
+    x: 'float',
+    y: 'float'
+});
+
+const Rectangle = koffi.struct('Rectangle', {
+    x: 'float',
+    y: 'float',
+    width: 'float',
+    height: 'float'
+});
+
+const Texture = koffi.struct('Texture', {
+    id: 'uint',
+    width: 'int',
+    height: 'int',
+    mipmaps: 'int',
+    format: 'int'
+});
+
+const Font = koffi.struct('Font', {
+    baseSize: 'int',
+    glyphCount: 'int',
+    glyphPadding: 'int',
+    texture: Texture,
+    recs: koffi.pointer(Rectangle),
+    glyphs: koffi.pointer(GlyphInfo)
+});
+
+main();
+
+function main() {
+    if (process.argv.length < 3)
+        throw new Error('Missing number of iterations');
+
+    let iterations = parseInt(process.argv[2], 10);
+    if (Number.isNaN(iterations))
+        throw new Error('Not a valid number');
+    if (iterations < 1)
+        throw new Error('Value must be positive');
+    console.log('Iterations:', iterations);
+
+    let lib_filename = path.dirname(__filename) + '/../test/build/raylib' + koffi.extension;
+    let lib = koffi.load(lib_filename);
+
+    const InitWindow = lib.cdecl('InitWindow', 'void', ['int', 'int', 'string']);
+    const SetTraceLogLevel = lib.cdecl('SetTraceLogLevel', 'void', ['int']);
+    const SetWindowState = lib.cdecl('SetWindowState', 'void', ['uint']);
+    const GenImageColor = lib.cdecl('GenImageColor', Image, ['int', 'int', Color]);
+    const GetFontDefault = lib.cdecl('GetFontDefault', Font, []);
+    const MeasureTextEx = lib.cdecl('MeasureTextEx', Vector2, [Font, 'string', 'float', 'float']);
+    const ImageClearBackground = lib.cdecl('ImageClearBackground', 'void', [koffi.pointer(Image), Color]);
+    const ImageDrawTextEx = lib.cdecl('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'string', Vector2, 'float', 'float', Color]);
+    const ExportImage = lib.cdecl('ExportImage', 'bool', [Image, 'string']);
+
+    // We need to call InitWindow before using anything else (such as fonts)
+    SetTraceLogLevel(4); // Warnings
+    SetWindowState(0x80); // Hidden
+    InitWindow(640, 480, "Raylib Test");
+
+    let img = GenImageColor(800, 600, { r: 0, g: 0, b: 0, a: 255 });
+    let font = GetFontDefault();
+
+    for (let i = 0; i < iterations; i++) {
+        ImageClearBackground(img, { r: 0, g: 0, b: 0, a: 255 });
+
+        for (let j = 0; j < 3600; j++) {
+            let text = 'Hello World!';
+            let text_width = MeasureTextEx(font, text, 10, 1).x;
+
+            let angle = (j * 7) * Math.PI / 180;
+            let color = {
+                r: 127.5 + 127.5 * Math.sin(angle),
+                g: 127.5 + 127.5 * Math.sin(angle + Math.PI / 2),
+                b: 127.5 + 127.5 * Math.sin(angle + Math.PI),
+                a: 255
+            };
+            let pos = {
+                x: (img.width / 2 - text_width / 2) + j * 0.1 * Math.cos(angle - Math.PI / 2),
+                y: (img.height / 2 - 16) + j * 0.1 * Math.sin(angle - Math.PI / 2)
+            };
+
+            ImageDrawTextEx(img, font, text, pos, 10, 1, color);
+        }
+    }
+}

package/benchmark/raylib_node_ffi.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const ref = require('ref-napi');
+const ffi = require('ffi-napi');
+const struct = require('ref-struct-di')(ref);
+const path = require('path');
+
+const Color = struct({
+    r: 'uchar',
+    g: 'uchar',
+    b: 'uchar',
+    a: 'uchar'
+});
+
+const Image = struct({
+    data: ref.refType(ref.types.void),
+    width: 'int',
+    height: 'int',
+    mipmaps: 'int',
+    format: 'int'
+});
+
+const GlyphInfo = struct({
+    value: 'int',
+    offsetX: 'int',
+    offsetY: 'int',
+    advanceX: 'int',
+    image: Image
+});
+
+const Vector2 = struct({
+    x: 'float',
+    y: 'float'
+});
+
+const Vector3 = struct({
+    x: 'float',
+    y: 'float',
+    z: 'float'
+});
+
+const Vector4 = struct({
+    x: 'float',
+    y: 'float',
+    z: 'float',
+    w: 'float'
+});
+
+const Rectangle = struct({
+    x: 'float',
+    y: 'float',
+    width: 'float',
+    height: 'float'
+});
+
+const Texture = struct({
+    id: 'uint',
+    width: 'int',
+    height: 'int',
+    mipmaps: 'int',
+    format: 'int'
+});
+
+const Font = struct({
+    baseSize: 'int',
+    glyphCount: 'int',
+    glyphPadding: 'int',
+    texture: Texture,
+    recs: ref.refType(Rectangle),
+    glyphs: ref.refType(GlyphInfo)
+});
+
+main();
+
+function main() {
+    if (process.argv.length < 3)
+        throw new Error('Missing number of iterations');
+
+    let iterations = parseInt(process.argv[2], 10);
+    if (Number.isNaN(iterations))
+        throw new Error('Not a valid number');
+    if (iterations < 1)
+        throw new Error('Value must be positive');
+    console.log('Iterations:', iterations);
+
+    let lib_filename = path.dirname(__filename) + '/../test/build/raylib' + koffi.extension;
+
+    const r = ffi.Library(lib_filename, {
+        InitWindow: ['void', ['int', 'int', 'string']],
+        SetTraceLogLevel: ['void', ['int']],
+        SetWindowState: ['void', ['uint']],
+        GenImageColor: [Image, ['int', 'int', Color]],
+        GetFontDefault: [Font, []],
+        MeasureTextEx: [Vector2, [Font, 'string', 'float', 'float']],
+        ImageClearBackground: ['void', [ref.refType(Image), Color]],
+        ImageDrawTextEx: ['void', [ref.refType(Image), Font, 'string', Vector2, 'float', 'float', Color]],
+        ExportImage: ['bool', [Image, 'string']]
+    });
+
+    // We need to call InitWindow before using anything else (such as fonts)
+    r.SetTraceLogLevel(4); // Warnings
+    r.SetWindowState(0x80); // Hidden
+    r.InitWindow(640, 480, "Raylib Test");
+
+    let img = r.GenImageColor(800, 600, new Color({ r: 0, g: 0, b: 0, a: 255 }));
+    let imgp = img.ref();
+    let font = r.GetFontDefault();
+
+    for (let i = 0; i < iterations; i++) {
+        r.ImageClearBackground(imgp, new Color({ r: 0, g: 0, b: 0, a: 255 }));
+
+        for (let j = 0; j < 3600; j++) {
+            let text = 'Hello World!';
+            let text_width = r.MeasureTextEx(font, text, 10, 1).x;
+
+            let angle = (j * 7) * Math.PI / 180;
+            let color = new Color({
+                r: 127.5 + 127.5 * Math.sin(angle),
+                g: 127.5 + 127.5 * Math.sin(angle + Math.PI / 2),
+                b: 127.5 + 127.5 * Math.sin(angle + Math.PI),
+                a: 255
+            });
+            let pos = new Vector2({
+                x: (img.width / 2 - text_width / 2) + j * 0.1 * Math.cos(angle - Math.PI / 2),
+                y: (img.height / 2 - 16) + j * 0.1 * Math.sin(angle - Math.PI / 2)
+            });
+
+            r.ImageDrawTextEx(imgp, font, text, pos, 10, 1, color);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "0.9.20",
+  "version": "0.9.23",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -18,7 +18,7 @@
   "author": "Niels Martignène <niels.martignene@protonmail.com>",
   "main": "src/index.js",
   "scripts": {
-    "install": "cnoke koffi",
+    "install": "cnoke",
     "test": "node test/test.js"
   },
   "license": "AGPL-3.0",
@@ -28,12 +28,14 @@
   "devDependencies": {
     "chalk": "^4.1.2",
     "ffi-napi": "^4.0.3",
+    "minimatch": "^5.0.1",
     "node-ssh": "^12.0.3",
     "ref-napi": "^3.0.3",
     "ref-struct-di": "^1.1.1"
   },
   "files": [
     "src",
+    "benchmark",
     "test/files",
     "test/registry",
     "test/tests",

package/src/call_arm32.cc

@@ -63,8 +63,8 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
     if (IsHFA(func->ret.type)) {
         func->ret.vec_count = func->ret.type->members.len *
                               (func->ret.type->members[0].type->size / 4);
-    } else if (func->ret.type->size <= 4) {
-        func->ret.gpr_count = 1;
+    } else if (func->ret.type->primitive != PrimitiveKind::Record) {
+        func->ret.gpr_count = (func->ret.type->size >= 4) ? 2 : 1;
     } else {
         func->ret.use_memory = true;
     }
@@ -267,7 +267,8 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint32_t)b;
                 } else {
-                    *(args_ptr++) = (uint8_t)b;
+                    *args_ptr = (uint8_t)b;
+                    args_ptr += 4;
                 }
             } break;
             case PrimitiveKind::Int8:
@@ -286,9 +287,8 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint32_t)v;
                 } else {
-                    args_ptr = AlignUp(args_ptr, param.type->align);
                     memcpy(args_ptr, &v, param.type->size); // Little Endian
-                    args_ptr += param.type->size;
+                    args_ptr += 4;
                 }
             } break;
             case PrimitiveKind::Int64:
@@ -320,7 +320,6 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.vec_count)) {
                     memcpy(vec_ptr++, &f, 4);
                 } else {
-                    args_ptr = AlignUp(args_ptr, 4);
                     memcpy(args_ptr, &f, 4);
                     args_ptr += 4;
                 }
@@ -358,7 +357,6 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)str;
                 } else {
-                    args_ptr = AlignUp(args_ptr, 4);
                     *(const char **)args_ptr = str;
                     args_ptr += 4;
                 }
@@ -390,7 +388,6 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)ptr;
                 } else {
-                    args_ptr = AlignUp(args_ptr, 4);
                     *(void **)args_ptr = ptr;
                     args_ptr += 4;
                 }

package/src/call_arm64.cc

@@ -123,7 +123,7 @@ Napi::Function::Callback AnalyseFunction(InstanceData *, FunctionInfo *func)
                     } else {
                         gpr_avail = 0;
                     }
-                } else if (gpr_avail) {
+                } else {
                     // Big types (more than 16 bytes) are replaced by a pointer
                     if (gpr_avail) {
                         param.gpr_count = 1;
@@ -255,7 +255,12 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)b;
                 } else {
-                    *(args_ptr++) = (uint8_t)b;
+                    *args_ptr = (uint8_t)b;
+#ifdef __APPLE__
+                    args_ptr++;
+#else
+                    args_ptr += 8;
+#endif
                 }
             } break;
             case PrimitiveKind::Int8:
@@ -278,7 +283,11 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 } else {
                     args_ptr = AlignUp(args_ptr, param.type->align);
                     memcpy(args_ptr, &v, param.type->size); // Little Endian
+#ifdef __APPLE__
                     args_ptr += param.type->size;
+#else
+                    args_ptr += 8;
+#endif
                 }
             } break;
             case PrimitiveKind::Float32: {
@@ -294,7 +303,11 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 } else {
                     args_ptr = AlignUp(args_ptr, 4);
                     memcpy(args_ptr, &f, 4);
+#ifdef __APPLE__
                     args_ptr += 4;
+#else
+                    args_ptr += 8;
+#endif
                 }
             } break;
             case PrimitiveKind::Float64: {
@@ -387,9 +400,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                             return env.Null();
                         gpr_ptr += param.gpr_count;
                     } else if (param.type->size) {
-                        int16_t align = (param.type->align <= 4) ? 4 : 8;
-
-                        args_ptr = AlignUp(args_ptr, align);
+                        args_ptr = AlignUp(args_ptr, 8);
                         if (!call.PushObject(obj, param.type, args_ptr))
                             return env.Null();
                         args_ptr += AlignLen(param.type->size, 8);

package/src/call_arm64_fwd.S

@@ -11,16 +11,22 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see https://www.gnu.org/licenses/.
 
+#ifdef __APPLE__
+    #define SYMBOL(Symbol) _ ## Symbol
+#else
+    #define SYMBOL(Symbol) Symbol
+#endif
+
 // These three are the same, but they differ (in the C side) by their return type.
 // Unlike the three next functions, these ones don't forward XMM argument registers.
-.global ForwardCallGG
-.global ForwardCallF
-.global ForwardCallDDDD
+.global SYMBOL(ForwardCallGG)
+.global SYMBOL(ForwardCallF)
+.global SYMBOL(ForwardCallDDDD)
 
 // The X variants are slightly slower, and are used when XMM arguments must be forwarded.
-.global ForwardCallXGG
-.global ForwardCallXF
-.global ForwardCallXDDDD
+.global SYMBOL(ForwardCallXGG)
+.global SYMBOL(ForwardCallXF)
+.global SYMBOL(ForwardCallXDDDD)
 
 // Copy function pointer to r9, in order to save it through argument forwarding.
 // Save RSP in r29 (non-volatile), and use carefully assembled stack provided by caller.
@@ -76,34 +82,34 @@
     ldr d0, [x1, 72]
 .endm
 
-ForwardCallGG:
+SYMBOL(ForwardCallGG):
     prologue
     forward_int
     epilogue
 
-ForwardCallF:
+SYMBOL(ForwardCallF):
     prologue
     forward_int
     epilogue
 
-ForwardCallDDDD:
+SYMBOL(ForwardCallDDDD):
     prologue
     forward_int
     epilogue
 
-ForwardCallXGG:
+SYMBOL(ForwardCallXGG):
     prologue
     forward_vec
     forward_int
     epilogue
 
-ForwardCallXF:
+SYMBOL(ForwardCallXF):
     prologue
     forward_vec
     forward_int
     epilogue
 
-ForwardCallXDDDD:
+SYMBOL(ForwardCallXDDDD):
     prologue
     forward_vec
     forward_int