Skip to content

V
V8
Commit ea16a752 authored by mtrofin's avatar mtrofin Committed by Commit bot
Browse files
Options

[turbofan] removed "auto" from register-allocator-verifier 

BUG=

Review URL: https://codereview.chromium.org/1740543002

Cr-Commit-Position: refs/heads/master@{#34271}
parent b915411c
Hide whitespace changes
Inline Side-by-side
Showing with 51 additions and 42 deletions
src/compiler/register-allocator-verifier.cc
View file @ ea16a752
......@@ -32,9 +32,9 @@ void VerifyAllocatedGaps(const Instruction* instr) {
i <= Instruction::LAST_GAP_POSITION; i++) {
Instruction::GapPosition inner_pos =
static_cast<Instruction::GapPosition>(i);
auto moves = instr->GetParallelMove(inner_pos);
const ParallelMove* moves = instr->GetParallelMove(inner_pos);
if (moves == nullptr) continue;
for (auto move : *moves) {
for (const MoveOperands* move : *moves) {
if (move->IsRedundant()) continue;
CHECK(move->source().IsAllocated() || move->source().IsConstant());
CHECK(move->destination().IsAllocated());
......@@ -81,11 +81,12 @@ RegisterAllocatorVerifier::RegisterAllocatorVerifier(
// TODO(dcarney): model unique constraints.
// Construct OperandConstraints for all InstructionOperands, eliminating
// kSameAsFirst along the way.
for (const auto* instr : sequence->instructions()) {
for (const Instruction* instr : sequence->instructions()) {
// All gaps should be totally unallocated at this point.
VerifyEmptyGaps(instr);
const size_t operand_count = OperandCount(instr);
auto* op_constraints = zone->NewArray<OperandConstraint>(operand_count);
OperandConstraint* op_constraints =
zone->NewArray<OperandConstraint>(operand_count);
size_t count = 0;
for (size_t i = 0; i < instr->InputCount(); ++i, ++count) {
BuildConstraint(instr->InputAt(i), &op_constraints[count]);
......@@ -115,11 +116,12 @@ void RegisterAllocatorVerifier::VerifyAssignment() {
CHECK(sequence()->instructions().size() == constraints()->size());
auto instr_it = sequence()->begin();
for (const auto& instr_constraint : *constraints()) {
const auto* instr = instr_constraint.instruction_;
const Instruction* instr = instr_constraint.instruction_;
// All gaps should be totally allocated at this point.
VerifyAllocatedGaps(instr);
const size_t operand_count = instr_constraint.operand_constaints_size_;
const auto* op_constraints = instr_constraint.operand_constraints_;
const OperandConstraint* op_constraints =
instr_constraint.operand_constraints_;
CHECK_EQ(instr, *instr_it);
CHECK(operand_count == OperandCount(instr));
size_t count = 0;
......@@ -148,14 +150,14 @@ void RegisterAllocatorVerifier::BuildConstraint(const InstructionOperand* op,
} else if (op->IsExplicit()) {
constraint->type_ = kExplicit;
} else if (op->IsImmediate()) {
auto imm = ImmediateOperand::cast(op);
const ImmediateOperand* imm = ImmediateOperand::cast(op);
int value = imm->type() == ImmediateOperand::INLINE ? imm->inline_value()
: imm->indexed_value();
constraint->type_ = kImmediate;
constraint->value_ = value;
} else {
CHECK(op->IsUnallocated());
const auto* unallocated = UnallocatedOperand::cast(op);
const UnallocatedOperand* unallocated = UnallocatedOperand::cast(op);
int vreg = unallocated->virtual_register();
constraint->virtual_register_ = vreg;
if (unallocated->basic_policy() == UnallocatedOperand::FIXED_SLOT) {
......@@ -213,7 +215,7 @@ void RegisterAllocatorVerifier::CheckConstraint(
return;
case kImmediate: {
CHECK(op->IsImmediate());
auto imm = ImmediateOperand::cast(op);
const ImmediateOperand* imm = ImmediateOperand::cast(op);
int value = imm->type() == ImmediateOperand::INLINE
? imm->inline_value()
: imm->indexed_value();
......@@ -324,7 +326,7 @@ class OperandMap : public ZoneObject {
if (this->empty()) return;
auto it = this->begin();
OperandLess less;
for (const auto& o : other) {
for (const std::pair<const InstructionOperand*, MapValue*>& o : other) {
while (less(it->first, o.first)) {
this->erase(it++);
if (it == this->end()) return;
......@@ -346,7 +348,7 @@ class OperandMap : public ZoneObject {
void RunParallelMoves(Zone* zone, const ParallelMove* moves) {
// Compute outgoing mappings.
Map to_insert(zone);
for (auto move : *moves) {
for (const MoveOperands* move : *moves) {
if (move->IsEliminated()) continue;
auto cur = map().find(&move->source());
CHECK(cur != map().end());
......@@ -356,7 +358,7 @@ class OperandMap : public ZoneObject {
CHECK(res.second);
}
// Drop current mappings.
for (auto move : *moves) {
for (const MoveOperands* move : *moves) {
if (move->IsEliminated()) continue;
auto cur = map().find(&move->destination());
if (cur != map().end()) map().erase(cur);
......@@ -368,8 +370,9 @@ class OperandMap : public ZoneObject {
void RunGaps(Zone* zone, const Instruction* instr) {
for (int i = Instruction::FIRST_GAP_POSITION;
i <= Instruction::LAST_GAP_POSITION; i++) {
auto inner_pos = static_cast<Instruction::GapPosition>(i);
auto move = instr->GetParallelMove(inner_pos);
Instruction::GapPosition inner_pos =
static_cast<Instruction::GapPosition>(i);
const ParallelMove* move = instr->GetParallelMove(inner_pos);
if (move == nullptr) continue;
RunParallelMoves(zone, move);
}
......@@ -383,7 +386,7 @@ class OperandMap : public ZoneObject {
void DropRegisters(const RegisterConfiguration* config) {
// TODO(dcarney): sort map by kind and drop range.
for (auto it = map().begin(); it != map().end();) {
auto op = it->first;
const InstructionOperand* op = it->first;
if (op->IsRegister() || op->IsDoubleRegister()) {
map().erase(it++);
} else {
......@@ -394,7 +397,7 @@ class OperandMap : public ZoneObject {
MapValue* Define(Zone* zone, const InstructionOperand* op,
int virtual_register) {
auto value = new (zone) MapValue();
MapValue* value = new (zone) MapValue();
value->define_vreg = virtual_register;
auto res = map().insert(std::make_pair(op, value));
if (!res.second) res.first->second = value;
......@@ -404,7 +407,7 @@ class OperandMap : public ZoneObject {
void Use(const InstructionOperand* op, int use_vreg, bool initial_pass) {
auto it = map().find(op);
CHECK(it != map().end());
auto v = it->second;
MapValue* v = it->second;
if (v->define_vreg != kInvalidVreg) {
CHECK_EQ(v->define_vreg, use_vreg);
}
......@@ -445,7 +448,7 @@ class OperandMap : public ZoneObject {
bool initial_pass) {
auto it = map().find(op);
CHECK(it != map().end());
auto v = it->second;
MapValue* v = it->second;
int use_vreg = phi->virtual_register;
// Phis are not defined.
CHECK_EQ(kInvalidVreg, v->define_vreg);
......@@ -473,7 +476,7 @@ class OperandMap : public ZoneObject {
CHECK(v->define_vreg == phi->first_pred_vreg);
} else if (v->use_vreg != phi->first_pred_vreg) {
// Walk the phi chain, hunting for a matching phi use.
auto p = phi;
const PhiData* p = phi;
for (; p != nullptr; p = p->first_pred_phi) {
if (p->virtual_register == v->use_vreg) break;
}
......@@ -529,12 +532,12 @@ class RegisterAllocatorVerifier::BlockMaps {
BlockIds block_ids((BlockIds::key_compare()),
zone_allocator<size_t>(zone()));
// First ensure that incoming contains only keys in all predecessors.
for (auto block : sequence()->instruction_blocks()) {
for (const InstructionBlock* block : sequence()->instruction_blocks()) {
size_t index = block->rpo_number().ToSize();
block_ids.insert(index);
auto& succ_map = incoming_maps_[index]->map();
OperandMap::Map& succ_map = incoming_maps_[index]->map();
for (size_t i = 0; i < block->PredecessorCount(); ++i) {
auto pred_rpo = block->predecessors()[i];
RpoNumber pred_rpo = block->predecessors()[i];
succ_map.Intersect(outgoing_maps_[pred_rpo.ToSize()]->map());
}
}
......@@ -545,8 +548,9 @@ class RegisterAllocatorVerifier::BlockMaps {
const size_t succ_index = *block_id_it;
block_ids.erase(block_id_it);
// Propagate uses back to their definition blocks using succ_vreg.
auto block = sequence()->instruction_blocks()[succ_index];
auto& succ_map = incoming_maps_[succ_index]->map();
const InstructionBlock* block =
sequence()->instruction_blocks()[succ_index];
OperandMap::Map& succ_map = incoming_maps_[succ_index]->map();
for (size_t i = 0; i < block->PredecessorCount(); ++i) {
for (auto& succ_val : succ_map) {
// An incoming map contains no defines.
......@@ -561,15 +565,15 @@ class RegisterAllocatorVerifier::BlockMaps {
if (succ_vreg == kInvalidVreg) continue;
// May need to transition phi.
if (IsPhi(succ_vreg)) {
auto phi = GetPhi(succ_vreg);
const PhiData* phi = GetPhi(succ_vreg);
if (phi->definition_rpo.ToSize() == succ_index) {
// phi definition block, transition to pred value.
succ_vreg = phi->operands[i];
}
}
// Push succ_vreg up to all predecessors.
auto pred_rpo = block->predecessors()[i];
auto& pred_map = outgoing_maps_[pred_rpo.ToSize()]->map();
RpoNumber pred_rpo = block->predecessors()[i];
OperandMap::Map& pred_map = outgoing_maps_[pred_rpo.ToSize()]->map();
auto& pred_val = *pred_map.find(succ_val.first);
if (pred_val.second->use_vreg != kInvalidVreg) {
CHECK_EQ(succ_vreg, pred_val.second->use_vreg);
......@@ -606,7 +610,7 @@ class RegisterAllocatorVerifier::BlockMaps {
}
}
// Clear uses and back links for second pass.
for (auto operand_map : incoming_maps_) {
for (OperandMap* operand_map : incoming_maps_) {
for (auto& succ_val : operand_map->map()) {
succ_val.second->incoming = nullptr;
succ_val.second->use_vreg = kInvalidVreg;
......@@ -616,18 +620,19 @@ class RegisterAllocatorVerifier::BlockMaps {
private:
OperandMap* InitializeFromFirstPredecessor(size_t block_index) {
auto to_init = outgoing_maps_[block_index];
OperandMap* to_init = outgoing_maps_[block_index];
CHECK(to_init->map().empty());
auto block = sequence()->instruction_blocks()[block_index];
const InstructionBlock* block =
sequence()->instruction_blocks()[block_index];
if (block->predecessors().empty()) return to_init;
size_t predecessor_index = block->predecessors()[0].ToSize();
// Ensure not a backedge.
CHECK(predecessor_index < block->rpo_number().ToSize());
auto incoming = outgoing_maps_[predecessor_index];
OperandMap* incoming = outgoing_maps_[predecessor_index];
// Copy map and replace values.
to_init->map() = incoming->map();
for (auto& it : to_init->map()) {
auto incoming = it.second;
OperandMap::MapValue* incoming = it.second;
it.second = new (zone()) OperandMap::MapValue();
it.second->incoming = incoming;
}
......@@ -653,8 +658,9 @@ class RegisterAllocatorVerifier::BlockMaps {
void InitializePhis() {
const size_t block_count = sequence()->instruction_blocks().size();
for (size_t block_index = 0; block_index < block_count; ++block_index) {
const auto block = sequence()->instruction_blocks()[block_index];
for (auto phi : block->phis()) {
const InstructionBlock* block =
sequence()->instruction_blocks()[block_index];
for (const PhiInstruction* phi : block->phis()) {
int first_pred_vreg = phi->operands()[0];
const PhiData* first_pred_phi = nullptr;
if (IsPhi(first_pred_vreg)) {
......@@ -662,7 +668,7 @@ class RegisterAllocatorVerifier::BlockMaps {
first_pred_vreg = first_pred_phi->first_pred_vreg;
}
CHECK(!IsPhi(first_pred_vreg));
auto phi_data = new (zone()) PhiData(
PhiData* phi_data = new (zone()) PhiData(
block->rpo_number(), phi, first_pred_vreg, first_pred_phi, zone());
auto res =
phi_map_.insert(std::make_pair(phi->virtual_register(), phi_data));
......@@ -700,14 +706,17 @@ void RegisterAllocatorVerifier::VerifyGapMoves(BlockMaps* block_maps,
bool initial_pass) {
const size_t block_count = sequence()->instruction_blocks().size();
for (size_t block_index = 0; block_index < block_count; ++block_index) {
auto current = block_maps->InitializeIncoming(block_index, initial_pass);
const auto block = sequence()->instruction_blocks()[block_index];
OperandMap* current =
block_maps->InitializeIncoming(block_index, initial_pass);
const InstructionBlock* block =
sequence()->instruction_blocks()[block_index];
for (int instr_index = block->code_start(); instr_index < block->code_end();
++instr_index) {
const auto& instr_constraint = constraints_[instr_index];
const auto instr = instr_constraint.instruction_;
const InstructionConstraint& instr_constraint = constraints_[instr_index];
const Instruction* instr = instr_constraint.instruction_;
current->RunGaps(zone(), instr);
const auto op_constraints = instr_constraint.operand_constraints_;
const OperandConstraint* op_constraints =
instr_constraint.operand_constraints_;
size_t count = 0;
for (size_t i = 0; i < instr->InputCount(); ++i, ++count) {
if (op_constraints[count].type_ == kImmediate ||
......@@ -715,11 +724,11 @@ void RegisterAllocatorVerifier::VerifyGapMoves(BlockMaps* block_maps,
continue;
}
int virtual_register = op_constraints[count].virtual_register_;
auto op = instr->InputAt(i);
const InstructionOperand* op = instr->InputAt(i);
if (!block_maps->IsPhi(virtual_register)) {
current->Use(op, virtual_register, initial_pass);
} else {
auto phi = block_maps->GetPhi(virtual_register);
const PhiData* phi = block_maps->GetPhi(virtual_register);
current->UsePhi(op, phi, initial_pass);
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment