*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopFragmentInside.java	Fri Jul  7 09:31:13 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopFragmentInside.java	Fri Jul  7 09:31:12 2017

*** 48,59 ****
--- 48,59 ----
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.nodes.ValuePhiNode;
  import org.graalvm.compiler.nodes.VirtualState.NodeClosure;
  import org.graalvm.compiler.nodes.memory.MemoryPhiNode;
  import org.graalvm.compiler.nodes.util.GraphUtil;
  import org.graalvm.util.Equivalence;
  import org.graalvm.util.EconomicMap;
+ import org.graalvm.util.Equivalence;
  
  public class LoopFragmentInside extends LoopFragment {
  
      /**
       * mergedInitializers. When an inside fragment's (loop)ends are merged to create a unique exit

*** 72,81 ****
--- 72,92 ----
              }
              return prim((ValueNode) oriInput);
          }
      };
  
+     private final DuplicationReplacement dataFixWithinAfter = new DuplicationReplacement() {
+ 
+         @Override
+         public Node replacement(Node oriInput) {
+             if (!(oriInput instanceof ValueNode)) {
+                 return oriInput;
+             }
+             return primAfter((ValueNode) oriInput);
+         }
+     };
+ 
      public LoopFragmentInside(LoopEx loop) {
          super(loop);
      }
  
      public LoopFragmentInside(LoopFragmentInside original) {

*** 119,128 ****
--- 130,145 ----
          AbstractBeginNode entry = getDuplicatedNode(loop.loopBegin());
          loop.entryPoint().replaceAtPredecessor(entry);
          end.setNext(loop.entryPoint());
      }
  
+     public void insertWithinAfter(LoopEx loop) {
+         assert this.isDuplicate() && this.original().loop() == loop;
+ 
+         patchNodes(dataFixWithinAfter);
+     }
+ 
      @Override
      public NodeBitMap nodes() {
          if (nodes == null) {
              LoopFragmentWhole whole = loop().whole();
              whole.nodes(); // init nodes bitmap in whole

*** 203,212 ****
--- 220,234 ----
      @Override
      protected void finishDuplication() {
          // TODO (gd) ?
      }
  
+     @Override
+     protected void beforeDuplication() {
+         // Nothing to do
+     }
+ 
      private static PhiNode patchPhi(StructuredGraph graph, PhiNode phi, AbstractMergeNode merge) {
          PhiNode ret;
          if (phi instanceof ValuePhiNode) {
              ret = new ValuePhiNode(phi.stamp(), merge);
          } else if (phi instanceof GuardPhiNode) {

*** 335,344 ****
--- 357,384 ----
          } else {
              return b;
          }
      }
  
+     protected ValueNode primAfter(ValueNode b) {
+         assert isDuplicate();
+         LoopBeginNode loopBegin = original().loop().loopBegin();
+         if (loopBegin.isPhiAtMerge(b)) {
+             PhiNode phi = (PhiNode) b;
+             assert phi.valueCount() == 2;
+             return phi.valueAt(1);
+         } else if (nodesReady) {
+             ValueNode v = getDuplicatedNode(b);
+             if (v == null) {
+                 return b;
+             }
+             return v;
+         } else {
+             return b;
+         }
+     }
+ 
      private AbstractBeginNode mergeEnds() {
          assert isDuplicate();
          List<EndNode> endsToMerge = new LinkedList<>();
          // map peel exits to the corresponding loop exits
          EconomicMap<AbstractEndNode, LoopEndNode> reverseEnds = EconomicMap.create(Equivalence.IDENTITY);