LLVMCodeBuilder: Use random number generator from execution context

Author: adazem009

src/dev/engine/internal/llvm/CMakeLists.txt

@@ -16,7 +16,6 @@ target_sources(scratchcpp
     llvmtypes.cpp
     llvmtypes.h
     llvmfunctions.cpp
-    llvmfunctions.h
     llvmexecutablecode.cpp
     llvmexecutablecode.h
     llvmexecutioncontext.cpp

src/dev/engine/internal/llvm/llvmcodebuilder.cpp

@@ -201,7 +201,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 if (reg1->type() == Compiler::StaticType::Bool && reg2->type() == Compiler::StaticType::Bool) {
                     llvm::Value *bool1 = castValue(arg1.second, Compiler::StaticType::Bool);
                     llvm::Value *bool2 = castValue(arg2.second, Compiler::StaticType::Bool);
-                    step.functionReturnReg->value = m_builder.CreateCall(resolve_llvm_random_bool(), { bool1, bool2 });
+                    step.functionReturnReg->value = m_builder.CreateCall(resolve_llvm_random_bool(), { executionContextPtr, bool1, bool2 });
                 } else {
                     llvm::Constant *inf = llvm::ConstantFP::getInfinity(m_builder.getDoubleTy(), false);
                     llvm::Value *num1 = removeNaN(castValue(arg1.second, Compiler::StaticType::Number));
@@ -212,11 +212,11 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
 
                     // NOTE: The random function will be called even in edge cases where it isn't needed, but they're rare, so it shouldn't be an issue
                     if (reg1->type() == Compiler::StaticType::Number && reg2->type() == Compiler::StaticType::Number)
-                        step.functionReturnReg->value = m_builder.CreateSelect(isInfOrNaN, sum, m_builder.CreateCall(resolve_llvm_random_double(), { num1, num2 }));
+                        step.functionReturnReg->value = m_builder.CreateSelect(isInfOrNaN, sum, m_builder.CreateCall(resolve_llvm_random_double(), { executionContextPtr, num1, num2 }));
                     else {
                         llvm::Value *value1 = createValue(reg1);
                         llvm::Value *value2 = createValue(reg2);
-                        step.functionReturnReg->value = m_builder.CreateSelect(isInfOrNaN, sum, m_builder.CreateCall(resolve_llvm_random(), { value1, value2 }));
+                        step.functionReturnReg->value = m_builder.CreateSelect(isInfOrNaN, sum, m_builder.CreateCall(resolve_llvm_random(), { executionContextPtr, value1, value2 }));
                     }
                 }
 
@@ -2373,18 +2373,21 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_list_to_string()
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_llvm_random()
 {
+    llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
     llvm::Type *valuePtr = m_valueDataType->getPointerTo();
-    return resolveFunction("llvm_random", llvm::FunctionType::get(m_builder.getDoubleTy(), { valuePtr, valuePtr }, false));
+    return resolveFunction("llvm_random", llvm::FunctionType::get(m_builder.getDoubleTy(), { pointerType, valuePtr, valuePtr }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_llvm_random_double()
 {
-    return resolveFunction("llvm_random_double", llvm::FunctionType::get(m_builder.getDoubleTy(), { m_builder.getDoubleTy(), m_builder.getDoubleTy() }, false));
+    llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("llvm_random_double", llvm::FunctionType::get(m_builder.getDoubleTy(), { pointerType, m_builder.getDoubleTy(), m_builder.getDoubleTy() }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_llvm_random_bool()
 {
-    return resolveFunction("llvm_random_bool", llvm::FunctionType::get(m_builder.getDoubleTy(), { m_builder.getInt1Ty(), m_builder.getInt1Ty() }, false));
+    llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("llvm_random_bool", llvm::FunctionType::get(m_builder.getDoubleTy(), { pointerType, m_builder.getInt1Ty(), m_builder.getInt1Ty() }, false));
 }
 
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()

src/dev/engine/internal/llvm/llvmfunctions.cpp

@@ -1,37 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/value_functions.h>
-
-#include "llvmfunctions.h"
-#include "../../../../engine/internal/randomgenerator.h"
+#include <scratchcpp/dev/executioncontext.h>
+#include <scratchcpp/irandomgenerator.h>
 
 namespace libscratchcpp
 {
 
 extern "C"
 {
-    double llvm_random(ValueData *from, ValueData *to)
+    double llvm_random(ExecutionContext *ctx, ValueData *from, ValueData *to)
     {
-        if (!llvm_rng)
-            llvm_rng = RandomGenerator::instance().get();
-
-        return value_isInt(from) && value_isInt(to) ? llvm_rng->randint(value_toLong(from), value_toLong(to)) : llvm_rng->randintDouble(value_toDouble(from), value_toDouble(to));
+        return value_isInt(from) && value_isInt(to) ? ctx->rng()->randint(value_toLong(from), value_toLong(to)) : ctx->rng()->randintDouble(value_toDouble(from), value_toDouble(to));
     }
 
-    double llvm_random_double(double from, double to)
+    double llvm_random_double(ExecutionContext *ctx, double from, double to)
     {
-        if (!llvm_rng)
-            llvm_rng = RandomGenerator::instance().get();
-
-        return value_doubleIsInt(from) && value_doubleIsInt(to) ? llvm_rng->randint(from, to) : llvm_rng->randintDouble(from, to);
+        return value_doubleIsInt(from) && value_doubleIsInt(to) ? ctx->rng()->randint(from, to) : ctx->rng()->randintDouble(from, to);
     }
 
-    double llvm_random_bool(bool from, bool to)
+    double llvm_random_bool(ExecutionContext *ctx, bool from, bool to)
     {
-        if (!llvm_rng)
-            llvm_rng = RandomGenerator::instance().get();
-
-        return llvm_rng->randint(from, to);
+        return ctx->rng()->randint(from, to);
     }
 }
 

src/dev/engine/internal/llvm/llvmfunctions.h

@@ -1,13 +1,13 @@
 #include <scratchcpp/value.h>
 #include <scratchcpp/dev/executablecode.h>
+#include <scratchcpp/dev/executioncontext.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/thread.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <dev/engine/internal/llvm/llvmcodebuilder.h>
-#include <dev/engine/internal/llvm/llvmfunctions.h>
 #include <gmock/gmock.h>
 #include <targetmock.h>
 #include <enginemock.h>
@@ -260,6 +260,7 @@ class LLVMCodeBuilderTest : public testing::Test
             script.setCode(code);
             Thread thread(&m_target, nullptr, &script);
             auto ctx = code->createExecutionContext(&thread);
+            ctx->setRng(&m_rng);
 
             testing::internal::CaptureStdout();
             code->run(ctx.get());
@@ -638,8 +639,6 @@ TEST_F(LLVMCodeBuilderTest, Divide)
 
 TEST_F(LLVMCodeBuilderTest, Random)
 {
-    llvm_rng = &m_rng;
-
     EXPECT_CALL(m_rng, randint(-45, 12)).Times(3).WillRepeatedly(Return(-18));
     runOpTest(OpType::Random, -45, 12);
 
@@ -716,8 +715,6 @@ TEST_F(LLVMCodeBuilderTest, Random)
     runOpTest(OpType::Random, -inf, -inf, -inf);
     runOpTest(OpType::Random, inf, -inf, nan);
     runOpTest(OpType::Random, -inf, inf, nan);
-
-    llvm_rng = nullptr;
 }
 
 TEST_F(LLVMCodeBuilderTest, EqualComparison)