*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/stackslotalloc/FixPointIntervalBuilder.java	Mon Mar 20 17:40:09 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/stackslotalloc/FixPointIntervalBuilder.java	Mon Mar 20 17:40:09 2017

*** 24,39 ****
--- 24,37 ----
  
  import static org.graalvm.compiler.lir.LIRValueUtil.asVirtualStackSlot;
  import static org.graalvm.compiler.lir.LIRValueUtil.isVirtualStackSlot;
  
  import java.util.ArrayDeque;
+ import java.util.ArrayList;
  import java.util.BitSet;
  import java.util.Deque;
  import java.util.EnumSet;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
  import org.graalvm.compiler.core.common.cfg.BlockMap;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.DebugCounter;

*** 42,51 ****
--- 40,51 ----
  import org.graalvm.compiler.lir.InstructionValueProcedure;
  import org.graalvm.compiler.lir.LIR;
  import org.graalvm.compiler.lir.LIRInstruction;
  import org.graalvm.compiler.lir.LIRInstruction.OperandFlag;
  import org.graalvm.compiler.lir.LIRInstruction.OperandMode;
+ import org.graalvm.util.Equivalence;
+ import org.graalvm.util.EconomicSet;
  import org.graalvm.compiler.lir.VirtualStackSlot;
  
  import jdk.vm.ci.meta.Value;
  
  /**

*** 55,65 ****
--- 55,65 ----
      private final BlockMap<BitSet> liveInMap;
      private final BlockMap<BitSet> liveOutMap;
      private final LIR lir;
      private final int maxOpId;
      private final StackInterval[] stackSlotMap;
!     private final HashSet<LIRInstruction> usePos;
!     private final EconomicSet<LIRInstruction> usePos;
  
      /**
       * The number of allocated stack slots.
       */
      private static final DebugCounter uninitializedSlots = Debug.counter("StackSlotAllocator[uninitializedSlots]");

*** 68,86 ****
--- 68,86 ----
          this.lir = lir;
          this.stackSlotMap = stackSlotMap;
          this.maxOpId = maxOpId;
          liveInMap = new BlockMap<>(lir.getControlFlowGraph());
          liveOutMap = new BlockMap<>(lir.getControlFlowGraph());
!         this.usePos = new HashSet<>();
!         this.usePos = EconomicSet.create(Equivalence.IDENTITY);
      }
  
      /**
       * Builds the lifetime intervals for {@link VirtualStackSlot virtual stack slots}, sets up
       * {@link #stackSlotMap} and returns a set of use positions, i.e. instructions that contain
       * virtual stack slots.
       */
!     EconomicSet<LIRInstruction> build() {
          Deque<AbstractBlockBase<?>> worklist = new ArrayDeque<>();
          AbstractBlockBase<?>[] blocks = lir.getControlFlowGraph().getBlocks();
          for (int i = blocks.length - 1; i >= 0; i--) {
              worklist.add(blocks[i]);
          }

*** 113,123 ****
--- 113,123 ----
  
      @SuppressWarnings("try")
      private void processBlock(AbstractBlockBase<?> block, Deque<AbstractBlockBase<?>> worklist) {
          if (updateOutBlock(block)) {
              try (Indent indent = Debug.logAndIndent("handle block %s", block)) {
!                 ArrayList<LIRInstruction> instructions = lir.getLIRforBlock(block);
                  // get out set and mark intervals
                  BitSet outSet = liveOutMap.get(block);
                  markOutInterval(outSet, getBlockEnd(instructions));
                  printLiveSet("liveOut", outSet);
  

*** 304,317 ****
--- 304,317 ----
  
      private StackInterval getIntervalFromStackId(int id) {
          return stackSlotMap[id];
      }
  
!     private static int getBlockBegin(ArrayList<LIRInstruction> instructions) {
          return instructions.get(0).id();
      }
  
!     private static int getBlockEnd(ArrayList<LIRInstruction> instructions) {
          return instructions.get(instructions.size() - 1).id() + 1;
      }
  
  }