src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopFragmentInside.java

*** 22,34 ****
   */
  package org.graalvm.compiler.loop;
  
  import java.util.LinkedList;
  import java.util.List;
- import java.util.Map;
  
- import org.graalvm.compiler.core.common.CollectionsFactory;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Graph.DuplicationReplacement;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.NodeBitMap;
  import org.graalvm.compiler.graph.iterators.NodeIterable;
--- 22,32 ----
*** 50,70 ****
  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;
  
  public class LoopFragmentInside extends LoopFragment {
  
      /**
       * mergedInitializers. When an inside fragment's (loop)ends are merged to create a unique exit
       * point, some phis must be created : they phis together all the back-values of the loop-phis
       * These can then be used to update the loop-phis' forward edge value ('initializer') in the
       * peeling case. In the unrolling case they will be used as the value that replace the loop-phis
       * of the duplicated inside fragment
       */
!     private Map<ValuePhiNode, ValueNode> mergedInitializers;
      private final DuplicationReplacement dataFixBefore = new DuplicationReplacement() {
  
          @Override
          public Node replacement(Node oriInput) {
              if (!(oriInput instanceof ValueNode)) {
--- 48,70 ----
  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;
  
  public class LoopFragmentInside extends LoopFragment {
  
      /**
       * mergedInitializers. When an inside fragment's (loop)ends are merged to create a unique exit
       * point, some phis must be created : they phis together all the back-values of the loop-phis
       * These can then be used to update the loop-phis' forward edge value ('initializer') in the
       * peeling case. In the unrolling case they will be used as the value that replace the loop-phis
       * of the duplicated inside fragment
       */
!     private EconomicMap<PhiNode, ValueNode> mergedInitializers;
      private final DuplicationReplacement dataFixBefore = new DuplicationReplacement() {
  
          @Override
          public Node replacement(Node oriInput) {
              if (!(oriInput instanceof ValueNode)) {
*** 162,172 ****
      protected DuplicationReplacement getDuplicationReplacement() {
          final LoopBeginNode loopBegin = loop().loopBegin();
          final StructuredGraph graph = graph();
          return new DuplicationReplacement() {
  
!             private Map<Node, Node> seenNode = Node.newMap();
  
              @Override
              public Node replacement(Node original) {
                  if (original == loopBegin) {
                      Node value = seenNode.get(original);
--- 162,172 ----
      protected DuplicationReplacement getDuplicationReplacement() {
          final LoopBeginNode loopBegin = loop().loopBegin();
          final StructuredGraph graph = graph();
          return new DuplicationReplacement() {
  
!             private EconomicMap<Node, Node> seenNode = EconomicMap.create(Equivalence.IDENTITY);
  
              @Override
              public Node replacement(Node original) {
                  if (original == loopBegin) {
                      Node value = seenNode.get(original);
*** 339,358 ****
  
      private AbstractBeginNode mergeEnds() {
          assert isDuplicate();
          List<EndNode> endsToMerge = new LinkedList<>();
          // map peel exits to the corresponding loop exits
!         Map<AbstractEndNode, LoopEndNode> reverseEnds = CollectionsFactory.newMap();
          LoopBeginNode loopBegin = original().loop().loopBegin();
          for (LoopEndNode le : loopBegin.loopEnds()) {
              AbstractEndNode duplicate = getDuplicatedNode(le);
              if (duplicate != null) {
                  endsToMerge.add((EndNode) duplicate);
                  reverseEnds.put(duplicate, le);
              }
          }
!         mergedInitializers = Node.newIdentityMap();
          AbstractBeginNode newExit;
          StructuredGraph graph = graph();
          if (endsToMerge.size() == 1) {
              AbstractEndNode end = endsToMerge.get(0);
              assert end.hasNoUsages();
--- 339,358 ----
  
      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);
          LoopBeginNode loopBegin = original().loop().loopBegin();
          for (LoopEndNode le : loopBegin.loopEnds()) {
              AbstractEndNode duplicate = getDuplicatedNode(le);
              if (duplicate != null) {
                  endsToMerge.add((EndNode) duplicate);
                  reverseEnds.put(duplicate, le);
              }
          }
!         mergedInitializers = EconomicMap.create(Equivalence.IDENTITY);
          AbstractBeginNode newExit;
          StructuredGraph graph = graph();
          if (endsToMerge.size() == 1) {
              AbstractEndNode end = endsToMerge.get(0);
              assert end.hasNoUsages();
*** 395,405 ****
                                  from.replaceFirstInput(phi, firstPhi);
                              }
                          }
                      });
                  }
!                 mergedInitializers.put((ValuePhiNode) phi, initializer);
              }
          }
          return newExit;
      }
  }
--- 395,405 ----
                                  from.replaceFirstInput(phi, firstPhi);
                              }
                          }
                      });
                  }
!                 mergedInitializers.put(phi, initializer);
              }
          }
          return newExit;
      }
  }