From eb00c5301a5b3eed6556e750411d0c436d0243bf Mon Sep 17 00:00:00 2001 From: "dcarney@chromium.org" Date: Mon, 6 Oct 2014 13:03:04 +0000 Subject: [PATCH] [turbofan] map vregs early R=bmeurer@chromium.org, jarin@chromium.org BUG= Review URL: https://codereview.chromium.org/623313003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24414 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/compiler/instruction-selector-impl.h | 10 ++++++---- src/compiler/instruction-selector.cc | 8 ++++---- src/compiler/instruction.cc | 29 +++++++++++++++++++++++++++++ src/compiler/instruction.h | 26 ++++++++------------------ src/compiler/register-allocator.cc | 15 ++++++++------- 5 files changed, 55 insertions(+), 33 deletions(-) diff --git a/src/compiler/instruction-selector-impl.h b/src/compiler/instruction-selector-impl.h index ac7c486..600ac39 100644 --- a/src/compiler/instruction-selector-impl.h +++ b/src/compiler/instruction-selector-impl.h @@ -45,8 +45,8 @@ class OperandGenerator { InstructionOperand* DefineAsConstant(Node* node) { selector()->MarkAsDefined(node); - sequence()->AddConstant(node->id(), ToConstant(node)); - return ConstantOperand::Create(node->id(), zone()); + int virtual_register = sequence()->AddConstant(node, ToConstant(node)); + return ConstantOperand::Create(virtual_register, zone()); } InstructionOperand* DefineAsLocation(Node* node, LinkageLocation location, @@ -166,7 +166,8 @@ class OperandGenerator { UnallocatedOperand* Define(Node* node, UnallocatedOperand* operand) { DCHECK_NOT_NULL(node); DCHECK_NOT_NULL(operand); - operand->set_virtual_register(node->id()); + operand->set_virtual_register( + selector_->sequence()->GetVirtualRegister(node)); selector()->MarkAsDefined(node); return operand; } @@ -174,7 +175,8 @@ class OperandGenerator { UnallocatedOperand* Use(Node* node, UnallocatedOperand* operand) { DCHECK_NOT_NULL(node); DCHECK_NOT_NULL(operand); - operand->set_virtual_register(node->id()); + operand->set_virtual_register( + selector_->sequence()->GetVirtualRegister(node)); selector()->MarkAsUsed(node); return operand; } diff --git a/src/compiler/instruction-selector.cc b/src/compiler/instruction-selector.cc index 1b2ea04..c141259 100644 --- a/src/compiler/instruction-selector.cc +++ b/src/compiler/instruction-selector.cc @@ -190,27 +190,27 @@ void InstructionSelector::MarkAsUsed(Node* node) { bool InstructionSelector::IsDouble(const Node* node) const { DCHECK_NOT_NULL(node); - return sequence()->IsDouble(node->id()); + return sequence()->IsDouble(sequence()->GetVirtualRegister(node)); } void InstructionSelector::MarkAsDouble(Node* node) { DCHECK_NOT_NULL(node); DCHECK(!IsReference(node)); - sequence()->MarkAsDouble(node->id()); + sequence()->MarkAsDouble(sequence()->GetVirtualRegister(node)); } bool InstructionSelector::IsReference(const Node* node) const { DCHECK_NOT_NULL(node); - return sequence()->IsReference(node->id()); + return sequence()->IsReference(sequence()->GetVirtualRegister(node)); } void InstructionSelector::MarkAsReference(Node* node) { DCHECK_NOT_NULL(node); DCHECK(!IsDouble(node)); - sequence()->MarkAsReference(node->id()); + sequence()->MarkAsReference(sequence()->GetVirtualRegister(node)); } diff --git a/src/compiler/instruction.cc b/src/compiler/instruction.cc index 280dd6e..e19a905 100644 --- a/src/compiler/instruction.cc +++ b/src/compiler/instruction.cc @@ -316,6 +316,35 @@ std::ostream& operator<<(std::ostream& os, const Constant& constant) { } +InstructionSequence::InstructionSequence(Linkage* linkage, Graph* graph, + Schedule* schedule) + : graph_(graph), + node_map_(zone()->NewArray(graph->NodeCount())), + linkage_(linkage), + schedule_(schedule), + constants_(ConstantMap::key_compare(), + ConstantMap::allocator_type(zone())), + immediates_(zone()), + instructions_(zone()), + next_virtual_register_(0), + pointer_maps_(zone()), + doubles_(std::less(), VirtualRegisterSet::allocator_type(zone())), + references_(std::less(), VirtualRegisterSet::allocator_type(zone())), + deoptimization_entries_(zone()) { + for (int i = 0; i < graph->NodeCount(); ++i) { + node_map_[i] = -1; + } +} + + +int InstructionSequence::GetVirtualRegister(const Node* node) { + if (node_map_[node->id()] == -1) { + node_map_[node->id()] = NextVirtualRegister(); + } + return node_map_[node->id()]; +} + + Label* InstructionSequence::GetLabel(BasicBlock* block) { return GetBlockStart(block)->label(); } diff --git a/src/compiler/instruction.h b/src/compiler/instruction.h index e3507f7..5811d54 100644 --- a/src/compiler/instruction.h +++ b/src/compiler/instruction.h @@ -34,8 +34,8 @@ const InstructionCode kSourcePositionInstruction = -3; #define INSTRUCTION_OPERAND_LIST(V) \ - V(Constant, CONSTANT, 128) \ - V(Immediate, IMMEDIATE, 128) \ + V(Constant, CONSTANT, 0) \ + V(Immediate, IMMEDIATE, 0) \ V(StackSlot, STACK_SLOT, 128) \ V(DoubleStackSlot, DOUBLE_STACK_SLOT, 128) \ V(Register, REGISTER, Register::kNumRegisters) \ @@ -804,20 +804,7 @@ typedef ZoneVector DeoptimizationVector; // TODO(titzer): s/IsDouble/IsFloat64/ class InstructionSequence FINAL { public: - InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule) - : graph_(graph), - linkage_(linkage), - schedule_(schedule), - constants_(ConstantMap::key_compare(), - ConstantMap::allocator_type(zone())), - immediates_(zone()), - instructions_(zone()), - next_virtual_register_(graph->NodeCount()), - pointer_maps_(zone()), - doubles_(std::less(), VirtualRegisterSet::allocator_type(zone())), - references_(std::less(), - VirtualRegisterSet::allocator_type(zone())), - deoptimization_entries_(zone()) {} + InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule); int NextVirtualRegister() { return next_virtual_register_++; } int VirtualRegisterCount() const { return next_virtual_register_; } @@ -840,7 +827,7 @@ class InstructionSequence FINAL { BasicBlock* GetBasicBlock(int instruction_index); - int GetVirtualRegister(Node* node) const { return node->id(); } + int GetVirtualRegister(const Node* node); bool IsReference(int virtual_register) const; bool IsDouble(int virtual_register) const; @@ -880,9 +867,11 @@ class InstructionSequence FINAL { void StartBlock(BasicBlock* block); void EndBlock(BasicBlock* block); - void AddConstant(int virtual_register, Constant constant) { + int AddConstant(Node* node, Constant constant) { + int virtual_register = GetVirtualRegister(node); DCHECK(constants_.find(virtual_register) == constants_.end()); constants_.insert(std::make_pair(virtual_register, constant)); + return virtual_register; } Constant GetConstant(int virtual_register) const { ConstantMap::const_iterator it = constants_.find(virtual_register); @@ -926,6 +915,7 @@ class InstructionSequence FINAL { typedef std::set, ZoneIntAllocator> VirtualRegisterSet; Graph* graph_; + int* node_map_; Linkage* linkage_; Schedule* schedule_; ConstantMap constants_; diff --git a/src/compiler/register-allocator.cc b/src/compiler/register-allocator.cc index ff196ea..fbaf4fa 100644 --- a/src/compiler/register-allocator.cc +++ b/src/compiler/register-allocator.cc @@ -548,10 +548,9 @@ BitVector* RegisterAllocator::ComputeLiveOut(BasicBlock* block) { Node* phi = *j; if (phi->opcode() != IrOpcode::kPhi) continue; Node* input = phi->InputAt(static_cast(index)); - live_out->Add(input->id()); + live_out->Add(code()->GetVirtualRegister(input)); } } - return live_out; } @@ -1066,7 +1065,8 @@ void RegisterAllocator::ResolvePhis(BasicBlock* block) { 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(); @@ -1077,7 +1077,7 @@ void RegisterAllocator::ResolvePhis(BasicBlock* block) { 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. @@ -1089,7 +1089,7 @@ void RegisterAllocator::ResolvePhis(BasicBlock* block) { 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()); @@ -1298,7 +1298,8 @@ void RegisterAllocator::BuildLiveRanges() { // 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; @@ -1310,7 +1311,7 @@ void RegisterAllocator::BuildLiveRanges() { 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; -- 2.7.4