src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/IfNode.java

*** 32,43 ****
  
  import org.graalvm.compiler.core.common.calc.Condition;
  import org.graalvm.compiler.core.common.type.IntegerStamp;
  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.DebugCounter;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.NodeClass;
  import org.graalvm.compiler.graph.iterators.NodeIterable;
  import org.graalvm.compiler.graph.spi.Canonicalizable;
--- 32,43 ----
  
  import org.graalvm.compiler.core.common.calc.Condition;
  import org.graalvm.compiler.core.common.type.IntegerStamp;
  import org.graalvm.compiler.core.common.type.Stamp;
  import org.graalvm.compiler.core.common.type.StampFactory;
! import org.graalvm.compiler.debug.CounterKey;
! import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.graph.NodeClass;
  import org.graalvm.compiler.graph.iterators.NodeIterable;
  import org.graalvm.compiler.graph.spi.Canonicalizable;
*** 71,81 ****
   */
  @NodeInfo(cycles = CYCLES_2, size = SIZE_2, sizeRationale = "2 jmps")
  public final class IfNode extends ControlSplitNode implements Simplifiable, LIRLowerable {
      public static final NodeClass<IfNode> TYPE = NodeClass.create(IfNode.class);
  
!     private static final DebugCounter CORRECTED_PROBABILITIES = Debug.counter("CorrectedProbabilities");
  
      @Successor AbstractBeginNode trueSuccessor;
      @Successor AbstractBeginNode falseSuccessor;
      @Input(InputType.Condition) LogicNode condition;
      protected double trueSuccessorProbability;
--- 71,81 ----
   */
  @NodeInfo(cycles = CYCLES_2, size = SIZE_2, sizeRationale = "2 jmps")
  public final class IfNode extends ControlSplitNode implements Simplifiable, LIRLowerable {
      public static final NodeClass<IfNode> TYPE = NodeClass.create(IfNode.class);
  
!     private static final CounterKey CORRECTED_PROBABILITIES = DebugContext.counter("CorrectedProbabilities");
  
      @Successor AbstractBeginNode trueSuccessor;
      @Successor AbstractBeginNode falseSuccessor;
      @Input(InputType.Condition) LogicNode condition;
      protected double trueSuccessorProbability;
*** 177,192 ****
  
      @Override
      public void simplify(SimplifierTool tool) {
          if (trueSuccessor().next() instanceof DeoptimizeNode) {
              if (trueSuccessorProbability != 0) {
!                 CORRECTED_PROBABILITIES.increment();
                  trueSuccessorProbability = 0;
              }
          } else if (falseSuccessor().next() instanceof DeoptimizeNode) {
              if (trueSuccessorProbability != 1) {
!                 CORRECTED_PROBABILITIES.increment();
                  trueSuccessorProbability = 1;
              }
          }
  
          if (condition() instanceof LogicNegationNode) {
--- 177,192 ----
  
      @Override
      public void simplify(SimplifierTool tool) {
          if (trueSuccessor().next() instanceof DeoptimizeNode) {
              if (trueSuccessorProbability != 0) {
!                 CORRECTED_PROBABILITIES.increment(getDebug());
                  trueSuccessorProbability = 0;
              }
          } else if (falseSuccessor().next() instanceof DeoptimizeNode) {
              if (trueSuccessorProbability != 1) {
!                 CORRECTED_PROBABILITIES.increment(getDebug());
                  trueSuccessorProbability = 1;
              }
          }
  
          if (condition() instanceof LogicNegationNode) {
*** 451,474 ****
          }
          return false;
      }
  
      private static boolean prepareForSwap(ConstantReflectionProvider constantReflection, LogicNode a, LogicNode b) {
          if (a instanceof InstanceOfNode) {
              InstanceOfNode instanceOfA = (InstanceOfNode) a;
              if (b instanceof IsNullNode) {
                  IsNullNode isNullNode = (IsNullNode) b;
                  if (isNullNode.getValue() == instanceOfA.getValue()) {
!                     Debug.log("Can swap instanceof and isnull if");
                      return true;
                  }
              } else if (b instanceof InstanceOfNode) {
                  InstanceOfNode instanceOfB = (InstanceOfNode) b;
                  if (instanceOfA.getValue() == instanceOfB.getValue() && !instanceOfA.type().getType().isInterface() && !instanceOfB.type().getType().isInterface() &&
                                  !instanceOfA.type().getType().isAssignableFrom(instanceOfB.type().getType()) && !instanceOfB.type().getType().isAssignableFrom(instanceOfA.type().getType())) {
                      // Two instanceof on the same value with mutually exclusive types.
!                     Debug.log("Can swap instanceof for types %s and %s", instanceOfA.type(), instanceOfB.type());
                      return true;
                  }
              }
          } else if (a instanceof CompareNode) {
              CompareNode compareA = (CompareNode) a;
--- 451,475 ----
          }
          return false;
      }
  
      private static boolean prepareForSwap(ConstantReflectionProvider constantReflection, LogicNode a, LogicNode b) {
+         DebugContext debug = a.getDebug();
          if (a instanceof InstanceOfNode) {
              InstanceOfNode instanceOfA = (InstanceOfNode) a;
              if (b instanceof IsNullNode) {
                  IsNullNode isNullNode = (IsNullNode) b;
                  if (isNullNode.getValue() == instanceOfA.getValue()) {
!                     debug.log("Can swap instanceof and isnull if");
                      return true;
                  }
              } else if (b instanceof InstanceOfNode) {
                  InstanceOfNode instanceOfB = (InstanceOfNode) b;
                  if (instanceOfA.getValue() == instanceOfB.getValue() && !instanceOfA.type().getType().isInterface() && !instanceOfB.type().getType().isInterface() &&
                                  !instanceOfA.type().getType().isAssignableFrom(instanceOfB.type().getType()) && !instanceOfB.type().getType().isAssignableFrom(instanceOfA.type().getType())) {
                      // Two instanceof on the same value with mutually exclusive types.
!                     debug.log("Can swap instanceof for types %s and %s", instanceOfA.type(), instanceOfB.type());
                      return true;
                  }
              }
          } else if (a instanceof CompareNode) {
              CompareNode compareA = (CompareNode) a;
*** 477,487 ****
                  return false;
              }
              if (b instanceof CompareNode) {
                  CompareNode compareB = (CompareNode) b;
                  if (compareA == compareB) {
!                     Debug.log("Same conditions => do not swap and leave the work for global value numbering.");
                      return false;
                  }
                  if (compareB.unorderedIsTrue()) {
                      return false;
                  }
--- 478,488 ----
                  return false;
              }
              if (b instanceof CompareNode) {
                  CompareNode compareB = (CompareNode) b;
                  if (compareA == compareB) {
!                     debug.log("Same conditions => do not swap and leave the work for global value numbering.");
                      return false;
                  }
                  if (compareB.unorderedIsTrue()) {
                      return false;
                  }
*** 495,505 ****
  
                  if (comparableCondition != null) {
                      Condition combined = conditionA.join(comparableCondition);
                      if (combined == null) {
                          // The two conditions are disjoint => can reorder.
!                         Debug.log("Can swap disjoint coditions on same values: %s and %s", conditionA, comparableCondition);
                          return true;
                      }
                  } else if (conditionA == Condition.EQ && conditionB == Condition.EQ) {
                      boolean canSwap = false;
                      if ((compareA.getX() == compareB.getX() && valuesDistinct(constantReflection, compareA.getY(), compareB.getY()))) {
--- 496,506 ----
  
                  if (comparableCondition != null) {
                      Condition combined = conditionA.join(comparableCondition);
                      if (combined == null) {
                          // The two conditions are disjoint => can reorder.
!                         debug.log("Can swap disjoint coditions on same values: %s and %s", conditionA, comparableCondition);
                          return true;
                      }
                  } else if (conditionA == Condition.EQ && conditionB == Condition.EQ) {
                      boolean canSwap = false;
                      if ((compareA.getX() == compareB.getX() && valuesDistinct(constantReflection, compareA.getY(), compareB.getY()))) {
*** 511,521 ****
                      } else if ((compareA.getY() == compareB.getY() && valuesDistinct(constantReflection, compareA.getX(), compareB.getX()))) {
                          canSwap = true;
                      }
  
                      if (canSwap) {
!                         Debug.log("Can swap equality condition with one shared and one disjoint value.");
                          return true;
                      }
                  }
              }
          }
--- 512,522 ----
                      } else if ((compareA.getY() == compareB.getY() && valuesDistinct(constantReflection, compareA.getX(), compareB.getX()))) {
                          canSwap = true;
                      }
  
                      if (canSwap) {
!                         debug.log("Can swap equality condition with one shared and one disjoint value.");
                          return true;
                      }
                  }
              }
          }