LLVMCodeBuilder: Implement not gate

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -35,6 +35,8 @@ class ICodeBuilder
 
         virtual void createAnd() = 0;
         virtual void createOr() = 0;
+        virtual void createNot() = 0;
+
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;

src/dev/engine/internal/llvmcodebuilder.cpp

@@ -172,6 +172,14 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case Step::Type::Not: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                llvm::Value *value = castValue(arg.second, arg.first);
+                step.functionReturnReg->value = m_builder.CreateNot(value);
+                break;
+            }
+
             case Step::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -535,6 +543,11 @@ void LLVMCodeBuilder::createOr()
     createOp(Step::Type::Or, Compiler::StaticType::Bool, Compiler::StaticType::Bool, 2);
 }
 
+void LLVMCodeBuilder::createNot()
+{
+    createOp(Step::Type::Not, Compiler::StaticType::Bool, Compiler::StaticType::Bool, 1);
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     Step step(Step::Type::BeginIf);

src/dev/engine/internal/llvmcodebuilder.h

@@ -37,6 +37,8 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void createAnd() override;
         void createOr() override;
+        void createNot() override;
+
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -78,6 +80,7 @@ class LLVMCodeBuilder : public ICodeBuilder
                     CmpLT,
                     And,
                     Or,
+                    Not,
                     Yield,
                     BeginIf,
                     BeginElse,

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -962,6 +962,68 @@ TEST_F(LLVMCodeBuilderTest, AndOr)
     addOpTest("nan", nan);
 }
 
+TEST_F(LLVMCodeBuilderTest, Not)
+{
+    auto addOpTest = [this](Value v) {
+        createBuilder(true);
+
+        m_builder->addConstValue(v);
+        m_builder->createNot();
+        m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+        m_builder->addConstValue(v);
+        callConstFuncForType(v.type());
+        m_builder->createNot();
+        m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
+
+        std::string str = Value(!v.toBool()).toString() + '\n';
+        std::string expected = str + str;
+
+        auto code = m_builder->finalize();
+        auto ctx = code->createExecutionContext(&m_target);
+
+        testing::internal::CaptureStdout();
+        code->run(ctx.get());
+        const std::string quotes = v.isString() ? "\"" : "";
+        ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << "NOT: " << quotes << v.toString() << quotes;
+    };
+
+    addOpTest(10);
+    addOpTest(-4.25);
+    addOpTest(5.312);
+    addOpTest(1);
+    addOpTest(0);
+
+    addOpTest(true);
+    addOpTest(false);
+
+    addOpTest("abc");
+    addOpTest("5.25");
+    addOpTest("0");
+
+    static const double inf = std::numeric_limits<double>::infinity();
+    static const double nan = std::numeric_limits<double>::quiet_NaN();
+
+    addOpTest(inf);
+    addOpTest(-inf);
+    addOpTest(nan);
+
+    addOpTest("true");
+    addOpTest("false");
+    addOpTest("TRUE");
+    addOpTest("FALSE");
+
+    addOpTest("00001");
+    addOpTest("00000");
+
+    addOpTest("Infinity");
+    addOpTest("infinity");
+    addOpTest("-Infinity");
+    addOpTest("-infinity");
+    addOpTest("NaN");
+    addOpTest("nan");
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {

test/mocks/codebuildermock.h

@@ -25,6 +25,8 @@ class CodeBuilderMock : public ICodeBuilder
 
         MOCK_METHOD(void, createAnd, (), (override));
         MOCK_METHOD(void, createOr, (), (override));
+        MOCK_METHOD(void, createNot, (), (override));
+
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));
         MOCK_METHOD(void, endIf, (), (override));