*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/alloc/trace/TraceGlobalMoveResolver.java	Mon Mar 20 17:39:54 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/alloc/trace/TraceGlobalMoveResolver.java	Mon Mar 20 17:39:54 2017

*** 20,45 ****
--- 20,44 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.lir.alloc.trace;
  
  import static org.graalvm.compiler.lir.LIRValueUtil.asVirtualStackSlot;
  import static org.graalvm.compiler.lir.LIRValueUtil.isStackSlotValue;
  import static org.graalvm.compiler.lir.LIRValueUtil.isVirtualStackSlot;
  import static org.graalvm.compiler.lir.alloc.trace.TraceUtil.asShadowedRegisterValue;
  import static org.graalvm.compiler.lir.alloc.trace.TraceUtil.isShadowedRegisterValue;
  import static jdk.vm.ci.code.ValueUtil.asAllocatableValue;
  import static jdk.vm.ci.code.ValueUtil.asRegister;
  import static jdk.vm.ci.code.ValueUtil.asStackSlot;
  import static jdk.vm.ci.code.ValueUtil.isIllegal;
  import static jdk.vm.ci.code.ValueUtil.isRegister;
  import static jdk.vm.ci.code.ValueUtil.isStackSlot;
+ import static org.graalvm.compiler.lir.LIRValueUtil.asVirtualStackSlot;
+ import static org.graalvm.compiler.lir.LIRValueUtil.isStackSlotValue;
+ import static org.graalvm.compiler.lir.LIRValueUtil.isVirtualStackSlot;
+ import static org.graalvm.compiler.lir.alloc.trace.TraceUtil.asShadowedRegisterValue;
+ import static org.graalvm.compiler.lir.alloc.trace.TraceUtil.isShadowedRegisterValue;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.List;
  
  import org.graalvm.compiler.core.common.LIRKind;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.DebugCounter;
  import org.graalvm.compiler.debug.GraalError;

*** 50,59 ****
--- 49,59 ----
  import org.graalvm.compiler.lir.framemap.FrameMap;
  import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
  import org.graalvm.compiler.lir.framemap.FrameMapBuilderTool;
  import org.graalvm.compiler.lir.gen.LIRGenerationResult;
  import org.graalvm.compiler.lir.gen.LIRGeneratorTool.MoveFactory;
+ import org.graalvm.compiler.options.OptionValues;
  
  import jdk.vm.ci.code.Architecture;
  import jdk.vm.ci.code.RegisterArray;
  import jdk.vm.ci.code.StackSlot;
  import jdk.vm.ci.meta.AllocatableValue;

*** 67,85 ****
--- 67,86 ----
      private static final DebugCounter cycleBreakingSlotsReused = Debug.counter("TraceRA[cycleBreakingSlotsReused(global)]");
  
      private int insertIdx;
      private LIRInsertionBuffer insertionBuffer; // buffer where moves are inserted
  
!     private final ArrayList<Value> mappingFrom;
!     private final ArrayList<Value> mappingFromStack;
!     private final List<AllocatableValue> mappingTo;
!     private final ArrayList<AllocatableValue> mappingTo;
      private final int[] registerBlocked;
      private static final int STACK_SLOT_IN_CALLER_FRAME_IDX = -1;
      private int[] stackBlocked;
      private final int firstVirtualStackIndex;
      private final MoveFactory spillMoveFactory;
      private final FrameMapBuilder frameMapBuilder;
+     private final OptionValues options;
  
      private void setValueBlocked(Value location, int direction) {
          assert direction == 1 || direction == -1 : "out of bounds";
          if (isStackSlotValue(location)) {
              int stackIdx = getStackArrayIndex(location);

*** 150,159 ****
--- 151,161 ----
          FrameMapBuilderTool frameMapBuilderTool = (FrameMapBuilderTool) frameMapBuilder;
          this.stackBlocked = new int[frameMapBuilderTool.getNumberOfStackSlots()];
  
          FrameMap frameMap = frameMapBuilderTool.getFrameMap();
          this.firstVirtualStackIndex = !frameMap.frameNeedsAllocating() ? 0 : frameMap.currentFrameSize() + 1;
+         this.options = res.getLIR().getOptions();
      }
  
      private boolean checkEmpty() {
          for (int i = 0; i < stackBlocked.length; i++) {
              assert stackBlocked[i] == 0 : "stack map must be empty before and after processing";

*** 294,304 ****
--- 296,306 ----
  
      private static boolean mightBeBlocked(Value location) {
          return isRegister(location) || isStackSlotValue(location);
      }
  
!     private void createInsertionBuffer(ArrayList<LIRInstruction> list) {
          assert !insertionBuffer.initialized() : "overwriting existing buffer";
          insertionBuffer.init(list);
      }
  
      private void appendInsertionBuffer() {

*** 402,412 ****
--- 404,414 ----
  
          // create a new spill interval and assign a stack slot to it
          Value from = mappingFrom.get(spillCandidate);
          try (Indent indent = Debug.logAndIndent("BreakCycle: %s", from)) {
              AllocatableValue spillSlot = null;
!             if (TraceRegisterAllocationPhase.Options.TraceRAreuseStackSlotsForMoveResolutionCycleBreaking.getValue(options) && !isStackSlotValue(from)) {
                  // don't use the stack slot if from is already the stack slot
                  Value fromStack = mappingFromStack.get(spillCandidate);
                  if (fromStack != null) {
                      spillSlot = (AllocatableValue) fromStack;
                      cycleBreakingSlotsReused.increment();

*** 433,443 ****
--- 435,445 ----
                  Debug.log("move %s <- %s (%s)", mappingTo.get(i), mappingFrom.get(i), mappingFromStack.get(i));
              }
          }
      }
  
!     public void setInsertPosition(ArrayList<LIRInstruction> insertList, int insertIdx) {
          assert this.insertIdx == -1 : "use moveInsertPosition instead of setInsertPosition when data already set";
  
          createInsertionBuffer(insertList);
          this.insertIdx = insertIdx;
      }