V3: Added postdom, and other stuff

VedantParanjape · VedantParanjape · commit fdb906f10497 · 2023-09-10T22:23:07.000+05:30
diff --git a/include/blocks/basic_blocks.h b/include/blocks/basic_blocks.h
@@ -10,10 +10,23 @@ 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;
         block::stmt::Ptr parent;
         unsigned int ast_index;
         unsigned int ast_depth;
diff --git a/include/blocks/dominance.h b/include/blocks/dominance.h
@@ -17,8 +17,9 @@ class dominator_analysis {
         //     int bb_id;
         //     std::vector<std::shared_ptr<dominator_tree_>> child_nodes;
         // } dominator_tree;
-        dominator_analysis(basic_block::cfg_block &cfg);
-        basic_block::cfg_block &cfg_;
+        dominator_analysis(basic_block::cfg_block cfg, bool is_postdom = false);
+        basic_block::cfg_block cfg_;
+        bool is_postdom_;
         std::vector<int> &get_postorder_bb_map();
         std::vector<int> &get_postorder();
         std::vector<int> &get_idom();
@@ -37,6 +38,7 @@ class dominator_analysis {
         std::vector<int> postorder_idom;
         std::vector<int> postorder;
         std::vector<int> postorder_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();
diff --git a/include/blocks/loops.h b/include/blocks/loops.h
@@ -28,13 +28,15 @@ class loop {
     std::unordered_set<int> blocks_id_map;
     std::shared_ptr<loop> parent_loop;
     std::shared_ptr<basic_block> header_block;
+    std::shared_ptr<basic_block> unique_exit_block;
     basic_block::cfg_block loop_latch_blocks;
+    basic_block::cfg_block loop_exit_blocks;
     std::vector<std::shared_ptr<loop>> subloops;
 };
 
 class loop_info {
 public:
-    loop_info(basic_block::cfg_block ast, dominator_analysis &dt): parent_ast(ast), dta(dt) {
+    loop_info(basic_block::cfg_block ast, dominator_analysis &dt, dominator_analysis &post_dt): parent_ast(ast), dta(dt), post_dta(post_dt) {
         analyze();
     }
     std::shared_ptr<loop> allocate_loop(std::shared_ptr<basic_block> header);
@@ -47,6 +49,7 @@ class loop_info {
 private:
     basic_block::cfg_block parent_ast;
     dominator_analysis dta;
+    dominator_analysis post_dta;
     std::map<int, std::shared_ptr<loop>> bb_loop_map;
     void postorder_dfs_helper(std::vector<int> &postorder_loops_map, std::vector<bool> &visited_loops, int id);
     void preorder_dfs_helper(std::vector<int> &preorder_loops_map, std::vector<bool> &visited_loops, int id);
diff --git a/src/blocks/basic_blocks.cpp b/src/blocks/basic_blocks.cpp
@@ -110,6 +110,8 @@ basic_block::cfg_block generate_basic_blocks(block::stmt_block::Ptr ast) {
                 then_bb->successor.push_back(exit_bb);
                 // set the successor of the original if_stmt block to be this then block
                 bb->successor.push_back(then_bb);
+                // set the then branch ptr
+                bb->then_branch = then_bb;
                 // push the block to the work_list, to expand it further
                 work_list.push_front(then_bb);
             }
@@ -126,13 +128,19 @@ basic_block::cfg_block generate_basic_blocks(block::stmt_block::Ptr ast) {
                 else_bb->successor.push_back(exit_bb);
                 // set the successor of the orignal if_stmt block to be this else block
                 bb->successor.push_back(else_bb);
+                // set the else branch ptr
+                bb->else_branch = else_bb;
                 // push the block to the work_list, to expand it further
                 work_list.insert(work_list.begin() + 1, else_bb);
             }
 
-            // if there is no else block, then have the exit block as successor as well.
+            // if there is no then/else block, then have the exit block as successor as well.
             if (bb->successor.size() <= 1) bb->successor.push_back(exit_bb);
 
+            // set the missing block as the exit block
+            if (!bb->then_branch) bb->then_branch = exit_bb;
+            else if (!bb->else_branch) bb->else_branch = exit_bb;
+
             return_list.push_back(bb);
         }
         else if (isa<block::expr_stmt>(bb->parent)) {
diff --git a/src/blocks/dominance.cpp b/src/blocks/dominance.cpp
@@ -2,7 +2,38 @@
 
 using namespace block;
 
-dominator_analysis::dominator_analysis(basic_block::cfg_block &cfg) : cfg_(cfg) {
+void dominator_analysis::reverse_cfg() {
+    // TODO: Add a check for size, it should be greater than 2.
+    if (cfg_.size() == 0)
+        assert(0);
+
+    std::shared_ptr<basic_block> virtual_exit_bb = std::make_shared<basic_block>("virtualexit0");
+    virtual_exit_bb->id = cfg_.size();
+    cfg_.push_back(virtual_exit_bb);
+    
+    for (auto bb: cfg_) {
+        if (bb->successor.size() == 0) {
+            bb->successor.push_back(virtual_exit_bb);
+            virtual_exit_bb->predecessor.push_back(bb);
+        }
+    }
+
+    for (auto bb: cfg_) {
+        basic_block::cfg_block temp_pred = bb->predecessor;
+        bb->predecessor.clear();
+        bb->predecessor.insert(bb->predecessor.begin(), bb->successor.begin(), bb->successor.end());
+        std::reverse(bb->predecessor.begin(), bb->predecessor.end());
+        bb->successor.clear();
+        bb->successor.insert(bb->successor.begin(), temp_pred.begin(), temp_pred.end());
+        std::reverse(bb->successor.begin(), bb->successor.end());
+    }
+}
+
+dominator_analysis::dominator_analysis(basic_block::cfg_block cfg, bool is_postdom) : cfg_(cfg), is_postdom_(is_postdom) {
+    if (is_postdom) {
+        reverse_cfg();
+    }
+
     // TODO: Add a check for size, it should be greater than 2.
     idom.reserve(cfg_.size());
     idom.assign(cfg_.size(), -1);
@@ -16,7 +47,6 @@ dominator_analysis::dominator_analysis(basic_block::cfg_block &cfg) : cfg_(cfg)
 
 void dominator_analysis::postorder_idom_helper(std::vector<bool> &visited, int id) {
     for (int idom_id: idom_map[id]) {
-        // std::cerr << idom_id << "\n";
         if (idom_id != -1 && !visited[idom_id]) {
             visited[idom_id] = true;
             postorder_idom_helper(visited, idom_id);
@@ -26,21 +56,31 @@ void dominator_analysis::postorder_idom_helper(std::vector<bool> &visited, int i
 }
 
 void dominator_analysis::postorder_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;
-            postorder_dfs_helper(visited_bbs, child->id);
-            postorder.push_back(child->id);
+        for (auto child: cfg_[id]->successor) {
+            if (!visited_bbs[child->id]) {
+                visited_bbs[child->id] = true;
+                postorder_dfs_helper(visited_bbs, child->id);
+                postorder.push_back(child->id);
+            }
         }
-    }    
 }
+
 void dominator_analysis::postorder_dfs() {
     std::vector<bool> visited_bbs(cfg_.size());
     visited_bbs.assign(visited_bbs.size(), false);
-    visited_bbs[0] = true;
-
-    postorder_dfs_helper(visited_bbs, 0);
-    postorder.push_back(0);
+    if (is_postdom_)
+        visited_bbs[cfg_.size() - 1] = true;
+    else
+        visited_bbs[0] = true;
+
+    if (is_postdom_) {
+        postorder_dfs_helper(visited_bbs, cfg_.size() - 1);
+        postorder.push_back(cfg_.size() - 1);
+    }
+    else {
+        postorder_dfs_helper(visited_bbs, 0);
+        postorder.push_back(0);
+    }
 }
 
 std::vector<int> &dominator_analysis::get_postorder_bb_map() {
@@ -121,12 +161,16 @@ int dominator_analysis::intersect(int bb1_id, int bb2_id) {
 }
 
 void dominator_analysis::analyze() {
-    postorder_dfs();
+    postorder_dfs();    
     for (unsigned int i = 0; i < postorder.size(); i++) {
         postorder_bb_map[postorder[i]] = i;
     }
 
-    idom[0] = 0;
+    if (is_postdom_)
+        idom[cfg_.size() - 1] = cfg_.size() - 1;
+    else
+        idom[0] = 0;
+
     bool change = false;
 
     do {
@@ -135,7 +179,7 @@ void dominator_analysis::analyze() {
             int postorder_bb_num = postorder[i];
             std::shared_ptr<basic_block> bb = cfg_[postorder_bb_num];
             int bb_id_idom = bb->predecessor[0]->id;
-             
+
             for (unsigned int j = 1; j < bb->predecessor.size(); j++) {
                 int bb_id_idom_next = bb->predecessor[j]->id;
                 if (idom[bb_id_idom_next] != -1) {
@@ -150,7 +194,6 @@ void dominator_analysis::analyze() {
         }
     } while(change);
 
-
     // build a map of dominators for easy traversal.
     for (unsigned int i = 0; i < idom.size(); i++) {
         idom_map[idom[i]].push_back(i);
diff --git a/src/blocks/loops.cpp b/src/blocks/loops.cpp
diff --git a/src/builder/builder_context.cpp b/src/builder/builder_context.cpp
