Don't fall back to Quick in optimizing.
The compiler can now have a life of its own.
Change-Id: I804638c574d1a37299fa8427a3fd10d627d2844e
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index ee92e89..0de0907 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 @@
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 @@
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 @@
std::unique_ptr<std::ostream> 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<Compiler> delegate_;
-
DISALLOW_COPY_AND_ASSIGN(OptimizingCompiler);
};
@@ -143,21 +136,12 @@
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 @@
}
}
-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<uintptr_t>(method->GetEntryPointFromQuickCompiledCode());
}
bool OptimizingCompiler::WriteElf(art::File* file, OatWriter* oat_writer,
const std::vector<const art::DexFile*>& 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 @@
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::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);
}
