Lithium LLabel instruction are no longer used as gap instructions.

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 1029 matching lines @@
       // Thus we need to manually record a pointer.
       if (phi->representation().IsTagged()) {
         LInstruction* branch =
             InstructionAt(cur_block->last_instruction_index());
         if (branch->HasPointerMap()) {
           branch->pointer_map()->RecordPointer(phi_operand);
         }
       }
     }
 
+    // Insert spill-move in the first section of the first gap.
     LiveRange* live_range = LiveRangeFor(phi->id());
-    LLabel* label = chunk_->GetLabel(phi->block()->block_id());
-    label->GetOrCreateParallelMove(LGap::START)->
+    LGap* gap = chunk_->GetFirstGap(phi->block());
+    gap->GetOrCreateParallelMove(LGap::BEFORE)->
         AddMove(phi_operand, live_range->GetSpillOperand());
     live_range->SetSpillStartIndex(phi->block()->first_instruction_index());
   }
 }
 
 
 void LAllocator::Allocate(LChunk* chunk) {
   ASSERT(chunk_ == NULL);
   chunk_ = chunk;
   MeetRegisterConstraints();
@@ skipping 52 matching lines @@
     }
     cur_range = cur_range->next();
   }
 
   if (cur_cover->IsSpilled()) return;
   ASSERT(pred_cover != NULL && cur_cover != NULL);
   if (pred_cover != cur_cover) {
     LOperand* pred_op = pred_cover->CreateAssignedOperand();
     LOperand* cur_op = cur_cover->CreateAssignedOperand();
     if (!pred_op->Equals(cur_op)) {
-      LGap* gap = NULL;
       if (block->predecessors()->length() == 1) {
-        gap = GapAt(block->first_instruction_index());
+        LGap* gap = chunk_->GetFirstGap(block);
+        gap->GetOrCreateParallelMove(LGap::BEFORE)->AddMove(pred_op, cur_op);
       } else {
         ASSERT(pred->end()->SecondSuccessor() == NULL);
-        gap = GetLastGap(pred);
+        LGap* gap = GetLastGap(pred);
 
         // We are going to insert a move before the branch instruction.
         // Some branch instructions (e.g. loops' back edges)
         // can potentially cause a GC so they have a pointer map.
         // By inserting a move we essentially create a copy of a
         // value which is invisible to PopulatePointerMaps(), because we store
         // it into a location different from the operand of a live range
         // covering a branch instruction.
         // Thus we need to manually record a pointer.
         if (HasTaggedValue(range->id())) {
           LInstruction* branch = InstructionAt(pred->last_instruction_index());
           if (branch->HasPointerMap()) {
             branch->pointer_map()->RecordPointer(cur_op);
           }
         }
+        gap->GetOrCreateParallelMove(LGap::START)->AddMove(pred_op, cur_op);
       }
-      gap->GetOrCreateParallelMove(LGap::START)->AddMove(pred_op, cur_op);
     }
   }
 }
 
 
 LParallelMove* LAllocator::GetConnectingParallelMove(LifetimePosition pos) {
   int index = pos.InstructionIndex();
   if (IsGapAt(index)) {
     LGap* gap = GapAt(index);
     return gap->GetOrCreateParallelMove(
@@ skipping 954 matching lines @@
     LiveRange* current = live_ranges()->at(i);
     if (current != NULL) current->Verify();
   }
 }
 
 
 #endif
 
 
 } }  // namespace v8::internal