*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/cfg/ControlFlowGraph.java	Fri Jul  7 09:31:25 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/cfg/ControlFlowGraph.java	Fri Jul  7 09:31:25 2017

*** 28,38 ****
--- 28,38 ----
  import java.util.List;
  
  import org.graalvm.compiler.core.common.cfg.AbstractControlFlowGraph;
  import org.graalvm.compiler.core.common.cfg.CFGVerifier;
  import org.graalvm.compiler.core.common.cfg.Loop;
! import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.NodeMap;
  import org.graalvm.compiler.nodes.AbstractBeginNode;
  import org.graalvm.compiler.nodes.AbstractEndNode;

*** 592,602 ****
--- 592,602 ----
              for (Block block : reversePostOrder) {
                  AbstractBeginNode beginNode = block.getBeginNode();
                  if (beginNode instanceof LoopBeginNode) {
                      Loop<Block> loop = new HIRLoop(block.getLoop(), loops.size(), block);
                      loops.add(loop);
!                     block.loop = loop;
!                     block.setLoop(loop);
                      loop.getBlocks().add(block);
  
                      LoopBeginNode loopBegin = (LoopBeginNode) beginNode;
                      for (LoopEndNode end : loopBegin.loopEnds()) {
                          Block endBlock = nodeToBlock.get(end);

*** 606,628 ****
--- 606,628 ----
                      if (graph.getGuardsStage() != GuardsStage.AFTER_FSA) {
                          for (LoopExitNode exit : loopBegin.loopExits()) {
                              Block exitBlock = nodeToBlock.get(exit);
                              assert exitBlock.getPredecessorCount() == 1;
                              computeLoopBlocks(exitBlock.getFirstPredecessor(), loop, stack, true);
!                             loop.getExits().add(exitBlock);
!                             loop.addExit(exitBlock);
                          }
  
                          // The following loop can add new blocks to the end of the loop's block
                          // list.
                          int size = loop.getBlocks().size();
                          for (int i = 0; i < size; ++i) {
                              Block b = loop.getBlocks().get(i);
                              for (Block sux : b.getSuccessors()) {
!                                 if (sux.loop != loop) {
!                                 if (sux.getLoop() != loop) {
                                      AbstractBeginNode begin = sux.getBeginNode();
                                      if (!(begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == loopBegin)) {
!                                         Debug.log(Debug.VERBOSE_LEVEL, "Unexpected loop exit with %s, including whole branch in the loop", sux);
!                                         graph.getDebug().log(DebugContext.VERBOSE_LEVEL, "Unexpected loop exit with %s, including whole branch in the loop", sux);
                                          computeLoopBlocks(sux, loop, stack, false);
                                      }
                                  }
                              }
                          }

*** 643,653 ****
--- 643,653 ----
                              // and the succ loop is not a child loop of the curr one
                              if (succ.getLoop() == null) {
                                  // we might exit multiple loops if b.loops is not a loop at depth 0
                                  Loop<Block> curr = b.getLoop();
                                  while (curr != null) {
!                                     curr.getExits().add(succ);
!                                     curr.addExit(succ);
                                      curr = curr.getParent();
                                  }
                              } else {
                                  /*
                                   * succ also has a loop, might be a child loop

*** 665,675 ****
--- 665,675 ----
                                      assert succ.getLoop().getDepth() < b.getLoop().getDepth();
                                      // b.loop must not be a transitive parent of succ.loop
                                      assert !Loop.transitiveParentLoop(succ.getLoop(), b.getLoop());
                                      Loop<Block> curr = b.getLoop();
                                      while (curr != null && curr != succ.getLoop()) {
!                                         curr.getExits().add(succ);
!                                         curr.addExit(succ);
                                          curr = curr.getParent();
                                      }
                                  }
                              }
                          }

*** 679,701 ****
--- 679,701 ----
          }
  
      }
  
      private static void computeLoopBlocks(Block start, Loop<Block> loop, Block[] stack, boolean usePred) {
!         if (start.loop != loop) {
!             start.loop = loop;
!         if (start.getLoop() != loop) {
!             start.setLoop(loop);
              stack[0] = start;
              loop.getBlocks().add(start);
              int tos = 0;
              do {
                  Block block = stack[tos--];
  
                  // Add predecessors or successors to the loop.
                  for (Block b : (usePred ? block.getPredecessors() : block.getSuccessors())) {
!                     if (b.loop != loop) {
!                     if (b.getLoop() != loop) {
                          stack[++tos] = b;
!                         b.loop = loop;
!                         b.setLoop(loop);
                          loop.getBlocks().add(b);
                      }
                  }
              } while (tos >= 0);
          }