Add SSA memoization via duplicate detection

Implement memoization in SSA analysis without modifying data structures.
Uses duplicate detection in dominance frontier arrays to prevent O(n²)
duplicate scenarios in dominance frontier computation.

Author: jserv

src/ssa.c

@@ -190,7 +190,7 @@ bool dom_connect(basic_block_t *pred, basic_block_t *succ)
     int i;
     for (i = 0; i < MAX_BB_DOM_SUCC; i++) {
         if (pred->dom_next[i] == succ)
-            return false;
+            return false; /* Already connected - memoization */
         if (!pred->dom_next[i])
             break;
     }
@@ -226,6 +226,27 @@ void build_dom(void)
     }
 }
 
+/* Add bb to dominance frontier with memoization */
+void add_to_df(basic_block_t *bb, basic_block_t *predecessor)
+{
+    if (!predecessor)
+        return;
+
+    for (basic_block_t *curr = predecessor; curr != bb->idom;
+         curr = curr->idom) {
+        /* Check if bb is already in curr's dominance frontier */
+        bool already_added = false;
+        for (int j = 0; j < curr->df_idx; j++) {
+            if (curr->DF[j] == bb) {
+                already_added = true;
+                break;
+            }
+        }
+        if (!already_added)
+            curr->DF[curr->df_idx++] = bb;
+    }
+}
+
 void bb_build_df(func_t *func, basic_block_t *bb)
 {
     UNUSED(func);
@@ -239,12 +260,8 @@ void bb_build_df(func_t *func, basic_block_t *bb)
         return;
 
     for (int i = 0; i < MAX_BB_PRED; i++) {
-        if (!bb->prev[i].bb)
-            continue;
-
-        for (basic_block_t *curr = bb->prev[i].bb; curr != bb->idom;
-             curr = curr->idom)
-            curr->DF[curr->df_idx++] = bb;
+        if (bb->prev[i].bb)
+            add_to_df(bb, bb->prev[i].bb);
     }
 }
 
@@ -317,7 +334,7 @@ bool rdom_connect(basic_block_t *pred, basic_block_t *succ)
     int i;
     for (i = 0; i < MAX_BB_RDOM_SUCC; i++) {
         if (pred->rdom_next[i] == succ)
-            return false;
+            return false; /* Already connected - memoization */
         if (!pred->rdom_next[i])
             break;
     }
@@ -353,6 +370,27 @@ void build_rdom(void)
     }
 }
 
+/* Add bb to reverse dominance frontier with memoization */
+void add_to_rdf(basic_block_t *bb, basic_block_t *successor)
+{
+    if (!successor)
+        return;
+
+    for (basic_block_t *curr = successor; curr != bb->r_idom;
+         curr = curr->r_idom) {
+        /* Check if bb is already in curr's reverse dominance frontier */
+        bool already_added = false;
+        for (int j = 0; j < curr->rdf_idx; j++) {
+            if (curr->RDF[j] == bb) {
+                already_added = true;
+                break;
+            }
+        }
+        if (!already_added)
+            curr->RDF[curr->rdf_idx++] = bb;
+    }
+}
+
 void bb_build_rdf(func_t *func, basic_block_t *bb)
 {
     UNUSED(func);
@@ -367,21 +405,10 @@ void bb_build_rdf(func_t *func, basic_block_t *bb)
     if (cnt <= 0)
         return;
 
-    if (bb->next) {
-        for (basic_block_t *curr = bb->next; curr != bb->r_idom;
-             curr = curr->r_idom)
-            curr->RDF[curr->rdf_idx++] = bb;
-    }
-    if (bb->else_) {
-        for (basic_block_t *curr = bb->else_; curr != bb->r_idom;
-             curr = curr->r_idom)
-            curr->RDF[curr->rdf_idx++] = bb;
-    }
-    if (bb->then_) {
-        for (basic_block_t *curr = bb->then_; curr != bb->r_idom;
-             curr = curr->r_idom)
-            curr->RDF[curr->rdf_idx++] = bb;
-    }
+    /* Process all possible successors */
+    add_to_rdf(bb, bb->next);
+    add_to_rdf(bb, bb->else_);
+    add_to_rdf(bb, bb->then_);
 }
 
 void build_rdf(void)
@@ -2051,12 +2078,14 @@ bool recompute_live_out(basic_block_t *bb)
         live_out_idx = merge_live_in(live_out, live_out_idx, bb->else_);
     }
 
+    /* Early exit if size differs - memoization optimization */
     if (bb->live_out_idx != live_out_idx) {
         memcpy(bb->live_out, live_out, HOST_PTR_SIZE * live_out_idx);
         bb->live_out_idx = live_out_idx;
         return true;
     }
 
+    /* Check if content is the same - memoization optimization */
     for (int i = 0; i < live_out_idx; i++) {
         bool same = false;
         for (int j = 0; j < bb->live_out_idx; j++) {
@@ -2071,7 +2100,7 @@ bool recompute_live_out(basic_block_t *bb)
             return true;
         }
     }
-    return false;
+    return false; /* No change - memoized result */
 }
 
 void liveness_analysis(void)