js-port: CFG basic-block analysis (foundation for structured emission)

Add buildBasicBlocks() (instruction list -> basic blocks + successor
edges) and isAcyclicForward() as the foundation for the structured
control-flow (relooper) emitter that will replace the verbose
while(true) switch(pc) state machine with if/else (and later while/for)
for reducible CFGs -- keeping the generator threading model but emitting
far more compact JS.

Pure analysis: nothing consumes it for emission yet, so output is
unchanged. The acyclic-if/else emitter (slice 1) lands on top next,
gated behind a flag with switch(pc) as the irreducible fallback.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java

@@ -3749,6 +3749,130 @@ private static boolean isPcSkippableNoOp(Instruction instruction) {
      * label is purely decorative and a preceding ``pc = i; break;``
      * may be omitted.
      */
+    /**
+     * A basic block: a maximal straight-line instruction range [start, end) with
+     * a single entry (start) and successor block indices. Foundation for the
+     * structured-control-flow (relooper) emitter that will replace the switch(pc)
+     * state machine with if/else/while for reducible CFGs (keeping the generator
+     * model). Pure analysis -- nothing consumes it for emission yet.
+     */
+    static final class BasicBlock {
+        final int start;
+        int end;
+        final java.util.List<Integer> succs = new java.util.ArrayList<Integer>();
+        BasicBlock(int start) { this.start = start; }
+    }
+
+    /**
+     * Partition a method's instruction list into basic blocks and wire successor
+     * edges. Leaders: index 0, every branch/switch target, the instruction after a
+     * branch/return/throw, and try/catch range + handler boundaries.
+     */
+    static java.util.List<BasicBlock> buildBasicBlocks(List<Instruction> instructions, Map<Label, Integer> labelToIndex) {
+        int n = instructions.size();
+        boolean[] leader = new boolean[n + 1];
+        if (n > 0) {
+            leader[0] = true;
+        }
+        for (int i = 0; i < n; i++) {
+            Instruction instr = instructions.get(i);
+            if (instr instanceof Jump) {
+                Integer t = labelToIndex.get(((Jump) instr).getLabel());
+                if (t != null && t < n) {
+                    leader[t] = true;
+                }
+                if (i + 1 < n) {
+                    leader[i + 1] = true;
+                }
+            } else if (instr instanceof SwitchInstruction) {
+                SwitchInstruction sw = (SwitchInstruction) instr;
+                if (sw.getDefaultLabel() != null) {
+                    Integer d = labelToIndex.get(sw.getDefaultLabel());
+                    if (d != null && d < n) { leader[d] = true; }
+                }
+                if (sw.getLabels() != null) {
+                    for (Label l : sw.getLabels()) {
+                        Integer d = l == null ? null : labelToIndex.get(l);
+                        if (d != null && d < n) { leader[d] = true; }
+                    }
+                }
+                if (i + 1 < n) { leader[i + 1] = true; }
+            } else if (instr instanceof TryCatch) {
+                TryCatch tc = (TryCatch) instr;
+                for (Label l : new Label[]{ tc.getStart(), tc.getEnd(), tc.getHandler() }) {
+                    Integer d = l == null ? null : labelToIndex.get(l);
+                    if (d != null && d < n) { leader[d] = true; }
+                }
+            } else if (isTerminatingInstruction(instr) && i + 1 < n) {
+                leader[i + 1] = true;
+            }
+        }
+
+        java.util.List<BasicBlock> blocks = new java.util.ArrayList<BasicBlock>();
+        java.util.Map<Integer, Integer> startToBlock = new java.util.HashMap<Integer, Integer>();
+        BasicBlock cur = null;
+        for (int i = 0; i < n; i++) {
+            if (leader[i] || cur == null) {
+                if (cur != null) { cur.end = i; }
+                cur = new BasicBlock(i);
+                startToBlock.put(i, blocks.size());
+                blocks.add(cur);
+            }
+        }
+        if (cur != null) { cur.end = n; }
+
+        for (BasicBlock b : blocks) {
+            Instruction last = b.end > b.start ? instructions.get(b.end - 1) : null;
+            boolean addFallThrough = true;
+            if (last instanceof Jump) {
+                Integer t = labelToIndex.get(((Jump) last).getLabel());
+                if (t != null && startToBlock.containsKey((int) t)) {
+                    b.succs.add(startToBlock.get((int) t));
+                }
+                if (last.getOpcode() == Opcodes.GOTO) {
+                    addFallThrough = false;
+                }
+            } else if (last instanceof SwitchInstruction) {
+                SwitchInstruction sw = (SwitchInstruction) last;
+                if (sw.getDefaultLabel() != null) {
+                    Integer d = labelToIndex.get(sw.getDefaultLabel());
+                    if (d != null && startToBlock.containsKey((int) d)) { b.succs.add(startToBlock.get((int) d)); }
+                }
+                if (sw.getLabels() != null) {
+                    for (Label l : sw.getLabels()) {
+                        Integer d = l == null ? null : labelToIndex.get(l);
+                        if (d != null && startToBlock.containsKey((int) d)) { b.succs.add(startToBlock.get((int) d)); }
+                    }
+                }
+                addFallThrough = false;
+            } else if (last != null && isTerminatingInstruction(last)) {
+                addFallThrough = false;
+            }
+            if (addFallThrough && startToBlock.containsKey(b.end)) {
+                b.succs.add(startToBlock.get(b.end));
+            }
+        }
+        return blocks;
+    }
+
+    /**
+     * Conservatively true when the block graph is acyclic in index order (no back
+     * edge: every successor block index is strictly greater than its source).
+     * Acyclic single-entry blocks are the slice the structured emitter handles
+     * first (if / if-else); methods with loops or any backward edge stay on
+     * switch(pc).
+     */
+    static boolean isAcyclicForward(java.util.List<BasicBlock> blocks) {
+        for (int i = 0; i < blocks.size(); i++) {
+            for (int s : blocks.get(i).succs) {
+                if (s <= i) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
     private static java.util.Set<Integer> computeJumpTargets(List<Instruction> instructions, Map<Label, Integer> labelToIndex,
                                                               boolean forceThrowingTargets) {
         java.util.Set<Integer> targets = new java.util.HashSet<Integer>();