Add ffi to byte code

However we still need a way to put the function name strings into the byte code
Also currently I just use qword for all arg types

Author: MoritzGoeckel

src/executer/ByteCode.cpp

@@ -41,7 +41,13 @@ std::string instructionsToString(const std::vector<Instruction>& instructions, b
         { Op::LTE, {"LTE", {}} },
         { Op::GTE, {"GTE", {}} },
         { Op::NEQ, {"NEQ", {}} },
-        { Op::DUB, {"DUB", {"LOOKBACK"}} }
+        { Op::DUB, {"DUB", {"LOOKBACK"}} },
+        { Op::REG_FFI, {"REG_FFI", {}} },
+        { Op::PUSH_FFI_WORD, {"PUSH_FFI_WORD", {}} },
+        { Op::PUSH_FFI_DWORD, {"PUSH_FFI_DWORD", {}} },
+        { Op::PUSH_FFI_QWORD, {"PUSH_FFI_QWORD", {}} },
+        { Op::PUSH_FFI_XWORD, {"PUSH_FFI_XWORD", {}} },
+        { Op::CALL_FFI, {"CALL_FFI", {}} }
     };
 
     std::stringstream ss;
@@ -268,12 +274,42 @@ ProgramState ByteCodeVM::run(size_t maxInstructions) {
             case Op::TERM: {
                 return ProgramState::Finished;
             }
+            case Op::REG_FFI: {
+                // Register FFI function
+                // TODO: How do we get strings here?
+                // TODO: Need to somehow embed strings into the bytecode
+                ffiFunctions.add("library", "function");
+                break;
+            }
+            case Op::PUSH_FFI_WORD:
+            case Op::PUSH_FFI_DWORD:
+            case Op::PUSH_FFI_QWORD: 
+            case Op::PUSH_FFI_XWORD: // TODO: Distinguish between these types
+            {
+                auto value = stack.pop();
+                ffiArgs.addWord(value);
+                break;
+            }
+            case Op::CALL_FFI: {
+                auto id = stack.pop();
+                auto result = ffiFunctions.call(id, ffiArgs);
+                stack.push(result);
+                ffiArgs.clear();
+                break;
+            }
         }
     }
     return ProgramState::Paused;
 }
 
-ByteCodeVM::ByteCodeVM(const Program& program) : idx{0ull}, callstack{}, stack{}, program(program), debug{true} {}
+ByteCodeVM::ByteCodeVM(const Program& program) : 
+    idx{0ull}, 
+    callstack{}, 
+    stack{}, 
+    program(program), 
+    debug{true},
+    ffiFunctions{},
+    ffiArgs{} {}
 
 std::string ByteCodeVM::execute(size_t maxInstructions) {
     auto state = run(maxInstructions);

src/executer/ByteCode.h

@@ -6,14 +6,48 @@
 #include <map>
 #include <sstream>
 
+#include "../executer/ExternalFunctions.h"
 #include "../error/Exceptions.h"
 #include "Stack.h"
 
 namespace executor {
 
 using word_t = unsigned long;
 
-enum class Op { NOP, LOCALS, LOCALL, CALL, RET, PUSH, POP, ADD, SUB, MUL, DIV, MOD, JUMP, JUMP_IF, ALLOC, PRINTS, TERM, LT, GT, EQ, LTE, GTE, NEQ, LOADW, STOREW, DUB };
+enum class Op { 
+    NOP, 
+    LOCALS, 
+    LOCALL, 
+    CALL, 
+    RET, 
+    PUSH, 
+    POP, 
+    ADD, 
+    SUB, 
+    MUL, 
+    DIV, 
+    MOD, 
+    JUMP, 
+    JUMP_IF, 
+    ALLOC, 
+    PRINTS, 
+    TERM, 
+    LT, 
+    GT, 
+    EQ, 
+    LTE, 
+    GTE, 
+    NEQ, 
+    LOADW, 
+    STOREW, 
+    DUB,
+    REG_FFI,
+    PUSH_FFI_WORD, 
+    PUSH_FFI_DWORD, 
+    PUSH_FFI_QWORD, 
+    PUSH_FFI_XWORD, 
+    CALL_FFI
+};
 
 // TODO: ADD etc should be type specific, so IADD, FADD
 // TODO: Logic operator missing: AND, OR, NOT
@@ -83,6 +117,8 @@ class ByteCodeVM {
         std::vector<word_t> heap;
         Program program;
         bool debug;
+        ffi::ExternalFunctions ffiFunctions;
+        ffi::Arguments ffiArgs;
 
     ProgramState run(size_t maxInstructions);
 

src/executer/ExternalFunctions.cpp

@@ -78,7 +78,6 @@ size_t ExternalFunctions::add(const std::string& library, const std::string& fun
     ASSURE_NOT_NULL(libraryHandle);
     dlerror(); // Clear any existing error
 
-    //void (*print)() = (void (*)())dlsym(handle, "print");
     functionInfo.functionPtr = dlsym(libraryHandle, functionName.c_str());
     const char* dlsym_error = dlerror();
     if (dlsym_error) {
@@ -95,11 +94,21 @@ qword_t ExternalFunctions::call(size_t id, const Arguments& args) {
     ASSURE(id < functions.size(), "Function ID out of bounds");
 
     const ExternalFunction& func = functions[id];
+    ASSURE_NOT_NULL(func.functionPtr);
 
-    qword_t result;
+    // TODO: We don't support more than 6 arguments yet (put on stack)
+    ASSURE(args.getSize() <= 6, "Too many arguments for external function");
 
-    __asm__ volatile (
+    // TODO: We don't support float/double arguments yet (xmm registers)
+
+    // https://github.com/tsoding/b/blob/main/src/codegen/fasm_x86_64.rs#L221
+    // Floating point numbers are passed in xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7
+    // Integer numbers are passed in rdi, rsi, rdx, rcx, r8, r9
+    // The result is returned in rax
+    // If we need more than 6 arguments, the rest are passed on the stack. (?)
 
+    qword_t result;
+    __asm__ volatile (
         "movq %[args_tag], %%R10\n" // Bring arg pointer into R10
 
         "call bring_next_value_into_rax\n"
@@ -156,12 +165,6 @@ qword_t ExternalFunctions::call(size_t id, const Arguments& args) {
         : [fn_tag] "r"(func.functionPtr), 
           [args_tag] "r"(args.getBuffer())) ;
 
-    // https://github.com/tsoding/b/blob/main/src/codegen/fasm_x86_64.rs#L221
-    // Floating point numbers are passed in xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7
-    // Integer numbers are passed in rdi, rsi, rdx, rcx, r8, r9
-    // The result is returned in rax
-    // If we need more than 6 arguments, the rest are passed on the stack. (?)
-
     return result;
 }
 

src/executer/ExternalFunctions.h

@@ -13,7 +13,7 @@ using byte_t = unsigned char;
 using word_t = unsigned short;
 using dword_t = unsigned int;
 using qword_t = unsigned long long;
-using xmmword_t = unsigned char[16]; // Probably we don't need this
+using xmmword_t = unsigned char[16]; // Probably we don't need this, we might for floats
 
 using ptr = void*;
 static_assert(sizeof(ptr) == 8);
@@ -64,8 +64,6 @@ struct ExternalFunction {
     std::string library;
     std::string name;
     void* functionPtr;
-    // std::vector<Type> parameters;
-    // Type returnType;
 };
 
 class ExternalFunctions {