Merge pull request #48 from AjayBrahmakshatriya/master

Fixed a bug in sub expression cleanup

Author: AjayBrahmakshatriya

include/blocks/stmt.h

@@ -29,6 +29,10 @@ class expr_stmt : public stmt {
 
 	expr::Ptr expr1;
 
+	// member to keep track if this expr stmt
+	// has been spuriously created and needs to be deleted
+	bool mark_for_deletion = false;
+
 	virtual bool is_same(block::Ptr other) override {
 		if (!isa<expr_stmt>(other))
 			return false;

include/blocks/sub_expr_cleanup.h

@@ -0,0 +1,12 @@
+#ifndef SUB_EXPR_CLEANUP_H
+#define SUB_EXPR_CLEANUP_H
+#include "blocks/block_visitor.h"
+#include "blocks/stmt.h"
+namespace block {
+class sub_expr_cleanup : public block_visitor {
+public:
+	using block_visitor::visit;
+	virtual void visit(stmt_block::Ptr);
+};
+} // namespace block
+#endif

samples/outputs.var_names/sample48

@@ -0,0 +1,26 @@
+FUNC_DECL
+  SCALAR_TYPE (VOID)
+  STMT_BLOCK
+    DECL_STMT
+      SCALAR_TYPE (INT)
+      VAR (x_0)
+      NO_INITIALIZATION
+    WHILE_STMT
+      INT_CONST (1)
+      STMT_BLOCK
+        DECL_STMT
+          SCALAR_TYPE (INT)
+          VAR (var1)
+          INT_CONST (1)
+        DECL_STMT
+          SCALAR_TYPE (INT)
+          VAR (var2)
+          INT_CONST (2)
+void my_bar (void) {
+  int x_0;
+  while (1) {
+    int var1 = 1;
+    int var2 = 2;
+  }
+}
+

samples/outputs/sample48

@@ -0,0 +1,26 @@
+FUNC_DECL
+  SCALAR_TYPE (VOID)
+  STMT_BLOCK
+    DECL_STMT
+      SCALAR_TYPE (INT)
+      VAR (var0)
+      NO_INITIALIZATION
+    WHILE_STMT
+      INT_CONST (1)
+      STMT_BLOCK
+        DECL_STMT
+          SCALAR_TYPE (INT)
+          VAR (var1)
+          INT_CONST (1)
+        DECL_STMT
+          SCALAR_TYPE (INT)
+          VAR (var2)
+          INT_CONST (2)
+void my_bar (void) {
+  int var0;
+  while (1) {
+    int var1 = 1;
+    int var2 = 2;
+  }
+}
+

samples/sample48.cpp

@@ -0,0 +1,22 @@
+#include "blocks/c_code_generator.h"
+#include "builder/array.h"
+#include "builder/dyn_var.h"
+#include "builder/static_var.h"
+
+using builder::dyn_arr;
+using builder::dyn_var;
+using builder::static_var;
+
+static void foo(void) {
+	dyn_var<int> x;
+	while (1)
+		dyn_arr<int, 2> z = {1, 2};
+}
+int main(int argc, char *argv[]) {
+	builder::builder_context context;
+	auto ast = context.extract_function_ast(foo, "my_bar");
+	ast->dump(std::cout, 0);
+
+	block::c_code_generator::generate_code(ast, std::cout, 0);
+	return 0;
+}

src/blocks/sub_expr_cleanup.cpp

@@ -0,0 +1,16 @@
+#include "blocks/sub_expr_cleanup.h"
+
+namespace block {
+
+void sub_expr_cleanup::visit(stmt_block::Ptr sb) {
+	std::vector<stmt::Ptr> new_stmts;
+	for (auto stmt : sb->stmts) {
+		if (!isa<expr_stmt>(stmt) || !to<expr_stmt>(stmt)->mark_for_deletion) {
+			new_stmts.push_back(stmt);
+		}
+	}
+	sb->stmts = new_stmts;
+	block_visitor::visit(sb);
+}
+
+} // namespace block

src/builder/builder_context.cpp

@@ -5,6 +5,7 @@
 #include "blocks/loop_finder.h"
 #include "blocks/loop_roll.h"
 #include "blocks/rce.h"
+#include "blocks/sub_expr_cleanup.h"
 #include "blocks/var_namer.h"
 #include "builder/builder.h"
 #include "builder/dyn_var.h"
@@ -97,18 +98,16 @@ void builder_context::remove_node_from_sequence(block::expr::Ptr e) {
 	} else {
 		// Could be committed already
 		// It is safe to update the parent block here, because the memoization doesn't care about indices
-		std::vector<block::stmt::Ptr> new_stmts;
+		// But don't actually delete the statement, because there could be gotos that are jumping here
+		// instead just mark it for deletion later
 		for (auto stmt : current_block_stmt->stmts) {
-			bool found = false;
 			if (block::isa<block::expr_stmt>(stmt)) {
 				auto expr_s = block::to<block::expr_stmt>(stmt);
-				if (expr_s->expr1 == e)
-					found = true;
+				if (expr_s->expr1 == e) {
+					expr_s->mark_for_deletion = true;
+				}
 			}
-			if (!found)
-				new_stmts.push_back(stmt);
 		}
-		current_block_stmt->stmts = new_stmts;
 	}
 }
 void builder_context::add_node_to_sequence(block::expr::Ptr e) {
@@ -284,6 +283,11 @@ block::stmt::Ptr builder_context::extract_ast_from_function_impl(void) {
 	inserter.offset_to_label = creator.offset_to_label;
 	ast->accept(&inserter);
 
+	// At this point it is safe to remove statements that are
+	// marked for deletion
+	block::sub_expr_cleanup cleaner;
+	ast->accept(&cleaner);
+
 	if (run_rce) {
 		block::eliminate_redundant_vars(ast);
 	}