*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/alloc/trace/lsra/TraceLinearScanEliminateSpillMovePhase.java	Fri Jul  7 09:30:55 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/alloc/trace/lsra/TraceLinearScanEliminateSpillMovePhase.java	Fri Jul  7 09:30:55 2017

*** 32,42 ****
--- 32,42 ----
  
  import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
  import org.graalvm.compiler.core.common.alloc.Trace;
  import org.graalvm.compiler.core.common.alloc.TraceBuilderResult;
  import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
! import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.debug.Indent;
  import org.graalvm.compiler.lir.LIRInsertionBuffer;
  import org.graalvm.compiler.lir.LIRInstruction;
  import org.graalvm.compiler.lir.LIRInstruction.OperandMode;
  import org.graalvm.compiler.lir.StandardOp.LoadConstantOp;

*** 73,113 ****
--- 73,114 ----
      }
  
      // called once before assignment of register numbers
      @SuppressWarnings("try")
      private static void eliminateSpillMoves(TraceLinearScan allocator, boolean shouldEliminateSpillMoves, TraceBuilderResult traceBuilderResult, LIRGenerationResult res) {
          try (Indent indent = Debug.logAndIndent("Eliminating unnecessary spill moves: Trace%d", traceBuilderResult.getTraceForBlock(allocator.blockAt(0)).getId())) {
+         DebugContext debug = allocator.getDebug();
+         try (Indent indent = debug.logAndIndent("Eliminating unnecessary spill moves: Trace%d", traceBuilderResult.getTraceForBlock(allocator.blockAt(0)).getId())) {
              allocator.sortIntervalsBySpillPos();
  
              /*
               * collect all intervals that must be stored after their definition. The list is sorted
               * by Interval.spillDefinitionPos.
               */
              TraceInterval interval = allocator.createUnhandledListBySpillPos(spilledIntervals);
              if (DetailedAsserts.getValue(allocator.getOptions())) {
!                 checkIntervals(debug, interval);
              }
!             if (Debug.isLogEnabled()) {
!                 try (Indent indent2 = Debug.logAndIndent("Sorted intervals")) {
!             if (debug.isLogEnabled()) {
!                 try (Indent indent2 = debug.logAndIndent("Sorted intervals")) {
                      for (TraceInterval i = interval; i != null; i = i.next) {
!                         Debug.log("%5d: %s", i.spillDefinitionPos(), i);
!                         debug.log("%5d: %s", i.spillDefinitionPos(), i);
                      }
                  }
              }
  
              LIRInsertionBuffer insertionBuffer = new LIRInsertionBuffer();
              for (AbstractBlockBase<?> block : allocator.sortedBlocks()) {
!                 try (Indent indent1 = Debug.logAndIndent("Handle %s", block)) {
!                 try (Indent indent1 = debug.logAndIndent("Handle %s", block)) {
                      ArrayList<LIRInstruction> instructions = allocator.getLIR().getLIRforBlock(block);
                      int numInst = instructions.size();
  
                      int lastOpId = -1;
                      // iterate all instructions of the block.
                      for (int j = 0; j < numInst; j++) {
                          LIRInstruction op = instructions.get(j);
                          int opId = op.id();
!                         try (Indent indent2 = Debug.logAndIndent("%5d %s", opId, op)) {
!                         try (Indent indent2 = debug.logAndIndent("%5d %s", opId, op)) {
  
                              if (opId == -1) {
                                  MoveOp move = MoveOp.asMoveOp(op);
                                  /*
                                   * Remove move from register to stack if the stack slot is

*** 117,133 ****
--- 118,134 ----
                                  if (shouldEliminateSpillMoves && canEliminateSpillMove(allocator, block, move, lastOpId)) {
                                      /*
                                       * Move target is a stack slot that is always correct, so
                                       * eliminate instruction.
                                       */
!                                     if (Debug.isLogEnabled()) {
!                                     if (debug.isLogEnabled()) {
                                          if (ValueMoveOp.isValueMoveOp(op)) {
                                              ValueMoveOp vmove = ValueMoveOp.asValueMoveOp(op);
!                                             Debug.log("eliminating move from interval %s to %s in block %s", vmove.getInput(), vmove.getResult(), block);
!                                             debug.log("eliminating move from interval %s to %s in block %s", vmove.getInput(), vmove.getResult(), block);
                                          } else {
                                              LoadConstantOp load = LoadConstantOp.asLoadConstantOp(op);
!                                             Debug.log("eliminating constant load from %s to %s in block %s", load.getConstant(), load.getResult(),
!                                             debug.log("eliminating constant load from %s to %s in block %s", load.getConstant(), load.getResult(),
                                                              block);
                                          }
                                      }
  
                                      // null-instructions are deleted by assignRegNum

*** 143,153 ****
--- 144,154 ----
                                  // assert interval == TraceInterval.EndMarker ||
                                  // interval.spillDefinitionPos() >= opId : "invalid order";
                                  assert interval == TraceInterval.EndMarker || (interval.isSplitParent() && SpillState.IN_MEMORY.contains(interval.spillState())) : "invalid interval";
  
                                  while (interval != TraceInterval.EndMarker && interval.spillDefinitionPos() == opId) {
!                                     Debug.log("handle %s", interval);
!                                     debug.log("handle %s", interval);
                                      if (!interval.canMaterialize() && interval.spillState() != SpillState.StartInMemory) {
  
                                          AllocatableValue fromLocation = interval.getSplitChildAtOpId(opId, OperandMode.DEF).location();
                                          AllocatableValue toLocation = allocator.canonicalSpillOpr(interval);
                                          if (!fromLocation.equals(toLocation)) {

*** 166,177 ****
--- 167,178 ----
  
                                              LIRInstruction move = allocator.getSpillMoveFactory().createMove(toLocation, fromLocation);
                                              insertionBuffer.append(j + 1, move);
                                              move.setComment(res, "TraceLSRAEliminateSpillMove: spill def pos");
  
!                                             if (Debug.isLogEnabled()) {
!                                                 Debug.log("inserting move after definition of interval %d to stack slot %s at opId %d", interval.operandNumber, interval.spillSlot(), opId);
!                                             if (debug.isLogEnabled()) {
!                                                 debug.log("inserting move after definition of interval %d to stack slot %s at opId %d", interval.operandNumber, interval.spillSlot(), opId);
                                              }
                                          }
                                      }
                                      interval = interval.next;
                                  }

*** 224,234 ****
--- 225,235 ----
          assert ((LIRInstruction) move).id() == -1 : "Not a spill move: " + move;
          TraceInterval curInterval = allocator.intervalFor(asVariable(move.getResult()));
          return curInterval.isSplitParent();
      }
  
!     private static void checkIntervals(DebugContext debug, TraceInterval interval) {
          TraceInterval prev = null;
          TraceInterval temp = interval;
          while (temp != TraceInterval.EndMarker) {
              assert temp.spillDefinitionPos() >= 0 : "invalid spill definition pos " + temp;
              if (prev != null) {

*** 239,250 ****
--- 240,251 ----
              assert temp.spillSlot() != null || temp.canMaterialize() : "interval has no spill slot assigned";
              assert temp.spillDefinitionPos() >= temp.from() : "invalid order";
              // assert temp.spillDefinitionPos() <= temp.from() + 2 :
              // "only intervals defined once at their start-pos can be optimized";
  
!             if (Debug.isLogEnabled()) {
!                 Debug.log("interval %d (from %d to %d) must be stored at %d", temp.operandNumber, temp.from(), temp.to(), temp.spillDefinitionPos());
!             if (debug.isLogEnabled()) {
!                 debug.log("interval %d (from %d to %d) must be stored at %d", temp.operandNumber, temp.from(), temp.to(), temp.spillDefinitionPos());
              }
  
              prev = temp;
              temp = temp.next;
          }