*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/ConditionalEliminationPhase.java	Fri Jul  7 09:31:28 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/ConditionalEliminationPhase.java	Fri Jul  7 09:31:28 2017

*** 33,45 ****
--- 33,45 ----
  import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Or;
  import org.graalvm.compiler.core.common.type.IntegerStamp;
  import org.graalvm.compiler.core.common.type.ObjectStamp;
  import org.graalvm.compiler.core.common.type.Stamp;
  import org.graalvm.compiler.core.common.type.StampFactory;
! import org.graalvm.compiler.debug.Debug;
! import org.graalvm.compiler.debug.CounterKey;
  import org.graalvm.compiler.debug.DebugCloseable;
! import org.graalvm.compiler.debug.DebugCounter;
! import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.NodeMap;
  import org.graalvm.compiler.graph.NodeStack;
  import org.graalvm.compiler.graph.spi.CanonicalizerTool;
  import org.graalvm.compiler.nodeinfo.InputType;

*** 61,74 ****
--- 61,74 ----
  import org.graalvm.compiler.nodes.ParameterNode;
  import org.graalvm.compiler.nodes.PiNode;
  import org.graalvm.compiler.nodes.ProxyNode;
  import org.graalvm.compiler.nodes.ShortCircuitOrNode;
  import org.graalvm.compiler.nodes.StructuredGraph;
+ import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
  import org.graalvm.compiler.nodes.UnaryOpLogicNode;
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.nodes.ValuePhiNode;
  import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
  import org.graalvm.compiler.nodes.calc.AndNode;
  import org.graalvm.compiler.nodes.calc.BinaryArithmeticNode;
  import org.graalvm.compiler.nodes.calc.BinaryNode;
  import org.graalvm.compiler.nodes.calc.IntegerEqualsNode;
  import org.graalvm.compiler.nodes.calc.UnaryNode;

*** 94,107 ****
--- 94,107 ----
  import jdk.vm.ci.meta.JavaConstant;
  import jdk.vm.ci.meta.TriState;
  
  public class ConditionalEliminationPhase extends BasePhase<PhaseContext> {
  
!     private static final DebugCounter counterStampsRegistered = Debug.counter("StampsRegistered");
!     private static final DebugCounter counterStampsFound = Debug.counter("StampsFound");
!     private static final DebugCounter counterIfsKilled = Debug.counter("CE_KilledIfs");
!     private static final DebugCounter counterPhiStampsImproved = Debug.counter("CE_ImprovedPhis");
!     private static final CounterKey counterStampsRegistered = DebugContext.counter("StampsRegistered");
!     private static final CounterKey counterStampsFound = DebugContext.counter("StampsFound");
!     private static final CounterKey counterIfsKilled = DebugContext.counter("CE_KilledIfs");
!     private static final CounterKey counterPhiStampsImproved = DebugContext.counter("CE_ImprovedPhis");
      private final boolean fullSchedule;
      private final boolean moveGuards;
  
      public ConditionalEliminationPhase(boolean fullSchedule) {
          this(fullSchedule, true);

*** 113,123 ****
--- 113,123 ----
      }
  
      @Override
      @SuppressWarnings("try")
      protected void run(StructuredGraph graph, PhaseContext context) {
!         try (Debug.Scope s = Debug.scope("DominatorConditionalElimination")) {
!         try (DebugContext.Scope s = graph.getDebug().scope("DominatorConditionalElimination")) {
              BlockMap<List<Node>> blockToNodes = null;
              NodeMap<Block> nodeToBlock = null;
              ControlFlowGraph cfg = ControlFlowGraph.compute(graph, true, true, true, true);
              if (fullSchedule) {
                  if (moveGuards) {

*** 240,258 ****
--- 240,260 ----
          protected final NodeMap<InfoElement> map;
          protected final BlockMap<List<Node>> blockToNodes;
          protected final CanonicalizerTool tool;
          protected final NodeStack undoOperations;
          protected final StructuredGraph graph;
+         protected final DebugContext debug;
          protected final EconomicMap<MergeNode, EconomicMap<ValuePhiNode, PhiInfoElement>> mergeMaps;
  
          /**
           * Tests which may be eliminated because post dominating tests to prove a broader condition.
           */
          private Deque<PendingTest> pendingTests;
  
          public Instance(StructuredGraph graph, BlockMap<List<Node>> blockToNodes, PhaseContext context) {
              this.graph = graph;
+             this.debug = graph.getDebug();
              this.blockToNodes = blockToNodes;
              this.undoOperations = new NodeStack();
              this.map = graph.createNodeMap();
              pendingTests = new ArrayDeque<>();
              tool = GraphUtil.getDefaultSimplifier(context.getMetaAccess(), context.getConstantReflection(), context.getConstantFieldProvider(), false, graph.getAssumptions(), graph.getOptions(),

*** 302,312 ****
--- 304,314 ----
                      DeoptimizeNode deopt = node.graph().add(new DeoptimizeNode(node.getAction(), node.getReason(), node.getSpeculation()));
                      deopt.setStateBefore(node.stateBefore());
                      node.replaceAtPredecessor(deopt);
                      GraphUtil.killCFG(node);
                  }
!                 Debug.log("Kill fixed guard guard");
!                 debug.log("Kill fixed guard guard");
                  return true;
              })) {
                  registerNewCondition(node.condition(), node.isNegated(), node);
              }
          }

*** 316,334 ****
--- 318,336 ----
                  AbstractBeginNode survivingSuccessor = node.getSuccessor(result);
                  survivingSuccessor.replaceAtUsages(InputType.Guard, guard.asNode());
                  survivingSuccessor.replaceAtPredecessor(null);
                  node.replaceAtPredecessor(survivingSuccessor);
                  GraphUtil.killCFG(node);
!                 counterIfsKilled.increment(debug);
                  return true;
              });
          }
  
          @Override
          public Integer enter(Block block) {
              int mark = undoOperations.size();
!             Debug.log("[Pre Processing block %s]", block);
!             debug.log("[Pre Processing block %s]", block);
              // For now conservatively collect guards only within the same block.
              pendingTests.clear();
              processNodes(block);
              return mark;
          }

*** 346,356 ****
--- 348,358 ----
          }
  
          private void processBlock(Block block) {
              FixedNode n = block.getBeginNode();
              FixedNode endNode = block.getEndNode();
!             Debug.log("[Processing block %s]", block);
!             debug.log("[Processing block %s]", block);
              while (n != endNode) {
                  if (n.isDeleted() || endNode.isDeleted()) {
                      // This branch was deleted!
                      return;
                  }

*** 471,481 ****
--- 473,483 ----
                                      ValueNode valueNode = graph.maybeAddOrUnique(PiNode.create(input, curBestStamp, (ValueNode) infoElement.guard));
                                      valueAt = valueNode;
                                  }
                                  newPhi.addInput(valueAt);
                              }
!                             counterPhiStampsImproved.increment(debug);
                              phi.replaceAtUsagesAndDelete(newPhi);
                          }
                      }
                  }
              }

*** 695,705 ****
--- 697,707 ----
              }
              return map.getAndGrow(value);
          }
  
          protected boolean rewireGuards(GuardingNode guard, boolean result, ValueNode proxifiedInput, Stamp guardedValueStamp, GuardRewirer rewireGuardFunction) {
!             counterStampsFound.increment(debug);
              return rewireGuardFunction.rewire(guard, result, guardedValueStamp, proxifiedInput);
          }
  
          protected boolean tryProveCondition(LogicNode node, GuardRewirer rewireGuardFunction) {
              return tryProveGuardCondition(null, node, rewireGuardFunction);

*** 891,902 ****
--- 893,904 ----
                  ValueNode proxiedValue = null;
                  if (value instanceof PiNode) {
                      proxiedValue = value;
                  }
                  do {
!                     counterStampsRegistered.increment(debug);
!                     Debug.log("\t Saving stamp for node %s stamp %s guarded by %s", value, stamp, guard);
!                     debug.log("\t Saving stamp for node %s stamp %s guarded by %s", value, stamp, guard);
                      assert value instanceof LogicNode || stamp.isCompatible(value.stamp()) : stamp + " vs. " + value.stamp() + " (" + value + ")";
                      map.setAndGrow(value, new InfoElement(stamp, guard, proxiedValue, map.getAndGrow(value)));
                      undoOperations.push(value);
                      if (value instanceof StampInverter) {
                          StampInverter stampInverter = (StampInverter) value;