[turbofan] map vregs early

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 530 matching lines @@
 
     // All phi input operands corresponding to this successor edge are live
     // out from this block.
     size_t index = successor->PredecessorIndexOf(block);
     DCHECK(index < successor->PredecessorCount());
     for (BasicBlock::const_iterator j = successor->begin();
          j != successor->end(); ++j) {
       Node* phi = *j;
       if (phi->opcode() != IrOpcode::kPhi) continue;
       Node* input = phi->InputAt(static_cast<int>(index));
-      live_out->Add(input->id());
+      live_out->Add(code()->GetVirtualRegister(input));
     }
   }
-
   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());
@@ skipping 494 matching lines @@
 }
 
 
 void RegisterAllocator::ResolvePhis(BasicBlock* block) {
   for (BasicBlock::const_iterator i = block->begin(); i != block->end(); ++i) {
     Node* phi = *i;
     if (phi->opcode() != IrOpcode::kPhi) continue;
 
     UnallocatedOperand* phi_operand =
         new (code_zone()) UnallocatedOperand(UnallocatedOperand::NONE);
-    phi_operand->set_virtual_register(phi->id());
+    int phi_vreg = code()->GetVirtualRegister(phi);
+    phi_operand->set_virtual_register(phi_vreg);
 
     size_t j = 0;
     Node::Inputs inputs = phi->inputs();
     for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
          ++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(op->id());
+      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,
                          phi_operand);
 
       Instruction* branch = InstructionAt(cur_block->last_instruction_index());
       DCHECK(!branch->HasPointerMap());
       USE(branch);
     }
 
-    LiveRange* live_range = LiveRangeFor(phi->id());
+    LiveRange* live_range = LiveRangeFor(phi_vreg);
     BlockStartInstruction* block_start = code()->GetBlockStart(block);
     block_start->GetOrCreateParallelMove(GapInstruction::START, code_zone())
         ->AddMove(phi_operand, live_range->GetSpillOperand(), code_zone());
     live_range->SetSpillStartIndex(block->first_instruction_index());
 
     // 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 188 matching lines @@
     // live values.
     ProcessInstructions(block, live);
     // All phi output operands are killed by this block.
     for (BasicBlock::const_iterator i = block->begin(); i != block->end();
          ++i) {
       Node* phi = *i;
       if (phi->opcode() != IrOpcode::kPhi) continue;
 
       // The live range interval already ends at the first instruction of the
       // block.
-      live->Remove(phi->id());
+      int phi_vreg = code()->GetVirtualRegister(phi);
+      live->Remove(phi_vreg);
 
       InstructionOperand* hint = NULL;
       InstructionOperand* phi_operand = NULL;
       GapInstruction* gap = GetLastGap(block->PredecessorAt(0));
 
       // TODO(titzer): no need to create the parallel move if it doesn't exit.
       ParallelMove* move =
           gap->GetOrCreateParallelMove(GapInstruction::START, code_zone());
       for (int j = 0; j < move->move_operands()->length(); ++j) {
         InstructionOperand* to = move->move_operands()->at(j).destination();
         if (to->IsUnallocated() &&
-            UnallocatedOperand::cast(to)->virtual_register() == phi->id()) {
+            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());
       Define(block_start, phi_operand, hint);
@@ skipping 896 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