[turbofan] remove some of the dependency of Instruction on Schedule

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/register-allocator.h"
 
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/linkage.h"
 #include "src/hydrogen.h"
 #include "src/string-stream.h"
@@ skipping 541 matching lines @@
     }
   }
   return live_out;
 }
 
 
 void RegisterAllocator::AddInitialIntervals(BasicBlock* block,
                                             BitVector* live_out) {
   // Add an interval that includes the entire block to the live range for
   // each live_out value.
-  LifetimePosition start =
-      LifetimePosition::FromInstructionIndex(block->first_instruction_index());
-  LifetimePosition end = LifetimePosition::FromInstructionIndex(
-                             block->last_instruction_index()).NextInstruction();
+  LifetimePosition start = LifetimePosition::FromInstructionIndex(
+      code()->first_instruction_index(block));
+  LifetimePosition end =
+      LifetimePosition::FromInstructionIndex(
+          code()->last_instruction_index(block)).NextInstruction();
   BitVector::Iterator iterator(live_out);
   while (!iterator.Done()) {
     int operand_index = iterator.Current();
     LiveRange* range = LiveRangeFor(operand_index);
     range->AddUseInterval(start, end, zone());
     iterator.Advance();
   }
 }
 
 
@@ skipping 68 matching lines @@
   LiveRange* result = live_ranges_[index];
   if (result == NULL) {
     result = new (zone()) LiveRange(index, code_zone());
     live_ranges_[index] = result;
   }
   return result;
 }
 
 
 GapInstruction* RegisterAllocator::GetLastGap(BasicBlock* block) {
-  int last_instruction = block->last_instruction_index();
+  int last_instruction = code()->last_instruction_index(block);
   return code()->GapAt(last_instruction - 1);
 }
 
 
 LiveRange* RegisterAllocator::LiveRangeFor(InstructionOperand* operand) {
   if (operand->IsUnallocated()) {
     return LiveRangeFor(UnallocatedOperand::cast(operand)->virtual_register());
   } else if (operand->IsRegister()) {
     return FixedLiveRangeFor(operand->index());
   } else if (operand->IsDoubleRegister()) {
@@ skipping 57 matching lines @@
           return;
         }
       }
     }
   }
   move->AddMove(from, to, code_zone());
 }
 
 
 void RegisterAllocator::MeetRegisterConstraints(BasicBlock* block) {
-  int start = block->first_instruction_index();
-  int end = block->last_instruction_index();
+  int start = code()->first_instruction_index(block);
+  int end = code()->last_instruction_index(block);
   DCHECK_NE(-1, start);
   for (int i = start; i <= end; ++i) {
     if (code()->IsGapAt(i)) {
       Instruction* instr = NULL;
       Instruction* prev_instr = NULL;
       if (i < end) instr = InstructionAt(i + 1);
       if (i > start) prev_instr = InstructionAt(i - 1);
       MeetConstraintsBetween(prev_instr, instr, i);
       if (!AllocationOk()) return;
     }
   }
 
   // Meet register constraints for the instruction in the end.
   if (!code()->IsGapAt(end)) {
     MeetRegisterConstraintsForLastInstructionInBlock(block);
   }
 }
 
 
 void RegisterAllocator::MeetRegisterConstraintsForLastInstructionInBlock(
     BasicBlock* block) {
-  int end = block->last_instruction_index();
+  int end = code()->last_instruction_index(block);
   Instruction* last_instruction = InstructionAt(end);
   for (size_t i = 0; i < last_instruction->OutputCount(); i++) {
     InstructionOperand* output_operand = last_instruction->OutputAt(i);
     DCHECK(!output_operand->IsConstant());
     UnallocatedOperand* output = UnallocatedOperand::cast(output_operand);
     int output_vreg = output->virtual_register();
     LiveRange* range = LiveRangeFor(output_vreg);
     bool assigned = false;
     if (output->HasFixedPolicy()) {
       AllocateFixed(output, -1, false);
       // This value is produced on the stack, we never need to spill it.
       if (output->IsStackSlot()) {
         range->SetSpillOperand(output);
         range->SetSpillStartIndex(end);
         assigned = true;
       }
 
       for (BasicBlock::Successors::iterator succ = block->successors_begin();
            succ != block->successors_end(); ++succ) {
         DCHECK((*succ)->PredecessorCount() == 1);
-        int gap_index = (*succ)->first_instruction_index() + 1;
+        int gap_index = code()->first_instruction_index(*succ) + 1;
         DCHECK(code()->IsGapAt(gap_index));
 
         // Create an unconstrained operand for the same virtual register
         // and insert a gap move from the fixed output to the operand.
         UnallocatedOperand* output_copy =
             new (code_zone()) UnallocatedOperand(UnallocatedOperand::ANY);
         output_copy->set_virtual_register(output_vreg);
 
         code()->AddGapMove(gap_index, output, output_copy);
       }
     }
 
     if (!assigned) {
       for (BasicBlock::Successors::iterator succ = block->successors_begin();
            succ != block->successors_end(); ++succ) {
         DCHECK((*succ)->PredecessorCount() == 1);
-        int gap_index = (*succ)->first_instruction_index() + 1;
+        int gap_index = code()->first_instruction_index(*succ) + 1;
         range->SetSpillStartIndex(gap_index);
 
         // This move to spill operand is not a real use. Liveness analysis
         // and splitting of live ranges do not account for it.
         // Thus it should be inserted to a lifetime position corresponding to
         // the instruction end.
         GapInstruction* gap = code()->GapAt(gap_index);
         ParallelMove* move =
             gap->GetOrCreateParallelMove(GapInstruction::BEFORE, code_zone());
         move->AddMove(output, range->GetSpillOperand(), code_zone());
@@ skipping 126 matching lines @@
   for (size_t i = 0; i < instr->OutputCount(); i++) {
     InstructionOperand* output = instr->OutputAt(i);
     if (output->IsDoubleRegister() && output->index() == index) return true;
   }
   return false;
 }
 
 
 void RegisterAllocator::ProcessInstructions(BasicBlock* block,
                                             BitVector* live) {
-  int block_start = block->first_instruction_index();
+  int block_start = code()->first_instruction_index(block);
 
   LifetimePosition block_start_position =
       LifetimePosition::FromInstructionIndex(block_start);
 
-  for (int index = block->last_instruction_index(); index >= block_start;
+  for (int index = code()->last_instruction_index(block); index >= block_start;
        index--) {
     LifetimePosition curr_position =
         LifetimePosition::FromInstructionIndex(index);
 
     Instruction* instr = InstructionAt(index);
     DCHECK(instr != NULL);
     if (instr->IsGapMoves()) {
       // Process the moves of the gap instruction, making their sources live.
       GapInstruction* gap = code()->GapAt(index);
 
@@ skipping 118 matching lines @@
          ++iter, ++j) {
       Node* op = *iter;
       // TODO(mstarzinger): Use a ValueInputIterator instead.
       if (j >= block->PredecessorCount()) continue;
       UnallocatedOperand* operand =
           new (code_zone()) UnallocatedOperand(UnallocatedOperand::ANY);
       operand->set_virtual_register(code()->GetVirtualRegister(op));
       BasicBlock* cur_block = block->PredecessorAt(j);
       // The gap move must be added without any special processing as in
       // the AddConstraintsGapMove.
-      code()->AddGapMove(cur_block->last_instruction_index() - 1, operand,
+      code()->AddGapMove(code()->last_instruction_index(cur_block) - 1, operand,
                          phi_operand);
 
-      Instruction* branch = InstructionAt(cur_block->last_instruction_index());
+      Instruction* branch =
+          InstructionAt(code()->last_instruction_index(cur_block));
       DCHECK(!branch->HasPointerMap());
       USE(branch);
     }
 
     LiveRange* live_range = LiveRangeFor(phi_vreg);
-    BlockStartInstruction* block_start = code()->GetBlockStart(block);
+    BlockStartInstruction* block_start =
+        code()->GetBlockStart(block->GetRpoNumber());
     block_start->GetOrCreateParallelMove(GapInstruction::START, code_zone())
         ->AddMove(phi_operand, live_range->GetSpillOperand(), code_zone());
-    live_range->SetSpillStartIndex(block->first_instruction_index());
+    live_range->SetSpillStartIndex(code()->first_instruction_index(block));
 
     // We use the phi-ness of some nodes in some later heuristics.
     live_range->set_is_phi(true);
     if (!block->IsLoopHeader()) {
       live_range->set_is_non_loop_phi(true);
     }
   }
 }
 
 
@@ skipping 33 matching lines @@
 
   // Process the blocks in reverse order.
   for (int i = code()->BasicBlockCount() - 1; i >= 0; --i) {
     ResolvePhis(code()->BlockAt(i));
   }
 }
 
 
 void RegisterAllocator::ResolveControlFlow(LiveRange* range, BasicBlock* block,
                                            BasicBlock* pred) {
-  LifetimePosition pred_end =
-      LifetimePosition::FromInstructionIndex(pred->last_instruction_index());
-  LifetimePosition cur_start =
-      LifetimePosition::FromInstructionIndex(block->first_instruction_index());
+  LifetimePosition pred_end = LifetimePosition::FromInstructionIndex(
+      code()->last_instruction_index(pred));
+  LifetimePosition cur_start = LifetimePosition::FromInstructionIndex(
+      code()->first_instruction_index(block));
   LiveRange* pred_cover = NULL;
   LiveRange* cur_cover = NULL;
   LiveRange* cur_range = range;
   while (cur_range != NULL && (cur_cover == NULL || pred_cover == NULL)) {
     if (cur_range->CanCover(cur_start)) {
       DCHECK(cur_cover == NULL);
       cur_cover = cur_range;
     }
     if (cur_range->CanCover(pred_end)) {
       DCHECK(pred_cover == NULL);
       pred_cover = cur_range;
     }
     cur_range = cur_range->next();
   }
 
   if (cur_cover->IsSpilled()) return;
   DCHECK(pred_cover != NULL && cur_cover != NULL);
   if (pred_cover != cur_cover) {
     InstructionOperand* pred_op =
         pred_cover->CreateAssignedOperand(code_zone());
     InstructionOperand* cur_op = cur_cover->CreateAssignedOperand(code_zone());
     if (!pred_op->Equals(cur_op)) {
       GapInstruction* gap = NULL;
       if (block->PredecessorCount() == 1) {
-        gap = code()->GapAt(block->first_instruction_index());
+        gap = code()->GapAt(code()->first_instruction_index(block));
       } else {
         DCHECK(pred->SuccessorCount() == 1);
         gap = GetLastGap(pred);
 
-        Instruction* branch = InstructionAt(pred->last_instruction_index());
+        Instruction* branch =
+            InstructionAt(code()->last_instruction_index(pred));
         DCHECK(!branch->HasPointerMap());
         USE(branch);
       }
       gap->GetOrCreateParallelMove(GapInstruction::START, code_zone())
           ->AddMove(pred_op, cur_op, code_zone());
     }
   }
 }
 
 
@@ skipping 119 matching lines @@
         if (to->IsUnallocated() &&
             UnallocatedOperand::cast(to)->virtual_register() == phi_vreg) {
           hint = move->move_operands()->at(j).source();
           phi_operand = to;
           break;
         }
       }
       DCHECK(hint != NULL);
 
       LifetimePosition block_start = LifetimePosition::FromInstructionIndex(
-          block->first_instruction_index());
+          code()->first_instruction_index(block));
       Define(block_start, phi_operand, hint);
     }
 
     // Now live is live_in for this block except not including values live
     // out on backward successor edges.
     live_in_sets_[block_id] = live;
 
     if (block->IsLoopHeader()) {
       // Add a live range stretching from the first loop instruction to the last
       // for each value live on entry to the header.
       BitVector::Iterator iterator(live);
       LifetimePosition start = LifetimePosition::FromInstructionIndex(
-          block->first_instruction_index());
+          code()->first_instruction_index(block));
       int end_index =
-          code()->BlockAt(block->loop_end())->last_instruction_index();
+          code()->last_instruction_index(code()->BlockAt(block->loop_end()));
       LifetimePosition end =
           LifetimePosition::FromInstructionIndex(end_index).NextInstruction();
       while (!iterator.Done()) {
         int operand_index = iterator.Current();
         LiveRange* range = LiveRangeFor(operand_index);
         range->EnsureInterval(start, end, zone());
         iterator.Advance();
       }
 
       // Insert all values into the live in sets of all blocks in the loop.
@@ skipping 611 matching lines @@
 
   if (loop_header == NULL) return pos;
 
   UsePosition* prev_use = range->PreviousUsePositionRegisterIsBeneficial(pos);
 
   while (loop_header != NULL) {
     // We are going to spill live range inside the loop.
     // If possible try to move spilling position backwards to loop header.
     // This will reduce number of memory moves on the back edge.
     LifetimePosition loop_start = LifetimePosition::FromInstructionIndex(
-        loop_header->first_instruction_index());
+        code()->first_instruction_index(loop_header));
 
     if (range->Covers(loop_start)) {
       if (prev_use == NULL || prev_use->pos().Value() < loop_start.Value()) {
         // No register beneficial use inside the loop before the pos.
         pos = loop_start;
       }
     }
 
     // Try hoisting out to an outer loop.
     loop_header = code()->GetContainingLoop(loop_header);
@@ skipping 117 matching lines @@
          code()->GetContainingLoop(block)->rpo_number() >
              start_block->rpo_number()) {
     block = code()->GetContainingLoop(block);
   }
 
   // We did not find any suitable outer loop. Split at the latest possible
   // position unless end_block is a loop header itself.
   if (block == end_block && !end_block->IsLoopHeader()) return end;
 
   return LifetimePosition::FromInstructionIndex(
-      block->first_instruction_index());
+      code()->first_instruction_index(block));
 }
 
 
 void RegisterAllocator::SpillAfter(LiveRange* range, LifetimePosition pos) {
   LiveRange* second_part = SplitRangeAt(range, pos);
   if (!AllocationOk()) return;
   Spill(second_part);
 }
 
 
@@ skipping 102 matching lines @@
                     allocator_zone_start_allocation_size_;
     isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(), size);
   }
 #ifdef DEBUG
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 }
 }
 }  // namespace v8::internal::compiler