Merge "Refactored optimization passes setup."
diff --git a/compiler/optimizing/bounds_check_elimination.h b/compiler/optimizing/bounds_check_elimination.h
index 6dc5320..79c67a8 100644
--- a/compiler/optimizing/bounds_check_elimination.h
+++ b/compiler/optimizing/bounds_check_elimination.h
@@ -28,8 +28,9 @@
public:
BoundsCheckElimination(HGraph* graph,
const SideEffectsAnalysis& side_effects,
- HInductionVarAnalysis* induction_analysis)
- : HOptimization(graph, kBoundsCheckEliminationPassName),
+ HInductionVarAnalysis* induction_analysis,
+ const char* name = kBoundsCheckEliminationPassName)
+ : HOptimization(graph, name),
side_effects_(side_effects),
induction_analysis_(induction_analysis) {}
diff --git a/compiler/optimizing/cha_guard_optimization.h b/compiler/optimizing/cha_guard_optimization.h
index ba0cdb8..f14e07b 100644
--- a/compiler/optimizing/cha_guard_optimization.h
+++ b/compiler/optimizing/cha_guard_optimization.h
@@ -26,8 +26,9 @@
*/
class CHAGuardOptimization : public HOptimization {
public:
- explicit CHAGuardOptimization(HGraph* graph)
- : HOptimization(graph, kCHAGuardOptimizationPassName) {}
+ explicit CHAGuardOptimization(HGraph* graph,
+ const char* name = kCHAGuardOptimizationPassName)
+ : HOptimization(graph, name) {}
void Run() OVERRIDE;
diff --git a/compiler/optimizing/code_sinking.h b/compiler/optimizing/code_sinking.h
index 59cda52..836d9d4 100644
--- a/compiler/optimizing/code_sinking.h
+++ b/compiler/optimizing/code_sinking.h
@@ -28,8 +28,10 @@
*/
class CodeSinking : public HOptimization {
public:
- CodeSinking(HGraph* graph, OptimizingCompilerStats* stats)
- : HOptimization(graph, kCodeSinkingPassName, stats) {}
+ CodeSinking(HGraph* graph,
+ OptimizingCompilerStats* stats,
+ const char* name = kCodeSinkingPassName)
+ : HOptimization(graph, name, stats) {}
void Run() OVERRIDE;
diff --git a/compiler/optimizing/constructor_fence_redundancy_elimination.h b/compiler/optimizing/constructor_fence_redundancy_elimination.h
index d89210c..f4b06d5 100644
--- a/compiler/optimizing/constructor_fence_redundancy_elimination.h
+++ b/compiler/optimizing/constructor_fence_redundancy_elimination.h
@@ -48,12 +48,13 @@
class ConstructorFenceRedundancyElimination : public HOptimization {
public:
ConstructorFenceRedundancyElimination(HGraph* graph,
- OptimizingCompilerStats* stats)
- : HOptimization(graph, kPassName, stats) {}
+ OptimizingCompilerStats* stats,
+ const char* name = kCFREPassName)
+ : HOptimization(graph, name, stats) {}
void Run() OVERRIDE;
- static constexpr const char* kPassName = "constructor_fence_redundancy_elimination";
+ static constexpr const char* kCFREPassName = "constructor_fence_redundancy_elimination";
private:
DISALLOW_COPY_AND_ASSIGN(ConstructorFenceRedundancyElimination);
diff --git a/compiler/optimizing/induction_var_analysis.cc b/compiler/optimizing/induction_var_analysis.cc
index e2747af..ad29ba5 100644
--- a/compiler/optimizing/induction_var_analysis.cc
+++ b/compiler/optimizing/induction_var_analysis.cc
@@ -97,8 +97,8 @@
// Class methods.
//
-HInductionVarAnalysis::HInductionVarAnalysis(HGraph* graph)
- : HOptimization(graph, kInductionPassName),
+HInductionVarAnalysis::HInductionVarAnalysis(HGraph* graph, const char* name)
+ : HOptimization(graph, name),
global_depth_(0),
stack_(graph->GetAllocator()->Adapter(kArenaAllocInductionVarAnalysis)),
map_(std::less<HInstruction*>(),
diff --git a/compiler/optimizing/induction_var_analysis.h b/compiler/optimizing/induction_var_analysis.h
index a2d302a..8737b89 100644
--- a/compiler/optimizing/induction_var_analysis.h
+++ b/compiler/optimizing/induction_var_analysis.h
@@ -35,7 +35,7 @@
*/
class HInductionVarAnalysis : public HOptimization {
public:
- explicit HInductionVarAnalysis(HGraph* graph);
+ explicit HInductionVarAnalysis(HGraph* graph, const char* name = kInductionPassName);
void Run() OVERRIDE;
diff --git a/compiler/optimizing/inliner.h b/compiler/optimizing/inliner.h
index c4b3a32..042eee3 100644
--- a/compiler/optimizing/inliner.h
+++ b/compiler/optimizing/inliner.h
@@ -44,8 +44,9 @@
size_t total_number_of_dex_registers,
size_t total_number_of_instructions,
HInliner* parent,
- size_t depth = 0)
- : HOptimization(outer_graph, kInlinerPassName, stats),
+ size_t depth = 0,
+ const char* name = kInlinerPassName)
+ : HOptimization(outer_graph, name, stats),
outermost_graph_(outermost_graph),
outer_compilation_unit_(outer_compilation_unit),
caller_compilation_unit_(caller_compilation_unit),
diff --git a/compiler/optimizing/intrinsics.h b/compiler/optimizing/intrinsics.h
index 707ff34..818d7f6 100644
--- a/compiler/optimizing/intrinsics.h
+++ b/compiler/optimizing/intrinsics.h
@@ -37,8 +37,10 @@
// Recognize intrinsics from HInvoke nodes.
class IntrinsicsRecognizer : public HOptimization {
public:
- IntrinsicsRecognizer(HGraph* graph, OptimizingCompilerStats* stats)
- : HOptimization(graph, kIntrinsicsRecognizerPassName, stats) {}
+ IntrinsicsRecognizer(HGraph* graph,
+ OptimizingCompilerStats* stats,
+ const char* name = kIntrinsicsRecognizerPassName)
+ : HOptimization(graph, name, stats) {}
void Run() OVERRIDE;
diff --git a/compiler/optimizing/licm.h b/compiler/optimizing/licm.h
index bf56f53..ee567ae 100644
--- a/compiler/optimizing/licm.h
+++ b/compiler/optimizing/licm.h
@@ -26,8 +26,11 @@
class LICM : public HOptimization {
public:
- LICM(HGraph* graph, const SideEffectsAnalysis& side_effects, OptimizingCompilerStats* stats)
- : HOptimization(graph, kLoopInvariantCodeMotionPassName, stats),
+ LICM(HGraph* graph,
+ const SideEffectsAnalysis& side_effects,
+ OptimizingCompilerStats* stats,
+ const char* name = kLoopInvariantCodeMotionPassName)
+ : HOptimization(graph, name, stats),
side_effects_(side_effects) {}
void Run() OVERRIDE;
diff --git a/compiler/optimizing/load_store_analysis.h b/compiler/optimizing/load_store_analysis.h
index aa8b5bb..437e6be 100644
--- a/compiler/optimizing/load_store_analysis.h
+++ b/compiler/optimizing/load_store_analysis.h
@@ -564,8 +564,8 @@
class LoadStoreAnalysis : public HOptimization {
public:
- explicit LoadStoreAnalysis(HGraph* graph)
- : HOptimization(graph, kLoadStoreAnalysisPassName),
+ explicit LoadStoreAnalysis(HGraph* graph, const char* name = kLoadStoreAnalysisPassName)
+ : HOptimization(graph, name),
heap_location_collector_(graph) {}
const HeapLocationCollector& GetHeapLocationCollector() const {
diff --git a/compiler/optimizing/load_store_elimination.h b/compiler/optimizing/load_store_elimination.h
index 20a8a76..7153541 100644
--- a/compiler/optimizing/load_store_elimination.h
+++ b/compiler/optimizing/load_store_elimination.h
@@ -29,8 +29,9 @@
LoadStoreElimination(HGraph* graph,
const SideEffectsAnalysis& side_effects,
const LoadStoreAnalysis& lsa,
- OptimizingCompilerStats* stats)
- : HOptimization(graph, kLoadStoreEliminationPassName, stats),
+ OptimizingCompilerStats* stats,
+ const char* name = kLoadStoreEliminationPassName)
+ : HOptimization(graph, name, stats),
side_effects_(side_effects),
lsa_(lsa) {}
diff --git a/compiler/optimizing/loop_optimization.cc b/compiler/optimizing/loop_optimization.cc
index fcc59ea..1ca0960 100644
--- a/compiler/optimizing/loop_optimization.cc
+++ b/compiler/optimizing/loop_optimization.cc
@@ -448,8 +448,9 @@
HLoopOptimization::HLoopOptimization(HGraph* graph,
CompilerDriver* compiler_driver,
HInductionVarAnalysis* induction_analysis,
- OptimizingCompilerStats* stats)
- : HOptimization(graph, kLoopOptimizationPassName, stats),
+ OptimizingCompilerStats* stats,
+ const char* name)
+ : HOptimization(graph, name, stats),
compiler_driver_(compiler_driver),
induction_range_(induction_analysis),
loop_allocator_(nullptr),
diff --git a/compiler/optimizing/loop_optimization.h b/compiler/optimizing/loop_optimization.h
index 51e0a98..a707ad1 100644
--- a/compiler/optimizing/loop_optimization.h
+++ b/compiler/optimizing/loop_optimization.h
@@ -37,7 +37,8 @@
HLoopOptimization(HGraph* graph,
CompilerDriver* compiler_driver,
HInductionVarAnalysis* induction_analysis,
- OptimizingCompilerStats* stats);
+ OptimizingCompilerStats* stats,
+ const char* name = kLoopOptimizationPassName);
void Run() OVERRIDE;
diff --git a/compiler/optimizing/optimization.cc b/compiler/optimizing/optimization.cc
index 1e68ca2..7edb642 100644
--- a/compiler/optimizing/optimization.cc
+++ b/compiler/optimizing/optimization.cc
@@ -16,5 +16,317 @@
#include "optimization.h"
+#ifdef ART_ENABLE_CODEGEN_arm
+#include "instruction_simplifier_arm.h"
+#endif
+#ifdef ART_ENABLE_CODEGEN_arm64
+#include "instruction_simplifier_arm64.h"
+#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+#include "instruction_simplifier_mips.h"
+#include "pc_relative_fixups_mips.h"
+#endif
+#ifdef ART_ENABLE_CODEGEN_x86
+#include "pc_relative_fixups_x86.h"
+#endif
+#if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
+#include "x86_memory_gen.h"
+#endif
+
+#include "bounds_check_elimination.h"
+#include "cha_guard_optimization.h"
+#include "code_sinking.h"
+#include "constant_folding.h"
+#include "constructor_fence_redundancy_elimination.h"
+#include "dead_code_elimination.h"
+#include "driver/dex_compilation_unit.h"
+#include "gvn.h"
+#include "induction_var_analysis.h"
+#include "inliner.h"
+#include "instruction_simplifier.h"
+#include "intrinsics.h"
+#include "licm.h"
+#include "load_store_analysis.h"
+#include "load_store_elimination.h"
+#include "loop_optimization.h"
+#include "scheduler.h"
+#include "select_generator.h"
+#include "sharpening.h"
+#include "side_effects_analysis.h"
+
+// Decide between default or alternative pass name.
+
namespace art {
+
+const char* OptimizationPassName(OptimizationPass pass) {
+ switch (pass) {
+ case OptimizationPass::kSideEffectsAnalysis:
+ return SideEffectsAnalysis::kSideEffectsAnalysisPassName;
+ case OptimizationPass::kInductionVarAnalysis:
+ return HInductionVarAnalysis::kInductionPassName;
+ case OptimizationPass::kLoadStoreAnalysis:
+ return LoadStoreAnalysis::kLoadStoreAnalysisPassName;
+ case OptimizationPass::kGlobalValueNumbering:
+ return GVNOptimization::kGlobalValueNumberingPassName;
+ case OptimizationPass::kInvariantCodeMotion:
+ return LICM::kLoopInvariantCodeMotionPassName;
+ case OptimizationPass::kLoopOptimization:
+ return HLoopOptimization::kLoopOptimizationPassName;
+ case OptimizationPass::kBoundsCheckElimination:
+ return BoundsCheckElimination::kBoundsCheckEliminationPassName;
+ case OptimizationPass::kLoadStoreElimination:
+ return LoadStoreElimination::kLoadStoreEliminationPassName;
+ case OptimizationPass::kConstantFolding:
+ return HConstantFolding::kConstantFoldingPassName;
+ case OptimizationPass::kDeadCodeElimination:
+ return HDeadCodeElimination::kDeadCodeEliminationPassName;
+ case OptimizationPass::kInliner:
+ return HInliner::kInlinerPassName;
+ case OptimizationPass::kSharpening:
+ return HSharpening::kSharpeningPassName;
+ case OptimizationPass::kSelectGenerator:
+ return HSelectGenerator::kSelectGeneratorPassName;
+ case OptimizationPass::kInstructionSimplifier:
+ return InstructionSimplifier::kInstructionSimplifierPassName;
+ case OptimizationPass::kIntrinsicsRecognizer:
+ return IntrinsicsRecognizer::kIntrinsicsRecognizerPassName;
+ case OptimizationPass::kCHAGuardOptimization:
+ return CHAGuardOptimization::kCHAGuardOptimizationPassName;
+ case OptimizationPass::kCodeSinking:
+ return CodeSinking::kCodeSinkingPassName;
+ case OptimizationPass::kConstructorFenceRedundancyElimination:
+ return ConstructorFenceRedundancyElimination::kCFREPassName;
+ case OptimizationPass::kScheduling:
+ return HInstructionScheduling::kInstructionSchedulingPassName;
+#ifdef ART_ENABLE_CODEGEN_arm
+ case OptimizationPass::kInstructionSimplifierArm:
+ return arm::InstructionSimplifierArm::kInstructionSimplifierArmPassName;
+#endif
+#ifdef ART_ENABLE_CODEGEN_arm64
+ case OptimizationPass::kInstructionSimplifierArm64:
+ return arm64::InstructionSimplifierArm64::kInstructionSimplifierArm64PassName;
+#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+ case OptimizationPass::kPcRelativeFixupsMips:
+ return mips::PcRelativeFixups::kPcRelativeFixupsMipsPassName;
+ case OptimizationPass::kInstructionSimplifierMips:
+ return mips::InstructionSimplifierMips::kInstructionSimplifierMipsPassName;
+#endif
+#ifdef ART_ENABLE_CODEGEN_x86
+ case OptimizationPass::kPcRelativeFixupsX86:
+ return x86::PcRelativeFixups::kPcRelativeFixupsX86PassName;
+#endif
+#if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
+ case OptimizationPass::kX86MemoryOperandGeneration:
+ return x86::X86MemoryOperandGeneration::kX86MemoryOperandGenerationPassName;
+#endif
+ }
+}
+
+#define X(x) if (name == OptimizationPassName((x))) return (x)
+
+OptimizationPass OptimizationPassByName(const std::string& name) {
+ X(OptimizationPass::kBoundsCheckElimination);
+ X(OptimizationPass::kCHAGuardOptimization);
+ X(OptimizationPass::kCodeSinking);
+ X(OptimizationPass::kConstantFolding);
+ X(OptimizationPass::kConstructorFenceRedundancyElimination);
+ X(OptimizationPass::kDeadCodeElimination);
+ X(OptimizationPass::kGlobalValueNumbering);
+ X(OptimizationPass::kInductionVarAnalysis);
+ X(OptimizationPass::kInliner);
+ X(OptimizationPass::kInstructionSimplifier);
+ X(OptimizationPass::kIntrinsicsRecognizer);
+ X(OptimizationPass::kInvariantCodeMotion);
+ X(OptimizationPass::kLoadStoreAnalysis);
+ X(OptimizationPass::kLoadStoreElimination);
+ X(OptimizationPass::kLoopOptimization);
+ X(OptimizationPass::kScheduling);
+ X(OptimizationPass::kSelectGenerator);
+ X(OptimizationPass::kSharpening);
+ X(OptimizationPass::kSideEffectsAnalysis);
+#ifdef ART_ENABLE_CODEGEN_arm
+ X(OptimizationPass::kInstructionSimplifierArm);
+#endif
+#ifdef ART_ENABLE_CODEGEN_arm64
+ X(OptimizationPass::kInstructionSimplifierArm64);
+#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+ X(OptimizationPass::kPcRelativeFixupsMips);
+ X(OptimizationPass::kInstructionSimplifierMips);
+#endif
+#ifdef ART_ENABLE_CODEGEN_x86
+ X(OptimizationPass::kPcRelativeFixupsX86);
+ X(OptimizationPass::kX86MemoryOperandGeneration);
+#endif
+ LOG(FATAL) << "Cannot find optimization " << name;
+ UNREACHABLE();
+}
+
+#undef X
+
+ArenaVector<HOptimization*> ConstructOptimizations(
+ const OptimizationDef definitions[],
+ size_t length,
+ ArenaAllocator* allocator,
+ HGraph* graph,
+ OptimizingCompilerStats* stats,
+ CodeGenerator* codegen,
+ CompilerDriver* driver,
+ const DexCompilationUnit& dex_compilation_unit,
+ VariableSizedHandleScope* handles) {
+ ArenaVector<HOptimization*> optimizations(allocator->Adapter());
+
+ // Some optimizations require SideEffectsAnalysis or HInductionVarAnalysis
+ // instances. This method uses the nearest instance preceeding it in the pass
+ // name list or fails fatally if no such analysis can be found.
+ SideEffectsAnalysis* most_recent_side_effects = nullptr;
+ HInductionVarAnalysis* most_recent_induction = nullptr;
+ LoadStoreAnalysis* most_recent_lsa = nullptr;
+
+ // Loop over the requested optimizations.
+ for (size_t i = 0; i < length; i++) {
+ OptimizationPass pass = definitions[i].first;
+ const char* alt_name = definitions[i].second;
+ const char* name = alt_name != nullptr
+ ? alt_name
+ : OptimizationPassName(pass);
+ HOptimization* opt = nullptr;
+
+ switch (pass) {
+ //
+ // Analysis passes (kept in most recent for subsequent passes).
+ //
+ case OptimizationPass::kSideEffectsAnalysis:
+ opt = most_recent_side_effects = new (allocator) SideEffectsAnalysis(graph, name);
+ break;
+ case OptimizationPass::kInductionVarAnalysis:
+ opt = most_recent_induction = new (allocator) HInductionVarAnalysis(graph, name);
+ break;
+ case OptimizationPass::kLoadStoreAnalysis:
+ opt = most_recent_lsa = new (allocator) LoadStoreAnalysis(graph, name);
+ break;
+ //
+ // Passes that need prior analysis.
+ //
+ case OptimizationPass::kGlobalValueNumbering:
+ CHECK(most_recent_side_effects != nullptr);
+ opt = new (allocator) GVNOptimization(graph, *most_recent_side_effects, name);
+ break;
+ case OptimizationPass::kInvariantCodeMotion:
+ CHECK(most_recent_side_effects != nullptr);
+ opt = new (allocator) LICM(graph, *most_recent_side_effects, stats, name);
+ break;
+ case OptimizationPass::kLoopOptimization:
+ CHECK(most_recent_induction != nullptr);
+ opt = new (allocator) HLoopOptimization(graph, driver, most_recent_induction, stats, name);
+ break;
+ case OptimizationPass::kBoundsCheckElimination:
+ CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr);
+ opt = new (allocator) BoundsCheckElimination(
+ graph, *most_recent_side_effects, most_recent_induction, name);
+ break;
+ case OptimizationPass::kLoadStoreElimination:
+ CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr);
+ opt = new (allocator) LoadStoreElimination(
+ graph, *most_recent_side_effects, *most_recent_lsa, stats, name);
+ break;
+ //
+ // Regular passes.
+ //
+ case OptimizationPass::kConstantFolding:
+ opt = new (allocator) HConstantFolding(graph, name);
+ break;
+ case OptimizationPass::kDeadCodeElimination:
+ opt = new (allocator) HDeadCodeElimination(graph, stats, name);
+ break;
+ case OptimizationPass::kInliner: {
+ size_t number_of_dex_registers = dex_compilation_unit.GetCodeItem()->registers_size_;
+ opt = new (allocator) HInliner(graph, // outer_graph
+ graph, // outermost_graph
+ codegen,
+ dex_compilation_unit, // outer_compilation_unit
+ dex_compilation_unit, // outermost_compilation_unit
+ driver,
+ handles,
+ stats,
+ number_of_dex_registers,
+ /* total_number_of_instructions */ 0,
+ /* parent */ nullptr,
+ /* depth */ 0,
+ name);
+ break;
+ }
+ case OptimizationPass::kSharpening:
+ opt = new (allocator) HSharpening(
+ graph, codegen, dex_compilation_unit, driver, handles, name);
+ break;
+ case OptimizationPass::kSelectGenerator:
+ opt = new (allocator) HSelectGenerator(graph, handles, stats, name);
+ break;
+ case OptimizationPass::kInstructionSimplifier:
+ opt = new (allocator) InstructionSimplifier(graph, codegen, driver, stats, name);
+ break;
+ case OptimizationPass::kIntrinsicsRecognizer:
+ opt = new (allocator) IntrinsicsRecognizer(graph, stats, name);
+ break;
+ case OptimizationPass::kCHAGuardOptimization:
+ opt = new (allocator) CHAGuardOptimization(graph, name);
+ break;
+ case OptimizationPass::kCodeSinking:
+ opt = new (allocator) CodeSinking(graph, stats, name);
+ break;
+ case OptimizationPass::kConstructorFenceRedundancyElimination:
+ opt = new (allocator) ConstructorFenceRedundancyElimination(graph, stats, name);
+ break;
+ case OptimizationPass::kScheduling:
+ opt = new (allocator) HInstructionScheduling(
+ graph, driver->GetInstructionSet(), codegen, name);
+ break;
+ //
+ // Arch-specific passes.
+ //
+#ifdef ART_ENABLE_CODEGEN_arm
+ case OptimizationPass::kInstructionSimplifierArm:
+ DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
+ opt = new (allocator) arm::InstructionSimplifierArm(graph, stats);
+ break;
+#endif
+#ifdef ART_ENABLE_CODEGEN_arm64
+ case OptimizationPass::kInstructionSimplifierArm64:
+ DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
+ opt = new (allocator) arm64::InstructionSimplifierArm64(graph, stats);
+ break;
+#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+ case OptimizationPass::kPcRelativeFixupsMips:
+ DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
+ opt = new (allocator) mips::PcRelativeFixups(graph, codegen, stats);
+ break;
+ case OptimizationPass::kInstructionSimplifierMips:
+ DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
+ opt = new (allocator) mips::InstructionSimplifierMips(graph, codegen, stats);
+ break;
+#endif
+#ifdef ART_ENABLE_CODEGEN_x86
+ case OptimizationPass::kPcRelativeFixupsX86:
+ DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
+ opt = new (allocator) x86::PcRelativeFixups(graph, codegen, stats);
+ break;
+ case OptimizationPass::kX86MemoryOperandGeneration:
+ DCHECK(alt_name == nullptr) << "arch-specific pass does not support alternative name";
+ opt = new (allocator) x86::X86MemoryOperandGeneration(graph, codegen, stats);
+ break;
+#endif
+ } // switch
+
+ // Add each next optimization to result vector.
+ CHECK(opt != nullptr);
+ DCHECK_STREQ(name, opt->GetPassName()); // sanity
+ optimizations.push_back(opt);
+ }
+
+ return optimizations;
+}
+
} // namespace art
diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h
index ce41a2e..c170f15 100644
--- a/compiler/optimizing/optimization.h
+++ b/compiler/optimizing/optimization.h
@@ -23,6 +23,10 @@
namespace art {
+class CodeGenerator;
+class CompilerDriver;
+class DexCompilationUnit;
+
/**
* Abstraction to implement an optimization pass.
*/
@@ -58,6 +62,81 @@
DISALLOW_COPY_AND_ASSIGN(HOptimization);
};
+// Optimization passes that can be constructed by the helper method below. An enum
+// field is preferred over a string lookup at places where performance matters.
+// TODO: generate this table and lookup methods below automatically?
+enum class OptimizationPass {
+ kBoundsCheckElimination,
+ kCHAGuardOptimization,
+ kCodeSinking,
+ kConstantFolding,
+ kConstructorFenceRedundancyElimination,
+ kDeadCodeElimination,
+ kGlobalValueNumbering,
+ kInductionVarAnalysis,
+ kInliner,
+ kInstructionSimplifier,
+ kIntrinsicsRecognizer,
+ kInvariantCodeMotion,
+ kLoadStoreAnalysis,
+ kLoadStoreElimination,
+ kLoopOptimization,
+ kScheduling,
+ kSelectGenerator,
+ kSharpening,
+ kSideEffectsAnalysis,
+#ifdef ART_ENABLE_CODEGEN_arm
+ kInstructionSimplifierArm,
+#endif
+#ifdef ART_ENABLE_CODEGEN_arm64
+ kInstructionSimplifierArm64,
+#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+ kPcRelativeFixupsMips,
+ kInstructionSimplifierMips,
+#endif
+#ifdef ART_ENABLE_CODEGEN_x86
+ kPcRelativeFixupsX86,
+#endif
+#if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
+ kX86MemoryOperandGeneration,
+#endif
+};
+
+// Lookup name of optimization pass.
+const char* OptimizationPassName(OptimizationPass pass);
+
+// Lookup optimization pass by name.
+OptimizationPass OptimizationPassByName(const std::string& name);
+
+// Optimization definition consisting of an optimization pass
+// and an optional alternative name (nullptr denotes default).
+typedef std::pair<OptimizationPass, const char*> OptimizationDef;
+
+// Helper method for optimization definition array entries.
+inline OptimizationDef OptDef(OptimizationPass pass, const char* name = nullptr) {
+ return std::make_pair(pass, name);
+}
+
+// Helper method to construct series of optimization passes.
+// The array should consist of the requested optimizations
+// and optional alternative names for repeated passes.
+// Example:
+// { OptPass(kConstantFolding),
+// OptPass(Inliner),
+// OptPass(kConstantFolding, "constant_folding$after_inlining")
+// }
+ArenaVector<HOptimization*> ConstructOptimizations(
+ const OptimizationDef definitions[],
+ size_t length,
+ ArenaAllocator* allocator,
+ HGraph* graph,
+ OptimizingCompilerStats* stats,
+ CodeGenerator* codegen,
+ CompilerDriver* driver,
+ const DexCompilationUnit& dex_compilation_unit,
+ VariableSizedHandleScope* handles);
+
} // namespace art
#endif // ART_COMPILER_OPTIMIZING_OPTIMIZATION_H_
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index 4974ed0..53f9ec4 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -22,23 +22,6 @@
#include <stdint.h>
-#ifdef ART_ENABLE_CODEGEN_arm64
-#include "instruction_simplifier_arm64.h"
-#endif
-
-#ifdef ART_ENABLE_CODEGEN_mips
-#include "instruction_simplifier_mips.h"
-#include "pc_relative_fixups_mips.h"
-#endif
-
-#ifdef ART_ENABLE_CODEGEN_x86
-#include "pc_relative_fixups_x86.h"
-#endif
-
-#if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
-#include "x86_memory_gen.h"
-#endif
-
#include "art_method-inl.h"
#include "base/arena_allocator.h"
#include "base/arena_containers.h"
@@ -47,16 +30,10 @@
#include "base/mutex.h"
#include "base/scoped_arena_allocator.h"
#include "base/timing_logger.h"
-#include "bounds_check_elimination.h"
#include "builder.h"
-#include "cha_guard_optimization.h"
#include "code_generator.h"
-#include "code_sinking.h"
#include "compiled_method.h"
#include "compiler.h"
-#include "constant_folding.h"
-#include "constructor_fence_redundancy_elimination.h"
-#include "dead_code_elimination.h"
#include "debug/elf_debug_writer.h"
#include "debug/method_debug_info.h"
#include "dex/verification_results.h"
@@ -67,31 +44,19 @@
#include "driver/dex_compilation_unit.h"
#include "graph_checker.h"
#include "graph_visualizer.h"
-#include "gvn.h"
-#include "induction_var_analysis.h"
#include "inliner.h"
-#include "instruction_simplifier.h"
-#include "instruction_simplifier_arm.h"
-#include "intrinsics.h"
#include "jit/debugger_interface.h"
#include "jit/jit.h"
#include "jit/jit_code_cache.h"
#include "jit/jit_logger.h"
#include "jni/quick/jni_compiler.h"
-#include "licm.h"
#include "linker/linker_patch.h"
-#include "load_store_analysis.h"
-#include "load_store_elimination.h"
-#include "loop_optimization.h"
#include "nodes.h"
#include "oat_quick_method_header.h"
#include "prepare_for_register_allocation.h"
#include "reference_type_propagation.h"
#include "register_allocator_linear_scan.h"
-#include "scheduler.h"
#include "select_generator.h"
-#include "sharpening.h"
-#include "side_effects_analysis.h"
#include "ssa_builder.h"
#include "ssa_liveness_analysis.h"
#include "ssa_phi_elimination.h"
@@ -335,21 +300,52 @@
private:
void RunOptimizations(HGraph* graph,
CodeGenerator* codegen,
- CompilerDriver* driver,
+ const DexCompilationUnit& dex_compilation_unit,
+ PassObserver* pass_observer,
+ VariableSizedHandleScope* handles,
+ const OptimizationDef definitions[],
+ size_t length) const {
+ // Convert definitions to optimization passes.
+ ArenaVector<HOptimization*> optimizations = ConstructOptimizations(
+ definitions,
+ length,
+ graph->GetAllocator(),
+ graph,
+ compilation_stats_.get(),
+ codegen,
+ GetCompilerDriver(),
+ dex_compilation_unit,
+ handles);
+ DCHECK_EQ(length, optimizations.size());
+ // Run the optimization passes one by one.
+ for (size_t i = 0; i < length; ++i) {
+ PassScope scope(optimizations[i]->GetPassName(), pass_observer);
+ optimizations[i]->Run();
+ }
+ }
+
+ template <size_t length> void RunOptimizations(
+ HGraph* graph,
+ CodeGenerator* codegen,
+ const DexCompilationUnit& dex_compilation_unit,
+ PassObserver* pass_observer,
+ VariableSizedHandleScope* handles,
+ const OptimizationDef (&definitions)[length]) const {
+ RunOptimizations(
+ graph, codegen, dex_compilation_unit, pass_observer, handles, definitions, length);
+ }
+
+ void RunOptimizations(HGraph* graph,
+ CodeGenerator* codegen,
const DexCompilationUnit& dex_compilation_unit,
PassObserver* pass_observer,
VariableSizedHandleScope* handles) const;
- void RunOptimizations(HOptimization* optimizations[],
- size_t length,
- PassObserver* pass_observer) const;
-
private:
// Create a 'CompiledMethod' for an optimized graph.
CompiledMethod* Emit(ArenaAllocator* allocator,
CodeVectorAllocator* code_allocator,
CodeGenerator* codegen,
- CompilerDriver* driver,
const DexFile::CodeItem* item) const;
// Try compiling a method and return the code generator used for
@@ -376,15 +372,15 @@
void MaybeRunInliner(HGraph* graph,
CodeGenerator* codegen,
- CompilerDriver* driver,
const DexCompilationUnit& dex_compilation_unit,
PassObserver* pass_observer,
VariableSizedHandleScope* handles) const;
- void RunArchOptimizations(InstructionSet instruction_set,
- HGraph* graph,
+ void RunArchOptimizations(HGraph* graph,
CodeGenerator* codegen,
- PassObserver* pass_observer) const;
+ const DexCompilationUnit& dex_compilation_unit,
+ PassObserver* pass_observer,
+ VariableSizedHandleScope* handles) const;
std::unique_ptr<OptimizingCompilerStats> compilation_stats_;
@@ -440,299 +436,130 @@
|| instruction_set == InstructionSet::kX86_64;
}
-// Strip pass name suffix to get optimization name.
-static std::string ConvertPassNameToOptimizationName(const std::string& pass_name) {
- size_t pos = pass_name.find(kPassNameSeparator);
- return pos == std::string::npos ? pass_name : pass_name.substr(0, pos);
-}
-
-static HOptimization* BuildOptimization(
- const std::string& pass_name,
- ArenaAllocator* allocator,
- HGraph* graph,
- OptimizingCompilerStats* stats,
- CodeGenerator* codegen,
- CompilerDriver* driver,
- const DexCompilationUnit& dex_compilation_unit,
- VariableSizedHandleScope* handles,
- SideEffectsAnalysis* most_recent_side_effects,
- HInductionVarAnalysis* most_recent_induction,
- LoadStoreAnalysis* most_recent_lsa) {
- std::string opt_name = ConvertPassNameToOptimizationName(pass_name);
- if (opt_name == BoundsCheckElimination::kBoundsCheckEliminationPassName) {
- CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr);
- return new (allocator) BoundsCheckElimination(graph,
- *most_recent_side_effects,
- most_recent_induction);
- } else if (opt_name == GVNOptimization::kGlobalValueNumberingPassName) {
- CHECK(most_recent_side_effects != nullptr);
- return new (allocator) GVNOptimization(graph, *most_recent_side_effects, pass_name.c_str());
- } else if (opt_name == HConstantFolding::kConstantFoldingPassName) {
- return new (allocator) HConstantFolding(graph, pass_name.c_str());
- } else if (opt_name == HDeadCodeElimination::kDeadCodeEliminationPassName) {
- return new (allocator) HDeadCodeElimination(graph, stats, pass_name.c_str());
- } else if (opt_name == HInliner::kInlinerPassName) {
- size_t number_of_dex_registers = dex_compilation_unit.GetCodeItem()->registers_size_;
- return new (allocator) HInliner(graph, // outer_graph
- graph, // outermost_graph
- codegen,
- dex_compilation_unit, // outer_compilation_unit
- dex_compilation_unit, // outermost_compilation_unit
- driver,
- handles,
- stats,
- number_of_dex_registers,
- /* total_number_of_instructions */ 0,
- /* parent */ nullptr);
- } else if (opt_name == HSharpening::kSharpeningPassName) {
- return new (allocator) HSharpening(graph, codegen, dex_compilation_unit, driver, handles);
- } else if (opt_name == HSelectGenerator::kSelectGeneratorPassName) {
- return new (allocator) HSelectGenerator(graph, handles, stats);
- } else if (opt_name == HInductionVarAnalysis::kInductionPassName) {
- return new (allocator) HInductionVarAnalysis(graph);
- } else if (opt_name == InstructionSimplifier::kInstructionSimplifierPassName) {
- return new (allocator) InstructionSimplifier(graph, codegen, driver, stats, pass_name.c_str());
- } else if (opt_name == IntrinsicsRecognizer::kIntrinsicsRecognizerPassName) {
- return new (allocator) IntrinsicsRecognizer(graph, stats);
- } else if (opt_name == LICM::kLoopInvariantCodeMotionPassName) {
- CHECK(most_recent_side_effects != nullptr);
- return new (allocator) LICM(graph, *most_recent_side_effects, stats);
- } else if (opt_name == LoadStoreAnalysis::kLoadStoreAnalysisPassName) {
- return new (allocator) LoadStoreAnalysis(graph);
- } else if (opt_name == LoadStoreElimination::kLoadStoreEliminationPassName) {
- CHECK(most_recent_side_effects != nullptr);
- CHECK(most_recent_lsa != nullptr);
- return new (allocator) LoadStoreElimination(graph,
- *most_recent_side_effects,
- *most_recent_lsa, stats);
- } else if (opt_name == SideEffectsAnalysis::kSideEffectsAnalysisPassName) {
- return new (allocator) SideEffectsAnalysis(graph);
- } else if (opt_name == HLoopOptimization::kLoopOptimizationPassName) {
- return new (allocator) HLoopOptimization(graph, driver, most_recent_induction, stats);
- } else if (opt_name == CHAGuardOptimization::kCHAGuardOptimizationPassName) {
- return new (allocator) CHAGuardOptimization(graph);
- } else if (opt_name == CodeSinking::kCodeSinkingPassName) {
- return new (allocator) CodeSinking(graph, stats);
- } else if (opt_name == ConstructorFenceRedundancyElimination::kPassName) {
- return new (allocator) ConstructorFenceRedundancyElimination(graph, stats);
-#ifdef ART_ENABLE_CODEGEN_arm
- } else if (opt_name == arm::InstructionSimplifierArm::kInstructionSimplifierArmPassName) {
- return new (allocator) arm::InstructionSimplifierArm(graph, stats);
-#endif
-#ifdef ART_ENABLE_CODEGEN_arm64
- } else if (opt_name == arm64::InstructionSimplifierArm64::kInstructionSimplifierArm64PassName) {
- return new (allocator) arm64::InstructionSimplifierArm64(graph, stats);
-#endif
-#ifdef ART_ENABLE_CODEGEN_mips
- } else if (opt_name == mips::PcRelativeFixups::kPcRelativeFixupsMipsPassName) {
- return new (allocator) mips::PcRelativeFixups(graph, codegen, stats);
- } else if (opt_name == mips::InstructionSimplifierMips::kInstructionSimplifierMipsPassName) {
- return new (allocator) mips::InstructionSimplifierMips(graph, codegen, stats);
-#endif
-#ifdef ART_ENABLE_CODEGEN_x86
- } else if (opt_name == x86::PcRelativeFixups::kPcRelativeFixupsX86PassName) {
- return new (allocator) x86::PcRelativeFixups(graph, codegen, stats);
- } else if (opt_name == x86::X86MemoryOperandGeneration::kX86MemoryOperandGenerationPassName) {
- return new (allocator) x86::X86MemoryOperandGeneration(graph, codegen, stats);
-#endif
- }
- return nullptr;
-}
-
-static ArenaVector<HOptimization*> BuildOptimizations(
- const std::vector<std::string>& pass_names,
- ArenaAllocator* allocator,
- HGraph* graph,
- OptimizingCompilerStats* stats,
- CodeGenerator* codegen,
- CompilerDriver* driver,
- const DexCompilationUnit& dex_compilation_unit,
- VariableSizedHandleScope* handles) {
- // Few HOptimizations constructors require SideEffectsAnalysis or HInductionVarAnalysis
- // instances. This method assumes that each of them expects the nearest instance preceeding it
- // in the pass name list.
- SideEffectsAnalysis* most_recent_side_effects = nullptr;
- HInductionVarAnalysis* most_recent_induction = nullptr;
- LoadStoreAnalysis* most_recent_lsa = nullptr;
- ArenaVector<HOptimization*> ret(allocator->Adapter());
- for (const std::string& pass_name : pass_names) {
- HOptimization* opt = BuildOptimization(
- pass_name,
- allocator,
- graph,
- stats,
- codegen,
- driver,
- dex_compilation_unit,
- handles,
- most_recent_side_effects,
- most_recent_induction,
- most_recent_lsa);
- CHECK(opt != nullptr) << "Couldn't build optimization: \"" << pass_name << "\"";
- ret.push_back(opt);
-
- std::string opt_name = ConvertPassNameToOptimizationName(pass_name);
- if (opt_name == SideEffectsAnalysis::kSideEffectsAnalysisPassName) {
- most_recent_side_effects = down_cast<SideEffectsAnalysis*>(opt);
- } else if (opt_name == HInductionVarAnalysis::kInductionPassName) {
- most_recent_induction = down_cast<HInductionVarAnalysis*>(opt);
- } else if (opt_name == LoadStoreAnalysis::kLoadStoreAnalysisPassName) {
- most_recent_lsa = down_cast<LoadStoreAnalysis*>(opt);
- }
- }
- return ret;
-}
-
-void OptimizingCompiler::RunOptimizations(HOptimization* optimizations[],
- size_t length,
- PassObserver* pass_observer) const {
- for (size_t i = 0; i < length; ++i) {
- PassScope scope(optimizations[i]->GetPassName(), pass_observer);
- optimizations[i]->Run();
- }
-}
-
void OptimizingCompiler::MaybeRunInliner(HGraph* graph,
CodeGenerator* codegen,
- CompilerDriver* driver,
const DexCompilationUnit& dex_compilation_unit,
PassObserver* pass_observer,
VariableSizedHandleScope* handles) const {
- OptimizingCompilerStats* stats = compilation_stats_.get();
- const CompilerOptions& compiler_options = driver->GetCompilerOptions();
+ const CompilerOptions& compiler_options = GetCompilerDriver()->GetCompilerOptions();
bool should_inline = (compiler_options.GetInlineMaxCodeUnits() > 0);
if (!should_inline) {
return;
}
- size_t number_of_dex_registers = dex_compilation_unit.GetCodeItem()->registers_size_;
- HInliner* inliner = new (graph->GetAllocator()) HInliner(
- graph, // outer_graph
- graph, // outermost_graph
- codegen,
- dex_compilation_unit, // outer_compilation_unit
- dex_compilation_unit, // outermost_compilation_unit
- driver,
- handles,
- stats,
- number_of_dex_registers,
- /* total_number_of_instructions */ 0,
- /* parent */ nullptr);
- HOptimization* optimizations[] = { inliner };
-
- RunOptimizations(optimizations, arraysize(optimizations), pass_observer);
+ OptimizationDef optimizations[] = {
+ OptDef(OptimizationPass::kInliner)
+ };
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ optimizations);
}
-void OptimizingCompiler::RunArchOptimizations(InstructionSet instruction_set,
- HGraph* graph,
+void OptimizingCompiler::RunArchOptimizations(HGraph* graph,
CodeGenerator* codegen,
- PassObserver* pass_observer) const {
- UNUSED(codegen); // To avoid compilation error when compiling for svelte
- OptimizingCompilerStats* stats = compilation_stats_.get();
- ArenaAllocator* allocator = graph->GetAllocator();
- switch (instruction_set) {
+ const DexCompilationUnit& dex_compilation_unit,
+ PassObserver* pass_observer,
+ VariableSizedHandleScope* handles) const {
+ switch (GetCompilerDriver()->GetInstructionSet()) {
#if defined(ART_ENABLE_CODEGEN_arm)
case InstructionSet::kThumb2:
case InstructionSet::kArm: {
- arm::InstructionSimplifierArm* simplifier =
- new (allocator) arm::InstructionSimplifierArm(graph, stats);
- SideEffectsAnalysis* side_effects = new (allocator) SideEffectsAnalysis(graph);
- GVNOptimization* gvn =
- new (allocator) GVNOptimization(graph, *side_effects, "GVN$after_arch");
- HInstructionScheduling* scheduling =
- new (allocator) HInstructionScheduling(graph, instruction_set, codegen);
- HOptimization* arm_optimizations[] = {
- simplifier,
- side_effects,
- gvn,
- scheduling,
+ OptimizationDef arm_optimizations[] = {
+ OptDef(OptimizationPass::kInstructionSimplifierArm),
+ OptDef(OptimizationPass::kSideEffectsAnalysis),
+ OptDef(OptimizationPass::kGlobalValueNumbering, "GVN$after_arch"),
+ OptDef(OptimizationPass::kScheduling)
};
- RunOptimizations(arm_optimizations, arraysize(arm_optimizations), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ arm_optimizations);
break;
}
#endif
#ifdef ART_ENABLE_CODEGEN_arm64
case InstructionSet::kArm64: {
- arm64::InstructionSimplifierArm64* simplifier =
- new (allocator) arm64::InstructionSimplifierArm64(graph, stats);
- SideEffectsAnalysis* side_effects = new (allocator) SideEffectsAnalysis(graph);
- GVNOptimization* gvn =
- new (allocator) GVNOptimization(graph, *side_effects, "GVN$after_arch");
- HInstructionScheduling* scheduling =
- new (allocator) HInstructionScheduling(graph, instruction_set);
- HOptimization* arm64_optimizations[] = {
- simplifier,
- side_effects,
- gvn,
- scheduling,
+ OptimizationDef arm64_optimizations[] = {
+ OptDef(OptimizationPass::kInstructionSimplifierArm64),
+ OptDef(OptimizationPass::kSideEffectsAnalysis),
+ OptDef(OptimizationPass::kGlobalValueNumbering, "GVN$after_arch"),
+ OptDef(OptimizationPass::kScheduling)
};
- RunOptimizations(arm64_optimizations, arraysize(arm64_optimizations), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ arm64_optimizations);
break;
}
#endif
#ifdef ART_ENABLE_CODEGEN_mips
case InstructionSet::kMips: {
- mips::InstructionSimplifierMips* simplifier =
- new (allocator) mips::InstructionSimplifierMips(graph, codegen, stats);
- SideEffectsAnalysis* side_effects = new (allocator) SideEffectsAnalysis(graph);
- GVNOptimization* gvn =
- new (allocator) GVNOptimization(graph, *side_effects, "GVN$after_arch");
- mips::PcRelativeFixups* pc_relative_fixups =
- new (allocator) mips::PcRelativeFixups(graph, codegen, stats);
- HOptimization* mips_optimizations[] = {
- simplifier,
- side_effects,
- gvn,
- pc_relative_fixups,
+ OptimizationDef mips_optimizations[] = {
+ OptDef(OptimizationPass::kInstructionSimplifierMips),
+ OptDef(OptimizationPass::kSideEffectsAnalysis),
+ OptDef(OptimizationPass::kGlobalValueNumbering, "GVN$after_arch"),
+ OptDef(OptimizationPass::kPcRelativeFixupsMips)
};
- RunOptimizations(mips_optimizations, arraysize(mips_optimizations), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ mips_optimizations);
break;
}
#endif
#ifdef ART_ENABLE_CODEGEN_mips64
case InstructionSet::kMips64: {
- SideEffectsAnalysis* side_effects = new (allocator) SideEffectsAnalysis(graph);
- GVNOptimization* gvn =
- new (allocator) GVNOptimization(graph, *side_effects, "GVN$after_arch");
- HOptimization* mips64_optimizations[] = {
- side_effects,
- gvn,
+ OptimizationDef mips64_optimizations[] = {
+ OptDef(OptimizationPass::kSideEffectsAnalysis),
+ OptDef(OptimizationPass::kGlobalValueNumbering, "GVN$after_arch")
};
- RunOptimizations(mips64_optimizations, arraysize(mips64_optimizations), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ mips64_optimizations);
break;
}
#endif
#ifdef ART_ENABLE_CODEGEN_x86
case InstructionSet::kX86: {
- SideEffectsAnalysis* side_effects = new (allocator) SideEffectsAnalysis(graph);
- GVNOptimization* gvn =
- new (allocator) GVNOptimization(graph, *side_effects, "GVN$after_arch");
- x86::PcRelativeFixups* pc_relative_fixups =
- new (allocator) x86::PcRelativeFixups(graph, codegen, stats);
- x86::X86MemoryOperandGeneration* memory_gen =
- new (allocator) x86::X86MemoryOperandGeneration(graph, codegen, stats);
- HOptimization* x86_optimizations[] = {
- side_effects,
- gvn,
- pc_relative_fixups,
- memory_gen
+ OptimizationDef x86_optimizations[] = {
+ OptDef(OptimizationPass::kSideEffectsAnalysis),
+ OptDef(OptimizationPass::kGlobalValueNumbering, "GVN$after_arch"),
+ OptDef(OptimizationPass::kPcRelativeFixupsX86),
+ OptDef(OptimizationPass::kX86MemoryOperandGeneration)
};
- RunOptimizations(x86_optimizations, arraysize(x86_optimizations), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ x86_optimizations);
break;
}
#endif
#ifdef ART_ENABLE_CODEGEN_x86_64
case InstructionSet::kX86_64: {
- SideEffectsAnalysis* side_effects = new (allocator) SideEffectsAnalysis(graph);
- GVNOptimization* gvn =
- new (allocator) GVNOptimization(graph, *side_effects, "GVN$after_arch");
- x86::X86MemoryOperandGeneration* memory_gen =
- new (allocator) x86::X86MemoryOperandGeneration(graph, codegen, stats);
- HOptimization* x86_64_optimizations[] = {
- side_effects,
- gvn,
- memory_gen
+ OptimizationDef x86_64_optimizations[] = {
+ OptDef(OptimizationPass::kSideEffectsAnalysis),
+ OptDef(OptimizationPass::kGlobalValueNumbering, "GVN$after_arch"),
+ OptDef(OptimizationPass::kX86MemoryOperandGeneration)
};
- RunOptimizations(x86_64_optimizations, arraysize(x86_64_optimizations), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ x86_64_optimizations);
break;
}
#endif
@@ -768,110 +595,93 @@
}
}
+// Strip pass name suffix to get optimization name.
+static std::string ConvertPassNameToOptimizationName(const std::string& pass_name) {
+ size_t pos = pass_name.find(kPassNameSeparator);
+ return pos == std::string::npos ? pass_name : pass_name.substr(0, pos);
+}
+
void OptimizingCompiler::RunOptimizations(HGraph* graph,
CodeGenerator* codegen,
- CompilerDriver* driver,
const DexCompilationUnit& dex_compilation_unit,
PassObserver* pass_observer,
VariableSizedHandleScope* handles) const {
- OptimizingCompilerStats* stats = compilation_stats_.get();
- ArenaAllocator* allocator = graph->GetAllocator();
- if (driver->GetCompilerOptions().GetPassesToRun() != nullptr) {
- ArenaVector<HOptimization*> optimizations = BuildOptimizations(
- *driver->GetCompilerOptions().GetPassesToRun(),
- allocator,
- graph,
- stats,
- codegen,
- driver,
- dex_compilation_unit,
- handles);
- RunOptimizations(optimizations.data(), optimizations.size(), pass_observer);
+ const std::vector<std::string>* pass_names =
+ GetCompilerDriver()->GetCompilerOptions().GetPassesToRun();
+ if (pass_names != nullptr) {
+ // If passes were defined on command-line, build the optimization
+ // passes and run these instead of the built-in optimizations.
+ const size_t length = pass_names->size();
+ std::vector<OptimizationDef> optimizations;
+ for (const std::string& pass_name : *pass_names) {
+ std::string opt_name = ConvertPassNameToOptimizationName(pass_name);
+ optimizations.push_back(OptDef(OptimizationPassByName(opt_name.c_str()), pass_name.c_str()));
+ }
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ optimizations.data(),
+ length);
return;
}
- HDeadCodeElimination* dce1 = new (allocator) HDeadCodeElimination(
- graph, stats, "dead_code_elimination$initial");
- HDeadCodeElimination* dce2 = new (allocator) HDeadCodeElimination(
- graph, stats, "dead_code_elimination$after_inlining");
- HDeadCodeElimination* dce3 = new (allocator) HDeadCodeElimination(
- graph, stats, "dead_code_elimination$final");
- HConstantFolding* fold1 = new (allocator) HConstantFolding(graph, "constant_folding");
- InstructionSimplifier* simplify1 = new (allocator) InstructionSimplifier(
- graph, codegen, driver, stats);
- HSelectGenerator* select_generator = new (allocator) HSelectGenerator(graph, handles, stats);
- HConstantFolding* fold2 = new (allocator) HConstantFolding(
- graph, "constant_folding$after_inlining");
- HConstantFolding* fold3 = new (allocator) HConstantFolding(graph, "constant_folding$after_bce");
- SideEffectsAnalysis* side_effects1 = new (allocator) SideEffectsAnalysis(
- graph, "side_effects$before_gvn");
- SideEffectsAnalysis* side_effects2 = new (allocator) SideEffectsAnalysis(
- graph, "side_effects$before_lse");
- GVNOptimization* gvn = new (allocator) GVNOptimization(graph, *side_effects1);
- LICM* licm = new (allocator) LICM(graph, *side_effects1, stats);
- HInductionVarAnalysis* induction = new (allocator) HInductionVarAnalysis(graph);
- BoundsCheckElimination* bce =
- new (allocator) BoundsCheckElimination(graph, *side_effects1, induction);
- HLoopOptimization* loop = new (allocator) HLoopOptimization(graph, driver, induction, stats);
- LoadStoreAnalysis* lsa = new (allocator) LoadStoreAnalysis(graph);
- LoadStoreElimination* lse =
- new (allocator) LoadStoreElimination(graph, *side_effects2, *lsa, stats);
- HSharpening* sharpening = new (allocator) HSharpening(
- graph, codegen, dex_compilation_unit, driver, handles);
- InstructionSimplifier* simplify2 = new (allocator) InstructionSimplifier(
- graph, codegen, driver, stats, "instruction_simplifier$after_inlining");
- InstructionSimplifier* simplify3 = new (allocator) InstructionSimplifier(
- graph, codegen, driver, stats, "instruction_simplifier$after_bce");
- InstructionSimplifier* simplify4 = new (allocator) InstructionSimplifier(
- graph, codegen, driver, stats, "instruction_simplifier$before_codegen");
- IntrinsicsRecognizer* intrinsics = new (allocator) IntrinsicsRecognizer(graph, stats);
- CHAGuardOptimization* cha_guard = new (allocator) CHAGuardOptimization(graph);
- CodeSinking* code_sinking = new (allocator) CodeSinking(graph, stats);
- ConstructorFenceRedundancyElimination* cfre =
- new (allocator) ConstructorFenceRedundancyElimination(graph, stats);
-
- HOptimization* optimizations1[] = {
- intrinsics,
- sharpening,
- fold1,
- simplify1,
- dce1,
+ OptimizationDef optimizations1[] = {
+ OptDef(OptimizationPass::kIntrinsicsRecognizer),
+ OptDef(OptimizationPass::kSharpening),
+ OptDef(OptimizationPass::kConstantFolding),
+ OptDef(OptimizationPass::kInstructionSimplifier),
+ OptDef(OptimizationPass::kDeadCodeElimination, "dead_code_elimination$initial")
};
- RunOptimizations(optimizations1, arraysize(optimizations1), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ optimizations1);
- MaybeRunInliner(graph, codegen, driver, dex_compilation_unit, pass_observer, handles);
+ MaybeRunInliner(graph, codegen, dex_compilation_unit, pass_observer, handles);
- HOptimization* optimizations2[] = {
+ OptimizationDef optimizations2[] = {
// SelectGenerator depends on the InstructionSimplifier removing
// redundant suspend checks to recognize empty blocks.
- select_generator,
- fold2, // TODO: if we don't inline we can also skip fold2.
- simplify2,
- dce2,
- side_effects1,
- gvn,
- licm,
- induction,
- bce,
- loop,
- fold3, // evaluates code generated by dynamic bce
- simplify3,
- side_effects2,
- lsa,
- lse,
- cha_guard,
- dce3,
- code_sinking,
+ OptDef(OptimizationPass::kSelectGenerator),
+ // TODO: if we don't inline we can also skip fold2.
+ OptDef(OptimizationPass::kConstantFolding, "constant_folding$after_inlining"),
+ OptDef(OptimizationPass::kInstructionSimplifier, "instruction_simplifier$after_inlining"),
+ OptDef(OptimizationPass::kDeadCodeElimination, "dead_code_elimination$after_inlining"),
+ OptDef(OptimizationPass::kSideEffectsAnalysis, "side_effects$before_gvn"),
+ OptDef(OptimizationPass::kGlobalValueNumbering),
+ OptDef(OptimizationPass::kInvariantCodeMotion),
+ OptDef(OptimizationPass::kInductionVarAnalysis),
+ OptDef(OptimizationPass::kBoundsCheckElimination),
+ OptDef(OptimizationPass::kLoopOptimization),
+ // Evaluates code generated by dynamic bce.
+ OptDef(OptimizationPass::kConstantFolding, "constant_folding$after_bce"),
+ OptDef(OptimizationPass::kInstructionSimplifier, "instruction_simplifier$after_bce"),
+ OptDef(OptimizationPass::kSideEffectsAnalysis, "side_effects$before_lse"),
+ OptDef(OptimizationPass::kLoadStoreAnalysis),
+ OptDef(OptimizationPass::kLoadStoreElimination),
+ OptDef(OptimizationPass::kCHAGuardOptimization),
+ OptDef(OptimizationPass::kDeadCodeElimination, "dead_code_elimination$final"),
+ OptDef(OptimizationPass::kCodeSinking),
// The codegen has a few assumptions that only the instruction simplifier
// can satisfy. For example, the code generator does not expect to see a
// HTypeConversion from a type to the same type.
- simplify4,
- cfre, // Eliminate constructor fences after code sinking to avoid
- // complicated sinking logic to split a fence with many inputs.
+ OptDef(OptimizationPass::kInstructionSimplifier, "instruction_simplifier$before_codegen"),
+ // Eliminate constructor fences after code sinking to avoid
+ // complicated sinking logic to split a fence with many inputs.
+ OptDef(OptimizationPass::kConstructorFenceRedundancyElimination)
};
- RunOptimizations(optimizations2, arraysize(optimizations2), pass_observer);
+ RunOptimizations(graph,
+ codegen,
+ dex_compilation_unit,
+ pass_observer,
+ handles,
+ optimizations2);
- RunArchOptimizations(driver->GetInstructionSet(), graph, codegen, pass_observer);
+ RunArchOptimizations(graph, codegen, dex_compilation_unit, pass_observer, handles);
}
static ArenaVector<linker::LinkerPatch> EmitAndSortLinkerPatches(CodeGenerator* codegen) {
@@ -890,7 +700,6 @@
CompiledMethod* OptimizingCompiler::Emit(ArenaAllocator* allocator,
CodeVectorAllocator* code_allocator,
CodeGenerator* codegen,
- CompilerDriver* compiler_driver,
const DexFile::CodeItem* code_item_for_osr_check) const {
ArenaVector<linker::LinkerPatch> linker_patches = EmitAndSortLinkerPatches(codegen);
ArenaVector<uint8_t> stack_map(allocator->Adapter(kArenaAllocStackMaps));
@@ -905,7 +714,7 @@
code_item_for_osr_check);
CompiledMethod* compiled_method = CompiledMethod::SwapAllocCompiledMethod(
- compiler_driver,
+ GetCompilerDriver(),
codegen->GetInstructionSet(),
ArrayRef<const uint8_t>(code_allocator->GetMemory()),
// Follow Quick's behavior and set the frame size to zero if it is
@@ -1049,7 +858,6 @@
RunOptimizations(graph,
codegen.get(),
- compiler_driver,
dex_compilation_unit,
&pass_observer,
handles);
@@ -1140,20 +948,20 @@
builder.BuildIntrinsicGraph(method);
}
- OptimizingCompilerStats* stats = compilation_stats_.get();
- InstructionSimplifier* simplify = new (allocator) InstructionSimplifier(
- graph, codegen.get(), compiler_driver, stats);
- IntrinsicsRecognizer* intrinsics = new (allocator) IntrinsicsRecognizer(graph, stats);
-
- HOptimization* optimizations[] = {
- intrinsics,
- // Some intrinsics are converted to HIR by the simplifier and the codegen also
- // has a few assumptions that only the instruction simplifier can satisfy.
- simplify,
+ OptimizationDef optimizations[] = {
+ OptDef(OptimizationPass::kIntrinsicsRecognizer),
+ // Some intrinsics are converted to HIR by the simplifier and the codegen also
+ // has a few assumptions that only the instruction simplifier can satisfy.
+ OptDef(OptimizationPass::kInstructionSimplifier),
};
- RunOptimizations(optimizations, arraysize(optimizations), &pass_observer);
+ RunOptimizations(graph,
+ codegen.get(),
+ dex_compilation_unit,
+ &pass_observer,
+ handles,
+ optimizations);
- RunArchOptimizations(compiler_driver->GetInstructionSet(), graph, codegen.get(), &pass_observer);
+ RunArchOptimizations(graph, codegen.get(), dex_compilation_unit, &pass_observer, handles);
AllocateRegisters(graph,
codegen.get(),
@@ -1243,7 +1051,6 @@
compiled_method = Emit(&allocator,
&code_allocator,
codegen.get(),
- compiler_driver,
compiled_intrinsic ? nullptr : code_item);
if (compiled_intrinsic) {
compiled_method->MarkAsIntrinsic();
@@ -1325,7 +1132,6 @@
CompiledMethod* compiled_method = Emit(&allocator,
&code_allocator,
codegen.get(),
- GetCompilerDriver(),
/* code_item_for_osr_check */ nullptr);
compiled_method->MarkAsIntrinsic();
return compiled_method;
diff --git a/compiler/optimizing/pc_relative_fixups_mips.h b/compiler/optimizing/pc_relative_fixups_mips.h
index 5a7397b..ec2c711 100644
--- a/compiler/optimizing/pc_relative_fixups_mips.h
+++ b/compiler/optimizing/pc_relative_fixups_mips.h
@@ -29,7 +29,7 @@
class PcRelativeFixups : public HOptimization {
public:
PcRelativeFixups(HGraph* graph, CodeGenerator* codegen, OptimizingCompilerStats* stats)
- : HOptimization(graph, "pc_relative_fixups_mips", stats),
+ : HOptimization(graph, kPcRelativeFixupsMipsPassName, stats),
codegen_(codegen) {}
static constexpr const char* kPcRelativeFixupsMipsPassName = "pc_relative_fixups_mips";
diff --git a/compiler/optimizing/scheduler.h b/compiler/optimizing/scheduler.h
index a6e1603..bb7c353 100644
--- a/compiler/optimizing/scheduler.h
+++ b/compiler/optimizing/scheduler.h
@@ -495,8 +495,11 @@
class HInstructionScheduling : public HOptimization {
public:
- HInstructionScheduling(HGraph* graph, InstructionSet instruction_set, CodeGenerator* cg = nullptr)
- : HOptimization(graph, kInstructionScheduling),
+ HInstructionScheduling(HGraph* graph,
+ InstructionSet instruction_set,
+ CodeGenerator* cg = nullptr,
+ const char* name = kInstructionSchedulingPassName)
+ : HOptimization(graph, name),
codegen_(cg),
instruction_set_(instruction_set) {}
@@ -505,7 +508,7 @@
}
void Run(bool only_optimize_loop_blocks, bool schedule_randomly);
- static constexpr const char* kInstructionScheduling = "scheduler";
+ static constexpr const char* kInstructionSchedulingPassName = "scheduler";
private:
CodeGenerator* const codegen_;
diff --git a/compiler/optimizing/select_generator.cc b/compiler/optimizing/select_generator.cc
index 77ec9a6..66e5142 100644
--- a/compiler/optimizing/select_generator.cc
+++ b/compiler/optimizing/select_generator.cc
@@ -24,8 +24,9 @@
HSelectGenerator::HSelectGenerator(HGraph* graph,
VariableSizedHandleScope* handles,
- OptimizingCompilerStats* stats)
- : HOptimization(graph, kSelectGeneratorPassName, stats),
+ OptimizingCompilerStats* stats,
+ const char* name)
+ : HOptimization(graph, name, stats),
handle_scope_(handles) {
}
diff --git a/compiler/optimizing/select_generator.h b/compiler/optimizing/select_generator.h
index f8cf00e..bda57fd 100644
--- a/compiler/optimizing/select_generator.h
+++ b/compiler/optimizing/select_generator.h
@@ -65,7 +65,8 @@
public:
HSelectGenerator(HGraph* graph,
VariableSizedHandleScope* handles,
- OptimizingCompilerStats* stats);
+ OptimizingCompilerStats* stats,
+ const char* name = kSelectGeneratorPassName);
void Run() OVERRIDE;
diff --git a/compiler/optimizing/sharpening.h b/compiler/optimizing/sharpening.h
index f74b0af..bb1954e 100644
--- a/compiler/optimizing/sharpening.h
+++ b/compiler/optimizing/sharpening.h
@@ -36,8 +36,9 @@
CodeGenerator* codegen,
const DexCompilationUnit& compilation_unit,
CompilerDriver* compiler_driver,
- VariableSizedHandleScope* handles)
- : HOptimization(graph, kSharpeningPassName),
+ VariableSizedHandleScope* handles,
+ const char* name = kSharpeningPassName)
+ : HOptimization(graph, name),
codegen_(codegen),
compilation_unit_(compilation_unit),
compiler_driver_(compiler_driver),