Reduce nested levels from 6 to 4

- Restructure conditional checks using early exit pattern
- Consolidate skip conditions with sequential continue statements

Author: jserv

src/ssa.c

@@ -606,59 +606,66 @@ void solve_phi_insertion(void)
             basic_block_t *work_list[64];
             int work_list_idx = 0;
 
+            /* Initialize work list with blocks that reference this variable */
             for (ref_block_t *ref = var->ref_block_list.head; ref;
                  ref = ref->next) {
                 if (work_list_idx >= 64) /* Prevent buffer overflow */
                     break;
                 work_list[work_list_idx++] = ref->bb;
             }
 
+            /* Process work list items */
             for (int i = 0; i < work_list_idx; i++) {
                 basic_block_t *bb = work_list[i];
+
                 for (int j = 0; j < bb->df_idx; j++) {
                     basic_block_t *df = bb->DF[j];
+
+                    /* Skip early conditions */
                     if (!var_check_in_scope(var, df->scope))
                         continue;
+                    if (df == func->exit)
+                        continue;
+                    if (var->is_global)
+                        continue;
 
+                    /* Check if variable already declared in this block */
                     bool is_decl = false;
                     for (symbol_t *s = df->symbol_list.head; s; s = s->next) {
                         if (s->var == var) {
                             is_decl = true;
                             break;
                         }
                     }
-
                     if (is_decl)
                         continue;
 
-                    if (df == func->exit)
+                    /* Try to insert phi instruction */
+                    if (!insert_phi_insn(df, var))
                         continue;
 
-                    if (var->is_global)
+                    /* Restrict phi insertion of ternary operation, and
+                     * logical-and/or operation.
+                     *
+                     * The ternary and logical-and/or operations don't
+                     * create new scope, so prevent temporary variable from
+                     * propagating through the dominance tree.
+                     */
+                    if (var->is_ternary_ret || var->is_logical_ret)
                         continue;
 
-                    if (insert_phi_insn(df, var)) {
-                        bool found = false;
-
-                        /* Restrict phi insertion of ternary operation, and
-                         * logical-and/or operation.
-                         *
-                         * The ternary and logical-and/or operations don't
-                         * create new scope, so prevent temporary variable from
-                         * propagating through the dominance tree.
-                         */
-                        if (var->is_ternary_ret || var->is_logical_ret)
-                            continue;
-
-                        for (int l = 0; l < work_list_idx; l++) {
-                            if (work_list[l] == df) {
-                                found = true;
-                                break;
-                            }
+                    /* Check if already in work list */
+                    bool found = false;
+                    for (int l = 0; l < work_list_idx; l++) {
+                        if (work_list[l] == df) {
+                            found = true;
+                            break;
                         }
-                        if (!found && work_list_idx < 64) /* Bounds check */
-                            work_list[work_list_idx++] = df;
                     }
+
+                    /* Add to work list if not found and space available */
+                    if (!found && work_list_idx < 64) /* Bounds check */
+                        work_list[work_list_idx++] = df;
                 }
             }
         }