[turbofan] put gaps before instructions

src/compiler/register-allocator.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 1060 matching lines @@
     }
   }
 }
 
 
 void RegisterAllocator::ProcessPhis(const InstructionBlock* block) {
   for (auto phi : block->phis()) {
     auto output = phi->output();
     int phi_vreg = phi->virtual_register();
     LiveRange* live_range = LiveRangeFor(phi_vreg);
-    BlockStartInstruction* block_start =
-        code()->GetBlockStart(block->rpo_number());
-    block_start->GetOrCreateParallelMove(GapInstruction::BEFORE, code_zone())
+    GapInstruction* gap = code()->GapAt(block->code_start() + 1);
+    gap->GetOrCreateParallelMove(GapInstruction::BEFORE, code_zone())
         ->AddMove(output, live_range->GetSpillOperand(), code_zone());
     live_range->SetSpillStartIndex(block->first_instruction_index());
   }
 }
 
 
 void RegisterAllocator::MeetRegisterConstraints() {
   for (auto block : code()->instruction_blocks()) {
     ProcessPhis(block);
     MeetRegisterConstraints(block);
@@ skipping 245 matching lines @@
 }
 
 
 void RegisterAllocator::ResolveControlFlow(const InstructionBlock* block,
                                            InstructionOperand* cur_op,
                                            const InstructionBlock* pred,
                                            InstructionOperand* pred_op) {
   if (pred_op->Equals(cur_op)) return;
   GapInstruction* gap = nullptr;
   if (block->PredecessorCount() == 1) {
-    gap = code()->GapAt(block->first_instruction_index());
+    gap = code()->GapAt(block->first_instruction_index() + 1);
   } else {
     DCHECK(pred->SuccessorCount() == 1);
     gap = GetLastGap(pred);
-
-    Instruction* branch = InstructionAt(pred->last_instruction_index());
-    DCHECK(!branch->HasPointerMap());
-    USE(branch);
+    DCHECK(!InstructionAt(pred->last_instruction_index())->HasPointerMap());
   }
   gap->GetOrCreateParallelMove(GapInstruction::START, code_zone())
       ->AddMove(pred_op, cur_op, code_zone());
 }
 
 
 void RegisterAllocator::BuildLiveRanges() {
   InitializeLivenessAnalysis();
   // Process the blocks in reverse order.
   for (int block_id = code()->InstructionBlockCount() - 1; block_id >= 0;
@@ skipping 866 matching lines @@
   } else {
     DCHECK(range->Kind() == GENERAL_REGISTERS);
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg, code_zone());
 }
 
 }
 }
 }  // namespace v8::internal::compiler