Passing strings to ffi

Author: MoritzGoeckel

lib/libtest.cpp

@@ -3,7 +3,8 @@
 
 // To avoid renaming the function in the exported symbols
 extern "C" {
-    void print();
+    void printNoArgs();
+    void print(const char*);
     int mul(int a, int b);
     void test_v();
     int test_ii_i(int a, int b);
@@ -16,7 +17,11 @@ extern "C" {
     const char* test_pp_p(char* a, char* b);
 }
 
-void print() { printf("It's working!\n"); }
+void printNoArgs() { printf("It's working!\n"); }
+
+void print(const char* str) {
+    printf("%s\n", str);
+}
 
 int mul(int a, int b){
     int r = a * b;

mfiles/TODO_str.m

@@ -0,0 +1,7 @@
+# expect_result=void
+
+let s = "Hello, World!";
+let str = s;
+
+let print = extern test::print(s: Str): Void;
+print(str);

mfiles/str.m

@@ -275,17 +275,23 @@ void ByteCodeEmitter::process(const std::shared_ptr<AST::Node>& node, bool hasCo
             } else {
                 loadIdentifier(call->getIdentifier()); // Bring the function addr on the stack
 
+                const auto& returnType = fnDataType.getReturn();
+                ASSURE_NOT_NULL(returnType);
+
+                // CALL consumes the arguments from the stack, so we don't need to pop them
+                // If we don't have a consumer, we have to pop the result. We assume only one result.
+                // Only if the function is not void, of course.
                 if (functionType.isExtern) {
                     code().push_back(executor::Instruction(executor::Op::CALL_FFI));
+
+                    // CALL_FFI always pushes a result, so we need to get rid of it
+                    // if we don't have a consumer or the return type is None.
+                    if(!hasConsumer || *returnType == DataType::Primitive::None) {
+                        code().push_back(executor::Instruction(executor::Op::POP));
+                    }
                 } else {
                     code().push_back(executor::Instruction(executor::Op::CALL, call->getArguments().size()));
 
-                    // CALL consumes the arguments from the stack, so we don't need to pop them
-                    // If we don't have a consumer, we have to pop the result. We assume only one result.
-                    // Only if the function is not void, of course.
-
-                    const auto& returnType = fnDataType.getReturn();
-                    ASSURE_NOT_NULL(returnType);
                     if(!hasConsumer && *returnType != DataType::Primitive::None) {
                         code().push_back(executor::Instruction(executor::Op::POP));
                     }
@@ -299,7 +305,7 @@ void ByteCodeEmitter::process(const std::shared_ptr<AST::Node>& node, bool hasCo
                 auto literal = std::dynamic_pointer_cast<AST::Literal>(node);
                 if (literal->getDataType() == DataType::Primitive::String) {
                     auto strIdx = program.data.addString(literal->getStringValue());
-                    code().push_back(executor::Instruction(executor::Op::PUSH, strIdx));
+                    code().push_back(executor::Instruction(executor::Op::DATA_ADDR, strIdx));
                 } else if (literal->getDataType() == DataType::Primitive::Bool) {
                     code().push_back(executor::Instruction(
                         executor::Op::PUSH, literal->getBoolValue() ? 1 : 0));

src/emitter/ByteCodeEmitter.cpp

@@ -47,7 +47,8 @@ std::string instructionsToString(const std::vector<Instruction>& instructions, b
         { 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", {}} }
+        { Op::CALL_FFI, {"CALL_FFI", {}} },
+        { Op::DATA_ADDR, {"DATA_ADDR", {"DATA_IDX"}} }
     };
 
     std::stringstream ss;
@@ -288,7 +289,7 @@ ProgramState ByteCodeVM::run(size_t maxInstructions) {
             case Op::PUSH_FFI_XWORD: // TODO: Distinguish between these types
             {
                 auto value = stack.pop();
-                ffiArgs.addWord(value);
+                ffiArgs.addQWord(value);
                 break;
             }
             case Op::CALL_FFI: {
@@ -298,6 +299,14 @@ ProgramState ByteCodeVM::run(size_t maxInstructions) {
                 ffiArgs.clear();
                 break;
             }
+            case Op::DATA_ADDR: {
+                // DATA_ADDR DATA_IDX
+                auto dataIdx = inst.arg1;
+                void* addr = program.data.getAddr(dataIdx);
+                static_assert(sizeof(word_t) == sizeof(void*));
+                stack.push(reinterpret_cast<word_t>(addr));
+                break;
+            }
         }
     }
     return ProgramState::Paused;

src/executer/ByteCode.cpp

@@ -47,7 +47,8 @@ enum class Op {
     PUSH_FFI_DWORD, 
     PUSH_FFI_QWORD, 
     PUSH_FFI_XWORD, 
-    CALL_FFI
+    CALL_FFI,
+    DATA_ADDR
 };
 
 // TODO: ADD etc should be type specific, so IADD, FADD
@@ -96,6 +97,13 @@ class Data {
         data[startIdx + str.size()] = 0; // Null terminator
         return startIdx;
     }
+
+    void* getAddr(size_t idx) {
+        if (idx >= data.size()) {
+            throwConstraintViolated("Data: Index out of bounds");
+        }
+        return reinterpret_cast<void*>(&data[idx]);
+    }
 };
 
 struct Program {

src/executer/ByteCode.h

@@ -281,8 +281,7 @@ void suiteTestfiles(){
     testFile("mfiles/struct.m");
     testFile("mfiles/struct_nested.m");
     testFile("mfiles/extern.m");
-
-    testFile("mfiles/TODO_str.m");
+    testFile("mfiles/str.m");
 
     // TODO: blob type (alloc8(size), get(blob, idx), set(blob, idx)):
     //    synatx sugar for get, set with []