*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/EffectsClosure.java	Fri Jul  7 09:31:52 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/EffectsClosure.java	Fri Jul  7 09:31:52 2017

*** 26,36 ****
--- 26,36 ----
  import java.util.List;
  
  import org.graalvm.compiler.core.common.cfg.BlockMap;
  import org.graalvm.compiler.core.common.cfg.Loop;
  import org.graalvm.compiler.core.common.type.Stamp;
! import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.debug.Indent;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.NodeBitMap;
  import org.graalvm.compiler.graph.NodeMap;

*** 57,70 ****
--- 57,70 ----
  import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
  import org.graalvm.compiler.options.OptionValues;
  import org.graalvm.compiler.phases.graph.ReentrantBlockIterator;
  import org.graalvm.compiler.phases.graph.ReentrantBlockIterator.BlockIteratorClosure;
  import org.graalvm.compiler.phases.graph.ReentrantBlockIterator.LoopInfo;
  import org.graalvm.util.Equivalence;
  import org.graalvm.word.LocationIdentity;
  import org.graalvm.util.EconomicMap;
  import org.graalvm.util.EconomicSet;
+ import org.graalvm.util.Equivalence;
+ import org.graalvm.word.LocationIdentity;
  
  public abstract class EffectsClosure<BlockT extends EffectsBlockState<BlockT>> extends EffectsPhase.Closure<BlockT> {
  
      protected final ControlFlowGraph cfg;
      protected final ScheduleResult schedule;

*** 110,128 ****
--- 110,130 ----
  
      // Intended to be used by read-eliminating phases based on the effects phase.
      protected final EconomicMap<Loop<Block>, LoopKillCache> loopLocationKillCache = EconomicMap.create(Equivalence.IDENTITY);
  
      protected boolean changed;
+     protected final DebugContext debug;
  
      public EffectsClosure(ScheduleResult schedule, ControlFlowGraph cfg) {
          this.schedule = schedule;
          this.cfg = cfg;
          this.aliases = cfg.graph.createNodeMap();
          this.hasScalarReplacedInputs = cfg.graph.createNodeBitMap();
          this.blockEffects = new BlockMap<>(cfg);
+         this.debug = cfg.graph.getDebug();
          for (Block block : cfg.getBlocks()) {
!             blockEffects.put(block, new GraphEffectList(debug));
          }
      }
  
      @Override
      public boolean hasChanged() {

*** 180,202 ****
--- 182,204 ----
                  return info.exitStates;
              }
          };
          ReentrantBlockIterator.apply(closure, cfg.getStartBlock());
          for (GraphEffectList effects : effectList) {
!             Debug.log(" ==== effects");
!             debug.log(" ==== effects");
              effects.apply(graph, obsoleteNodes, false);
          }
          /*
           * Effects that modify the cfg (e.g., removing a branch for an if that got a constant
           * condition) need to be performed after all other effects, because they change phi value
           * indexes.
           */
          for (GraphEffectList effects : effectList) {
!             Debug.log(" ==== cfg kill effects");
!             debug.log(" ==== cfg kill effects");
              effects.apply(graph, obsoleteNodes, true);
          }
!         Debug.dump(Debug.DETAILED_LEVEL, graph, "After applying effects");
!         debug.dump(DebugContext.DETAILED_LEVEL, graph, "After applying effects");
          assert VirtualUtil.assertNonReachable(graph, obsoleteNodes);
          for (Node node : obsoleteNodes) {
              if (node.isAlive() && node.hasNoUsages()) {
                  if (node instanceof FixedWithNextNode) {
                      assert ((FixedWithNextNode) node).next() == null;

*** 231,241 ****
--- 233,243 ----
                      }
                  }
              }
  
              OptionValues options = block.getBeginNode().getOptions();
!             VirtualUtil.trace(options, debug, "\nBlock: %s, preds: %s, succ: %s (", block, block.getPredecessors(), block.getSuccessors());
  
              // a lastFixedNode is needed in case we want to insert fixed nodes
              FixedWithNextNode lastFixedNode = null;
              Iterable<? extends Node> nodes = schedule != null ? schedule.getBlockToNodesMap().get(block) : block.getNodes();
              for (Node node : nodes) {

*** 255,265 ****
--- 257,267 ----
                  }
                  if (state.isDead()) {
                      break;
                  }
              }
!             VirtualUtil.trace(options, debug, ")\n    end state: %s\n", state);
          }
          return state;
      }
  
      /**

*** 327,347 ****
--- 329,349 ----
           *
           * This processing converges because the merge processing always makes the starting state
           * more generic, e.g., adding phis instead of non-phi values.
           */
          for (int iteration = 0; iteration < 10; iteration++) {
!             try (Indent i = Debug.logAndIndent("================== Process Loop Effects Closure: block:%s begin node:%s", loop.getHeader(), loop.getHeader().getBeginNode())) {
!             try (Indent i = debug.logAndIndent("================== Process Loop Effects Closure: block:%s begin node:%s", loop.getHeader(), loop.getHeader().getBeginNode())) {
                  LoopInfo<BlockT> info = ReentrantBlockIterator.processLoop(this, loop, cloneState(lastMergedState));
  
                  List<BlockT> states = new ArrayList<>();
                  states.add(initialStateRemovedKilledLocations);
                  states.addAll(info.endStates);
                  doMergeWithoutDead(mergeProcessor, states);
  
!                 Debug.log("MergeProcessor New State: %s", mergeProcessor.newState);
!                 Debug.log("===== vs.");
!                 Debug.log("Last Merged State: %s", lastMergedState);
!                 debug.log("MergeProcessor New State: %s", mergeProcessor.newState);
!                 debug.log("===== vs.");
!                 debug.log("Last Merged State: %s", lastMergedState);
  
                  if (mergeProcessor.newState.equivalentTo(lastMergedState)) {
                      blockEffects.get(loop.getHeader()).insertAll(mergeProcessor.mergeEffects, 0);
                      loopMergeEffects.put(loop, mergeProcessor.afterMergeEffects);
  

*** 439,450 ****
--- 441,452 ----
          protected BlockT newState;
  
          public MergeProcessor(Block mergeBlock) {
              this.mergeBlock = mergeBlock;
              this.merge = (AbstractMergeNode) mergeBlock.getBeginNode();
!             this.mergeEffects = new GraphEffectList(debug);
!             this.afterMergeEffects = new GraphEffectList(debug);
          }
  
          /**
           * @param states the states that should be merged.
           */