Add print instruction

Author: adazem009

src/engine/internal/icodebuilder.h

@@ -104,6 +104,8 @@ class ICodeBuilder
         virtual void invalidateTarget() = 0;
 
         virtual void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args) = 0;
+
+        virtual void createPrint(CompilerValue *string) = 0;
 };
 
 } // namespace libscratchcpp

src/engine/internal/llvm/instructions/control.cpp

@@ -68,6 +68,10 @@ ProcessResult Control::process(LLVMInstruction *ins)
             ret.next = buildInvalidateTarget(ins);
             break;
 
+        case LLVMInstruction::Type::Print:
+            ret.next = buildPrint(ins);
+            break;
+
         default:
             ret.match = false;
             break;
@@ -365,3 +369,14 @@ LLVMInstruction *Control::buildInvalidateTarget(LLVMInstruction *ins)
     m_utils.invalidateTarget();
     return ins->next;
 }
+
+LLVMInstruction *Control::buildPrint(LLVMInstruction *ins)
+{
+    assert(ins->args.size() == 1);
+
+    const auto &arg = ins->args[0];
+    llvm::Value *str = m_utils.castValue(arg.second, arg.first);
+
+    m_builder.CreateCall(m_utils.functions().resolve_llvm_print(), str);
+    return ins->next;
+}

src/engine/internal/llvm/instructions/control.h

@@ -29,6 +29,7 @@ class Control : public InstructionGroup
         LLVMInstruction *buildStop(LLVMInstruction *ins);
         LLVMInstruction *buildThreadStop(LLVMInstruction *ins);
         LLVMInstruction *buildInvalidateTarget(LLVMInstruction *ins);
+        LLVMInstruction *buildPrint(LLVMInstruction *ins);
 };
 
 } // namespace libscratchcpp::llvmins

src/engine/internal/llvm/llvmcodebuilder.cpp

@@ -594,6 +594,11 @@ void LLVMCodeBuilder::createProcedureCall(BlockPrototype *prototype, const Compi
     createOp(ins, Compiler::StaticType::Void, types, args);
 }
 
+void LLVMCodeBuilder::createPrint(CompilerValue *string)
+{
+    createOp(LLVMInstruction::Type::Print, Compiler::StaticType::Void, Compiler::StaticType::String, { string });
+}
+
 void LLVMCodeBuilder::initTypes()
 {
     m_valueDataType = m_ctx->valueDataType();

src/engine/internal/llvm/llvmcodebuilder.h

@@ -119,6 +119,8 @@ class LIBSCRATCHCPP_TEST_EXPORT LLVMCodeBuilder : public ICodeBuilder
 
         void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args) override;
 
+        void createPrint(CompilerValue *string) override;
+
     private:
         void initTypes();
 

src/engine/internal/llvm/llvmfunctions.cpp

@@ -2,6 +2,9 @@
 
 #include <scratchcpp/value_functions.h>
 #include <scratchcpp/irandomgenerator.h>
+#include <scratchcpp/stringptr.h>
+#include <utf8.h>
+#include <iostream>
 
 #include "llvmfunctions.h"
 #include "llvmcompilercontext.h"
@@ -45,6 +48,12 @@ extern "C"
     {
         return static_cast<LLVMExecutionContext *>(ctx)->finished();
     }
+
+    LIBSCRATCHCPP_EXPORT void llvm_print(const StringPtr *string)
+    {
+        // TODO: Using a string function would be better
+        std::cout << utf8::utf16to8(std::u16string(string->data));
+    }
 }
 
 LLVMFunctions::LLVMFunctions(LLVMCompilerContext *ctx, llvm::IRBuilder<> *builder) :
@@ -304,6 +313,11 @@ llvm::FunctionCallee LLVMFunctions::resolve_llvm_is_thread_finished()
     return resolveFunction("llvm_is_thread_finished", llvm::FunctionType::get(m_builder->getInt1Ty(), { pointerType }, false));
 }
 
+llvm::FunctionCallee LLVMFunctions::resolve_llvm_print()
+{
+    return resolveFunction("llvm_print", llvm::FunctionType::get(m_builder->getVoidTy(), { m_stringPtrType->getPointerTo() }, false));
+}
+
 llvm::FunctionCallee LLVMFunctions::resolve_string_pool_new()
 {
     return resolveFunction("string_pool_new", llvm::FunctionType::get(m_stringPtrType->getPointerTo(), false));

src/engine/internal/llvm/llvmfunctions.h

@@ -50,6 +50,7 @@ class LLVMFunctions
         llvm::FunctionCallee resolve_llvm_get_string_array();
         llvm::FunctionCallee resolve_llvm_mark_thread_as_finished();
         llvm::FunctionCallee resolve_llvm_is_thread_finished();
+        llvm::FunctionCallee resolve_llvm_print();
         llvm::FunctionCallee resolve_string_pool_new();
         llvm::FunctionCallee resolve_string_pool_free();
         llvm::FunctionCallee resolve_string_alloc();

src/engine/internal/llvm/llvminstruction.h

@@ -80,7 +80,8 @@ struct LLVMInstruction
             ThreadStop,
             InvalidateTarget,
             CallProcedure,
-            ProcedureArg
+            ProcedureArg,
+            Print
         };
 
         LLVMInstruction(Type type, bool loopCondition) :

test/llvm/llvmcodebuilder_test.cpp

@@ -3779,6 +3779,27 @@ TEST_F(LLVMCodeBuilderTest, ProcedureThreadStop_NonWarp_AfterYield)
     ASSERT_TRUE(code->isFinished(ctx.get()));
 }
 
+TEST_F(LLVMCodeBuilderTest, Print)
+{
+    Sprite sprite;
+    LLVMCodeBuilder *builder = m_utils.createBuilder(&sprite, true);
+
+    CompilerValue *ret = builder->addTargetFunctionCall("test_function_no_args_ret", Compiler::StaticType::String, {}, {});
+    builder->createPrint(ret);
+    builder->createPrint(builder->addConstValue("\n"));
+
+    std::string expected = "no_args_ret\nno_args_output\n";
+
+    auto code = builder->build();
+    Script script(&sprite, nullptr, nullptr);
+    script.setCode(code);
+    Thread thread(&sprite, nullptr, &script);
+    auto ctx = code->createExecutionContext(&thread);
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+}
+
 TEST_F(LLVMCodeBuilderTest, HatPredicates)
 {
     Sprite sprite;

test/mocks/codebuildermock.h

@@ -93,4 +93,6 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(void, invalidateTarget, (), (override));
 
         MOCK_METHOD(void, createProcedureCall, (BlockPrototype *, const Compiler::Args &), (override));
+
+        MOCK_METHOD(void, createPrint, (CompilerValue *), (override));
 };