Extend CSE to support more binary operations

- Add CSE support for OP_add and OP_mul with commutativity
- Add CSE support for OP_sub and OP_div without commutativity

Author: jserv

src/ssa.c

@@ -1220,78 +1220,146 @@ void ssa_build(void)
 /* TODO: release detached insns node */
 bool cse(insn_t *insn, basic_block_t *bb)
 {
-    if (insn->opcode != OP_read)
-        return false;
+    /* Handle memory reads */
+    if (insn->opcode == OP_read) {
+        insn_t *prev = insn->prev;
+        if (!prev)
+            return false;
+        if (prev->opcode != OP_add)
+            return false;
+        if (prev->rd != insn->rs1)
+            return false;
 
-    insn_t *prev = insn->prev;
-    if (!prev)
-        return false;
-    if (prev->opcode != OP_add)
-        return false;
-    if (prev->rd != insn->rs1)
-        return false;
+        var_t *def = insn->rd, *base = prev->rs1, *idx = prev->rs2;
+        if (base->is_global || idx->is_global)
+            return false;
 
-    var_t *def = insn->rd, *base = prev->rs1, *idx = prev->rs2;
-    if (base->is_global || idx->is_global)
-        return false;
+        use_chain_t *rs1_delete_user = NULL, *rs2_delete_user = NULL;
+        for (use_chain_t *user = base->users_head; user; user = user->next) {
+            insn_t *i = user->insn;
+
+            /* Delete the use chain nodes found in the last loop */
+            if (rs1_delete_user) {
+                use_chain_delete(rs1_delete_user, rs1_delete_user->insn->rs1);
+                rs1_delete_user = NULL;
+            }
+            if (rs2_delete_user) {
+                use_chain_delete(rs2_delete_user, rs2_delete_user->insn->rs2);
+                rs2_delete_user = NULL;
+            }
+            if (i == prev)
+                continue;
+            if (i->opcode != OP_add)
+                continue;
+            if (!i->next)
+                continue;
+            if (i->next->opcode != OP_read)
+                continue;
+            if (i->rs1 != base || i->rs2 != idx)
+                continue;
 
-    use_chain_t *rs1_delete_user = NULL;
-    use_chain_t *rs2_delete_user = NULL;
-    for (use_chain_t *user = base->users_head; user; user = user->next) {
-        insn_t *i = user->insn;
+            basic_block_t *i_bb = i->belong_to;
+            bool check_dom = 0;
+            /* Check if the instructions are under the same dominate tree */
+            for (;; i_bb = i_bb->idom) {
+                if (i_bb == bb) {
+                    check_dom = true;
+                    break;
+                }
+                if (i_bb == i_bb->idom)
+                    break;
+            }
+            if (!check_dom)
+                continue;
 
-        /* Delete the use chain nodes found in the last loop */
-        if (rs1_delete_user) {
-            use_chain_delete(rs1_delete_user, rs1_delete_user->insn->rs1);
-            rs1_delete_user = NULL;
-        }
-        if (rs2_delete_user) {
-            use_chain_delete(rs2_delete_user, rs2_delete_user->insn->rs2);
-            rs2_delete_user = NULL;
+            i->next->opcode = OP_assign;
+            i->next->rs1 = def;
+            if (i->prev) {
+                i->prev->next = i->next;
+                i->next->prev = i->prev;
+            } else {
+                i->belong_to->insn_list.head = i->next;
+                i->next->prev = NULL;
+            }
+            i->next->opcode = OP_assign;
+            i->next->rs1 = def;
+            /* Prepare information for deleting use chain nodes */
+            rs1_delete_user = user;
+            for (rs2_delete_user = i->rs2->users_head;
+                 rs2_delete_user->insn != rs1_delete_user->insn;
+                 rs2_delete_user = rs2_delete_user->next)
+                ;
         }
-        if (i == prev)
-            continue;
-        if (i->opcode != OP_add)
-            continue;
-        if (!i->next)
-            continue;
-        if (i->next->opcode != OP_read)
-            continue;
-        if (i->rs1 != base || i->rs2 != idx)
-            continue;
-        basic_block_t *i_bb = i->belong_to;
-        bool check_dom = 0;
-        /* Check if the instructions are under the same dominate tree */
-        for (;; i_bb = i_bb->idom) {
-            if (i_bb == bb) {
-                check_dom = true;
-                break;
+        return true;
+    }
+
+    /* Handle non-commutative binary operations (OP_sub, OP_div) */
+    if (insn->opcode == OP_sub || insn->opcode == OP_div) {
+        if (!insn->rs1 || !insn->rs2 || !insn->rd)
+            return false;
+
+        /* Don't CSE operations with global variables (safety) */
+        if (insn->rs1->is_global || insn->rs2->is_global)
+            return false;
+
+        /* Look for identical expressions in the same basic block */
+        for (insn_t *candidate = bb->insn_list.head;
+             candidate && candidate != insn; candidate = candidate->next) {
+            if (candidate->opcode != insn->opcode || !candidate->rd)
+                continue;
+
+            if (!candidate->rs1 || !candidate->rs2)
+                continue;
+
+            /* Check for exact match only (no commutativity for sub/div) */
+            if (candidate->rs1 == insn->rs1 && candidate->rs2 == insn->rs2) {
+                insn->opcode = OP_assign;
+                insn->rs1 = candidate->rd;
+                insn->rs2 = NULL;
+                return true;
             }
-            if (i_bb == i_bb->idom)
-                break;
         }
-        if (!check_dom)
-            continue;
+        return false;
+    }
 
-        i->next->opcode = OP_assign;
-        i->next->rs1 = def;
-        if (i->prev) {
-            i->prev->next = i->next;
-            i->next->prev = i->prev;
-        } else {
-            i->belong_to->insn_list.head = i->next;
-            i->next->prev = NULL;
+    /* Handle commutative binary operations (OP_add, OP_mul) */
+    if (insn->opcode == OP_add || insn->opcode == OP_mul) {
+        if (!insn->rs1 || !insn->rs2 || !insn->rd)
+            return false;
+
+        /* Don't CSE operations with global variables (safety) */
+        if (insn->rs1->is_global || insn->rs2->is_global)
+            return false;
+
+        /* Look for identical expressions in the same basic block */
+        for (insn_t *candidate = bb->insn_list.head;
+             candidate && candidate != insn; candidate = candidate->next) {
+            if (candidate->opcode != insn->opcode || !candidate->rd)
+                continue;
+
+            if (!candidate->rs1 || !candidate->rs2)
+                continue;
+
+            /* Check for exact match: a op b */
+            if (candidate->rs1 == insn->rs1 && candidate->rs2 == insn->rs2) {
+                insn->opcode = OP_assign;
+                insn->rs1 = candidate->rd;
+                insn->rs2 = NULL;
+                return true;
+            }
+
+            /* Check for commutative match: b op a = a op b */
+            if (candidate->rs1 == insn->rs2 && candidate->rs2 == insn->rs1) {
+                insn->opcode = OP_assign;
+                insn->rs1 = candidate->rd;
+                insn->rs2 = NULL;
+                return true;
+            }
         }
-        i->next->opcode = OP_assign;
-        i->next->rs1 = def;
-        /* Prepare information for deleting use chain nodes */
-        rs1_delete_user = user;
-        for (rs2_delete_user = i->rs2->users_head;
-             rs2_delete_user->insn != rs1_delete_user->insn;
-             rs2_delete_user = rs2_delete_user->next)
-            ;
+        return false;
     }
-    return true;
+
+    return false;
 }
 
 bool mark_const(insn_t *insn)