Frame* frame() const { return code()->frame(); }
Isolate* isolate() const { return zone()->isolate(); }
Linkage* linkage() const { return code()->linkage(); }
- Schedule* schedule() const { return code()->schedule(); }
private:
MacroAssembler* masm() { return &masm_; }
PrintIntProperty("loop_depth", current->loop_depth());
- if (instructions->code_start(current) >= 0) {
- int first_index = instructions->first_instruction_index(current);
- int last_index = instructions->last_instruction_index(current);
+ const InstructionBlock* instruction_block =
+ instructions->InstructionBlockAt(current->GetRpoNumber());
+ if (instruction_block->code_start() >= 0) {
+ int first_index = instruction_block->first_instruction_index();
+ int last_index = instruction_block->last_instruction_index();
PrintIntProperty("first_lir_id", LifetimePosition::FromInstructionIndex(
first_index).Value());
PrintIntProperty("last_lir_id", LifetimePosition::FromInstructionIndex(
if (instructions != NULL) {
Tag LIR_tag(this, "LIR");
- for (int j = instructions->first_instruction_index(current);
- j <= instructions->last_instruction_index(current); j++) {
+ for (int j = instruction_block->first_instruction_index();
+ j <= instruction_block->last_instruction_index(); j++) {
PrintIndent();
os_ << j << " " << *instructions->InstructionAt(j) << " <|@\n";
}
namespace compiler {
InstructionSelector::InstructionSelector(InstructionSequence* sequence,
+ Schedule* schedule,
SourcePositionTable* source_positions,
Features features)
: zone_(sequence->isolate()),
sequence_(sequence),
source_positions_(source_positions),
features_(features),
+ schedule_(schedule),
current_block_(NULL),
instructions_(zone()),
defined_(sequence->node_count(), false, zone()),
// Schedule the selected instructions.
for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
BasicBlock* block = *i;
- size_t end = sequence()->code_end(block);
- size_t start = sequence()->code_start(block);
+ InstructionBlock* instruction_block =
+ sequence()->InstructionBlockAt(block->GetRpoNumber());
+ size_t end = instruction_block->code_end();
+ size_t start = instruction_block->code_start();
sequence()->StartBlock(block);
while (start-- > end) {
sequence()->AddInstruction(instructions_[start]);
}
// We're done with the block.
- sequence()->set_code_start(block, static_cast<int>(instructions_.size()));
- sequence()->set_code_end(block, current_block_end);
+ InstructionBlock* instruction_block =
+ sequence()->InstructionBlockAt(block->GetRpoNumber());
+ instruction_block->set_code_start(static_cast<int>(instructions_.size()));
+ instruction_block->set_code_end(current_block_end);
current_block_ = NULL;
}
PhiInstruction* phi = new (instruction_zone())
PhiInstruction(instruction_zone(), sequence()->GetVirtualRegister(node));
sequence()->InstructionBlockAt(current_block_->GetRpoNumber())->AddPhi(phi);
- Node::Inputs inputs = node->inputs();
- size_t j = 0;
- for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
- ++iter, ++j) {
- MarkAsUsed(*iter);
- // TODO(mstarzinger): Use a ValueInputIterator instead.
- if (j >= current_block_->PredecessorCount()) continue;
- phi->operands().push_back(sequence()->GetVirtualRegister(*iter));
+ const int input_count = node->op()->InputCount();
+ phi->operands().reserve(static_cast<size_t>(input_count));
+ for (int i = 0; i < input_count; ++i) {
+ Node* const input = node->InputAt(i);
+ MarkAsUsed(input);
+ phi->operands().push_back(sequence()->GetVirtualRegister(input));
}
}
// Forward declarations.
class Features;
- InstructionSelector(InstructionSequence* sequence,
+ InstructionSelector(InstructionSequence* sequence, Schedule* schedule,
SourcePositionTable* source_positions,
Features features = SupportedFeatures());
// ===========================================================================
Linkage* linkage() const { return sequence()->linkage(); }
- Schedule* schedule() const { return sequence()->schedule(); }
+ Schedule* schedule() const { return schedule_; }
InstructionSequence* sequence() const { return sequence_; }
Zone* instruction_zone() const { return sequence()->zone(); }
Zone* zone() { return &zone_; }
InstructionSequence* sequence_;
SourcePositionTable* source_positions_;
Features features_;
+ Schedule* schedule_;
BasicBlock* current_block_;
ZoneDeque<Instruction*> instructions_;
BoolVector defined_;
predecessors_(static_cast<int>(block->PredecessorCount()),
BasicBlock::RpoNumber::Invalid(), zone),
phis_(zone),
+ id_(block->id()),
rpo_number_(block->GetRpoNumber()),
loop_header_(GetRpo(block->loop_header())),
loop_end_(GetLoopEndRpo(block)),
}
-InstructionSequence::InstructionSequence(Linkage* linkage, Graph* graph,
- Schedule* schedule)
- : zone_(schedule->zone()), // TODO(dcarney): new zone.
+InstructionSequence::InstructionSequence(Linkage* linkage, const Graph* graph,
+ const Schedule* schedule)
+ : zone_(graph->zone()->isolate()),
node_count_(graph->NodeCount()),
node_map_(zone()->NewArray<int>(node_count_)),
instruction_blocks_(static_cast<int>(schedule->rpo_order()->size()), NULL,
zone()),
linkage_(linkage),
- schedule_(schedule),
constants_(ConstantMap::key_compare(),
ConstantMap::allocator_type(zone())),
immediates_(zone()),
BlockStartInstruction* InstructionSequence::GetBlockStart(
BasicBlock::RpoNumber rpo) {
+ InstructionBlock* block = InstructionBlockAt(rpo);
BlockStartInstruction* block_start =
- BlockStartInstruction::cast(InstructionAt(code_start(rpo)));
+ BlockStartInstruction::cast(InstructionAt(block->code_start()));
DCHECK_EQ(rpo.ToInt(), block_start->rpo_number().ToInt());
return block_start;
}
-void InstructionSequence::StartBlock(BasicBlock* block) {
- set_code_start(block, static_cast<int>(instructions_.size()));
+void InstructionSequence::StartBlock(BasicBlock* basic_block) {
+ InstructionBlock* block = InstructionBlockAt(basic_block->GetRpoNumber());
+ block->set_code_start(static_cast<int>(instructions_.size()));
BlockStartInstruction* block_start =
- BlockStartInstruction::New(zone(), block);
+ BlockStartInstruction::New(zone(), basic_block);
AddInstruction(block_start);
}
-void InstructionSequence::EndBlock(BasicBlock* block) {
+void InstructionSequence::EndBlock(BasicBlock* basic_block) {
int end = static_cast<int>(instructions_.size());
- DCHECK(code_start(block) >= 0 && code_start(block) < end);
- set_code_end(block, end);
+ InstructionBlock* block = InstructionBlockAt(basic_block->GetRpoNumber());
+ DCHECK(block->code_start() >= 0 && block->code_start() < end);
+ block->set_code_end(end);
}
}
-BasicBlock* InstructionSequence::GetBasicBlock(int instruction_index) {
- // TODO(turbofan): Optimize this.
- for (;;) {
- DCHECK_LE(0, instruction_index);
- Instruction* instruction = InstructionAt(instruction_index--);
- if (instruction->IsBlockStart()) {
- return schedule()->rpo_order()->at(
- BlockStartInstruction::cast(instruction)->rpo_number().ToSize());
- }
- }
-}
-
-
const InstructionBlock* InstructionSequence::GetInstructionBlock(
int instruction_index) const {
// TODO(turbofan): Optimize this.
os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
}
for (int i = 0; i < code.BasicBlockCount(); i++) {
- BasicBlock* block = code.BlockAt(i);
+ BasicBlock::RpoNumber rpo = BasicBlock::RpoNumber::FromInt(i);
+ const InstructionBlock* block = code.InstructionBlockAt(rpo);
+ CHECK(block->rpo_number() == rpo);
os << "RPO#" << block->rpo_number() << ": B" << block->id();
- CHECK(block->rpo_number() == i);
if (block->IsLoopHeader()) {
os << " loop blocks: [" << block->rpo_number() << ", "
<< block->loop_end() << ")";
}
- os << " instructions: [" << code.code_start(block) << ", "
- << code.code_end(block) << ")\n predecessors:";
+ os << " instructions: [" << block->code_start() << ", "
+ << block->code_end() << ")\n predecessors:";
- for (BasicBlock::Predecessors::iterator iter = block->predecessors_begin();
- iter != block->predecessors_end(); ++iter) {
- os << " B" << (*iter)->id();
+ for (auto pred : block->predecessors()) {
+ const InstructionBlock* pred_block = code.InstructionBlockAt(pred);
+ os << " B" << pred_block->id();
}
os << "\n";
- for (BasicBlock::const_iterator j = block->begin(); j != block->end();
- ++j) {
- Node* phi = *j;
- if (phi->opcode() != IrOpcode::kPhi) continue;
- os << " phi: v" << phi->id() << " =";
- Node::Inputs inputs = phi->inputs();
- for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
- ++iter) {
- os << " v" << (*iter)->id();
+ for (auto phi : block->phis()) {
+ os << " phi: v" << phi->virtual_register() << " =";
+ for (auto op_vreg : phi->operands()) {
+ os << " v" << op_vreg;
}
os << "\n";
}
ScopedVector<char> buf(32);
- for (int j = code.first_instruction_index(block);
- j <= code.last_instruction_index(block); j++) {
+ for (int j = block->first_instruction_index();
+ j <= block->last_instruction_index(); j++) {
// TODO(svenpanne) Add some basic formatting to our streams.
SNPrintF(buf, "%5d", j);
os << " " << buf.start() << ": " << *code.InstructionAt(j) << "\n";
}
- os << " " << block->control();
+ // TODO(dcarney): add this back somehow?
+ // os << " " << block->control();
- if (block->control_input() != NULL) {
- os << " v" << block->control_input()->id();
- }
+ // if (block->control_input() != NULL) {
+ // os << " v" << block->control_input()->id();
+ // }
- for (BasicBlock::Successors::iterator iter = block->successors_begin();
- iter != block->successors_end(); ++iter) {
- os << " B" << (*iter)->id();
+ for (auto succ : block->successors()) {
+ const InstructionBlock* succ_block = code.InstructionBlockAt(succ);
+ os << " B" << succ_block->id();
}
os << "\n";
}
// TODO(dcarney): this is a temporary hack. turn into an actual instruction.
-class PhiInstruction : public ZoneObject {
+class PhiInstruction FINAL : public ZoneObject {
public:
PhiInstruction(Zone* zone, int virtual_register)
: virtual_register_(virtual_register), operands_(zone) {}
// Analogue of BasicBlock for Instructions instead of Nodes.
-class InstructionBlock : public ZoneObject {
+class InstructionBlock FINAL : public ZoneObject {
public:
explicit InstructionBlock(Zone* zone, const BasicBlock* block);
int32_t code_end() const { return code_end_; }
void set_code_end(int32_t end) { code_end_ = end; }
+ BasicBlock::Id id() const { return id_; }
BasicBlock::RpoNumber rpo_number() const { return rpo_number_; }
BasicBlock::RpoNumber loop_header() const { return loop_header_; }
BasicBlock::RpoNumber loop_end() const {
Successors successors_;
Predecessors predecessors_;
PhiInstructions phis_;
+ BasicBlock::Id id_;
// TODO(dcarney): probably dont't need this.
BasicBlock::RpoNumber rpo_number_;
BasicBlock::RpoNumber loop_header_;
// TODO(titzer): s/IsDouble/IsFloat64/
class InstructionSequence FINAL {
public:
- InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule);
+ InstructionSequence(Linkage* linkage, const Graph* graph,
+ const Schedule* schedule);
int NextVirtualRegister() { return next_virtual_register_++; }
int VirtualRegisterCount() const { return next_virtual_register_; }
return static_cast<int>(instruction_blocks_.size());
}
- BasicBlock* BlockAt(int rpo_number) const {
- return (*schedule_->rpo_order())[rpo_number];
- }
-
InstructionBlock* InstructionBlockAt(BasicBlock::RpoNumber rpo_number) {
- return GetBlock(rpo_number);
+ return instruction_blocks_[rpo_number.ToSize()];
}
const InstructionBlock* InstructionBlockAt(
BasicBlock::RpoNumber rpo_number) const {
- return GetBlock(rpo_number);
+ return instruction_blocks_[rpo_number.ToSize()];
}
// TODO(dcarney): move to register allocator.
return instruction_blocks_[index.ToInt()];
}
- BasicBlock* GetBasicBlock(int instruction_index);
const InstructionBlock* GetInstructionBlock(int instruction_index) const;
int GetVirtualRegister(const Node* node);
}
Frame* frame() { return &frame_; }
- Isolate* isolate() const { return zone()->isolate(); }
+ Isolate* isolate() { return zone()->isolate(); }
Linkage* linkage() const { return linkage_; }
- Schedule* schedule() const { return schedule_; }
const PointerMapDeque* pointer_maps() const { return &pointer_maps_; }
- Zone* zone() const { return zone_; }
+ Zone* zone() { return &zone_; }
// Used by the instruction selector while adding instructions.
int AddInstruction(Instruction* instr);
void StartBlock(BasicBlock* block);
void EndBlock(BasicBlock* block);
- void set_code_start(BasicBlock* block, int start) {
- return GetBlock(block->GetRpoNumber())->set_code_start(start);
- }
- void set_code_end(BasicBlock* block, int end) {
- return GetBlock(block->GetRpoNumber())->set_code_end(end);
- }
- // TODO(dcarney): use RpoNumber for all of the below.
- int code_start(BasicBlock::RpoNumber rpo_number) const {
- return GetBlock(rpo_number)->code_start();
- }
- int code_start(BasicBlock* block) const {
- return GetBlock(block->GetRpoNumber())->code_start();
- }
- int code_end(BasicBlock* block) const {
- return GetBlock(block->GetRpoNumber())->code_end();
- }
- int first_instruction_index(BasicBlock* block) const {
- return GetBlock(block->GetRpoNumber())->first_instruction_index();
- }
- int last_instruction_index(BasicBlock* block) const {
- return GetBlock(block->GetRpoNumber())->last_instruction_index();
- }
- int first_instruction_index(InstructionBlock* block) const {
- return GetBlock(block->rpo_number())->first_instruction_index();
- }
- int last_instruction_index(InstructionBlock* block) const {
- return GetBlock(block->rpo_number())->last_instruction_index();
- }
int AddConstant(Node* node, Constant constant) {
int virtual_register = GetVirtualRegister(node);
int GetFrameStateDescriptorCount();
private:
- InstructionBlock* GetBlock(BasicBlock::RpoNumber rpo_number) const {
- return instruction_blocks_[rpo_number.ToSize()];
- }
-
friend std::ostream& operator<<(std::ostream& os,
const InstructionSequence& code);
typedef std::set<int, std::less<int>, ZoneIntAllocator> VirtualRegisterSet;
- Zone* zone_;
+ Zone zone_;
int node_count_;
int* node_map_;
InstructionBlocks instruction_blocks_;
Linkage* linkage_;
- Schedule* schedule_;
ConstantMap constants_;
ConstantDeque immediates_;
InstructionDeque instructions_;
// Select and schedule instructions covering the scheduled graph.
{
- InstructionSelector selector(&sequence, source_positions);
+ InstructionSelector selector(&sequence, schedule, source_positions);
selector.SelectInstructions();
}
}
+std::ostream& operator<<(std::ostream& os, const BasicBlock::RpoNumber& rpo) {
+ return os << rpo.ToSize();
+}
+
+
Schedule::Schedule(Zone* zone, size_t node_count_hint)
: zone_(zone),
all_blocks_(zone),
std::ostream& operator<<(std::ostream& os, const BasicBlock::Control& c);
std::ostream& operator<<(std::ostream& os, const BasicBlock::Id& id);
+std::ostream& operator<<(std::ostream& os, const BasicBlock::RpoNumber& rpo);
typedef ZoneVector<BasicBlock*> BasicBlockVector;
typedef BasicBlockVector::iterator BasicBlockVectorIter;
code = new v8::internal::compiler::InstructionSequence(linkage, graph,
schedule);
SourcePositionTable source_positions(graph);
- InstructionSelector selector(code, &source_positions);
+ InstructionSelector selector(code, schedule, &source_positions);
selector.SelectInstructions();
if (FLAG_trace_turbo) {
unallocated->set_virtual_register(vreg);
return unallocated;
}
+
+ InstructionBlock* BlockAt(BasicBlock* block) {
+ return code->InstructionBlockAt(block->GetRpoNumber());
+ }
+ BasicBlock* GetBasicBlock(int instruction_index) {
+ const InstructionBlock* block =
+ code->GetInstructionBlock(instruction_index);
+ return schedule.rpo_order()->at(block->rpo_number().ToSize());
+ }
+ int first_instruction_index(BasicBlock* block) {
+ return BlockAt(block)->first_instruction_index();
+ }
+ int last_instruction_index(BasicBlock* block) {
+ return BlockAt(block)->last_instruction_index();
+ }
};
for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end();
i++, index++) {
BasicBlock* block = *i;
- CHECK_EQ(block, R.code->BlockAt(index));
+ CHECK_EQ(block->rpo_number(), R.BlockAt(block)->rpo_number().ToInt());
+ CHECK_EQ(block->id().ToInt(), R.BlockAt(block)->id().ToInt());
CHECK_EQ(-1, block->loop_end());
}
}
R.code->StartBlock(b3);
R.code->EndBlock(b3);
- CHECK_EQ(b0, R.code->GetBasicBlock(i0));
- CHECK_EQ(b0, R.code->GetBasicBlock(i1));
+ CHECK_EQ(b0, R.GetBasicBlock(i0));
+ CHECK_EQ(b0, R.GetBasicBlock(i1));
- CHECK_EQ(b1, R.code->GetBasicBlock(i2));
- CHECK_EQ(b1, R.code->GetBasicBlock(i3));
- CHECK_EQ(b1, R.code->GetBasicBlock(i4));
- CHECK_EQ(b1, R.code->GetBasicBlock(i5));
+ CHECK_EQ(b1, R.GetBasicBlock(i2));
+ CHECK_EQ(b1, R.GetBasicBlock(i3));
+ CHECK_EQ(b1, R.GetBasicBlock(i4));
+ CHECK_EQ(b1, R.GetBasicBlock(i5));
- CHECK_EQ(b2, R.code->GetBasicBlock(i6));
- CHECK_EQ(b2, R.code->GetBasicBlock(i7));
- CHECK_EQ(b2, R.code->GetBasicBlock(i8));
+ CHECK_EQ(b2, R.GetBasicBlock(i6));
+ CHECK_EQ(b2, R.GetBasicBlock(i7));
+ CHECK_EQ(b2, R.GetBasicBlock(i8));
- CHECK_EQ(b0, R.code->GetBasicBlock(R.code->first_instruction_index(b0)));
- CHECK_EQ(b0, R.code->GetBasicBlock(R.code->last_instruction_index(b0)));
+ CHECK_EQ(b0, R.GetBasicBlock(R.first_instruction_index(b0)));
+ CHECK_EQ(b0, R.GetBasicBlock(R.last_instruction_index(b0)));
- CHECK_EQ(b1, R.code->GetBasicBlock(R.code->first_instruction_index(b1)));
- CHECK_EQ(b1, R.code->GetBasicBlock(R.code->last_instruction_index(b1)));
+ CHECK_EQ(b1, R.GetBasicBlock(R.first_instruction_index(b1)));
+ CHECK_EQ(b1, R.GetBasicBlock(R.last_instruction_index(b1)));
- CHECK_EQ(b2, R.code->GetBasicBlock(R.code->first_instruction_index(b2)));
- CHECK_EQ(b2, R.code->GetBasicBlock(R.code->last_instruction_index(b2)));
+ CHECK_EQ(b2, R.GetBasicBlock(R.first_instruction_index(b2)));
+ CHECK_EQ(b2, R.GetBasicBlock(R.last_instruction_index(b2)));
- CHECK_EQ(b3, R.code->GetBasicBlock(R.code->first_instruction_index(b3)));
- CHECK_EQ(b3, R.code->GetBasicBlock(R.code->last_instruction_index(b3)));
+ CHECK_EQ(b3, R.GetBasicBlock(R.first_instruction_index(b3)));
+ CHECK_EQ(b3, R.GetBasicBlock(R.last_instruction_index(b3)));
}
Linkage linkage(&info, call_descriptor());
InstructionSequence sequence(&linkage, graph(), schedule);
SourcePositionTable source_position_table(graph());
- InstructionSelector selector(&sequence, &source_position_table, features);
+ InstructionSelector selector(&sequence, schedule, &source_position_table,
+ features);
selector.SelectInstructions();
if (FLAG_trace_turbo) {
OFStream out(stdout);
projects / platform / upstream / v8.git / commitdiff