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

*** 87,99 ****
--- 87,99 ----
       *            intervals
       */
      IntervalWalker(LinearScan allocator, Interval unhandledFixed, Interval unhandledAny) {
          this.allocator = allocator;
  
!         unhandledLists = new RegisterBindingLists(unhandledFixed, unhandledAny, Interval.EndMarker);
!         activeLists = new RegisterBindingLists(Interval.EndMarker, Interval.EndMarker, Interval.EndMarker);
!         inactiveLists = new RegisterBindingLists(Interval.EndMarker, Interval.EndMarker, Interval.EndMarker);
!         unhandledLists = new RegisterBindingLists(unhandledFixed, unhandledAny, allocator.intervalEndMarker);
!         activeLists = new RegisterBindingLists(allocator.intervalEndMarker, allocator.intervalEndMarker, allocator.intervalEndMarker);
!         inactiveLists = new RegisterBindingLists(allocator.intervalEndMarker, allocator.intervalEndMarker, allocator.intervalEndMarker);
          currentPosition = -1;
      }
  
      protected void removeFromList(Interval interval) {
          if (interval.state == State.Active) {

*** 182,200 ****
--- 182,200 ----
      private Interval nextInterval(int toOpId) {
          RegisterBinding binding;
          Interval any = unhandledLists.any;
          Interval fixed = unhandledLists.fixed;
  
!         if (any != Interval.EndMarker) {
!         if (!any.isEndMarker()) {
              // intervals may start at same position . prefer fixed interval
!             binding = fixed != Interval.EndMarker && fixed.from() <= any.from() ? RegisterBinding.Fixed : RegisterBinding.Any;
!             binding = !fixed.isEndMarker() && fixed.from() <= any.from() ? RegisterBinding.Fixed : RegisterBinding.Any;
  
              assert binding == RegisterBinding.Fixed && fixed.from() <= any.from() || binding == RegisterBinding.Any && any.from() <= fixed.from() : "wrong interval!!!";
!             assert any == Interval.EndMarker || fixed == Interval.EndMarker || any.from() != fixed.from() ||
!             assert any.isEndMarker() || fixed.isEndMarker() || any.from() != fixed.from() ||
                              binding == RegisterBinding.Fixed : "if fixed and any-Interval start at same position, fixed must be processed first";
  
!         } else if (fixed != Interval.EndMarker) {
!         } else if (!fixed.isEndMarker()) {
              binding = RegisterBinding.Fixed;
          } else {
              return null;
          }
          Interval currentInterval = unhandledLists.get(binding);

*** 203,213 ****
--- 203,213 ----
              return null;
          }
  
          currentBinding = binding;
          unhandledLists.set(binding, currentInterval.next);
!         currentInterval.next = Interval.EndMarker;
!         currentInterval.next = allocator.intervalEndMarker;
          currentInterval.rewindRange();
          return currentInterval;
      }
  
      /**

*** 269,279 ****
--- 269,279 ----
       * Note that for {@linkplain RegisterBinding#Fixed fixed} and {@linkplain RegisterBinding#Any
       * any} intervals this is done in {@link #nextInterval(int)}.
       */
      private void updateUnhandledStackIntervals(int opId) {
          Interval currentInterval = unhandledLists.get(RegisterBinding.Stack);
!         while (currentInterval != Interval.EndMarker && currentInterval.from() <= opId) {
!         while (!currentInterval.isEndMarker() && currentInterval.from() <= opId) {
              Interval next = currentInterval.next;
              if (currentInterval.to() > opId) {
                  currentInterval.state = State.Active;
                  activeLists.addToListSortedByCurrentFromPositions(RegisterBinding.Stack, currentInterval);
                  intervalMoved(currentInterval, State.Unhandled, State.Active);