WIP v3: got majority test cases working

Author: VedantParanjape

include/blocks/basic_blocks.h

@@ -10,23 +10,13 @@ class basic_block {
     public:
         typedef std::vector<std::shared_ptr<basic_block>> cfg_block;
         basic_block(std::string label): name(label) {};
-        // only does a shallow copy (leaves out predecessors and successors)
-        // basic_block(basic_block &bb) {
-        //     bb.branch_expr = branch_expr;
-        //     bb.then_branch = then_branch;
-        //     bb.else_branch = else_branch;
-        //     bb.parent = parent;
-        //     bb.ast_index = ast_index;
-        //     bb.ast_depth = ast_depth;
-        //     bb.id = id;
-        //     bb.name = name;
-        // }
 
         cfg_block predecessor;
         cfg_block successor;
         block::expr::Ptr branch_expr;
         std::shared_ptr<basic_block> then_branch;
         std::shared_ptr<basic_block> else_branch;
+        bool is_exit_block;
         block::stmt::Ptr parent;
         unsigned int ast_index;
         unsigned int ast_depth;

include/blocks/dominance.h

@@ -22,6 +22,8 @@ class dominator_analysis {
         bool is_postdom_;
         std::vector<int> &get_postorder_bb_map();
         std::vector<int> &get_postorder();
+        std::vector<int> &get_preorder_bb_map();
+        std::vector<int> &get_preorder(); 
         std::vector<int> &get_idom();
         std::map<int, std::vector<int>> &get_idom_map();
         std::vector<int> &get_postorder_idom_map();
@@ -38,10 +40,14 @@ class dominator_analysis {
         std::vector<int> postorder_idom;
         std::vector<int> postorder;
         std::vector<int> postorder_bb_map;
+        std::vector<int> preorder;
+        std::vector<int> preorder_bb_map;
         void reverse_cfg();
         void postorder_idom_helper(std::vector<bool> &visited, int id);
         void postorder_dfs_helper(std::vector<bool> &visited_bbs, int id);
         void postorder_dfs();
+        void preorder_dfs_helper(std::vector<bool> &visited_bbs, int id);
+        void preorder_dfs();
         int intersect(int bb1_id, int bb2_id);
 };
 

src/blocks/basic_blocks.cpp

@@ -81,6 +81,8 @@ basic_block::cfg_block generate_basic_blocks(block::stmt_block::Ptr ast) {
             auto exit_bb = std::make_shared<basic_block>("exit" + std::to_string(basic_block_count));
             // assign it a empty stmt_block as parent
             exit_bb->parent = std::make_shared<stmt_block>();
+            // mark the basic block as exit block
+            exit_bb->is_exit_block = true;
             // add mapping in ast to bb map
             // exit_bb->ast_to_basic_block_map[exit_bb->parent] = exit_bb;
             // set the ast depth of the basic block

src/blocks/dominance.cpp

@@ -40,6 +40,9 @@ dominator_analysis::dominator_analysis(basic_block::cfg_block cfg, bool is_postd
     postorder.reserve(cfg_.size());
     postorder_bb_map.reserve(cfg_.size());
     postorder_bb_map.assign(cfg_.size(), -1);
+    preorder.reserve(cfg_.size());
+    preorder_bb_map.reserve(cfg_.size());
+    preorder_bb_map.assign(cfg_.size(), -1);
 
     // and call the anaylse function
     analyze();
@@ -83,6 +86,34 @@ void dominator_analysis::postorder_dfs() {
     }
 }
 
+void dominator_analysis::preorder_dfs_helper(std::vector<bool> &visited_bbs, int id) {
+        for (auto child: cfg_[id]->successor) {
+            if (!visited_bbs[child->id]) {
+                visited_bbs[child->id] = true;
+                preorder.push_back(child->id);
+                preorder_dfs_helper(visited_bbs, child->id);
+            }
+        }
+}
+
+void dominator_analysis::preorder_dfs() {
+    std::vector<bool> visited_bbs(cfg_.size());
+    visited_bbs.assign(visited_bbs.size(), false);
+    if (is_postdom_)
+        visited_bbs[cfg_.size() - 1] = true;
+    else
+        visited_bbs[0] = true;
+
+    if (is_postdom_) {
+        preorder.push_back(cfg_.size() - 1);
+        preorder_dfs_helper(visited_bbs, cfg_.size() - 1);
+    }
+    else {
+        preorder.push_back(0);
+        preorder_dfs_helper(visited_bbs, 0);
+    }
+}
+
 std::vector<int> &dominator_analysis::get_postorder_bb_map() {
     return postorder_bb_map;
 }
@@ -91,6 +122,14 @@ std::vector<int> &dominator_analysis::get_postorder() {
     return postorder;
 }
 
+std::vector<int> &dominator_analysis::get_preorder_bb_map() {
+    return preorder_bb_map;
+}
+
+std::vector<int> &dominator_analysis::get_preorder() {
+    return preorder;
+}
+
 std::vector<int> &dominator_analysis::get_idom() {
     return idom;
 }
@@ -161,11 +200,14 @@ int dominator_analysis::intersect(int bb1_id, int bb2_id) {
 }
 
 void dominator_analysis::analyze() {
-    postorder_dfs();    
+    preorder_dfs();
+    postorder_dfs(); 
+    for (unsigned int i = 0; i < preorder.size(); i++) {
+        preorder_bb_map[preorder[i]] = i;
+    }
     for (unsigned int i = 0; i < postorder.size(); i++) {
         postorder_bb_map[postorder[i]] = i;
     }
-
     if (is_postdom_)
         idom[cfg_.size() - 1] = cfg_.size() - 1;
     else