Remove NearestNextGapPos. It is not used anymore.

src/lithium-allocator.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1768 matching lines @@
   }
 
   if (free_pos[max_reg].InstructionIndex() == 0) {
     return false;
   } else if (free_pos[max_reg].Value() >= current->End().Value()) {
     TraceAlloc("Assigning reg %d to live range %d\n", max_reg, current->id());
     current->set_assigned_register(max_reg, mode_ == XMM_REGISTERS);
   } else {
     // Split the interval at the nearest gap and never split an interval at its
     // start position.
-    LifetimePosition pos =
-        LifetimePosition::FromInstructionIndex(
-            chunk_->NearestGapPos(free_pos[max_reg].InstructionIndex()));
+    LifetimePosition pos = free_pos[max_reg];

[fschneider, 2010/12/07 14:47:08]

Fix the comment above.

     if (pos.Value() <= current->Start().Value()) return false;
     LiveRange* second_range = Split(current, pos);
     AddToUnhandledSorted(second_range);
     current->set_assigned_register(max_reg, mode_ == XMM_REGISTERS);
   }
 
   return true;
 }
 
 
@@ skipping 62 matching lines @@
 
     current->set_assigned_register(max_reg, mode_ == XMM_REGISTERS);
     SplitAndSpillIntersecting(current);
   }
 }
 
 
 void LAllocator::SplitAndSpillIntersecting(LiveRange* current) {
   ASSERT(current->HasRegisterAssigned());
   int reg = current->assigned_register();
-  LifetimePosition split_pos =
-      LifetimePosition::FromInstructionIndex(
-          chunk_->NearestGapPos(current->Start().InstructionIndex()));
+  LifetimePosition split_pos = current->Start();
   for (int i = 0; i < active_live_ranges_.length(); ++i) {
     LiveRange* range = active_live_ranges_[i];
     if (range->assigned_register() == reg) {
       UsePosition* next_pos = range->NextRegisterPosition(current->Start());
       if (next_pos == NULL) {
         SplitAndSpill(range, split_pos);
       } else {
         SplitAndSpill(range, split_pos, next_pos->pos());
       }
       ActiveToHandled(range);
@@ skipping 118 matching lines @@
     Spill(tail_part);
     ASSERT(third_part != tail_part);
     AddToUnhandledSorted(third_part);
   } else {
     AddToUnhandledSorted(tail_part);
   }
 }
 
 
 void LAllocator::SplitAndSpill(LiveRange* range, LifetimePosition at) {
-  at = LifetimePosition::FromInstructionIndex(
-      chunk_->NearestGapPos(at.InstructionIndex()));
   LiveRange* second_part = Split(range, at);
   Spill(second_part);
 }
 
 
 void LAllocator::Spill(LiveRange* range) {
   ASSERT(!range->IsSpilled());
   TraceAlloc("Spilling live range %d\n", range->id());
   LiveRange* first = range->TopLevel();
 
@@ skipping 19 matching lines @@
     LiveRange* current = live_ranges()->at(i);
     if (current != NULL) current->Verify();
   }
 }
 
 
 #endif
 
 
 } }  // namespace v8::internal