From e2dc6fa7aa319ee892d6ed407c986c5a3ec3dcd7 Mon Sep 17 00:00:00 2001 From: Nicolas Geoffray Date: Mon, 17 Nov 2014 12:55:12 +0000 Subject: [PATCH] Don't fall back to Quick in optimizing. The compiler can now have a life of its own. Change-Id: I804638c574d1a37299fa8427a3fd10d627d2844e --- compiler/optimizing/optimizing_compiler.cc | 91 +++++++++--------------------- 1 file changed, 26 insertions(+), 65 deletions(-) diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc index ee92e89ff..0de090752 100644 --- a/compiler/optimizing/optimizing_compiler.cc +++ b/compiler/optimizing/optimizing_compiler.cc @@ -26,9 +26,12 @@ #include "dead_code_elimination.h" #include "driver/compiler_driver.h" #include "driver/dex_compilation_unit.h" +#include "elf_writer_quick.h" #include "graph_visualizer.h" #include "gvn.h" #include "instruction_simplifier.h" +#include "jni/quick/jni_compiler.h" +#include "mirror/art_method-inl.h" #include "nodes.h" #include "prepare_for_register_allocation.h" #include "register_allocator.h" @@ -88,15 +91,6 @@ class OptimizingCompiler FINAL : public Compiler { jobject class_loader, const DexFile& dex_file) const OVERRIDE; - CompiledMethod* TryCompile(const DexFile::CodeItem* code_item, - uint32_t access_flags, - InvokeType invoke_type, - uint16_t class_def_idx, - uint32_t method_idx, - jobject class_loader, - const DexFile& dex_file) const; - - // For the following methods we will use the fallback. This is a delegation pattern. CompiledMethod* JniCompile(uint32_t access_flags, uint32_t method_idx, const DexFile& dex_file) const OVERRIDE; @@ -110,13 +104,16 @@ class OptimizingCompiler FINAL : public Compiler { const std::string& android_root, bool is_host) const OVERRIDE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - Backend* GetCodeGenerator(CompilationUnit* cu, void* compilation_unit) const OVERRIDE; + Backend* GetCodeGenerator(CompilationUnit* cu ATTRIBUTE_UNUSED, + void* compilation_unit ATTRIBUTE_UNUSED) const OVERRIDE { + return nullptr; + } - void InitCompilationUnit(CompilationUnit& cu) const OVERRIDE; + void InitCompilationUnit(CompilationUnit& cu ATTRIBUTE_UNUSED) const OVERRIDE {} - void Init() const OVERRIDE; + void Init() const OVERRIDE {} - void UnInit() const OVERRIDE; + void UnInit() const OVERRIDE {} private: // Whether we should run any optimization or register allocation. If false, will @@ -128,10 +125,6 @@ class OptimizingCompiler FINAL : public Compiler { std::unique_ptr visualizer_output_; - // Delegate to another compiler in case the optimizing compiler cannot compile a method. - // Currently the fallback is the quick compiler. - std::unique_ptr delegate_; - DISALLOW_COPY_AND_ASSIGN(OptimizingCompiler); }; @@ -143,21 +136,12 @@ OptimizingCompiler::OptimizingCompiler(CompilerDriver* driver) driver->GetCompilerOptions().GetCompilerFilter() != CompilerOptions::kTime), total_compiled_methods_(0), unoptimized_compiled_methods_(0), - optimized_compiled_methods_(0), - delegate_(Create(driver, Compiler::Kind::kQuick)) { + optimized_compiled_methods_(0) { if (kIsVisualizerEnabled) { visualizer_output_.reset(new std::ofstream("art.cfg")); } } -void OptimizingCompiler::Init() const { - delegate_->Init(); -} - -void OptimizingCompiler::UnInit() const { - delegate_->UnInit(); -} - OptimizingCompiler::~OptimizingCompiler() { if (total_compiled_methods_ == 0) { LOG(INFO) << "Did not compile any method."; @@ -170,33 +154,27 @@ OptimizingCompiler::~OptimizingCompiler() { } } -bool OptimizingCompiler::CanCompileMethod(uint32_t method_idx, const DexFile& dex_file, - CompilationUnit* cu) const { - return delegate_->CanCompileMethod(method_idx, dex_file, cu); +bool OptimizingCompiler::CanCompileMethod(uint32_t method_idx ATTRIBUTE_UNUSED, + const DexFile& dex_file ATTRIBUTE_UNUSED, + CompilationUnit* cu ATTRIBUTE_UNUSED) const { + return true; } CompiledMethod* OptimizingCompiler::JniCompile(uint32_t access_flags, uint32_t method_idx, const DexFile& dex_file) const { - return delegate_->JniCompile(access_flags, method_idx, dex_file); + return ArtQuickJniCompileMethod(GetCompilerDriver(), access_flags, method_idx, dex_file); } uintptr_t OptimizingCompiler::GetEntryPointOf(mirror::ArtMethod* method) const { - return delegate_->GetEntryPointOf(method); + return reinterpret_cast(method->GetEntryPointFromQuickCompiledCode()); } bool OptimizingCompiler::WriteElf(art::File* file, OatWriter* oat_writer, const std::vector& dex_files, const std::string& android_root, bool is_host) const { - return delegate_->WriteElf(file, oat_writer, dex_files, android_root, is_host); -} - -Backend* OptimizingCompiler::GetCodeGenerator(CompilationUnit* cu, void* compilation_unit) const { - return delegate_->GetCodeGenerator(cu, compilation_unit); -} - -void OptimizingCompiler::InitCompilationUnit(CompilationUnit& cu) const { - delegate_->InitCompilationUnit(cu); + return art::ElfWriterQuick32::Create(file, oat_writer, dex_files, android_root, is_host, + *GetCompilerDriver()); } static bool IsInstructionSetSupported(InstructionSet instruction_set) { @@ -211,13 +189,13 @@ static bool CanOptimize(const DexFile::CodeItem& code_item) { return code_item.tries_size_ == 0; } -CompiledMethod* OptimizingCompiler::TryCompile(const DexFile::CodeItem* code_item, - uint32_t access_flags, - InvokeType invoke_type, - uint16_t class_def_idx, - uint32_t method_idx, - jobject class_loader, - const DexFile& dex_file) const { +CompiledMethod* OptimizingCompiler::Compile(const DexFile::CodeItem* code_item, + uint32_t access_flags, + InvokeType invoke_type, + uint16_t class_def_idx, + uint32_t method_idx, + jobject class_loader, + const DexFile& dex_file) const { UNUSED(invoke_type); total_compiled_methods_++; InstructionSet instruction_set = GetCompilerDriver()->GetInstructionSet(); @@ -361,23 +339,6 @@ CompiledMethod* OptimizingCompiler::TryCompile(const DexFile::CodeItem* code_ite } } -CompiledMethod* OptimizingCompiler::Compile(const DexFile::CodeItem* code_item, - uint32_t access_flags, - InvokeType invoke_type, - uint16_t class_def_idx, - uint32_t method_idx, - jobject class_loader, - const DexFile& dex_file) const { - CompiledMethod* method = TryCompile(code_item, access_flags, invoke_type, class_def_idx, - method_idx, class_loader, dex_file); - if (method != nullptr) { - return method; - } - - return delegate_->Compile(code_item, access_flags, invoke_type, class_def_idx, method_idx, - class_loader, dex_file); -} - Compiler* CreateOptimizingCompiler(CompilerDriver* driver) { return new OptimizingCompiler(driver); } -- 2.11.0