Handle irreducible loops after async program splitting

teavm-core/src/main/java/org/teavm/common/DominatorTreeBuilder.java

@@ -58,8 +58,10 @@ class DominatorTreeBuilder {
             }
             for (int v : graph.incomingEdges(w)) {
                 int u = eval(v);
+                if (semidominators[u] >= 0) {
                     semidominators[w] = Math.min(semidominators[w], semidominators[u]);
                 }
+            }
             addToBucket(vertices[semidominators[w]], w);
             link(parents[w], w);
             for (int v : getBucket(w)) {

teavm-core/src/main/java/org/teavm/model/util/AsyncProgramSplitter.java

@@ -16,6 +16,7 @@
 package org.teavm.model.util;
 
 import java.util.*;
+import org.teavm.common.*;
 import org.teavm.model.*;
 import org.teavm.model.instructions.InvokeInstruction;
 import org.teavm.model.instructions.JumpInstruction;
@@ -147,6 +148,18 @@ public class AsyncProgramSplitter {
             }
         }
 
+        for (Part part : parts) {
+            IntegerArray blockSuccessors = IntegerArray.of(part.blockSuccessors);
+            AsyncProgramSplittingBackend splittingBackend = new AsyncProgramSplittingBackend(
+                    new ProgramNodeSplittingBackend(part.program), blockSuccessors);
+            Graph graph = ProgramUtils.buildControlFlowGraphWithTryCatch(part.program);
+            int[] weights = new int[graph.size()];
+            for (int i = 0; i < part.program.basicBlockCount(); ++i) {
+                weights[i] = part.program.basicBlockAt(i).getInstructions().size();
+            }
+            GraphUtils.splitIrreducibleGraph(graph, weights, splittingBackend);
+            part.blockSuccessors = splittingBackend.blockSuccessors.getAll();
+        }
         partMap.clear();
     }
 
@@ -207,4 +220,28 @@ public class AsyncProgramSplitter {
         Part targetPart;
         int source;
     }
+
+    private static class AsyncProgramSplittingBackend implements GraphSplittingBackend {
+        private GraphSplittingBackend inner;
+        private IntegerArray blockSuccessors;
+
+        public AsyncProgramSplittingBackend(GraphSplittingBackend inner, IntegerArray blockSuccessors) {
+            this.inner = inner;
+            this.blockSuccessors = blockSuccessors;
+        }
+
+        @Override
+        public int[] split(int[] domain, int[] nodes) {
+            int[] copies = inner.split(domain, nodes);
+            for (int i = 0; i < copies.length; ++i) {
+                int copy = copies[i];
+                int node = nodes[i];
+                if (blockSuccessors.size() <= copy) {
+                    blockSuccessors.add(-1);
+                }
+                blockSuccessors.set(copy, blockSuccessors.get(node));
+            }
+            return copies;
+        }
+    }
 }

teavm-core/src/main/java/org/teavm/model/util/BasicBlockMapper.java

@@ -27,7 +27,11 @@ public abstract class BasicBlockMapper implements InstructionVisitor {
 
     public void transform(Program program) {
         for (int i = 0; i < program.basicBlockCount(); ++i) {
-            BasicBlock block = program.basicBlockAt(i);
+            transform(program.basicBlockAt(i));
+        }
+    }
+
+    public void transform(BasicBlock block) {
         block.getLastInstruction().acceptVisitor(this);
         for (Phi phi : block.getPhis()) {
             for (Incoming incoming : phi.getIncomings()) {
@@ -38,7 +42,6 @@ public abstract class BasicBlockMapper implements InstructionVisitor {
             tryCatch.setHandler(map(tryCatch.getHandler()));
         }
     }
-    }
 
     @Override
     public void visit(EmptyInstruction insn) {

teavm-core/src/main/java/org/teavm/model/util/ProgramNodeSplittingBackend.java

@@ -0,0 +1,74 @@
+/*
+ *  Copyright 2015 Alexey Andreev.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.teavm.model.util;
+
+import com.carrotsearch.hppc.IntIntMap;
+import com.carrotsearch.hppc.IntIntOpenHashMap;
+import org.teavm.common.GraphSplittingBackend;
+import org.teavm.model.BasicBlock;
+import org.teavm.model.Program;
+
+/**
+ *
+ * @author Alexey Andreev
+ */
+public class ProgramNodeSplittingBackend implements GraphSplittingBackend {
+    private Program program;
+
+    public ProgramNodeSplittingBackend(Program program) {
+        this.program = program;
+    }
+
+    @Override
+    public int[] split(int[] domain, int[] nodes) {
+        int[] copies = new int[nodes.length];
+        IntIntMap map = new IntIntOpenHashMap();
+        for (int i = 0; i < nodes.length; ++i) {
+            int node = nodes[i];
+            BasicBlock block = program.basicBlockAt(node);
+            BasicBlock blockCopy = program.createBasicBlock();
+            blockCopy.getInstructions().addAll(ProgramUtils.copyInstructions(block, 0,
+                    block.getInstructions().size(), program));
+            copies[i] = blockCopy.getIndex();
+            map.put(nodes[i], copies[i] + 1);
+        }
+        CopyBlockMapper copyBlockMapper = new CopyBlockMapper(map);
+        for (int i = 0; i < copies.length; ++i) {
+            copyBlockMapper.transform(program.basicBlockAt(copies[i]));
+        }
+        for (int i = 0; i < domain.length; ++i) {
+            copyBlockMapper.transform(program.basicBlockAt(domain[i]));
+        }
+        return copies;
+    }
+
+    private static class CopyBlockMapper extends BasicBlockMapper {
+        private IntIntMap map;
+
+        public CopyBlockMapper(IntIntMap map) {
+            this.map = map;
+        }
+
+        @Override
+        protected BasicBlock map(BasicBlock block) {
+            int mappedIndex = map.get(block.getIndex());
+            if (mappedIndex == 0) {
+                return block;
+            }
+            return block.getProgram().basicBlockAt(mappedIndex - 1);
+        }
+    }
+}