LLVMCodeBuilder: Implement hat predicates

Author: adazem009

src/engine/internal/llvm/llvmcodebuilder.cpp

@@ -26,15 +26,16 @@ static std::unordered_map<ValueType, Compiler::StaticType>
 static const std::unordered_set<LLVMInstruction::Type>
     VAR_LIST_READ_INSTRUCTIONS = { LLVMInstruction::Type::ReadVariable, LLVMInstruction::Type::GetListItem, LLVMInstruction::Type::GetListItemIndex, LLVMInstruction::Type::ListContainsItem };
 
-LLVMCodeBuilder::LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype) :
+LLVMCodeBuilder::LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype, bool isPredicate) :
     m_ctx(ctx),
     m_target(ctx->target()),
     m_llvmCtx(*ctx->llvmCtx()),
     m_module(ctx->module()),
     m_builder(m_llvmCtx),
     m_procedurePrototype(procedurePrototype),
     m_defaultWarp(procedurePrototype ? procedurePrototype->warp() : false),
-    m_warp(m_defaultWarp)
+    m_warp(m_defaultWarp),
+    m_isPredicate(isPredicate)
 {
     initTypes();
     createVariableMap();
@@ -54,6 +55,10 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
 
         if (it == m_instructions.end())
             m_warp = true;
+
+        // Do not create coroutine in hat predicates
+        if (m_isPredicate)
+            m_warp = true;
     }
 
     // Set fast math flags
@@ -1314,10 +1319,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     // End and verify the function
     llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_llvmCtx), 0);
 
-    if (m_warp)
-        m_builder.CreateRet(llvm::ConstantPointerNull::get(pointerType));
-    else
-        coro->end();
+    if (m_isPredicate) {
+        // Use last instruction return value
+        assert(!m_instructions.empty());
+        m_builder.CreateRet(m_instructions.back()->functionReturnReg->value);
+    } else {
+        if (m_warp)
+            m_builder.CreateRet(llvm::ConstantPointerNull::get(pointerType));
+        else
+            coro->end();
+    }
 
     verifyFunction(m_function);
 
@@ -1338,7 +1349,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
 
     verifyFunction(resumeFunc);
 
-    return std::make_shared<LLVMExecutableCode>(m_ctx, m_function->getName().str(), resumeFunc->getName().str());
+    return std::make_shared<LLVMExecutableCode>(m_ctx, m_function->getName().str(), resumeFunc->getName().str(), m_isPredicate);
 }
 
 CompilerValue *LLVMCodeBuilder::addFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args)
@@ -2008,7 +2019,7 @@ void LLVMCodeBuilder::popLoopScope()
 
 std::string LLVMCodeBuilder::getMainFunctionName(BlockPrototype *procedurePrototype)
 {
-    return procedurePrototype ? "proc." + procedurePrototype->procCode() : "script";
+    return procedurePrototype ? "proc." + procedurePrototype->procCode() : (m_isPredicate ? "predicate" : "script");
 }
 
 std::string LLVMCodeBuilder::getResumeFunctionName(BlockPrototype *procedurePrototype)
@@ -2019,7 +2030,8 @@ std::string LLVMCodeBuilder::getResumeFunctionName(BlockPrototype *procedureProt
 llvm::FunctionType *LLVMCodeBuilder::getMainFunctionType(BlockPrototype *procedurePrototype)
 {
     // void *f(ExecutionContext *, Target *, ValueData **, List **, (warp arg), (procedure args...))
-    llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_llvmCtx), 0);
+    // bool f(...) (hat predicates)
+    llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_llvmCtx), 0);
     std::vector<llvm::Type *> argTypes = { pointerType, pointerType, pointerType, pointerType };
 
     if (procedurePrototype) {
@@ -2034,7 +2046,7 @@ llvm::FunctionType *LLVMCodeBuilder::getMainFunctionType(BlockPrototype *procedu
         }
     }
 
-    return llvm::FunctionType::get(pointerType, argTypes, false);
+    return llvm::FunctionType::get(m_isPredicate ? m_builder.getInt1Ty() : pointerType, argTypes, false);
 }
 
 llvm::Function *LLVMCodeBuilder::getOrCreateFunction(const std::string &name, llvm::FunctionType *type)

src/engine/internal/llvm/llvmcodebuilder.h

@@ -25,7 +25,7 @@ class LLVMLoopScope;
 class LLVMCodeBuilder : public ICodeBuilder
 {
     public:
-        LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr);
+        LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, bool isPredicate = false);
 
         std::shared_ptr<ExecutableCode> finalize() override;
 
@@ -239,6 +239,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         bool m_defaultWarp = false;
         bool m_warp = false;
         int m_defaultArgCount = 0;
+        bool m_isPredicate = false; // for hat predicates
 
         long m_loopScope = -1; // index
         std::vector<std::shared_ptr<LLVMLoopScope>> m_loopScopes;

test/llvm/llvmcodebuilder_test.cpp

@@ -67,12 +67,12 @@ class LLVMCodeBuilderTest : public testing::Test
             test_function(nullptr, nullptr, nullptr, nullptr, nullptr); // force dependency
         }
 
-        void createBuilder(Target *target, BlockPrototype *procedurePrototype)
+        void createBuilder(Target *target, BlockPrototype *procedurePrototype, bool isPredicate = false)
         {
             if (m_contexts.find(target) == m_contexts.cend() || !target)
                 m_contexts[target] = std::make_unique<LLVMCompilerContext>(&m_engine, target);
 
-            m_builder = std::make_unique<LLVMCodeBuilder>(m_contexts[target].get(), procedurePrototype);
+            m_builder = std::make_unique<LLVMCodeBuilder>(m_contexts[target].get(), procedurePrototype, isPredicate);
         }
 
         void createBuilder(Target *target, bool warp)
@@ -82,6 +82,8 @@ class LLVMCodeBuilderTest : public testing::Test
             createBuilder(target, m_procedurePrototype.get());
         }
 
+        void createPredicateBuilder(Target *target) { createBuilder(target, nullptr, true); }
+
         void createBuilder(bool warp) { createBuilder(nullptr, warp); }
 
         CompilerValue *callConstFuncForType(ValueType type, CompilerValue *arg)
@@ -5995,3 +5997,38 @@ TEST_F(LLVMCodeBuilderTest, Procedures)
     ASSERT_EQ(testing::internal::GetCapturedStdout(), expected2 + expected3);
     ASSERT_TRUE(code->isFinished(ctx.get()));
 }
+
+TEST_F(LLVMCodeBuilderTest, HatPredicates)
+{
+    Sprite sprite;
+
+    // Predicate 1
+    createPredicateBuilder(&sprite);
+
+    CompilerValue *v = m_builder->addConstValue(true);
+    m_builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v });
+
+    auto code1 = m_builder->finalize();
+
+    // Predicate 2
+    createPredicateBuilder(&sprite);
+
+    v = m_builder->addConstValue(false);
+    m_builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v });
+
+    auto code2 = m_builder->finalize();
+
+    Script script1(&sprite, nullptr, nullptr);
+    script1.setCode(code1);
+    Thread thread1(&sprite, nullptr, &script1);
+    auto ctx = code1->createExecutionContext(&thread1);
+
+    ASSERT_TRUE(code1->runPredicate(ctx.get()));
+
+    Script script2(&sprite, nullptr, nullptr);
+    script2.setCode(code2);
+    Thread thread2(&sprite, nullptr, &script2);
+    ctx = code2->createExecutionContext(&thread2);
+
+    ASSERT_FALSE(code2->runPredicate(ctx.get()));
+}