Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +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 | |
| 17 | #include "inliner.h" |
| 18 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 19 | #include "art_method-inl.h" |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 20 | #include "builder.h" |
| 21 | #include "class_linker.h" |
| 22 | #include "constant_folding.h" |
| 23 | #include "dead_code_elimination.h" |
| 24 | #include "driver/compiler_driver-inl.h" |
Calin Juravle | ec74835 | 2015-07-29 13:52:12 +0100 | [diff] [blame] | 25 | #include "driver/compiler_options.h" |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 26 | #include "driver/dex_compilation_unit.h" |
| 27 | #include "instruction_simplifier.h" |
Scott Wakeling | d60a1af | 2015-07-22 14:32:44 +0100 | [diff] [blame] | 28 | #include "intrinsics.h" |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 29 | #include "mirror/class_loader.h" |
| 30 | #include "mirror/dex_cache.h" |
| 31 | #include "nodes.h" |
Nicolas Geoffray | 335005e | 2015-06-25 10:01:47 +0100 | [diff] [blame] | 32 | #include "optimizing_compiler.h" |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 33 | #include "reference_type_propagation.h" |
Nicolas Geoffray | 259136f | 2014-12-17 23:21:58 +0000 | [diff] [blame] | 34 | #include "register_allocator.h" |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 35 | #include "ssa_phi_elimination.h" |
| 36 | #include "scoped_thread_state_change.h" |
| 37 | #include "thread.h" |
Calin Juravle | f1c6d9e | 2015-04-13 18:42:21 +0100 | [diff] [blame] | 38 | #include "dex/verified_method.h" |
| 39 | #include "dex/verification_results.h" |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 40 | |
| 41 | namespace art { |
| 42 | |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 43 | static constexpr size_t kMaximumNumberOfHInstructions = 12; |
| 44 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 45 | void HInliner::Run() { |
Nicolas Geoffray | e50b8d2 | 2015-03-13 08:57:42 +0000 | [diff] [blame] | 46 | if (graph_->IsDebuggable()) { |
| 47 | // For simplicity, we currently never inline when the graph is debuggable. This avoids |
| 48 | // doing some logic in the runtime to discover if a method could have been inlined. |
| 49 | return; |
| 50 | } |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 51 | const GrowableArray<HBasicBlock*>& blocks = graph_->GetReversePostOrder(); |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 52 | HBasicBlock* next_block = blocks.Get(0); |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 53 | for (size_t i = 0; i < blocks.Size(); ++i) { |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 54 | // Because we are changing the graph when inlining, we need to remember the next block. |
| 55 | // This avoids doing the inlining work again on the inlined blocks. |
| 56 | if (blocks.Get(i) != next_block) { |
| 57 | continue; |
| 58 | } |
| 59 | HBasicBlock* block = next_block; |
| 60 | next_block = (i == blocks.Size() - 1) ? nullptr : blocks.Get(i + 1); |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 61 | for (HInstruction* instruction = block->GetFirstInstruction(); instruction != nullptr;) { |
| 62 | HInstruction* next = instruction->GetNext(); |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 63 | HInvoke* call = instruction->AsInvoke(); |
Razvan A Lupusoru | 3e90a96 | 2015-03-27 13:44:44 -0700 | [diff] [blame] | 64 | // As long as the call is not intrinsified, it is worth trying to inline. |
| 65 | if (call != nullptr && call->GetIntrinsic() == Intrinsics::kNone) { |
Nicolas Geoffray | 7904129 | 2015-03-26 10:05:54 +0000 | [diff] [blame] | 66 | // We use the original invoke type to ensure the resolution of the called method |
| 67 | // works properly. |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 68 | if (!TryInline(call)) { |
Nicolas Geoffray | 335005e | 2015-06-25 10:01:47 +0100 | [diff] [blame] | 69 | if (kIsDebugBuild && IsCompilingWithCoreImage()) { |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 70 | std::string callee_name = |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 71 | PrettyMethod(call->GetDexMethodIndex(), *outer_compilation_unit_.GetDexFile()); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 72 | bool should_inline = callee_name.find("$inline$") != std::string::npos; |
| 73 | CHECK(!should_inline) << "Could not inline " << callee_name; |
| 74 | } |
Guillaume "Vermeille" Sanchez | e918d38 | 2015-06-03 15:32:41 +0100 | [diff] [blame] | 75 | } else { |
Nicolas Geoffray | 335005e | 2015-06-25 10:01:47 +0100 | [diff] [blame] | 76 | if (kIsDebugBuild && IsCompilingWithCoreImage()) { |
Guillaume "Vermeille" Sanchez | e918d38 | 2015-06-03 15:32:41 +0100 | [diff] [blame] | 77 | std::string callee_name = |
| 78 | PrettyMethod(call->GetDexMethodIndex(), *outer_compilation_unit_.GetDexFile()); |
| 79 | bool must_not_inline = callee_name.find("$noinline$") != std::string::npos; |
| 80 | CHECK(!must_not_inline) << "Should not have inlined " << callee_name; |
| 81 | } |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 82 | } |
| 83 | } |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 84 | instruction = next; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 85 | } |
| 86 | } |
| 87 | } |
| 88 | |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 89 | static bool IsMethodOrDeclaringClassFinal(ArtMethod* method) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 90 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 91 | return method->IsFinal() || method->GetDeclaringClass()->IsFinal(); |
| 92 | } |
| 93 | |
| 94 | /** |
| 95 | * Given the `resolved_method` looked up in the dex cache, try to find |
| 96 | * the actual runtime target of an interface or virtual call. |
| 97 | * Return nullptr if the runtime target cannot be proven. |
| 98 | */ |
| 99 | static ArtMethod* FindVirtualOrInterfaceTarget(HInvoke* invoke, ArtMethod* resolved_method) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 100 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 101 | if (IsMethodOrDeclaringClassFinal(resolved_method)) { |
| 102 | // No need to lookup further, the resolved method will be the target. |
| 103 | return resolved_method; |
| 104 | } |
| 105 | |
| 106 | HInstruction* receiver = invoke->InputAt(0); |
| 107 | if (receiver->IsNullCheck()) { |
| 108 | // Due to multiple levels of inlining within the same pass, it might be that |
| 109 | // null check does not have the reference type of the actual receiver. |
| 110 | receiver = receiver->InputAt(0); |
| 111 | } |
| 112 | ReferenceTypeInfo info = receiver->GetReferenceTypeInfo(); |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 113 | DCHECK(info.IsValid()) << "Invalid RTI for " << receiver->DebugName(); |
| 114 | if (!info.IsExact()) { |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 115 | // We currently only support inlining with known receivers. |
| 116 | // TODO: Remove this check, we should be able to inline final methods |
| 117 | // on unknown receivers. |
| 118 | return nullptr; |
| 119 | } else if (info.GetTypeHandle()->IsInterface()) { |
| 120 | // Statically knowing that the receiver has an interface type cannot |
| 121 | // help us find what is the target method. |
| 122 | return nullptr; |
| 123 | } else if (!resolved_method->GetDeclaringClass()->IsAssignableFrom(info.GetTypeHandle().Get())) { |
| 124 | // The method that we're trying to call is not in the receiver's class or super classes. |
| 125 | return nullptr; |
| 126 | } |
| 127 | |
| 128 | ClassLinker* cl = Runtime::Current()->GetClassLinker(); |
| 129 | size_t pointer_size = cl->GetImagePointerSize(); |
| 130 | if (invoke->IsInvokeInterface()) { |
| 131 | resolved_method = info.GetTypeHandle()->FindVirtualMethodForInterface( |
| 132 | resolved_method, pointer_size); |
| 133 | } else { |
| 134 | DCHECK(invoke->IsInvokeVirtual()); |
| 135 | resolved_method = info.GetTypeHandle()->FindVirtualMethodForVirtual( |
| 136 | resolved_method, pointer_size); |
| 137 | } |
| 138 | |
| 139 | if (resolved_method == nullptr) { |
| 140 | // The information we had on the receiver was not enough to find |
| 141 | // the target method. Since we check above the exact type of the receiver, |
| 142 | // the only reason this can happen is an IncompatibleClassChangeError. |
| 143 | return nullptr; |
| 144 | } else if (resolved_method->IsAbstract()) { |
| 145 | // The information we had on the receiver was not enough to find |
| 146 | // the target method. Since we check above the exact type of the receiver, |
| 147 | // the only reason this can happen is an IncompatibleClassChangeError. |
| 148 | return nullptr; |
| 149 | } else if (IsMethodOrDeclaringClassFinal(resolved_method)) { |
| 150 | // A final method has to be the target method. |
| 151 | return resolved_method; |
| 152 | } else if (info.IsExact()) { |
| 153 | // If we found a method and the receiver's concrete type is statically |
| 154 | // known, we know for sure the target. |
| 155 | return resolved_method; |
| 156 | } else { |
| 157 | // Even if we did find a method, the receiver type was not enough to |
| 158 | // statically find the runtime target. |
| 159 | return nullptr; |
| 160 | } |
| 161 | } |
| 162 | |
| 163 | static uint32_t FindMethodIndexIn(ArtMethod* method, |
| 164 | const DexFile& dex_file, |
| 165 | uint32_t referrer_index) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 166 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 167 | if (method->GetDexFile()->GetLocation().compare(dex_file.GetLocation()) == 0) { |
| 168 | return method->GetDexMethodIndex(); |
| 169 | } else { |
| 170 | return method->FindDexMethodIndexInOtherDexFile(dex_file, referrer_index); |
| 171 | } |
| 172 | } |
| 173 | |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 174 | bool HInliner::TryInline(HInvoke* invoke_instruction) { |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 175 | uint32_t method_index = invoke_instruction->GetDexMethodIndex(); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 176 | ScopedObjectAccess soa(Thread::Current()); |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 177 | const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile(); |
| 178 | VLOG(compiler) << "Try inlining " << PrettyMethod(method_index, caller_dex_file); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 179 | |
Nicolas Geoffray | 3507105 | 2015-06-09 15:43:38 +0100 | [diff] [blame] | 180 | ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker(); |
| 181 | // We can query the dex cache directly. The verifier has populated it already. |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 182 | ArtMethod* resolved_method; |
| 183 | if (invoke_instruction->IsInvokeStaticOrDirect()) { |
| 184 | MethodReference ref = invoke_instruction->AsInvokeStaticOrDirect()->GetTargetMethod(); |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 185 | mirror::DexCache* const dex_cache = (&caller_dex_file == ref.dex_file) |
| 186 | ? caller_compilation_unit_.GetDexCache().Get() |
| 187 | : class_linker->FindDexCache(soa.Self(), *ref.dex_file); |
| 188 | resolved_method = dex_cache->GetResolvedMethod( |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 189 | ref.dex_method_index, class_linker->GetImagePointerSize()); |
| 190 | } else { |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 191 | resolved_method = caller_compilation_unit_.GetDexCache().Get()->GetResolvedMethod( |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 192 | method_index, class_linker->GetImagePointerSize()); |
| 193 | } |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 194 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 195 | if (resolved_method == nullptr) { |
Nicolas Geoffray | 3507105 | 2015-06-09 15:43:38 +0100 | [diff] [blame] | 196 | // Method cannot be resolved if it is in another dex file we do not have access to. |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 197 | VLOG(compiler) << "Method cannot be resolved " << PrettyMethod(method_index, caller_dex_file); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 198 | return false; |
| 199 | } |
| 200 | |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 201 | if (!invoke_instruction->IsInvokeStaticOrDirect()) { |
| 202 | resolved_method = FindVirtualOrInterfaceTarget(invoke_instruction, resolved_method); |
| 203 | if (resolved_method == nullptr) { |
| 204 | VLOG(compiler) << "Interface or virtual call to " |
| 205 | << PrettyMethod(method_index, caller_dex_file) |
| 206 | << " could not be statically determined"; |
| 207 | return false; |
| 208 | } |
| 209 | // We have found a method, but we need to find where that method is for the caller's |
| 210 | // dex file. |
| 211 | method_index = FindMethodIndexIn(resolved_method, caller_dex_file, method_index); |
| 212 | if (method_index == DexFile::kDexNoIndex) { |
| 213 | VLOG(compiler) << "Interface or virtual call to " |
| 214 | << PrettyMethod(resolved_method) |
| 215 | << " cannot be inlined because unaccessible to caller"; |
| 216 | return false; |
| 217 | } |
| 218 | } |
| 219 | |
Vladimir Marko | 5815501 | 2015-08-19 12:49:41 +0000 | [diff] [blame] | 220 | bool same_dex_file = |
| 221 | IsSameDexFile(*outer_compilation_unit_.GetDexFile(), *resolved_method->GetDexFile()); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 222 | |
| 223 | const DexFile::CodeItem* code_item = resolved_method->GetCodeItem(); |
| 224 | |
| 225 | if (code_item == nullptr) { |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 226 | VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 227 | << " is not inlined because it is native"; |
| 228 | return false; |
| 229 | } |
| 230 | |
Calin Juravle | ec74835 | 2015-07-29 13:52:12 +0100 | [diff] [blame] | 231 | size_t inline_max_code_units = compiler_driver_->GetCompilerOptions().GetInlineMaxCodeUnits(); |
| 232 | if (code_item->insns_size_in_code_units_ > inline_max_code_units) { |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 233 | VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 234 | << " is too big to inline"; |
| 235 | return false; |
| 236 | } |
| 237 | |
| 238 | if (code_item->tries_size_ != 0) { |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 239 | VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 240 | << " is not inlined because of try block"; |
| 241 | return false; |
| 242 | } |
| 243 | |
Calin Juravle | f1c6d9e | 2015-04-13 18:42:21 +0100 | [diff] [blame] | 244 | uint16_t class_def_idx = resolved_method->GetDeclaringClass()->GetDexClassDefIndex(); |
| 245 | if (!compiler_driver_->IsMethodVerifiedWithoutFailures( |
| 246 | resolved_method->GetDexMethodIndex(), class_def_idx, *resolved_method->GetDexFile())) { |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 247 | VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file) |
Calin Juravle | f1c6d9e | 2015-04-13 18:42:21 +0100 | [diff] [blame] | 248 | << " couldn't be verified, so it cannot be inlined"; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 249 | return false; |
| 250 | } |
| 251 | |
Roland Levillain | 4c0eb42 | 2015-04-24 16:43:49 +0100 | [diff] [blame] | 252 | if (invoke_instruction->IsInvokeStaticOrDirect() && |
| 253 | invoke_instruction->AsInvokeStaticOrDirect()->IsStaticWithImplicitClinitCheck()) { |
| 254 | // Case of a static method that cannot be inlined because it implicitly |
| 255 | // requires an initialization check of its declaring class. |
| 256 | VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file) |
| 257 | << " is not inlined because it is static and requires a clinit" |
| 258 | << " check that cannot be emitted due to Dex cache limitations"; |
| 259 | return false; |
| 260 | } |
| 261 | |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 262 | if (!TryBuildAndInline(resolved_method, invoke_instruction, same_dex_file)) { |
Nicolas Geoffray | c0365b1 | 2015-03-18 18:31:52 +0000 | [diff] [blame] | 263 | return false; |
| 264 | } |
| 265 | |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 266 | VLOG(compiler) << "Successfully inlined " << PrettyMethod(method_index, caller_dex_file); |
Nicolas Geoffray | c0365b1 | 2015-03-18 18:31:52 +0000 | [diff] [blame] | 267 | MaybeRecordStat(kInlinedInvoke); |
| 268 | return true; |
| 269 | } |
| 270 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 271 | bool HInliner::TryBuildAndInline(ArtMethod* resolved_method, |
Nicolas Geoffray | c0365b1 | 2015-03-18 18:31:52 +0000 | [diff] [blame] | 272 | HInvoke* invoke_instruction, |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 273 | bool same_dex_file) { |
Nicolas Geoffray | c0365b1 | 2015-03-18 18:31:52 +0000 | [diff] [blame] | 274 | ScopedObjectAccess soa(Thread::Current()); |
| 275 | const DexFile::CodeItem* code_item = resolved_method->GetCodeItem(); |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 276 | const DexFile& callee_dex_file = *resolved_method->GetDexFile(); |
| 277 | uint32_t method_index = resolved_method->GetDexMethodIndex(); |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 278 | ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker(); |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 279 | Handle<mirror::DexCache> dex_cache(handles_->NewHandle(resolved_method->GetDexCache())); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 280 | DexCompilationUnit dex_compilation_unit( |
| 281 | nullptr, |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 282 | caller_compilation_unit_.GetClassLoader(), |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 283 | class_linker, |
Nicolas Geoffray | 8dbf0cf | 2015-08-11 02:14:38 +0000 | [diff] [blame] | 284 | callee_dex_file, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 285 | code_item, |
| 286 | resolved_method->GetDeclaringClass()->GetDexClassDefIndex(), |
Nicolas Geoffray | 8dbf0cf | 2015-08-11 02:14:38 +0000 | [diff] [blame] | 287 | method_index, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 288 | resolved_method->GetAccessFlags(), |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 289 | compiler_driver_->GetVerifiedMethod(&callee_dex_file, method_index), |
| 290 | dex_cache); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 291 | |
Calin Juravle | 3cd4fc8 | 2015-05-14 15:15:42 +0100 | [diff] [blame] | 292 | bool requires_ctor_barrier = false; |
| 293 | |
| 294 | if (dex_compilation_unit.IsConstructor()) { |
| 295 | // If it's a super invocation and we already generate a barrier there's no need |
| 296 | // to generate another one. |
| 297 | // We identify super calls by looking at the "this" pointer. If its value is the |
| 298 | // same as the local "this" pointer then we must have a super invocation. |
| 299 | bool is_super_invocation = invoke_instruction->InputAt(0)->IsParameterValue() |
| 300 | && invoke_instruction->InputAt(0)->AsParameterValue()->IsThis(); |
| 301 | if (is_super_invocation && graph_->ShouldGenerateConstructorBarrier()) { |
| 302 | requires_ctor_barrier = false; |
| 303 | } else { |
| 304 | Thread* self = Thread::Current(); |
| 305 | requires_ctor_barrier = compiler_driver_->RequiresConstructorBarrier(self, |
| 306 | dex_compilation_unit.GetDexFile(), |
| 307 | dex_compilation_unit.GetClassDefIndex()); |
| 308 | } |
| 309 | } |
| 310 | |
Nicolas Geoffray | 3507105 | 2015-06-09 15:43:38 +0100 | [diff] [blame] | 311 | InvokeType invoke_type = invoke_instruction->GetOriginalInvokeType(); |
| 312 | if (invoke_type == kInterface) { |
| 313 | // We have statically resolved the dispatch. To please the class linker |
| 314 | // at runtime, we change this call as if it was a virtual call. |
| 315 | invoke_type = kVirtual; |
| 316 | } |
Nicolas Geoffray | e0fe7ae | 2015-03-09 10:02:49 +0000 | [diff] [blame] | 317 | HGraph* callee_graph = new (graph_->GetArena()) HGraph( |
Nicolas Geoffray | 0a23d74 | 2015-05-07 11:57:35 +0100 | [diff] [blame] | 318 | graph_->GetArena(), |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 319 | callee_dex_file, |
Nicolas Geoffray | 0a23d74 | 2015-05-07 11:57:35 +0100 | [diff] [blame] | 320 | method_index, |
Calin Juravle | 3cd4fc8 | 2015-05-14 15:15:42 +0100 | [diff] [blame] | 321 | requires_ctor_barrier, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 322 | compiler_driver_->GetInstructionSet(), |
Nicolas Geoffray | 3507105 | 2015-06-09 15:43:38 +0100 | [diff] [blame] | 323 | invoke_type, |
Nicolas Geoffray | 0a23d74 | 2015-05-07 11:57:35 +0100 | [diff] [blame] | 324 | graph_->IsDebuggable(), |
| 325 | graph_->GetCurrentInstructionId()); |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 326 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 327 | OptimizingCompilerStats inline_stats; |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 328 | HGraphBuilder builder(callee_graph, |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 329 | &dex_compilation_unit, |
| 330 | &outer_compilation_unit_, |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 331 | resolved_method->GetDexFile(), |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 332 | compiler_driver_, |
Nicolas Geoffray | 9523a3e | 2015-07-17 11:51:28 +0000 | [diff] [blame] | 333 | &inline_stats, |
Mathieu Chartier | 736b560 | 2015-09-02 14:54:11 -0700 | [diff] [blame] | 334 | resolved_method->GetQuickenedInfo(), |
| 335 | dex_cache); |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 336 | |
David Brazdil | 5e8b137 | 2015-01-23 14:39:08 +0000 | [diff] [blame] | 337 | if (!builder.BuildGraph(*code_item)) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 338 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 339 | << " could not be built, so cannot be inlined"; |
| 340 | return false; |
| 341 | } |
| 342 | |
Nicolas Geoffray | 259136f | 2014-12-17 23:21:58 +0000 | [diff] [blame] | 343 | if (!RegisterAllocator::CanAllocateRegistersFor(*callee_graph, |
| 344 | compiler_driver_->GetInstructionSet())) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 345 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | 259136f | 2014-12-17 23:21:58 +0000 | [diff] [blame] | 346 | << " cannot be inlined because of the register allocator"; |
| 347 | return false; |
| 348 | } |
| 349 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 350 | if (!callee_graph->TryBuildingSsa()) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 351 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 352 | << " could not be transformed to SSA"; |
| 353 | return false; |
| 354 | } |
| 355 | |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 356 | size_t parameter_index = 0; |
| 357 | for (HInstructionIterator instructions(callee_graph->GetEntryBlock()->GetInstructions()); |
| 358 | !instructions.Done(); |
| 359 | instructions.Advance()) { |
| 360 | HInstruction* current = instructions.Current(); |
| 361 | if (current->IsParameterValue()) { |
| 362 | HInstruction* argument = invoke_instruction->InputAt(parameter_index++); |
| 363 | if (argument->IsNullConstant()) { |
| 364 | current->ReplaceWith(callee_graph->GetNullConstant()); |
| 365 | } else if (argument->IsIntConstant()) { |
| 366 | current->ReplaceWith(callee_graph->GetIntConstant(argument->AsIntConstant()->GetValue())); |
| 367 | } else if (argument->IsLongConstant()) { |
| 368 | current->ReplaceWith(callee_graph->GetLongConstant(argument->AsLongConstant()->GetValue())); |
| 369 | } else if (argument->IsFloatConstant()) { |
| 370 | current->ReplaceWith( |
| 371 | callee_graph->GetFloatConstant(argument->AsFloatConstant()->GetValue())); |
| 372 | } else if (argument->IsDoubleConstant()) { |
| 373 | current->ReplaceWith( |
| 374 | callee_graph->GetDoubleConstant(argument->AsDoubleConstant()->GetValue())); |
| 375 | } else if (argument->GetType() == Primitive::kPrimNot) { |
| 376 | current->SetReferenceTypeInfo(argument->GetReferenceTypeInfo()); |
| 377 | current->AsParameterValue()->SetCanBeNull(argument->CanBeNull()); |
| 378 | } |
| 379 | } |
| 380 | } |
| 381 | |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 382 | // Run simple optimizations on the graph. |
Calin Juravle | 7a9c885 | 2015-04-21 14:07:50 +0100 | [diff] [blame] | 383 | HDeadCodeElimination dce(callee_graph, stats_); |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 384 | HConstantFolding fold(callee_graph); |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 385 | ReferenceTypePropagation type_propagation(callee_graph, handles_); |
Calin Juravle | acf735c | 2015-02-12 15:25:22 +0000 | [diff] [blame] | 386 | InstructionSimplifier simplify(callee_graph, stats_); |
Scott Wakeling | d60a1af | 2015-07-22 14:32:44 +0100 | [diff] [blame] | 387 | IntrinsicsRecognizer intrinsics(callee_graph, compiler_driver_); |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 388 | |
| 389 | HOptimization* optimizations[] = { |
Scott Wakeling | d60a1af | 2015-07-22 14:32:44 +0100 | [diff] [blame] | 390 | &intrinsics, |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 391 | &type_propagation, |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 392 | &simplify, |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 393 | &dce, |
| 394 | &fold, |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 395 | }; |
| 396 | |
| 397 | for (size_t i = 0; i < arraysize(optimizations); ++i) { |
| 398 | HOptimization* optimization = optimizations[i]; |
| 399 | optimization->Run(); |
| 400 | } |
| 401 | |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 402 | size_t number_of_instructions_budget = kMaximumNumberOfHInstructions; |
Calin Juravle | ec74835 | 2015-07-29 13:52:12 +0100 | [diff] [blame] | 403 | if (depth_ + 1 < compiler_driver_->GetCompilerOptions().GetInlineDepthLimit()) { |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 404 | HInliner inliner(callee_graph, |
| 405 | outer_compilation_unit_, |
| 406 | dex_compilation_unit, |
| 407 | compiler_driver_, |
Nicolas Geoffray | 454a481 | 2015-06-09 10:37:32 +0100 | [diff] [blame] | 408 | handles_, |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 409 | stats_, |
| 410 | depth_ + 1); |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 411 | inliner.Run(); |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 412 | number_of_instructions_budget += inliner.number_of_inlined_instructions_; |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 413 | } |
| 414 | |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 415 | // TODO: We should abort only if all predecessors throw. However, |
| 416 | // HGraph::InlineInto currently does not handle an exit block with |
| 417 | // a throw predecessor. |
| 418 | HBasicBlock* exit_block = callee_graph->GetExitBlock(); |
| 419 | if (exit_block == nullptr) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 420 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 421 | << " could not be inlined because it has an infinite loop"; |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 422 | return false; |
| 423 | } |
| 424 | |
| 425 | bool has_throw_predecessor = false; |
Vladimir Marko | 6058455 | 2015-09-03 13:35:12 +0000 | [diff] [blame] | 426 | for (HBasicBlock* predecessor : exit_block->GetPredecessors()) { |
| 427 | if (predecessor->GetLastInstruction()->IsThrow()) { |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 428 | has_throw_predecessor = true; |
| 429 | break; |
| 430 | } |
| 431 | } |
| 432 | if (has_throw_predecessor) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 433 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 434 | << " could not be inlined because one branch always throws"; |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 435 | return false; |
| 436 | } |
| 437 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 438 | HReversePostOrderIterator it(*callee_graph); |
Nicolas Geoffray | ef87c5d | 2015-01-30 12:41:14 +0000 | [diff] [blame] | 439 | it.Advance(); // Past the entry block, it does not contain instructions that prevent inlining. |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 440 | size_t number_of_instructions = 0; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 441 | for (; !it.Done(); it.Advance()) { |
| 442 | HBasicBlock* block = it.Current(); |
| 443 | if (block->IsLoopHeader()) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 444 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 445 | << " could not be inlined because it contains a loop"; |
| 446 | return false; |
| 447 | } |
| 448 | |
| 449 | for (HInstructionIterator instr_it(block->GetInstructions()); |
| 450 | !instr_it.Done(); |
| 451 | instr_it.Advance()) { |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 452 | if (number_of_instructions++ == number_of_instructions_budget) { |
| 453 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
| 454 | << " could not be inlined because it is too big."; |
| 455 | return false; |
| 456 | } |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 457 | HInstruction* current = instr_it.Current(); |
Nicolas Geoffray | 276d9da | 2015-02-02 18:24:11 +0000 | [diff] [blame] | 458 | |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 459 | if (current->IsInvokeInterface()) { |
| 460 | // Disable inlining of interface calls. The cost in case of entering the |
| 461 | // resolution conflict is currently too high. |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 462 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 463 | << " could not be inlined because it has an interface call."; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 464 | return false; |
| 465 | } |
| 466 | |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 467 | if (!same_dex_file && current->NeedsEnvironment()) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 468 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 469 | << " could not be inlined because " << current->DebugName() |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 470 | << " needs an environment and is in a different dex file"; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 471 | return false; |
| 472 | } |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 473 | |
Nicolas Geoffray | d23eeef | 2015-05-18 22:31:29 +0100 | [diff] [blame] | 474 | if (!same_dex_file && current->NeedsDexCache()) { |
Guillaume "Vermeille" Sanchez | ae09d2d | 2015-05-29 10:52:55 +0100 | [diff] [blame] | 475 | VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file) |
Nicolas Geoffray | 9437b78 | 2015-03-25 10:08:51 +0000 | [diff] [blame] | 476 | << " could not be inlined because " << current->DebugName() |
| 477 | << " it is in a different dex file and requires access to the dex cache"; |
| 478 | return false; |
| 479 | } |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 480 | } |
| 481 | } |
Nicolas Geoffray | e418dda | 2015-08-11 20:03:09 -0700 | [diff] [blame] | 482 | number_of_inlined_instructions_ += number_of_instructions; |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 483 | |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 484 | HInstruction* return_replacement = callee_graph->InlineInto(graph_, invoke_instruction); |
| 485 | |
| 486 | // When merging the graph we might create a new NullConstant in the caller graph which does |
| 487 | // not have the chance to be typed. We assign the correct type here so that we can keep the |
| 488 | // assertion that every reference has a valid type. This also simplifies checks along the way. |
| 489 | HNullConstant* null_constant = graph_->GetNullConstant(); |
| 490 | if (!null_constant->GetReferenceTypeInfo().IsValid()) { |
| 491 | ReferenceTypeInfo::TypeHandle obj_handle = |
| 492 | handles_->NewHandle(class_linker->GetClassRoot(ClassLinker::kJavaLangObject)); |
| 493 | null_constant->SetReferenceTypeInfo( |
| 494 | ReferenceTypeInfo::Create(obj_handle, false /* is_exact */)); |
| 495 | } |
| 496 | |
| 497 | if ((return_replacement != nullptr) |
| 498 | && (return_replacement->GetType() == Primitive::kPrimNot)) { |
| 499 | if (!return_replacement->GetReferenceTypeInfo().IsValid()) { |
| 500 | // Make sure that we have a valid type for the return. We may get an invalid one when |
| 501 | // we inline invokes with multiple branches and create a Phi for the result. |
| 502 | // TODO: we could be more precise by merging the phi inputs but that requires |
| 503 | // some functionality from the reference type propagation. |
| 504 | DCHECK(return_replacement->IsPhi()); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 505 | size_t pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 506 | ReferenceTypeInfo::TypeHandle return_handle = |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 507 | handles_->NewHandle(resolved_method->GetReturnType(true /* resolve */, pointer_size)); |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 508 | return_replacement->SetReferenceTypeInfo(ReferenceTypeInfo::Create( |
David Brazdil | baf89b8 | 2015-09-15 11:36:54 +0100 | [diff] [blame^] | 509 | return_handle, return_handle->CannotBeAssignedFromOtherTypes() /* is_exact */)); |
Calin Juravle | 2e76830 | 2015-07-28 14:41:11 +0000 | [diff] [blame] | 510 | } |
| 511 | } |
Nicolas Geoffray | 7c5367b | 2014-12-17 10:13:46 +0000 | [diff] [blame] | 512 | |
Nicolas Geoffray | e53798a | 2014-12-01 10:31:54 +0000 | [diff] [blame] | 513 | return true; |
| 514 | } |
| 515 | |
| 516 | } // namespace art |