Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 17 | #include "optimizing_compiler.h" |
| 18 | |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 19 | #include <fstream> |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 20 | #include <stdint.h> |
| 21 | |
Mingyao Yang | f384f88 | 2014-10-22 16:08:18 -0700 | [diff] [blame] | 22 | #include "bounds_check_elimination.h" |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 23 | #include "builder.h" |
| 24 | #include "code_generator.h" |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 25 | #include "compiler.h" |
Roland Levillain | 75be283 | 2014-10-17 17:02:00 +0100 | [diff] [blame] | 26 | #include "constant_folding.h" |
| 27 | #include "dead_code_elimination.h" |
Andreas Gampe | 71fb52f | 2014-12-29 17:43:08 -0800 | [diff] [blame] | 28 | #include "dex/quick/dex_file_to_method_inliner_map.h" |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 29 | #include "driver/compiler_driver.h" |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 30 | #include "driver/dex_compilation_unit.h" |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 31 | #include "elf_writer_quick.h" |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 32 | #include "graph_visualizer.h" |
Nicolas Geoffray | d31cf3d | 2014-09-08 17:30:24 +0100 | [diff] [blame] | 33 | #include "gvn.h" |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 34 | #include "inliner.h" |
Nicolas Geoffray | 3c04974 | 2014-09-24 18:10:46 +0100 | [diff] [blame] | 35 | #include "instruction_simplifier.h" |
Andreas Gampe | 71fb52f | 2014-12-29 17:43:08 -0800 | [diff] [blame] | 36 | #include "intrinsics.h" |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 37 | #include "jni/quick/jni_compiler.h" |
| 38 | #include "mirror/art_method-inl.h" |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 39 | #include "nodes.h" |
Nicolas Geoffray | 26a25ef | 2014-09-30 13:54:09 +0100 | [diff] [blame] | 40 | #include "prepare_for_register_allocation.h" |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 41 | #include "register_allocator.h" |
Nicolas Geoffray | 827eedb | 2015-01-26 15:18:36 +0000 | [diff] [blame] | 42 | #include "side_effects_analysis.h" |
Nicolas Geoffray | 3159674 | 2014-11-24 15:28:45 +0000 | [diff] [blame] | 43 | #include "ssa_builder.h" |
Nicolas Geoffray | 7dc206a | 2014-07-11 09:49:49 +0100 | [diff] [blame] | 44 | #include "ssa_phi_elimination.h" |
Nicolas Geoffray | 804d093 | 2014-05-02 08:46:00 +0100 | [diff] [blame] | 45 | #include "ssa_liveness_analysis.h" |
Calin Juravle | 10e244f | 2015-01-26 18:54:32 +0000 | [diff] [blame^] | 46 | #include "reference_type_propagation.h" |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 47 | #include "utils/arena_allocator.h" |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 48 | |
| 49 | namespace art { |
| 50 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 51 | /** |
| 52 | * Used by the code generator, to allocate the code in a vector. |
| 53 | */ |
| 54 | class CodeVectorAllocator FINAL : public CodeAllocator { |
| 55 | public: |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 56 | CodeVectorAllocator() {} |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 57 | |
| 58 | virtual uint8_t* Allocate(size_t size) { |
| 59 | size_ = size; |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 60 | memory_.resize(size); |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 61 | return &memory_[0]; |
| 62 | } |
| 63 | |
| 64 | size_t GetSize() const { return size_; } |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 65 | const std::vector<uint8_t>& GetMemory() const { return memory_; } |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 66 | |
| 67 | private: |
| 68 | std::vector<uint8_t> memory_; |
| 69 | size_t size_; |
| 70 | |
| 71 | DISALLOW_COPY_AND_ASSIGN(CodeVectorAllocator); |
| 72 | }; |
| 73 | |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 74 | /** |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 75 | * Filter to apply to the visualizer. Methods whose name contain that filter will |
David Brazdil | ee690a3 | 2014-12-01 17:04:16 +0000 | [diff] [blame] | 76 | * be dumped. |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 77 | */ |
| 78 | static const char* kStringFilter = ""; |
| 79 | |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 80 | class OptimizingCompiler FINAL : public Compiler { |
| 81 | public: |
| 82 | explicit OptimizingCompiler(CompilerDriver* driver); |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 83 | ~OptimizingCompiler(); |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 84 | |
| 85 | bool CanCompileMethod(uint32_t method_idx, const DexFile& dex_file, CompilationUnit* cu) const |
| 86 | OVERRIDE; |
| 87 | |
| 88 | CompiledMethod* Compile(const DexFile::CodeItem* code_item, |
| 89 | uint32_t access_flags, |
| 90 | InvokeType invoke_type, |
| 91 | uint16_t class_def_idx, |
| 92 | uint32_t method_idx, |
| 93 | jobject class_loader, |
| 94 | const DexFile& dex_file) const OVERRIDE; |
| 95 | |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 96 | CompiledMethod* JniCompile(uint32_t access_flags, |
| 97 | uint32_t method_idx, |
| 98 | const DexFile& dex_file) const OVERRIDE; |
| 99 | |
| 100 | uintptr_t GetEntryPointOf(mirror::ArtMethod* method) const OVERRIDE |
| 101 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 102 | |
| 103 | bool WriteElf(art::File* file, |
| 104 | OatWriter* oat_writer, |
| 105 | const std::vector<const art::DexFile*>& dex_files, |
| 106 | const std::string& android_root, |
| 107 | bool is_host) const OVERRIDE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 108 | |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 109 | void InitCompilationUnit(CompilationUnit& cu ATTRIBUTE_UNUSED) const OVERRIDE {} |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 110 | |
David Brazdil | ee690a3 | 2014-12-01 17:04:16 +0000 | [diff] [blame] | 111 | void Init() OVERRIDE; |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 112 | |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 113 | void UnInit() const OVERRIDE {} |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 114 | |
| 115 | private: |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 116 | // Whether we should run any optimization or register allocation. If false, will |
| 117 | // just run the code generation after the graph was built. |
| 118 | const bool run_optimizations_; |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 119 | |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 120 | // Optimize and compile `graph`. |
| 121 | CompiledMethod* CompileOptimized(HGraph* graph, |
| 122 | CodeGenerator* codegen, |
| 123 | CompilerDriver* driver, |
| 124 | const DexCompilationUnit& dex_compilation_unit, |
| 125 | const HGraphVisualizer& visualizer) const; |
| 126 | |
| 127 | // Just compile without doing optimizations. |
| 128 | CompiledMethod* CompileBaseline(CodeGenerator* codegen, |
| 129 | CompilerDriver* driver, |
| 130 | const DexCompilationUnit& dex_compilation_unit) const; |
| 131 | |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 132 | mutable OptimizingCompilerStats compilation_stats_; |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 133 | |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 134 | std::unique_ptr<std::ostream> visualizer_output_; |
| 135 | |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 136 | DISALLOW_COPY_AND_ASSIGN(OptimizingCompiler); |
| 137 | }; |
| 138 | |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 139 | static const int kMaximumCompilationTimeBeforeWarning = 100; /* ms */ |
| 140 | |
| 141 | OptimizingCompiler::OptimizingCompiler(CompilerDriver* driver) |
| 142 | : Compiler(driver, kMaximumCompilationTimeBeforeWarning), |
| 143 | run_optimizations_( |
| 144 | driver->GetCompilerOptions().GetCompilerFilter() != CompilerOptions::kTime), |
David Brazdil | ee690a3 | 2014-12-01 17:04:16 +0000 | [diff] [blame] | 145 | compilation_stats_() {} |
| 146 | |
| 147 | void OptimizingCompiler::Init() { |
| 148 | // Enable C1visualizer output. Must be done in Init() because the compiler |
| 149 | // driver is not fully initialized when passed to the compiler's constructor. |
| 150 | CompilerDriver* driver = GetCompilerDriver(); |
David Brazdil | 866c031 | 2015-01-13 21:21:31 +0000 | [diff] [blame] | 151 | const std::string cfg_file_name = driver->GetDumpCfgFileName(); |
| 152 | if (!cfg_file_name.empty()) { |
David Brazdil | ee690a3 | 2014-12-01 17:04:16 +0000 | [diff] [blame] | 153 | CHECK_EQ(driver->GetThreadCount(), 1U) |
| 154 | << "Graph visualizer requires the compiler to run single-threaded. " |
| 155 | << "Invoke the compiler with '-j1'."; |
David Brazdil | 866c031 | 2015-01-13 21:21:31 +0000 | [diff] [blame] | 156 | visualizer_output_.reset(new std::ofstream(cfg_file_name)); |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 157 | } |
| 158 | } |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 159 | |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 160 | OptimizingCompiler::~OptimizingCompiler() { |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 161 | compilation_stats_.Log(); |
Nicolas Geoffray | 88157ef | 2014-09-12 10:29:53 +0100 | [diff] [blame] | 162 | } |
| 163 | |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 164 | bool OptimizingCompiler::CanCompileMethod(uint32_t method_idx ATTRIBUTE_UNUSED, |
| 165 | const DexFile& dex_file ATTRIBUTE_UNUSED, |
| 166 | CompilationUnit* cu ATTRIBUTE_UNUSED) const { |
| 167 | return true; |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 168 | } |
| 169 | |
| 170 | CompiledMethod* OptimizingCompiler::JniCompile(uint32_t access_flags, |
| 171 | uint32_t method_idx, |
| 172 | const DexFile& dex_file) const { |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 173 | return ArtQuickJniCompileMethod(GetCompilerDriver(), access_flags, method_idx, dex_file); |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | uintptr_t OptimizingCompiler::GetEntryPointOf(mirror::ArtMethod* method) const { |
Nicolas Geoffray | 4179cc1 | 2014-11-19 08:35:17 +0000 | [diff] [blame] | 177 | return reinterpret_cast<uintptr_t>(method->GetEntryPointFromQuickCompiledCodePtrSize( |
| 178 | InstructionSetPointerSize(GetCompilerDriver()->GetInstructionSet()))); |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | bool OptimizingCompiler::WriteElf(art::File* file, OatWriter* oat_writer, |
| 182 | const std::vector<const art::DexFile*>& dex_files, |
| 183 | const std::string& android_root, bool is_host) const { |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 184 | return art::ElfWriterQuick32::Create(file, oat_writer, dex_files, android_root, is_host, |
| 185 | *GetCompilerDriver()); |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 188 | static bool IsInstructionSetSupported(InstructionSet instruction_set) { |
| 189 | return instruction_set == kArm64 |
| 190 | || (instruction_set == kThumb2 && !kArm32QuickCodeUseSoftFloat) |
| 191 | || instruction_set == kX86 |
| 192 | || instruction_set == kX86_64; |
| 193 | } |
| 194 | |
Nicolas Geoffray | de58ab2 | 2014-11-05 12:46:03 +0000 | [diff] [blame] | 195 | static bool CanOptimize(const DexFile::CodeItem& code_item) { |
| 196 | // TODO: We currently cannot optimize methods with try/catch. |
| 197 | return code_item.tries_size_ == 0; |
| 198 | } |
| 199 | |
Calin Juravle | 10e244f | 2015-01-26 18:54:32 +0000 | [diff] [blame^] | 200 | static void RunOptimizations(HOptimization* optimizations[], |
| 201 | size_t length, |
| 202 | const HGraphVisualizer& visualizer) { |
| 203 | for (size_t i = 0; i < length; ++i) { |
| 204 | HOptimization* optimization = optimizations[i]; |
| 205 | visualizer.DumpGraph(optimization->GetPassName(), /*is_after=*/false); |
| 206 | optimization->Run(); |
| 207 | visualizer.DumpGraph(optimization->GetPassName(), /*is_after=*/true); |
| 208 | optimization->Check(); |
| 209 | } |
| 210 | } |
| 211 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 212 | static void RunOptimizations(HGraph* graph, |
| 213 | CompilerDriver* driver, |
| 214 | OptimizingCompilerStats* stats, |
| 215 | const DexCompilationUnit& dex_compilation_unit, |
| 216 | const HGraphVisualizer& visualizer) { |
| 217 | SsaRedundantPhiElimination redundant_phi(graph); |
| 218 | SsaDeadPhiElimination dead_phi(graph); |
| 219 | HDeadCodeElimination dce(graph); |
Nicolas Geoffray | 9ee6618 | 2015-01-16 12:35:40 +0000 | [diff] [blame] | 220 | HConstantFolding fold1(graph); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 221 | InstructionSimplifier simplify1(graph); |
| 222 | |
| 223 | HInliner inliner(graph, dex_compilation_unit, driver, stats); |
| 224 | |
Nicolas Geoffray | 9ee6618 | 2015-01-16 12:35:40 +0000 | [diff] [blame] | 225 | HConstantFolding fold2(graph); |
Nicolas Geoffray | 86dde16 | 2015-01-26 12:54:33 +0000 | [diff] [blame] | 226 | SideEffectsAnalysis side_effects(graph); |
| 227 | GVNOptimization gvn(graph, side_effects); |
Mingyao Yang | f384f88 | 2014-10-22 16:08:18 -0700 | [diff] [blame] | 228 | BoundsCheckElimination bce(graph); |
Calin Juravle | 10e244f | 2015-01-26 18:54:32 +0000 | [diff] [blame^] | 229 | ReferenceTypePropagation type_propagation(graph); |
| 230 | InstructionSimplifier simplify2(graph, "instruction_simplifier_after_types"); |
Nicolas Geoffray | 5e6916c | 2014-11-18 16:53:35 +0000 | [diff] [blame] | 231 | |
Andreas Gampe | 71fb52f | 2014-12-29 17:43:08 -0800 | [diff] [blame] | 232 | IntrinsicsRecognizer intrinsics(graph, dex_compilation_unit.GetDexFile(), driver); |
| 233 | |
Nicolas Geoffray | 3159674 | 2014-11-24 15:28:45 +0000 | [diff] [blame] | 234 | HOptimization* optimizations[] = { |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 235 | &redundant_phi, |
| 236 | &dead_phi, |
Andreas Gampe | 71fb52f | 2014-12-29 17:43:08 -0800 | [diff] [blame] | 237 | &intrinsics, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 238 | &dce, |
Nicolas Geoffray | 9ee6618 | 2015-01-16 12:35:40 +0000 | [diff] [blame] | 239 | &fold1, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 240 | &simplify1, |
| 241 | &inliner, |
Nicolas Geoffray | 9ee6618 | 2015-01-16 12:35:40 +0000 | [diff] [blame] | 242 | &fold2, |
Nicolas Geoffray | 86dde16 | 2015-01-26 12:54:33 +0000 | [diff] [blame] | 243 | &side_effects, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 244 | &gvn, |
Mingyao Yang | f384f88 | 2014-10-22 16:08:18 -0700 | [diff] [blame] | 245 | &bce, |
Calin Juravle | 10e244f | 2015-01-26 18:54:32 +0000 | [diff] [blame^] | 246 | &type_propagation, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 247 | &simplify2 |
Nicolas Geoffray | 3159674 | 2014-11-24 15:28:45 +0000 | [diff] [blame] | 248 | }; |
Nicolas Geoffray | 5e6916c | 2014-11-18 16:53:35 +0000 | [diff] [blame] | 249 | |
Calin Juravle | 10e244f | 2015-01-26 18:54:32 +0000 | [diff] [blame^] | 250 | RunOptimizations(optimizations, arraysize(optimizations), visualizer); |
Nicolas Geoffray | 5e6916c | 2014-11-18 16:53:35 +0000 | [diff] [blame] | 251 | } |
| 252 | |
Nicolas Geoffray | 376b2bb | 2014-12-09 14:26:32 +0000 | [diff] [blame] | 253 | // The stack map we generate must be 4-byte aligned on ARM. Since existing |
| 254 | // maps are generated alongside these stack maps, we must also align them. |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 255 | static ArrayRef<const uint8_t> AlignVectorSize(std::vector<uint8_t>& vector) { |
Nicolas Geoffray | 376b2bb | 2014-12-09 14:26:32 +0000 | [diff] [blame] | 256 | size_t size = vector.size(); |
| 257 | size_t aligned_size = RoundUp(size, 4); |
| 258 | for (; size < aligned_size; ++size) { |
| 259 | vector.push_back(0); |
| 260 | } |
Andreas Gampe | e21dc3d | 2014-12-08 16:59:43 -0800 | [diff] [blame] | 261 | return ArrayRef<const uint8_t>(vector); |
Nicolas Geoffray | 376b2bb | 2014-12-09 14:26:32 +0000 | [diff] [blame] | 262 | } |
| 263 | |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 264 | |
| 265 | CompiledMethod* OptimizingCompiler::CompileOptimized(HGraph* graph, |
| 266 | CodeGenerator* codegen, |
| 267 | CompilerDriver* compiler_driver, |
| 268 | const DexCompilationUnit& dex_compilation_unit, |
| 269 | const HGraphVisualizer& visualizer) const { |
| 270 | RunOptimizations( |
| 271 | graph, compiler_driver, &compilation_stats_, dex_compilation_unit, visualizer); |
| 272 | |
| 273 | PrepareForRegisterAllocation(graph).Run(); |
| 274 | SsaLivenessAnalysis liveness(*graph, codegen); |
| 275 | liveness.Analyze(); |
| 276 | visualizer.DumpGraph(kLivenessPassName); |
| 277 | |
| 278 | RegisterAllocator register_allocator(graph->GetArena(), codegen, liveness); |
| 279 | register_allocator.AllocateRegisters(); |
| 280 | visualizer.DumpGraph(kRegisterAllocatorPassName); |
| 281 | |
| 282 | CodeVectorAllocator allocator; |
| 283 | codegen->CompileOptimized(&allocator); |
| 284 | |
| 285 | std::vector<uint8_t> stack_map; |
| 286 | codegen->BuildStackMaps(&stack_map); |
| 287 | |
| 288 | compilation_stats_.RecordStat(MethodCompilationStat::kCompiledOptimized); |
| 289 | |
| 290 | return CompiledMethod::SwapAllocCompiledMethodStackMap( |
| 291 | compiler_driver, |
| 292 | codegen->GetInstructionSet(), |
| 293 | ArrayRef<const uint8_t>(allocator.GetMemory()), |
| 294 | codegen->GetFrameSize(), |
| 295 | codegen->GetCoreSpillMask(), |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 296 | codegen->GetFpuSpillMask(), |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 297 | ArrayRef<const uint8_t>(stack_map)); |
| 298 | } |
| 299 | |
| 300 | |
| 301 | CompiledMethod* OptimizingCompiler::CompileBaseline( |
| 302 | CodeGenerator* codegen, |
| 303 | CompilerDriver* compiler_driver, |
| 304 | const DexCompilationUnit& dex_compilation_unit) const { |
| 305 | CodeVectorAllocator allocator; |
| 306 | codegen->CompileBaseline(&allocator); |
| 307 | |
| 308 | std::vector<uint8_t> mapping_table; |
| 309 | DefaultSrcMap src_mapping_table; |
| 310 | bool include_debug_symbol = compiler_driver->GetCompilerOptions().GetIncludeDebugSymbols(); |
| 311 | codegen->BuildMappingTable(&mapping_table, include_debug_symbol ? &src_mapping_table : nullptr); |
| 312 | std::vector<uint8_t> vmap_table; |
| 313 | codegen->BuildVMapTable(&vmap_table); |
| 314 | std::vector<uint8_t> gc_map; |
| 315 | codegen->BuildNativeGCMap(&gc_map, dex_compilation_unit); |
| 316 | |
| 317 | compilation_stats_.RecordStat(MethodCompilationStat::kCompiledBaseline); |
| 318 | return CompiledMethod::SwapAllocCompiledMethod(compiler_driver, |
| 319 | codegen->GetInstructionSet(), |
| 320 | ArrayRef<const uint8_t>(allocator.GetMemory()), |
| 321 | codegen->GetFrameSize(), |
| 322 | codegen->GetCoreSpillMask(), |
Nicolas Geoffray | d97dc40 | 2015-01-22 13:50:01 +0000 | [diff] [blame] | 323 | codegen->GetFpuSpillMask(), |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 324 | &src_mapping_table, |
| 325 | AlignVectorSize(mapping_table), |
| 326 | AlignVectorSize(vmap_table), |
| 327 | AlignVectorSize(gc_map), |
| 328 | ArrayRef<const uint8_t>()); |
| 329 | } |
| 330 | |
Nicolas Geoffray | e2dc6fa | 2014-11-17 12:55:12 +0000 | [diff] [blame] | 331 | CompiledMethod* OptimizingCompiler::Compile(const DexFile::CodeItem* code_item, |
| 332 | uint32_t access_flags, |
| 333 | InvokeType invoke_type, |
| 334 | uint16_t class_def_idx, |
| 335 | uint32_t method_idx, |
| 336 | jobject class_loader, |
| 337 | const DexFile& dex_file) const { |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 338 | UNUSED(invoke_type); |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 339 | compilation_stats_.RecordStat(MethodCompilationStat::kAttemptCompilation); |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 340 | CompilerDriver* compiler_driver = GetCompilerDriver(); |
| 341 | InstructionSet instruction_set = compiler_driver->GetInstructionSet(); |
Nicolas Geoffray | 8d48673 | 2014-07-16 16:23:40 +0100 | [diff] [blame] | 342 | // Always use the thumb2 assembler: some runtime functionality (like implicit stack |
| 343 | // overflow checks) assume thumb2. |
| 344 | if (instruction_set == kArm) { |
| 345 | instruction_set = kThumb2; |
Nicolas Geoffray | 8fb5ce3 | 2014-07-04 09:43:26 +0100 | [diff] [blame] | 346 | } |
| 347 | |
| 348 | // Do not attempt to compile on architectures we do not support. |
Nicolas Geoffray | 1ba0f59 | 2014-10-27 15:14:55 +0000 | [diff] [blame] | 349 | if (!IsInstructionSetSupported(instruction_set)) { |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 350 | compilation_stats_.RecordStat(MethodCompilationStat::kNotCompiledUnsupportedIsa); |
Nicolas Geoffray | 8fb5ce3 | 2014-07-04 09:43:26 +0100 | [diff] [blame] | 351 | return nullptr; |
| 352 | } |
| 353 | |
Nicolas Geoffray | b5f62b3 | 2014-10-30 10:58:41 +0000 | [diff] [blame] | 354 | if (Compiler::IsPathologicalCase(*code_item, method_idx, dex_file)) { |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 355 | compilation_stats_.RecordStat(MethodCompilationStat::kNotCompiledPathological); |
Nicolas Geoffray | b5f62b3 | 2014-10-30 10:58:41 +0000 | [diff] [blame] | 356 | return nullptr; |
| 357 | } |
| 358 | |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 359 | DexCompilationUnit dex_compilation_unit( |
| 360 | nullptr, class_loader, art::Runtime::Current()->GetClassLinker(), dex_file, code_item, |
Ian Rogers | 72d3262 | 2014-05-06 16:20:11 -0700 | [diff] [blame] | 361 | class_def_idx, method_idx, access_flags, |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 362 | compiler_driver->GetVerifiedMethod(&dex_file, method_idx)); |
Nicolas Geoffray | 92cf83e | 2014-03-18 17:59:20 +0000 | [diff] [blame] | 363 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 364 | std::string method_name = PrettyMethod(method_idx, dex_file); |
| 365 | |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 366 | // For testing purposes, we put a special marker on method names that should be compiled |
| 367 | // with this compiler. This makes sure we're not regressing. |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 368 | bool shouldCompile = method_name.find("$opt$") != std::string::npos; |
| 369 | bool shouldOptimize = method_name.find("$opt$reg$") != std::string::npos; |
Nicolas Geoffray | 8ccc3f5 | 2014-03-19 10:34:11 +0000 | [diff] [blame] | 370 | |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 371 | ArenaPool pool; |
| 372 | ArenaAllocator arena(&pool); |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 373 | HGraphBuilder builder(&arena, |
| 374 | &dex_compilation_unit, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 375 | &dex_compilation_unit, |
| 376 | &dex_file, |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 377 | compiler_driver, |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 378 | &compilation_stats_); |
Nicolas Geoffray | f635e63 | 2014-05-14 09:43:38 +0100 | [diff] [blame] | 379 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 380 | VLOG(compiler) << "Building " << PrettyMethod(method_idx, dex_file); |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 381 | HGraph* graph = builder.BuildGraph(*code_item); |
| 382 | if (graph == nullptr) { |
Zheng Xu | 5667fdb | 2014-10-23 18:29:55 +0800 | [diff] [blame] | 383 | CHECK(!shouldCompile) << "Could not build graph in optimizing compiler"; |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 384 | return nullptr; |
| 385 | } |
| 386 | |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 387 | std::unique_ptr<CodeGenerator> codegen( |
Calin Juravle | cd6dffe | 2015-01-08 17:35:35 +0000 | [diff] [blame] | 388 | CodeGenerator::Create(graph, |
| 389 | instruction_set, |
| 390 | *compiler_driver->GetInstructionSetFeatures(), |
| 391 | compiler_driver->GetCompilerOptions())); |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 392 | if (codegen.get() == nullptr) { |
Zheng Xu | 5667fdb | 2014-10-23 18:29:55 +0800 | [diff] [blame] | 393 | CHECK(!shouldCompile) << "Could not find code generator for optimizing compiler"; |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 394 | compilation_stats_.RecordStat(MethodCompilationStat::kNotCompiledNoCodegen); |
Nicolas Geoffray | 787c307 | 2014-03-17 10:20:19 +0000 | [diff] [blame] | 395 | return nullptr; |
| 396 | } |
| 397 | |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 398 | HGraphVisualizer visualizer( |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 399 | visualizer_output_.get(), graph, kStringFilter, *codegen.get(), method_name.c_str()); |
Nicolas Geoffray | a7062e0 | 2014-05-22 12:50:17 +0100 | [diff] [blame] | 400 | visualizer.DumpGraph("builder"); |
| 401 | |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 402 | bool can_optimize = CanOptimize(*code_item); |
| 403 | bool can_allocate_registers = RegisterAllocator::CanAllocateRegistersFor(*graph, instruction_set); |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 404 | CompiledMethod* result = nullptr; |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 405 | if (run_optimizations_ && can_optimize && can_allocate_registers) { |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 406 | VLOG(compiler) << "Optimizing " << PrettyMethod(method_idx, dex_file); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 407 | if (!graph->TryBuildingSsa()) { |
| 408 | LOG(INFO) << "Skipping compilation of " |
| 409 | << PrettyMethod(method_idx, dex_file) |
| 410 | << ": it contains a non natural loop"; |
Nicolas Geoffray | f537012 | 2014-12-02 11:51:19 +0000 | [diff] [blame] | 411 | // We could not transform the graph to SSA, bailout. |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 412 | compilation_stats_.RecordStat(MethodCompilationStat::kNotCompiledCannotBuildSSA); |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 413 | } else { |
| 414 | result = CompileOptimized(graph, codegen.get(), compiler_driver, dex_compilation_unit, visualizer); |
Nicolas Geoffray | f537012 | 2014-12-02 11:51:19 +0000 | [diff] [blame] | 415 | } |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 416 | } else if (shouldOptimize && RegisterAllocator::Supports(instruction_set)) { |
| 417 | LOG(FATAL) << "Could not allocate registers in optimizing compiler"; |
Zheng Xu | 5667fdb | 2014-10-23 18:29:55 +0800 | [diff] [blame] | 418 | UNREACHABLE(); |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 419 | } else { |
Nicolas Geoffray | 43a539f | 2014-12-02 10:19:51 +0000 | [diff] [blame] | 420 | VLOG(compiler) << "Compile baseline " << PrettyMethod(method_idx, dex_file); |
Calin Juravle | 48c2b03 | 2014-12-09 18:11:36 +0000 | [diff] [blame] | 421 | |
| 422 | if (!run_optimizations_) { |
| 423 | compilation_stats_.RecordStat(MethodCompilationStat::kNotOptimizedDisabled); |
| 424 | } else if (!can_optimize) { |
| 425 | compilation_stats_.RecordStat(MethodCompilationStat::kNotOptimizedTryCatch); |
| 426 | } else if (!can_allocate_registers) { |
| 427 | compilation_stats_.RecordStat(MethodCompilationStat::kNotOptimizedRegisterAllocator); |
| 428 | } |
| 429 | |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 430 | result = CompileBaseline(codegen.get(), compiler_driver, dex_compilation_unit); |
Nicolas Geoffray | 86dbb9a | 2014-06-04 11:12:39 +0100 | [diff] [blame] | 431 | } |
Nicolas Geoffray | 12df9eb | 2015-01-09 14:53:50 +0000 | [diff] [blame] | 432 | return result; |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 433 | } |
| 434 | |
Andreas Gampe | 53c913b | 2014-08-12 23:19:23 -0700 | [diff] [blame] | 435 | Compiler* CreateOptimizingCompiler(CompilerDriver* driver) { |
| 436 | return new OptimizingCompiler(driver); |
| 437 | } |
| 438 | |
Nicolas Geoffray | b34f69a | 2014-03-07 15:28:39 +0000 | [diff] [blame] | 439 | } // namespace art |