last_processed_use_(NULL),
current_hint_operand_(NULL),
spill_operand_(new (zone) LOperand()),
- spill_start_index_(kMaxInt) {}
+ spill_start_index_(kMaxInt),
+ spill_range_(NULL) {}
void LiveRange::set_assigned_register(int reg, Zone* zone) {
DCHECK(TopLevel()->HasAllocatedSpillOperand());
spilled_ = true;
assigned_register_ = kInvalidAssignment;
- ConvertOperands(zone);
+ if (spill_range_ == NULL) {
+ ConvertOperands(zone);
+ }
}
bool LiveRange::HasAllocatedSpillOperand() const {
DCHECK(spill_operand_ != NULL);
- return !spill_operand_->IsIgnored();
+ return !spill_operand_->IsIgnored() || spill_range_ != NULL;
}
}
+void LiveRange::CommitSpillOperand(LOperand* operand) {
+ DCHECK(spill_range_ != NULL);
+ DCHECK(!IsChild());
+ spill_range_ = NULL;
+ SetSpillOperand(operand);
+ for (LiveRange* range = this; range != NULL; range = range->next()) {
+ if (range->IsSpilled()) {
+ range->ConvertUsesToOperand(operand);
+ }
+ }
+}
+
+
UsePosition* LiveRange::NextUsePosition(LifetimePosition start) {
UsePosition* use_pos = last_processed_use_;
if (use_pos == NULL) use_pos = first_pos();
}
-void LiveRange::ConvertOperands(Zone* zone) {
- LOperand* op = CreateAssignedOperand(zone);
+void LiveRange::ConvertUsesToOperand(LOperand* op) {
UsePosition* use_pos = first_pos();
while (use_pos != NULL) {
DCHECK(Start().Value() <= use_pos->pos().Value() &&
}
+void LiveRange::ConvertOperands(Zone* zone) {
+ LOperand* op = CreateAssignedOperand(zone);
+ ConvertUsesToOperand(op);
+}
+
+
bool LiveRange::CanCover(LifetimePosition position) const {
if (IsEmpty()) return false;
return Start().Value() <= position.Value() &&
active_live_ranges_(8, zone()),
inactive_live_ranges_(8, zone()),
reusable_slots_(8, zone()),
+ spill_ranges_(8, zone()),
next_virtual_register_(num_values),
first_artificial_register_(num_values),
mode_(UNALLOCATED_REGISTERS),
for (int i = 0; i < phis->length(); ++i) {
HPhi* phi = phis->at(i);
LUnallocated* phi_operand =
- new (chunk()->zone()) LUnallocated(LUnallocated::NONE);
+ new (chunk()->zone()) LUnallocated(LUnallocated::ANY);
phi_operand->set_virtual_register(phi->id());
for (int j = 0; j < phi->OperandCount(); ++j) {
HValue* op = phi->OperandAt(j);
if (!AllocationOk()) return false;
AllocateDoubleRegisters();
if (!AllocationOk()) return false;
+ ReuseSpillSlots();
PopulatePointerMaps();
ConnectRanges();
ResolveControlFlow();
}
+static bool AreUseIntervalsIntersecting(UseInterval* interval1,
+ UseInterval* interval2) {
+ while (interval1 != NULL && interval2 != NULL) {
+ if (interval1->start().Value() < interval2->start().Value()) {
+ if (interval1->end().Value() > interval2->start().Value()) {
+ return true;
+ }
+ interval1 = interval1->next();
+ } else {
+ if (interval2->end().Value() > interval1->start().Value()) {
+ return true;
+ }
+ interval2 = interval2->next();
+ }
+ }
+ return false;
+}
+
+
+SpillRange::SpillRange(LiveRange* range, int id, Zone* zone)
+ : id_(id), live_ranges_(1, zone), end_position_(range->End()) {
+ UseInterval* src = range->first_interval();
+ UseInterval* result = NULL;
+ UseInterval* node = NULL;
+ // Copy the nodes
+ while (src != NULL) {
+ UseInterval* new_node = new (zone) UseInterval(src->start(), src->end());
+ if (result == NULL) {
+ result = new_node;
+ } else {
+ node->set_next(new_node);
+ }
+ node = new_node;
+ src = src->next();
+ }
+ use_interval_ = result;
+ live_ranges_.Add(range, zone);
+ DCHECK(range->GetSpillRange() == NULL);
+ range->SetSpillRange(this);
+}
+
+
+bool SpillRange::IsIntersectingWith(SpillRange* other) {
+ if (End().Value() <= other->use_interval_->start().Value() ||
+ other->End().Value() <= use_interval_->start().Value()) {
+ return false;
+ }
+ return AreUseIntervalsIntersecting(use_interval_, other->use_interval_);
+}
+
+
+bool SpillRange::TryMerge(SpillRange* other, Zone* zone) {
+ if (Kind() == other->Kind() &&
+ !AreUseIntervalsIntersecting(use_interval_, other->use_interval_)) {
+ if (End().Value() < other->End().Value()) {
+ end_position_ = other->End();
+ }
+
+ MergeDisjointIntervals(other->use_interval_, zone);
+ other->use_interval_ = NULL;
+
+ for (int i = 0; i < other->live_ranges_.length(); i++) {
+ DCHECK(other->live_ranges_.at(i)->GetSpillRange() == other);
+ other->live_ranges_.at(i)->SetSpillRange(this);
+ }
+
+ live_ranges_.AddAll(other->live_ranges_, zone);
+ other->live_ranges_.Clear();
+
+ return true;
+ }
+ return false;
+}
+
+
+void SpillRange::SetOperand(LOperand* op) {
+ for (int i = 0; i < live_ranges_.length(); i++) {
+ DCHECK(live_ranges_.at(i)->GetSpillRange() == this);
+ live_ranges_.at(i)->CommitSpillOperand(op);
+ }
+}
+
+
+void SpillRange::MergeDisjointIntervals(UseInterval* other, Zone* zone) {
+ UseInterval* tail = NULL;
+ UseInterval* current = use_interval_;
+ while (other != NULL) {
+ // Make sure the 'current' list starts first
+ if (current == NULL || current->start().Value() > other->start().Value()) {
+ std::swap(current, other);
+ }
+
+ // Check disjointness
+ DCHECK(other == NULL || current->end().Value() <= other->start().Value());
+
+ // Append the 'current' node to the result accumulator and move forward
+ if (tail == NULL) {
+ use_interval_ = current;
+ } else {
+ tail->set_next(current);
+ }
+ tail = current;
+ current = current->next();
+ }
+ // Other list is empty => we are done
+}
+
+
+void LAllocator::ReuseSpillSlots() {
+ // Merge disjoint spill ranges
+ for (int i = 0; i < spill_ranges_.length(); i++) {
+ SpillRange* range = spill_ranges_.at(i);
+ if (!range->IsEmpty()) {
+ for (int j = i + 1; j < spill_ranges_.length(); j++) {
+ SpillRange* other = spill_ranges_.at(j);
+ if (!other->IsEmpty()) {
+ range->TryMerge(spill_ranges_.at(j), zone());
+ }
+ }
+ }
+ }
+
+ // Allocate slots for the merged spill ranges.
+ for (int i = 0; i < spill_ranges_.length(); i++) {
+ SpillRange* range = spill_ranges_.at(i);
+ if (!range->IsEmpty()) {
+ LOperand* op = chunk_->GetNextSpillSlot(range->Kind());
+ range->SetOperand(op);
+ }
+ }
+}
+
+
void LAllocator::MeetRegisterConstraints() {
LAllocatorPhase phase("L_Register constraints", this);
const ZoneList<HBasicBlock*>* blocks = graph_->blocks();
}
+bool LAllocator::TryReuseSpillForPhi(LiveRange* range) {
+ DCHECK(!range->HasAllocatedSpillOperand());
+ if (range->IsChild()) {
+ return false;
+ }
+ HValue* instr = graph_->LookupValue(range->id());
+ if (instr == NULL || !instr->IsPhi()) {
+ return false;
+ }
+
+ // Count the number of spilled operands.
+ HPhi* phi = HPhi::cast(instr);
+ int spilled_count = 0;
+ LiveRange* first_op = NULL;
+ for (int i = 0; i < phi->OperandCount(); i++) {
+ HValue* op = phi->OperandAt(i);
+ LiveRange* op_range = LiveRangeFor(op->id());
+ if (op_range->GetSpillRange() != NULL) {
+ HBasicBlock* pred = instr->block()->predecessors()->at(i);
+ LifetimePosition pred_end = LifetimePosition::FromInstructionIndex(
+ pred->last_instruction_index());
+ while (op_range != NULL && !op_range->CanCover(pred_end)) {
+ op_range = op_range->next();
+ }
+ if (op_range != NULL && op_range->IsSpilled()) {
+ spilled_count++;
+ if (first_op == NULL) {
+ first_op = op_range->TopLevel();
+ }
+ }
+ }
+ }
+
+ // Only continue if more than half of the operands are spilled.
+ if (spilled_count * 2 <= phi->OperandCount()) {
+ return false;
+ }
+
+ // Try to merge the spilled operands and count the number of merged spilled
+ // operands.
+ DCHECK(first_op != NULL);
+ SpillRange* first_op_spill = first_op->GetSpillRange();
+ int num_merged = 1;
+ for (int i = 1; i < phi->OperandCount(); i++) {
+ HValue* op = phi->OperandAt(i);
+ LiveRange* op_range = LiveRangeFor(op->id());
+ SpillRange* op_spill = op_range->GetSpillRange();
+ if (op_spill != NULL) {
+ if (op_spill->id() == first_op_spill->id() ||
+ first_op_spill->TryMerge(op_spill, zone())) {
+ num_merged++;
+ }
+ }
+ }
+
+ // Only continue if enough operands could be merged to the
+ // same spill slot.
+ if (num_merged * 2 <= phi->OperandCount() ||
+ AreUseIntervalsIntersecting(first_op_spill->interval(),
+ range->first_interval())) {
+ return false;
+ }
+
+ // If the range does not need register soon, spill it to the merged
+ // spill range.
+ LifetimePosition next_pos = range->Start();
+ if (IsGapAt(next_pos.InstructionIndex())) {
+ next_pos = next_pos.NextInstruction();
+ }
+ UsePosition* pos = range->NextUsePositionRegisterIsBeneficial(next_pos);
+ if (pos == NULL) {
+ SpillRange* spill_range = AssignSpillRangeToLiveRange(range->TopLevel());
+ CHECK(first_op_spill->TryMerge(spill_range, zone()));
+ Spill(range);
+ return true;
+ } else if (pos->pos().Value() > range->Start().NextInstruction().Value()) {
+ SpillRange* spill_range = AssignSpillRangeToLiveRange(range->TopLevel());
+ CHECK(first_op_spill->TryMerge(spill_range, zone()));
+ SpillBetween(range, range->Start(), pos->pos());
+ if (!AllocationOk()) return false;
+ DCHECK(UnhandledIsSorted());
+ return true;
+ }
+
+ return false;
+}
+
+
+SpillRange* LAllocator::AssignSpillRangeToLiveRange(LiveRange* range) {
+ int spill_id = spill_ranges_.length();
+ SpillRange* spill_range = new (zone()) SpillRange(range, spill_id, zone());
+ spill_ranges_.Add(spill_range, zone());
+ return spill_range;
+}
+
+
void LAllocator::AllocateRegisters() {
DCHECK(unhandled_live_ranges_.is_empty());
}
}
+ if (TryReuseSpillForPhi(current)) {
+ continue;
+ }
+ if (!AllocationOk()) return;
+
for (int i = 0; i < active_live_ranges_.length(); ++i) {
LiveRange* cur_active = active_live_ranges_.at(i);
if (cur_active->End().Value() <= position.Value()) {
}
-void LAllocator::FreeSpillSlot(LiveRange* range) {
- // Check that we are the last range.
- if (range->next() != NULL) return;
-
- if (!range->TopLevel()->HasAllocatedSpillOperand()) return;
-
- int index = range->TopLevel()->GetSpillOperand()->index();
- if (index >= 0) {
- reusable_slots_.Add(range, zone());
- }
-}
-
-
-LOperand* LAllocator::TryReuseSpillSlot(LiveRange* range) {
- if (reusable_slots_.is_empty()) return NULL;
- if (reusable_slots_.first()->End().Value() >
- range->TopLevel()->Start().Value()) {
- return NULL;
- }
- LOperand* result = reusable_slots_.first()->TopLevel()->GetSpillOperand();
- reusable_slots_.Remove(0);
- return result;
-}
-
-
void LAllocator::ActiveToHandled(LiveRange* range) {
DCHECK(active_live_ranges_.Contains(range));
active_live_ranges_.RemoveElement(range);
TraceAlloc("Moving live range %d from active to handled\n", range->id());
- FreeSpillSlot(range);
}
DCHECK(inactive_live_ranges_.Contains(range));
inactive_live_ranges_.RemoveElement(range);
TraceAlloc("Moving live range %d from inactive to handled\n", range->id());
- FreeSpillSlot(range);
}
AddToUnhandledSorted(tail);
}
-
// Register reg is available at the range start and is free until
// the range end.
DCHECK(pos.Value() >= current->End().Value());
LiveRange* first = range->TopLevel();
if (!first->HasAllocatedSpillOperand()) {
- LOperand* op = TryReuseSpillSlot(range);
- if (op == NULL) op = chunk_->GetNextSpillSlot(range->Kind());
- first->SetSpillOperand(op);
+ AssignSpillRangeToLiveRange(first);
}
range->MakeSpilled(chunk()->zone());
}
LifetimePosition end_;
UseInterval* next_;
+ friend class LAllocator; // Assigns to next_.
+ friend class SpillRange; // Assigns to next_.
friend class LiveRange; // Assigns to start_.
};
friend class LiveRange;
};
+class SpillRange;
+
// Representation of SSA values' live ranges as a collection of (continuous)
// intervals over the instruction ordering.
class LiveRange: public ZoneObject {
LOperand* GetSpillOperand() const { return spill_operand_; }
void SetSpillOperand(LOperand* operand);
+ void SetSpillRange(SpillRange* spill_range) { spill_range_ = spill_range; }
+ SpillRange* GetSpillRange() const { return spill_range_; }
+ void CommitSpillOperand(LOperand* operand);
+
void SetSpillStartIndex(int start) {
spill_start_index_ = Min(start, spill_start_index_);
}
private:
void ConvertOperands(Zone* zone);
+ void ConvertUsesToOperand(LOperand* op);
UseInterval* FirstSearchIntervalForPosition(LifetimePosition position) const;
void AdvanceLastProcessedMarker(UseInterval* to_start_of,
LifetimePosition but_not_past) const;
LOperand* current_hint_operand_;
LOperand* spill_operand_;
int spill_start_index_;
+ SpillRange* spill_range_;
friend class LAllocator; // Assigns to kind_.
};
+class SpillRange : public ZoneObject {
+ public:
+ SpillRange(LiveRange* range, int id, Zone* zone);
+
+ bool TryMerge(SpillRange* other, Zone* zone);
+ void SetOperand(LOperand* op);
+ bool IsEmpty() { return live_ranges_.length() == 0; }
+ int id() const { return id_; }
+ UseInterval* interval() { return use_interval_; }
+ RegisterKind Kind() const { return live_ranges_.at(0)->Kind(); }
+ LifetimePosition End() const { return end_position_; }
+ bool IsIntersectingWith(SpillRange* other);
+
+ private:
+ int id_;
+ ZoneList<LiveRange*> live_ranges_;
+ UseInterval* use_interval_;
+ LifetimePosition end_position_;
+
+ // Merge intervals, making sure the use intervals are sorted
+ void MergeDisjointIntervals(UseInterval* other, Zone* zone);
+};
+
+
class LAllocator BASE_EMBEDDED {
public:
LAllocator(int first_virtual_register, HGraph* graph);
void ResolveControlFlow();
void PopulatePointerMaps();
void AllocateRegisters();
+ void ReuseSpillSlots();
bool CanEagerlyResolveControlFlow(HBasicBlock* block) const;
inline bool SafePointsAreInOrder() const;
void ActiveToInactive(LiveRange* range);
void InactiveToHandled(LiveRange* range);
void InactiveToActive(LiveRange* range);
- void FreeSpillSlot(LiveRange* range);
- LOperand* TryReuseSpillSlot(LiveRange* range);
+ SpillRange* AssignSpillRangeToLiveRange(LiveRange* range);
// Helper methods for allocating registers.
bool TryAllocateFreeReg(LiveRange* range);
void AllocateBlockedReg(LiveRange* range);
+ bool TryReuseSpillForPhi(LiveRange* range);
// Live range splitting helpers.
ZoneList<LiveRange*> active_live_ranges_;
ZoneList<LiveRange*> inactive_live_ranges_;
ZoneList<LiveRange*> reusable_slots_;
+ ZoneList<SpillRange*> spill_ranges_;
// Next virtual register number to be assigned to temporaries.
int next_virtual_register_;
projects / platform / upstream / v8.git / commitdiff