kit

structure.c (28130B)

---

 /* Wasm CGTarget structurer.
  *
  * Walks the WIR list produced by CG record callbacks and rewrites it so
  * every label is bound to a structured Wasm scope. Free WIR_LABELs (those
  * placed via wasm_label_place outside any CG scope's break/continue role)
  * are wrapped in synthetic SCOPE_BLOCK (forward jumps) or SCOPE_LOOP
  * (backward jumps) records; jumps to the formerly-free labels resolve via
  * the existing scope-bound br_to_label machinery in emit.c.
  *
  * Switch islands — the C/toy `switch` shape `JUMP dispatch; case bodies;
  * LABEL dispatch; selector; WIR_SWITCH; LABEL end` — are pre-processed
  * by unroll_switch_islands, which reorders the WIR to put selector +
  * SWITCH first and the case bodies after. That conversion turns the
  * case labels into forward refs the structurer handles uniformly with
  * other forward gotos.
  *
  * Diagnostics (hard wfail):
  *   - irreducible: a label has both forward and backward predecessors
  *     (multi-entry loop or hybrid; v1 declines node splitting).
  *   - cross-scope: a free label sits at scope depth D, but a predecessor
  *     sits inside an extra CG scope; the synthetic block's start cannot
  *     lift across the scope boundary cleanly. */
 
 #include <stdarg.h>
 #include <string.h>
 
 #include "arch/wasm/internal.h"
 #include "core/heap.h"
 
 static _Noreturn void sfail(WTarget* t, const char* fmt, ...) {
   va_list ap;
   SrcLoc l = {0, 0, 0};
   va_start(ap, fmt);
   if (t->cur_fn_desc) l = t->cur_fn_desc->loc;
   compiler_panicv(t->c, l, fmt, ap);
 }
 
 /* Per-free-label working state. */
 typedef struct WSLbl {
   Label label;
   u32 wir_idx;     /* WIR_LABEL position */
   u32 scope_depth; /* CG-scope nesting depth at the label */
   /* Forward predecessor stats: min adjusted start (so the synthetic block
    * opens at the same scope depth as L). UINT32_MAX = no forward pred. */
   u32 fwd_start_idx;
   u32 nfwd;
   /* Backward predecessor stats: max adjusted end (exclusive) for the
    * synthetic loop close. UINT32_MAX = no backward pred. */
   u32 bwd_end_idx;
   u32 nbwd;
   /* After pass_decide: actual synthetic scope range. open_idx is mutable
    * by merge_ranges (extended backward to nest overlapping forward blocks);
    * close_idx is fixed at the label's natural position so jumps to the
    * label still land at the right place. */
   u32 open_idx;
   u32 close_idx;
   u8 is_loop;
   u8 valid; /* 1 if structurer will wrap this label */
   u8 pad[2];
 } WSLbl;
 
 /* Event inserted at a WIR position. Sorted primarily by wir_idx; within the
  * same wir_idx, closes fire before opens. The pair_idx field carries the
  * partner event's wir_idx so we can break ties: at a shared OPEN wir_idx,
  * the outer (larger pair_idx = later close) opens first; at a shared CLOSE
  * wir_idx, the inner (larger pair_idx = later open) closes first. */
 typedef enum WSEvKind {
   WSEV_CLOSE_LOOP = 0,
   WSEV_CLOSE_BLOCK = 1,
   WSEV_OPEN_BLOCK = 2,
   WSEV_OPEN_LOOP = 3,
 } WSEvKind;
 
 typedef struct WSEvent {
   u32 wir_idx;
   u32 pair_idx;
   u8 kind; /* WSEvKind */
   u8 pad[3];
   u32 scope_id;
   Label label; /* break (BLOCK) or continue (LOOP) */
 } WSEvent;
 
 /* Per-idx scope chain entry. */
 typedef struct WSScopeFrame {
   u32 scope_id;
   u32 open_idx;
   u32 depth; /* 1-based */
 } WSScopeFrame;
 
 typedef struct WSCtx {
   WTarget* t;
   WSLbl* lbls;
   u32 nlbls;
   u32 lbls_cap;
   /* Per-WIR-idx scope depth (immediately AT this index — for SCOPE_OPEN,
    * the depth AFTER pushing). */
   u32* depth_at;
   u32 ndepth;
   /* Stack of currently-open scopes during the WIR walk; recycled per
    * pass since CG scopes never go above 32. */
   WSScopeFrame stack[64];
   u32 nstack;
   WSEvent* events;
   u32 nevents;
   u32 events_cap;
 } WSCtx;
 
 /* ---- label index ---- */
 
 static WSLbl* find_lbl(WSCtx* x, Label l) {
   for (u32 i = 0; i < x->nlbls; ++i) {
     if (x->lbls[i].label == l) return &x->lbls[i];
   }
   return NULL;
 }
 
 static WSLbl* push_lbl(WSCtx* x, Label l) {
   Heap* h = x->t->c->ctx->heap;
   if (x->nlbls == x->lbls_cap) {
     u32 nc = x->lbls_cap ? x->lbls_cap * 2u : 8u;
     void* p = h->realloc(h, x->lbls, sizeof(WSLbl) * x->lbls_cap,
                          sizeof(WSLbl) * nc, _Alignof(WSLbl));
     if (!p) sfail(x->t, "wasm: out of memory in structurer");
     x->lbls = (WSLbl*)p;
     x->lbls_cap = nc;
   }
   WSLbl* L = &x->lbls[x->nlbls++];
   memset(L, 0, sizeof *L);
   L->label = l;
   L->fwd_start_idx = UINT32_MAX;
   L->bwd_end_idx = UINT32_MAX;
   L->open_idx = UINT32_MAX;
   L->close_idx = UINT32_MAX;
   return L;
 }
 
 /* ---- pass 1: scope-depth map + free-label discovery ---- */
 
 static void pass_scope_depth(WSCtx* x) {
   WTarget* t = x->t;
   Heap* h = t->c->ctx->heap;
   x->depth_at =
       (u32*)h->alloc(h, sizeof(u32) * (t->nwir ? t->nwir : 1u), _Alignof(u32));
   if (!x->depth_at) sfail(t, "wasm: out of memory in structurer");
   x->ndepth = t->nwir;
   x->nstack = 0;
   for (u32 i = 0; i < t->nwir; ++i) {
     WIR* w = &t->wir[i];
     if (w->op == WIR_SCOPE_OPEN) {
       if (x->nstack >= 64u) sfail(t, "wasm: scope nesting too deep");
       x->stack[x->nstack].scope_id = w->scope_id;
       x->stack[x->nstack].open_idx = i;
       x->stack[x->nstack].depth = x->nstack + 1u;
       x->nstack++;
     }
     x->depth_at[i] = x->nstack;
     if (w->op == WIR_SCOPE_CLOSE) {
       if (x->nstack == 0)
         sfail(t, "wasm: structurer saw SCOPE_CLOSE with empty stack");
       x->nstack--;
       /* Depth AT a CLOSE is the depth INSIDE the scope (we haven't popped
        * yet at the time the record sits in WIR). The pop above is for the
        * NEXT idx. Restore. */
       x->depth_at[i] = x->nstack + 1u;
     }
     if (w->op == WIR_LABEL) {
       WLabel* lbl = &t->labels[w->labels[0] - 1u];
       if (lbl->kind == WLBL_FORWARD || lbl->kind == WLBL_UNBOUND) {
         WSLbl* L = find_lbl(x, w->labels[0]);
         if (!L) L = push_lbl(x, w->labels[0]);
         L->wir_idx = i;
         L->scope_depth = x->depth_at[i];
       }
     }
   }
   if (x->nstack != 0)
     sfail(t, "wasm: structurer finished with %u scopes still open", x->nstack);
 }
 
 /* ---- pass 2: locate the smallest "outside" idx for a pred at depth `pd`
  *      whose target sits at depth `ld`. Walks backward through WIR's scope
  *      transitions to find the open_idx of the outermost CG scope that
  *      contains the pred but not the target. ---- */
 static u32 lift_to_label_depth(WSCtx* x, u32 pred_idx, u32 ld) {
   WTarget* t = x->t;
   u32 cur = x->depth_at[pred_idx];
   /* We need cur to drop to ld. Walk backward; each SCOPE_OPEN we cross
    * (going up the depth) corresponds to an extra scope above the target's
    * depth. We stop AT the outermost extra SCOPE_OPEN. */
   if (cur <= ld) return pred_idx;
   u32 i = pred_idx;
   u32 best = pred_idx;
   while (i > 0 && cur > ld) {
     --i;
     if (t->wir[i].op == WIR_SCOPE_OPEN) {
       cur--;
       if (cur == ld) {
         best = i; /* place synthetic OPEN right before this CG OPEN */
         break;
       }
     } else if (t->wir[i].op == WIR_SCOPE_CLOSE) {
       cur++;
     }
   }
   return best;
 }
 
 /* Symmetric: for a backward pred at idx pred_idx targeting label at depth ld,
  * return the WIR position (exclusive end) where the synthetic LOOP must
  * close so that it sits at the same scope depth as the label. */
 static u32 drop_to_label_depth_after(WSCtx* x, u32 pred_idx, u32 ld) {
   WTarget* t = x->t;
   u32 cur = x->depth_at[pred_idx];
   /* Walk forward across closes until we drop to ld. The synthetic close
    * happens AFTER the SCOPE_CLOSE that takes us back to ld. */
   if (cur <= ld) return pred_idx + 1u;
   u32 i = pred_idx;
   while (i < t->nwir && cur > ld) {
     ++i;
     if (i >= t->nwir) break;
     if (t->wir[i].op == WIR_SCOPE_OPEN) {
       cur++;
     } else if (t->wir[i].op == WIR_SCOPE_CLOSE) {
       cur--;
       if (cur == ld) {
         return i + 1u;
       }
     }
   }
   /* Couldn't drop — back-edge spans out of the function body? Treat as
    * unstructurable. */
   return UINT32_MAX;
 }
 
 /* ---- pass 3: record pred contributions for each free label. Walk WIR
  *      and for each JUMP/CMP_BRANCH/SWITCH that targets a tracked free
  *      label, update fwd_start_idx / bwd_end_idx / nfwd / nbwd. ---- */
 static void verify_well_nested_fwd(WSCtx* x, u32 start, u32 end, u32 ld) {
   /* Every WIR index in [start, end) must have scope depth >= ld so the
    * synthetic block can sit at L's depth without crossing a CG-scope
    * boundary outward. */
   for (u32 i = start; i < end; ++i) {
     if (x->depth_at[i] < ld) {
       sfail(x->t,
             "wasm: forward jump crosses out of structured scope at WIR[%u]; "
             "kit's CFG structurer does not split scopes in v1",
             i);
     }
   }
 }
 
 static void note_pred(WSCtx* x, u32 pred_idx, Label tgt) {
   WSLbl* L = find_lbl(x, tgt);
   if (!L) return;
   if (pred_idx < L->wir_idx) {
     /* Forward pred. */
     u32 lifted = lift_to_label_depth(x, pred_idx, L->scope_depth);
     verify_well_nested_fwd(x, lifted, L->wir_idx, L->scope_depth);
     if (lifted < L->fwd_start_idx) L->fwd_start_idx = lifted;
     L->nfwd++;
   } else if (pred_idx > L->wir_idx) {
     /* Backward pred. */
     u32 dropped = drop_to_label_depth_after(x, pred_idx, L->scope_depth);
     if (dropped == UINT32_MAX) {
       sfail(x->t,
             "wasm: backward jump at WIR[%u] to label outside function body; "
             "structurer cannot place enclosing loop",
             pred_idx);
     }
     if (L->bwd_end_idx == UINT32_MAX || dropped > L->bwd_end_idx)
       L->bwd_end_idx = dropped;
     L->nbwd++;
   }
 }
 
 /* Switch-island reorder.
  *
  * Frontends (C, toy) emit `switch` as:
  *     JUMP dispatch          // forward, to skip past case bodies on entry
  *     LABEL case_1; body; JUMP end
  *     LABEL case_2; body; JUMP end
  *     LABEL dispatch
  *     selector
  *     WIR_SWITCH cases: [case_1, case_2], default: end
  *     LABEL end
  *
  * The case labels are placed BEFORE the WIR_SWITCH that targets them — a
  * backward edge in WIR order that the natural structurer cannot wrap as
  * forward blocks. We rewrite the WIR to move the dispatch (selector +
  * SWITCH) up to the position of the original JUMP and let the case
  * bodies follow:
  *
  *     selector
  *     WIR_SWITCH cases: [case_1, case_2], default: end
  *     LABEL case_1; body; JUMP end
  *     LABEL case_2; body; JUMP end
  *     LABEL end
  *
  * Now case_i is forward from SWITCH and the structurer wraps it in a
  * synthetic SCOPE_BLOCK like any other forward goto. The JUMP and the
  * dispatch LABEL are dropped (the dispatch label is no longer reached).
  *
  * The pattern is detected by scanning forward from each WIR_JUMP. We
  * support multiple non-nested switch islands per function and stop on
  * the first intervening terminator that breaks the dispatch shape. */
 typedef struct WSIsland {
   u32 j; /* JUMP dispatch idx */
   u32 d; /* LABEL dispatch idx */
   u32 s; /* WIR_SWITCH idx */
 } WSIsland;
 
 static WIR* wir_append(WTarget* t, WIR** out, u32* nout, u32* cap);
 
 /* One pass of switch-island detection + reordering. Returns the number of
  * islands rewritten (0 = nothing to do). Nested switches need multiple passes:
  * the outer JUMP-to-dispatch sits before the inner switch's JUMP-to-dispatch
  * in WIR order, so the outer scan advances past the inner JUMP after recording
  * the outer island. Re-scanning the rewritten WIR brings the now-exposed inner
  * island into view. */
 static int unroll_switch_islands_once(WSCtx* x) {
   WTarget* t = x->t;
   Heap* h = t->c->ctx->heap;
   WSIsland islands[16];
   u32 nislands = 0;
   u32 scan = 0;
   while (scan < t->nwir) {
     if (t->wir[scan].op != WIR_JUMP) {
       scan++;
       continue;
     }
     Label disp = t->wir[scan].labels[0];
     if (disp == LABEL_NONE || disp - 1u >= t->nlabels) {
       scan++;
       continue;
     }
     WLabel* dlbl = &t->labels[disp - 1u];
     if (dlbl->kind != WLBL_FORWARD || !dlbl->placed ||
         dlbl->wir_index <= scan) {
       scan++;
       continue;
     }
     /* Find WIR_SWITCH just past dispatch label; bail on intervening
      * terminator or scope boundary. The C/toy frontends emit the
      * selector expression as a small straight-line sequence between
      * LABEL dispatch and WIR_SWITCH, with no SCOPE_OPEN/CLOSE — those
      * only appear at switch entry/exit, never around the dispatcher.
      * Rejecting SCOPE_OPEN here keeps a second pass from mistaking a
      * for-loop body label (which sits just before a `[switch open]`)
      * for a switch dispatch label. */
     u32 sw_i = UINT32_MAX;
     for (u32 k = dlbl->wir_index + 1u; k < t->nwir; ++k) {
       if (t->wir[k].op == WIR_SWITCH) {
         sw_i = k;
         break;
       }
       if (t->wir[k].op == WIR_JUMP || t->wir[k].op == WIR_CMP_BRANCH ||
           t->wir[k].op == WIR_RET || t->wir[k].op == WIR_UNREACHABLE ||
           t->wir[k].op == WIR_SCOPE_OPEN || t->wir[k].op == WIR_SCOPE_CLOSE)
         break;
     }
     if (sw_i == UINT32_MAX) {
       scan++;
       continue;
     }
     if (nislands >= 16u)
       sfail(t,
             "wasm: too many switch islands per function (max 16 supported in "
             "v1)");
     islands[nislands].j = scan;
     islands[nislands].d = dlbl->wir_index;
     islands[nislands].s = sw_i;
     nislands++;
     scan = sw_i + 1u;
   }
   if (nislands == 0) return 0;
 
   /* Build a rewritten WIR list. For each island, emit pre + (selector +
    * SWITCH) + (case bodies). Then everything after the last island's
    * SWITCH is copied through. */
   WIR* new_wir = NULL;
   u32 new_n = 0;
   u32 new_cap = 0;
   u32 cursor = 0;
   for (u32 ii = 0; ii < nislands; ++ii) {
     WSIsland* I = &islands[ii];
     /* pre-island: WIR[cursor .. I->j) */
     for (u32 k = cursor; k < I->j; ++k) {
       WIR* w = wir_append(t, &new_wir, &new_n, &new_cap);
       *w = t->wir[k];
     }
     /* selector + SWITCH: WIR[I->d+1 .. I->s] */
     for (u32 k = I->d + 1u; k <= I->s; ++k) {
       WIR* w = wir_append(t, &new_wir, &new_n, &new_cap);
       *w = t->wir[k];
     }
     /* case bodies: WIR[I->j+1 .. I->d) — drops the JUMP at j and LABEL at d */
     for (u32 k = I->j + 1u; k < I->d; ++k) {
       WIR* w = wir_append(t, &new_wir, &new_n, &new_cap);
       *w = t->wir[k];
     }
     cursor = I->s + 1u;
   }
   /* trailing region after the last island */
   for (u32 k = cursor; k < t->nwir; ++k) {
     WIR* w = wir_append(t, &new_wir, &new_n, &new_cap);
     *w = t->wir[k];
   }
 
   if (t->wir) h->free(h, t->wir, sizeof(WIR) * t->wir_cap);
   t->wir = new_wir;
   t->nwir = new_n;
   t->wir_cap = new_cap;
 
   /* Refresh WLabel.wir_index from the new layout so any downstream
    * consumer of t->labels[].wir_index sees the rewritten positions.
    * (pass_scope_depth re-discovers free-label positions on its own walk.) */
   for (u32 k = 0; k < t->nwir; ++k) {
     if (t->wir[k].op != WIR_LABEL) continue;
     Label l = t->wir[k].labels[0];
     if (l != LABEL_NONE && l - 1u < t->nlabels) t->labels[l - 1u].wir_index = k;
   }
   return (int)nislands;
 }
 
 /* Re-run the single-pass unroller to a fixed point so nested switches all
  * get reordered. Each pass reorders at most the outermost island in a chain
  * of nested switches; the next pass exposes the next inner one. The loop
  * terminates because every rewritten island drops one JUMP-to-dispatch from
  * the WIR (and a function has finitely many). */
 static void unroll_switch_islands(WSCtx* x) {
   while (unroll_switch_islands_once(x) > 0) { /* re-scan after each rewrite */
   }
 }
 
 /* For-loop de-rotation.
  *
  * The C frontend lowers `for (init; cond; step) body` in a single pass, so
  * the step clause (which appears before the body in source) is emitted into
  * a block placed BEFORE the body, with the body jumping back to it:
  *
  *     LABEL L_top                 // header
  *     <cond>; CMP_BRANCH L_end    // (cond optional)
  *     JUMP L_body                 // skip the step on entry
  *     LABEL L_step                // continue target
  *     <step>
  *     JUMP L_top                  // genuine loop back-edge
  *     LABEL L_body
  *     <body>
  *     JUMP L_step                 // body -> step (continue path)
  *     LABEL L_end
  *
  * In WIR textual order the body's `JUMP L_step` is a backward edge, so the
  * structurer misclassifies L_step as a loop header and emits a second,
  * unintended `loop` — the program spins forever. The CFG is reducible; only
  * the block layout is rotated. We restore a structure-compatible order by
  * moving the step block to AFTER the body, mirroring how
  * unroll_switch_islands reorders the switch shape:
  *
  *     LABEL L_top
  *     <cond>; CMP_BRANCH L_end
  *     LABEL L_body                // JUMP L_body dropped; falls through
  *     <body>
  *     JUMP L_step                 // now a forward edge
  *     LABEL L_step
  *     <step>
  *     JUMP L_top                  // sole back-edge -> L_top is the loop
  *     LABEL L_end
  *
  * The step block ends in an unconditional `JUMP L_top` (no fall-through out)
  * and is entered only via `JUMP L_step`, so relocating it preserves
  * semantics. Nested for-loops live entirely inside the body region and are
  * handled by re-scanning to a fixed point. */
 static int derotate_one_for_loop(WSCtx* x) {
   WTarget* t = x->t;
   Heap* h = t->c->ctx->heap;
   for (u32 j = 0; j < t->nwir; ++j) {
     if (t->wir[j].op != WIR_JUMP) continue;
     /* JUMP L_body, with L_body a forward label. */
     Label xb = t->wir[j].labels[0];
     if (xb == LABEL_NONE || xb - 1u >= t->nlabels) continue;
     WLabel* lx = &t->labels[xb - 1u];
     if (!lx->placed || lx->wir_index <= j) continue;
     /* Immediately followed by LABEL L_step. */
     if (j + 1u >= t->nwir || t->wir[j + 1u].op != WIR_LABEL) continue;
     Label s = t->wir[j + 1u].labels[0];
     if (s == LABEL_NONE || s == xb) continue;
     /* Scan the step block for `JUMP L_top; LABEL L_body`, L_top backward. */
     u32 jt = UINT32_MAX;
     for (u32 m = j + 2u; m + 1u < t->nwir; ++m) {
       u8 mop = t->wir[m].op;
       if (mop == WIR_RET || mop == WIR_UNREACHABLE) break;
       if (mop != WIR_JUMP) continue;
       Label cand = t->wir[m].labels[0];
       if (cand == LABEL_NONE || cand - 1u >= t->nlabels) continue;
       WLabel* lc = &t->labels[cand - 1u];
       if (lc->placed && lc->wir_index < j && t->wir[m + 1u].op == WIR_LABEL &&
           t->wir[m + 1u].labels[0] == xb) {
         jt = m;
         break;
       }
     }
     if (jt == UINT32_MAX) continue;
     /* k = last `JUMP L_step` (the body's closing/continue edges all target
      * L_step; the textually-last one closes the body, just before L_end). */
     u32 k = UINT32_MAX;
     for (u32 m = jt + 1u; m < t->nwir; ++m) {
       if (t->wir[m].op == WIR_JUMP && t->wir[m].labels[0] == s) k = m;
     }
     if (k == UINT32_MAX || k <= jt) continue;
 
     /* Rebuild: [0..j) drop JUMP at j, [jt+1..k] body, [j+1..jt] step,
      * [k+1..nwir). */
     WIR* nw = NULL;
     u32 nn = 0, ncap = 0;
     for (u32 m = 0; m < j; ++m) *wir_append(t, &nw, &nn, &ncap) = t->wir[m];
     for (u32 m = jt + 1u; m <= k; ++m)
       *wir_append(t, &nw, &nn, &ncap) = t->wir[m];
     for (u32 m = j + 1u; m <= jt; ++m)
       *wir_append(t, &nw, &nn, &ncap) = t->wir[m];
     for (u32 m = k + 1u; m < t->nwir; ++m)
       *wir_append(t, &nw, &nn, &ncap) = t->wir[m];
 
     if (t->wir) h->free(h, t->wir, sizeof(WIR) * t->wir_cap);
     t->wir = nw;
     t->nwir = nn;
     t->wir_cap = ncap;
     for (u32 m = 0; m < t->nwir; ++m) {
       if (t->wir[m].op != WIR_LABEL) continue;
       Label l = t->wir[m].labels[0];
       if (l != LABEL_NONE && l - 1u < t->nlabels)
         t->labels[l - 1u].wir_index = m;
     }
     return 1;
   }
   return 0;
 }
 
 static void derotate_for_loops(WSCtx* x) {
   while (derotate_one_for_loop(x)) { /* re-scan after each reorder */
   }
 }
 
 static void pass_preds(WSCtx* x) {
   WTarget* t = x->t;
   for (u32 i = 0; i < t->nwir; ++i) {
     WIR* w = &t->wir[i];
     switch (w->op) {
       case WIR_JUMP:
       case WIR_CMP_BRANCH:
         if (w->labels[0] != LABEL_NONE) note_pred(x, i, w->labels[0]);
         break;
       case WIR_SWITCH:
         if (w->labels[0] != LABEL_NONE) note_pred(x, i, w->labels[0]);
         for (u32 c = 0; c < w->switch_ncases; ++c) {
           if (w->switch_cases[c].label != LABEL_NONE)
             note_pred(x, i, w->switch_cases[c].label);
         }
         break;
       default:
         break;
     }
   }
 }
 
 /* ---- pass 4: produce per-label decisions. ---- */
 static void pass_decide(WSCtx* x) {
   WTarget* t = x->t;
   for (u32 i = 0; i < x->nlbls; ++i) {
     WSLbl* L = &x->lbls[i];
     if (L->nfwd == 0 && L->nbwd == 0) {
       /* Dead label — placed but never branched to. Drop quietly. */
       L->valid = 0;
       continue;
     }
     if (L->nfwd > 0 && L->nbwd > 0) {
       sfail(t,
             "wasm: label has both forward and backward gotos; kit's CFG "
             "structurer does not split hybrid labels in v1");
     }
     L->valid = 1;
     if (L->nfwd > 0) {
       L->is_loop = 0;
       L->open_idx = L->fwd_start_idx;
       L->close_idx = L->wir_idx;
     } else {
       L->is_loop = 1;
       L->open_idx = L->wir_idx;
       L->close_idx = L->bwd_end_idx;
     }
   }
 }
 
 /* ---- pass 5: emit event list and validate well-nesting. ---- */
 
 static void push_event(WSCtx* x, u32 wir_idx, u32 pair_idx, u8 kind,
                        u32 scope_id, Label label) {
   Heap* h = x->t->c->ctx->heap;
   if (x->nevents == x->events_cap) {
     u32 nc = x->events_cap ? x->events_cap * 2u : 16u;
     void* p = h->realloc(h, x->events, sizeof(WSEvent) * x->events_cap,
                          sizeof(WSEvent) * nc, _Alignof(WSEvent));
     if (!p) sfail(x->t, "wasm: out of memory in structurer");
     x->events = (WSEvent*)p;
     x->events_cap = nc;
   }
   WSEvent* e = &x->events[x->nevents++];
   e->wir_idx = wir_idx;
   e->pair_idx = pair_idx;
   e->kind = kind;
   e->scope_id = scope_id;
   e->label = label;
 }
 
 static int ev_cmp(const WSEvent* a, const WSEvent* b) {
   if (a->wir_idx != b->wir_idx) return a->wir_idx < b->wir_idx ? -1 : 1;
   /* At a tie: closes fire before opens (so we close existing scopes before
    * opening new ones). CLOSE kinds are 0..1, OPEN kinds are 2..3. */
   int a_close = a->kind < WSEV_OPEN_BLOCK;
   int b_close = b->kind < WSEV_OPEN_BLOCK;
   if (a_close != b_close) return a_close ? -1 : 1;
   if (a_close) {
     /* CLOSE: innermost first. pair_idx = open_idx; the more-recently-opened
      * scope has a LATER open_idx, so larger pair_idx closes first. */
     if (a->pair_idx != b->pair_idx) return a->pair_idx > b->pair_idx ? -1 : 1;
     return 0;
   }
   /* OPEN: outer first. pair_idx = close_idx; the larger range (later close)
    * encloses the smaller, so larger pair_idx opens first. */
   if (a->pair_idx != b->pair_idx) return a->pair_idx > b->pair_idx ? -1 : 1;
   return 0;
 }
 
 static void ev_sort(WSEvent* arr, u32 n) {
   /* Small n — insertion sort. */
   for (u32 i = 1; i < n; ++i) {
     WSEvent k = arr[i];
     u32 j = i;
     while (j > 0 && ev_cmp(&arr[j - 1u], &k) > 0) {
       arr[j] = arr[j - 1u];
       --j;
     }
     arr[j] = k;
   }
 }
 
 /* Resolve overlapping synthetic ranges into a properly-nested set.
  *
  * Close positions are FIXED — they correspond to the label's natural WIR
  * placement (for forward labels) or the last back-edge end (for loop
  * headers). Moving a close would change where a br to the label lands.
  *
  * So we only adjust OPEN positions, pushing them backward as needed: if
  * range A's close happens inside range B (a_o < b_o < a_c < b_c), pull
  * B's open back to A's open so A nests inside B (both open at a_o; A's
  * inner close at a_c fires before B's outer close at b_c).
  *
  * Iterate to a fixed point since extending one range can introduce new
  * overlaps with a third. The number of distinct opens is bounded by the
  * label count, so iteration terminates in O(nlbls^2). */
 static void merge_ranges(WSCtx* x) {
   for (;;) {
     int changed = 0;
     for (u32 i = 0; i < x->nlbls; ++i) {
       if (!x->lbls[i].valid) continue;
       for (u32 j = 0; j < x->nlbls; ++j) {
         if (j == i || !x->lbls[j].valid) continue;
         WSLbl* a = &x->lbls[i];
         WSLbl* b = &x->lbls[j];
         u32 a_o = a->open_idx, a_c = a->close_idx;
         u32 b_o = b->open_idx, b_c = b->close_idx;
         /* Disjoint or nested — fine. */
         if (a_c <= b_o || b_c <= a_o) continue;
         if (a_o <= b_o && b_c <= a_c) continue;
         if (b_o <= a_o && a_c <= b_c) continue;
         /* Overlap. Two cases:
          *   a_o < b_o < a_c < b_c  -> pull b's open back to a_o
          *   b_o < a_o < b_c < a_c  -> handled by the j-then-i symmetric
          *                              iteration.
          */
         if (a_o < b_o && b_o < a_c && a_c < b_c) {
           b->open_idx = a_o;
           changed = 1;
         }
       }
     }
     if (!changed) break;
   }
 }
 
 static void pass_events(WSCtx* x) {
   WTarget* t = x->t;
   for (u32 i = 0; i < x->nlbls; ++i) {
     WSLbl* L = &x->lbls[i];
     if (!L->valid) continue;
     u32 scope_id = ++t->next_scope_id;
     if (L->is_loop) {
       push_event(x, L->open_idx, L->close_idx, WSEV_OPEN_LOOP, scope_id,
                  L->label);
       push_event(x, L->close_idx, L->open_idx, WSEV_CLOSE_LOOP, scope_id,
                  L->label);
     } else {
       push_event(x, L->open_idx, L->close_idx, WSEV_OPEN_BLOCK, scope_id,
                  L->label);
       push_event(x, L->close_idx, L->open_idx, WSEV_CLOSE_BLOCK, scope_id,
                  L->label);
     }
     /* Re-bind the WLabel. */
     WLabel* wl = &t->labels[L->label - 1u];
     wl->scope_id = scope_id;
     wl->kind = L->is_loop ? WLBL_SCOPE_CONT : WLBL_SCOPE_BREAK;
   }
   ev_sort(x->events, x->nevents);
 }
 
 /* ---- pass 6: rebuild the WIR list, splicing in synthetic scope opens
  *      and closes at their event positions. ---- */
 
 static WIR* wir_append(WTarget* t, WIR** out, u32* nout, u32* cap) {
   Heap* h = t->c->ctx->heap;
   if (*nout == *cap) {
     u32 nc = *cap ? *cap * 2u : 64u;
     void* p = h->realloc(h, *out, sizeof(WIR) * *cap, sizeof(WIR) * nc,
                          _Alignof(WIR));
     if (!p) sfail(t, "wasm: out of memory in structurer");
     *out = (WIR*)p;
     *cap = nc;
   }
   WIR* w = &(*out)[(*nout)++];
   memset(w, 0, sizeof *w);
   return w;
 }
 
 static void emit_synthetic_scope(WTarget* t, WIR** out, u32* nout, u32* cap,
                                  u8 ev_kind, u32 scope_id) {
   WIR* w = wir_append(t, out, nout, cap);
   if (ev_kind == WSEV_OPEN_BLOCK || ev_kind == WSEV_OPEN_LOOP) {
     w->op = WIR_SCOPE_OPEN;
     w->cgop = (ev_kind == WSEV_OPEN_LOOP) ? SCOPE_LOOP : SCOPE_BLOCK;
   } else {
     w->op = WIR_SCOPE_CLOSE;
   }
   w->scope_id = scope_id;
   w->dst = REG_NONE;
 }
 
 static void pass_rewrite(WSCtx* x) {
   WTarget* t = x->t;
   WIR* new_wir = NULL;
   u32 new_n = 0;
   u32 new_cap = 0;
   u32 ev_i = 0;
   for (u32 i = 0; i <= t->nwir; ++i) {
     /* Fire all events whose wir_idx == i (closes first, then opens). */
     while (ev_i < x->nevents && x->events[ev_i].wir_idx == i) {
       emit_synthetic_scope(t, &new_wir, &new_n, &new_cap, x->events[ev_i].kind,
                            x->events[ev_i].scope_id);
       ev_i++;
     }
     if (i == t->nwir) break;
     WIR* src = &t->wir[i];
     WIR* dst = wir_append(t, &new_wir, &new_n, &new_cap);
     *dst = *src;
   }
   if (ev_i != x->nevents)
     sfail(t, "wasm: structurer left %u events unplaced", x->nevents - ev_i);
   /* Swap. */
   Heap* h = t->c->ctx->heap;
   if (t->wir) h->free(h, t->wir, sizeof(WIR) * t->wir_cap);
   t->wir = new_wir;
   t->nwir = new_n;
   t->wir_cap = new_cap;
 }
 
 /* ---- entry point ---- */
 
 void wasm_structurize(WTarget* t) {
   if (t->nwir == 0) return;
   Heap* h = t->c->ctx->heap;
   WSCtx x;
   memset(&x, 0, sizeof x);
   x.t = t;
   unroll_switch_islands(&x);
   derotate_for_loops(&x);
   pass_scope_depth(&x);
   pass_preds(&x);
   pass_decide(&x);
   if (x.nlbls > 0) {
     int any = 0;
     for (u32 i = 0; i < x.nlbls; ++i)
       if (x.lbls[i].valid) {
         any = 1;
         break;
       }
     if (any) {
       merge_ranges(&x);
       pass_events(&x);
       pass_rewrite(&x);
     }
   }
   if (x.depth_at) h->free(h, x.depth_at, sizeof(u32) * x.ndepth);
   if (x.lbls) h->free(h, x.lbls, sizeof(WSLbl) * x.lbls_cap);
   if (x.events) h->free(h, x.events, sizeof(WSEvent) * x.events_cap);
 }