Plug new optimizing compiler in compilation pipeline.
Also rename accessors to ART's conventions.
Change-Id: I344807055b98aa4b27215704ec362191464acecc
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index 56342aa..b2a69d8 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -19,38 +19,36 @@
#include "code_generator_arm.h"
#include "code_generator_x86.h"
#include "utils/assembler.h"
-#include "utils/arm/assembler_arm.h"
-#include "utils/mips/assembler_mips.h"
-#include "utils/x86/assembler_x86.h"
namespace art {
void CodeGenerator::Compile(CodeAllocator* allocator) {
- const GrowableArray<HBasicBlock*>* blocks = graph()->blocks();
- DCHECK(blocks->Get(0) == graph()->entry_block());
- DCHECK(GoesToNextBlock(graph()->entry_block(), blocks->Get(1)));
+ const GrowableArray<HBasicBlock*>* blocks = GetGraph()->GetBlocks();
+ DCHECK(blocks->Get(0) == GetGraph()->GetEntryBlock());
+ DCHECK(GoesToNextBlock(GetGraph()->GetEntryBlock(), blocks->Get(1)));
CompileEntryBlock();
for (size_t i = 1; i < blocks->Size(); i++) {
CompileBlock(blocks->Get(i));
}
- size_t code_size = assembler_->CodeSize();
+ size_t code_size = GetAssembler()->CodeSize();
uint8_t* buffer = allocator->Allocate(code_size);
MemoryRegion code(buffer, code_size);
- assembler_->FinalizeInstructions(code);
+ GetAssembler()->FinalizeInstructions(code);
}
void CodeGenerator::CompileEntryBlock() {
HGraphVisitor* location_builder = GetLocationBuilder();
+ HGraphVisitor* instruction_visitor = GetInstructionVisitor();
// The entry block contains all locals for this method. By visiting the entry block,
// we're computing the required frame size.
- for (HInstructionIterator it(graph()->entry_block()); !it.Done(); it.Advance()) {
+ for (HInstructionIterator it(GetGraph()->GetEntryBlock()); !it.Done(); it.Advance()) {
HInstruction* current = it.Current();
// Instructions in the entry block should not generate code.
if (kIsDebugBuild) {
current->Accept(location_builder);
- DCHECK(current->locations() == nullptr);
+ DCHECK(current->GetLocations() == nullptr);
}
- current->Accept(this);
+ current->Accept(instruction_visitor);
}
GenerateFrameEntry();
}
@@ -58,6 +56,7 @@
void CodeGenerator::CompileBlock(HBasicBlock* block) {
Bind(GetLabelOf(block));
HGraphVisitor* location_builder = GetLocationBuilder();
+ HGraphVisitor* instruction_visitor = GetInstructionVisitor();
for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
// For each instruction, we emulate a stack-based machine, where the inputs are popped from
// the runtime stack, and the result is pushed on the stack. We currently can do this because
@@ -66,17 +65,17 @@
HInstruction* current = it.Current();
current->Accept(location_builder);
InitLocations(current);
- current->Accept(this);
- if (current->locations() != nullptr && current->locations()->Out().IsValid()) {
- Push(current, current->locations()->Out());
+ current->Accept(instruction_visitor);
+ if (current->GetLocations() != nullptr && current->GetLocations()->Out().IsValid()) {
+ Push(current, current->GetLocations()->Out());
}
}
}
void CodeGenerator::InitLocations(HInstruction* instruction) {
- if (instruction->locations() == nullptr) return;
+ if (instruction->GetLocations() == nullptr) return;
for (int i = 0; i < instruction->InputCount(); i++) {
- Location location = instruction->locations()->InAt(i);
+ Location location = instruction->GetLocations()->InAt(i);
if (location.IsValid()) {
// Move the input to the desired location.
Move(instruction->InputAt(i), location);
@@ -86,32 +85,28 @@
bool CodeGenerator::GoesToNextBlock(HBasicBlock* current, HBasicBlock* next) const {
// We currently iterate over the block in insertion order.
- return current->block_id() + 1 == next->block_id();
+ return current->GetBlockId() + 1 == next->GetBlockId();
}
Label* CodeGenerator::GetLabelOf(HBasicBlock* block) const {
- return block_labels_.GetRawStorage() + block->block_id();
+ return block_labels_.GetRawStorage() + block->GetBlockId();
}
-bool CodeGenerator::CompileGraph(HGraph* graph,
- InstructionSet instruction_set,
- CodeAllocator* allocator) {
+CodeGenerator* CodeGenerator::Create(ArenaAllocator* allocator,
+ HGraph* graph,
+ InstructionSet instruction_set) {
switch (instruction_set) {
case kArm:
case kThumb2: {
- arm::ArmAssembler assembler;
- arm::CodeGeneratorARM(&assembler, graph).Compile(allocator);
- return true;
+ return new (allocator) arm::CodeGeneratorARM(graph);
}
case kMips:
- return false;
+ return nullptr;
case kX86: {
- x86::X86Assembler assembler;
- x86::CodeGeneratorX86(&assembler, graph).Compile(allocator);
- return true;
+ return new (allocator) x86::CodeGeneratorX86(graph);
}
default:
- return false;
+ return nullptr;
}
}