Plug new optimizing compiler in compilation pipeline.

Also rename accessors to ART's conventions.

Change-Id: I344807055b98aa4b27215704ec362191464acecc

1 files changed, 65 insertions, 1 deletions

diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index 73323a4..cc36bbe 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -14,10 +14,41 @@
  * limitations under the License.
  */
 
+#include <stdint.h>
+
+#include "builder.h"
+#include "code_generator.h"
 #include "compilers.h"
+#include "driver/compiler_driver.h"
+#include "nodes.h"
+#include "utils/arena_allocator.h"
 
 namespace art {
 
+/**
+ * Used by the code generator, to allocate the code in a vector.
+ */
+class CodeVectorAllocator FINAL : public CodeAllocator {
+ public:
+  CodeVectorAllocator() { }
+
+  virtual uint8_t* Allocate(size_t size) {
+    size_ = size;
+    memory_.reserve(size);
+    return &memory_[0];
+  }
+
+  size_t GetSize() const { return size_; }
+  std::vector<uint8_t>* GetMemory() { return &memory_; }
+
+ private:
+  std::vector<uint8_t> memory_;
+  size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(CodeVectorAllocator);
+};
+
+
 CompiledMethod* OptimizingCompiler::TryCompile(CompilerDriver& driver,
                                                const DexFile::CodeItem* code_item,
                                                uint32_t access_flags,
@@ -26,7 +57,40 @@ CompiledMethod* OptimizingCompiler::TryCompile(CompilerDriver& driver,
                                                uint32_t method_idx,
                                                jobject class_loader,
                                                const DexFile& dex_file) const {
-  return nullptr;
+  ArenaPool pool;
+  ArenaAllocator arena(&pool);
+  HGraphBuilder builder(&arena);
+  HGraph* graph = builder.BuildGraph(*code_item);
+  if (graph == nullptr) {
+    return nullptr;
+  }
+
+  InstructionSet instruction_set = driver.GetInstructionSet();
+  CodeGenerator* codegen = CodeGenerator::Create(&arena, graph, instruction_set);
+  if (codegen == nullptr) {
+    return nullptr;
+  }
+
+  CodeVectorAllocator allocator;
+  codegen->Compile(&allocator);
+
+  std::vector<uint8_t> mapping_table;
+  codegen->BuildMappingTable(&mapping_table);
+  std::vector<uint8_t> vmap_table;
+  codegen->BuildVMapTable(&vmap_table);
+  std::vector<uint8_t> gc_map;
+  codegen->BuildNativeGCMap(&gc_map);
+
+  return new CompiledMethod(driver,
+                            instruction_set,
+                            *allocator.GetMemory(),
+                            codegen->GetFrameSize(),
+                            0, /* GPR spill mask, unused */
+                            0, /* FPR spill mask, unused */
+                            mapping_table,
+                            vmap_table,
+                            gc_map,
+                            nullptr);
 }
 
 }  // namespace art