*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopEx.java	Mon Mar 20 17:40:13 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopEx.java	Mon Mar 20 17:40:13 2017

*** 20,35 ****
--- 20,31 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.loop;
  
  import static org.graalvm.compiler.graph.Node.newIdentityMap;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.Map;
  import java.util.Queue;
  
  import org.graalvm.compiler.core.common.calc.Condition;
  import org.graalvm.compiler.core.common.cfg.Loop;
  import org.graalvm.compiler.core.common.type.IntegerStamp;

*** 68,91 ****
--- 64,88 ----
  import org.graalvm.compiler.nodes.calc.SignExtendNode;
  import org.graalvm.compiler.nodes.calc.SubNode;
  import org.graalvm.compiler.nodes.calc.ZeroExtendNode;
  import org.graalvm.compiler.nodes.cfg.Block;
  import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
! import org.graalvm.compiler.nodes.debug.ControlFlowAnchorNode;
! import org.graalvm.compiler.nodes.debug.ControlFlowAnchored;
  import org.graalvm.compiler.nodes.extended.ValueAnchorNode;
  import org.graalvm.compiler.nodes.util.GraphUtil;
+ import org.graalvm.util.Equivalence;
+ import org.graalvm.util.EconomicMap;
  
  import jdk.vm.ci.code.BytecodeFrame;
  
  public class LoopEx {
  
      private final Loop<Block> loop;
      private LoopFragmentInside inside;
      private LoopFragmentWhole whole;
      private CountedLoopInfo counted;
      private LoopsData data;
!     private EconomicMap<Node, InductionVariable> ivs;
  
      LoopEx(Loop<Block> loop, LoopsData data) {
          this.loop = loop;
          this.data = data;
      }

*** 178,188 ****
--- 175,185 ----
          StructuredGraph graph = loopBegin().graph();
          for (BinaryArithmeticNode<?> binary : whole().nodes().filter(BinaryArithmeticNode.class)) {
              if (!binary.isAssociative()) {
                  continue;
              }
!             BinaryArithmeticNode<?> result = BinaryArithmeticNode.reassociate(binary, invariant, binary.getX(), binary.getY());
!             ValueNode result = BinaryArithmeticNode.reassociate(binary, invariant, binary.getX(), binary.getY());
              if (result != binary) {
                  if (Debug.isLogEnabled()) {
                      Debug.log("%s : Reassociated %s into %s", graph.method().format("%H::%n"), binary, result);
                  }
                  if (!result.isAlive()) {

*** 308,328 ****
--- 305,327 ----
              Block b = work.remove();
              if (loop().getExits().contains(b)) {
                  exits.add((LoopExitNode) b.getBeginNode());
              } else {
                  blocks.add(b.getBeginNode());
                  for (Block d : b.getDominated()) {
+                 Block d = b.getDominatedSibling();
+                 while (d != null) {
                      if (loop.getBlocks().contains(d)) {
                          work.add(d);
                      }
+                     d = d.getDominatedSibling();
                  }
              }
          }
          LoopFragment.computeNodes(branchNodes, branch.graph(), blocks, exits);
      }
  
!     public EconomicMap<Node, InductionVariable> getInductionVariables() {
          if (ivs == null) {
              ivs = findInductionVariables(this);
          }
          return ivs;
      }

*** 332,350 ****
--- 331,349 ----
       * which are derived from the basic ones.
       *
       * @param loop
       * @return a map from node to induction variable
       */
!     private static EconomicMap<Node, InductionVariable> findInductionVariables(LoopEx loop) {
!         Map<Node, InductionVariable> ivs = newIdentityMap();
!         EconomicMap<Node, InductionVariable> ivs = EconomicMap.create(Equivalence.IDENTITY);
  
          Queue<InductionVariable> scanQueue = new LinkedList<>();
          LoopBeginNode loopBegin = loop.loopBegin();
          AbstractEndNode forwardEnd = loopBegin.forwardEnd();
!         for (PhiNode phi : loopBegin.phis().filter(ValuePhiNode.class)) {
!             ValueNode backValue = phi.singleBackValue();
!             if (backValue == PhiNode.MULTIPLE_VALUES) {
!         for (PhiNode phi : loopBegin.valuePhis()) {
!             ValueNode backValue = phi.singleBackValueOrThis();
!             if (backValue == phi) {
                  continue;
              }
              ValueNode stride = addSub(loop, backValue, phi);
              if (stride != null) {
                  BasicInductionVariable biv = new BasicInductionVariable(loop, (ValuePhiNode) phi, phi.valueAt(forwardEnd), stride, (BinaryArithmeticNode<?>) backValue);

*** 392,402 ****
--- 391,401 ----
                      ivs.put(op, iv);
                      scanQueue.offer(iv);
                  }
              }
          }
!         return Collections.unmodifiableMap(ivs);
      }
  
      private static ValueNode addSub(LoopEx loop, ValueNode op, ValueNode base) {
          if (op.stamp() instanceof IntegerStamp && (op instanceof AddNode || op instanceof SubNode)) {
              BinaryArithmeticNode<?> aritOp = (BinaryArithmeticNode<?>) op;

*** 430,451 ****
--- 429,450 ----
      /**
       * Deletes any nodes created within the scope of this object that have no usages.
       */
      public void deleteUnusedNodes() {
          if (ivs != null) {
!             for (InductionVariable iv : ivs.values()) {
!             for (InductionVariable iv : ivs.getValues()) {
                  iv.deleteUnusedNodes();
              }
          }
      }
  
      /**
       * @return true if all nodes in the loop can be duplicated.
       */
      public boolean canDuplicateLoop() {
          for (Node node : inside().nodes()) {
!             if (node instanceof ControlFlowAnchorNode) {
!             if (node instanceof ControlFlowAnchored) {
                  return false;
              }
              if (node instanceof FrameState) {
                  FrameState frameState = (FrameState) node;
                  if (frameState.bci == BytecodeFrame.AFTER_EXCEPTION_BCI || frameState.bci == BytecodeFrame.UNWIND_BCI) {