Fixed memory bug with unary operators

ange-yaghi · Sep 14, 2020 · 8450a59 · 8450a59
1 parent 453f54f
commit 8450a59
Show file tree

Hide file tree

Showing 6 changed files with 42 additions and 6 deletions.
diff --git a/include/version.h b/include/version.h
@@ -1,6 +1,6 @@
 #ifndef PIRANHA_VERSION_H
 #define PIRANHA_VERSION_H
 
-#define PIRANHA_VERSION "v0.0.9a"
+#define PIRANHA_VERSION "v0.0.10a"
 
 #endif /* PIRANHA_VERSION_H */
diff --git a/src/ir_unary_operator.cpp b/src/ir_unary_operator.cpp
@@ -9,6 +9,7 @@
 #include "../include/ir_compilation_unit.h"
 #include "../include/ir_attribute.h"
 #include "../include/ir_attribute_list.h"
+#include "../include/ir_value_constant.h"
 #include "../include/memory_tracker.h"
 
 piranha::IrUnaryOperator::IrUnaryOperator(Operator op, IrValue *operand) : IrValue(IrValue::UNARY_OPERATION) {
@@ -80,7 +81,7 @@ void piranha::IrUnaryOperator::_expand(IrContextTree *context) {
 
     // Generate the expansion
     IrAttribute *attribute = TRACK(new IrAttribute());
-    attribute->setValue(m_operand);
+    attribute->setValue(TRACK(new IrInternalReference(m_operand, context)));
 
     IrAttributeList *attributeList = TRACK(new IrAttributeList());
     attributeList->addAttribute(attribute);

diff --git a/test/operator_tests.cpp b/test/operator_tests.cpp
@@ -280,6 +280,8 @@ TEST(IrOperatorTests, IrOperatorTest6) {
 }
 
 TEST(IrOperatorTests, IrOperatorTest7) {
+    MemoryTracker::get()->reset();
+
     const ErrorList *errList;
     Compiler *compiler;
     IrCompilationUnit *unit = compileToUnit("operator-tests/operator_test_7.mr", &errList, nullptr, &compiler);
@@ -295,6 +297,8 @@ TEST(IrOperatorTests, IrOperatorTest7) {
 }
 
 TEST(IrOperatorTests, IrOperatorTest8) {
+    MemoryTracker::get()->reset();
+
     const ErrorList *errList;
     LanguageRules *rules;
     Compiler *compiler;
@@ -319,3 +323,21 @@ TEST(IrOperatorTests, IrOperatorTest8) {
 
     EXPECT_EQ(MemoryTracker::get()->countLeaks(), 0);
 }
+
+TEST(IrOperatorTests, IrOperatorTest9) {
+    MemoryTracker::get()->reset();
+
+    const ErrorList *errList;
+    Compiler *compiler;
+    IrCompilationUnit *unit = compileToUnit("operator-tests/operator_test_9.mr", &errList, nullptr, &compiler);
+
+    EXPECT_EQ(errList->getErrorCount(), 0);
+
+    NodeProgram program;
+    unit->build(&program);
+
+    program.free();
+    compiler->free();
+
+    EXPECT_EQ(MemoryTracker::get()->countLeaks(), 0);
+}
diff --git a/test/sdl/operator-tests/operator_test_9.mr b/test/sdl/operator-tests/operator_test_9.mr
@@ -0,0 +1,8 @@
+private import "operators.mr" as operators
+
+node test {
+    input __in;
+    output __out: -__in; // InvalidOperandTypes
+}
+
+test test1(0.5)
diff --git a/test/sdl/operator-tests/operators.mr b/test/sdl/operator-tests/operators.mr
@@ -14,6 +14,11 @@ public inline node float_add => __piranha__float_add {
     alias output __out [float];
 }
 
+public inline node float_negate => __piranha__float_negate {
+    input __in;
+    alias output __out [float];
+}
+
 public inline node string_add => __piranha__string_add {
     input __in0;
     input __in1;

diff --git a/test/test_rules.cpp b/test/test_rules.cpp
@@ -218,18 +218,18 @@ void TestRules::registerBuiltinNodeTypes() {
         "__piranha__vector_positive"
     );
 
-    // NEGATIVE
+    // NEGATE
     registerUnaryOperator(
         { piranha::IrUnaryOperator::Operator::NumericNegate, &piranha::FundamentalType::IntType },
-        "__piranha__int_negative"
+        "__piranha__int_negate"
     );
     registerUnaryOperator(
         { piranha::IrUnaryOperator::Operator::NumericNegate, &piranha::FundamentalType::FloatType },
-        "__piranha__float_negative"
+        "__piranha__float_negate"
     );
     registerUnaryOperator(
         { piranha::IrUnaryOperator::Operator::NumericNegate, &piranha::FundamentalType::VectorType },
-        "__piranha__vector_negative"
+        "__piranha__vector_negate"
     );
 
     // INVERT