blob: 8ee04dd39676a0e49b3e7d87fb75095f836bb9f8 [file] [log] [blame]
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001/*
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 Chartiere401d142015-04-22 13:56:20 -070019#include "art_method-inl.h"
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000020#include "builder.h"
21#include "class_linker.h"
22#include "constant_folding.h"
23#include "dead_code_elimination.h"
Vladimir Markobe10e8e2016-01-22 12:09:44 +000024#include "dex/verified_method.h"
25#include "dex/verification_results.h"
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000026#include "driver/compiler_driver-inl.h"
Calin Juravleec748352015-07-29 13:52:12 +010027#include "driver/compiler_options.h"
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000028#include "driver/dex_compilation_unit.h"
29#include "instruction_simplifier.h"
Scott Wakelingd60a1af2015-07-22 14:32:44 +010030#include "intrinsics.h"
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +000031#include "jit/jit.h"
32#include "jit/jit_code_cache.h"
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000033#include "mirror/class_loader.h"
34#include "mirror/dex_cache.h"
35#include "nodes.h"
Nicolas Geoffray335005e2015-06-25 10:01:47 +010036#include "optimizing_compiler.h"
Nicolas Geoffray454a4812015-06-09 10:37:32 +010037#include "reference_type_propagation.h"
Nicolas Geoffray259136f2014-12-17 23:21:58 +000038#include "register_allocator.h"
Vladimir Markobe10e8e2016-01-22 12:09:44 +000039#include "quick/inline_method_analyser.h"
Vladimir Markodc151b22015-10-15 18:02:30 +010040#include "sharpening.h"
David Brazdil4833f5a2015-12-16 10:37:39 +000041#include "ssa_builder.h"
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000042#include "ssa_phi_elimination.h"
43#include "scoped_thread_state_change.h"
44#include "thread.h"
45
46namespace art {
47
Nicolas Geoffray5949fa02015-12-18 10:57:10 +000048static constexpr size_t kMaximumNumberOfHInstructions = 32;
49
50// Limit the number of dex registers that we accumulate while inlining
51// to avoid creating large amount of nested environments.
52static constexpr size_t kMaximumNumberOfCumulatedDexRegisters = 64;
53
54// Avoid inlining within a huge method due to memory pressure.
55static constexpr size_t kMaximumCodeUnitSize = 4096;
Nicolas Geoffraye418dda2015-08-11 20:03:09 -070056
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000057void HInliner::Run() {
Calin Juravle8f96df82015-07-29 15:58:48 +010058 const CompilerOptions& compiler_options = compiler_driver_->GetCompilerOptions();
59 if ((compiler_options.GetInlineDepthLimit() == 0)
60 || (compiler_options.GetInlineMaxCodeUnits() == 0)) {
61 return;
62 }
Nicolas Geoffray5949fa02015-12-18 10:57:10 +000063 if (caller_compilation_unit_.GetCodeItem()->insns_size_in_code_units_ > kMaximumCodeUnitSize) {
64 return;
65 }
Nicolas Geoffraye50b8d22015-03-13 08:57:42 +000066 if (graph_->IsDebuggable()) {
67 // For simplicity, we currently never inline when the graph is debuggable. This avoids
68 // doing some logic in the runtime to discover if a method could have been inlined.
69 return;
70 }
Vladimir Markofa6b93c2015-09-15 10:15:55 +010071 const ArenaVector<HBasicBlock*>& blocks = graph_->GetReversePostOrder();
72 DCHECK(!blocks.empty());
73 HBasicBlock* next_block = blocks[0];
74 for (size_t i = 0; i < blocks.size(); ++i) {
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +010075 // Because we are changing the graph when inlining, we need to remember the next block.
76 // This avoids doing the inlining work again on the inlined blocks.
Vladimir Markofa6b93c2015-09-15 10:15:55 +010077 if (blocks[i] != next_block) {
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +010078 continue;
79 }
80 HBasicBlock* block = next_block;
Vladimir Markofa6b93c2015-09-15 10:15:55 +010081 next_block = (i == blocks.size() - 1) ? nullptr : blocks[i + 1];
Nicolas Geoffrayef87c5d2015-01-30 12:41:14 +000082 for (HInstruction* instruction = block->GetFirstInstruction(); instruction != nullptr;) {
83 HInstruction* next = instruction->GetNext();
Nicolas Geoffray454a4812015-06-09 10:37:32 +010084 HInvoke* call = instruction->AsInvoke();
Razvan A Lupusoru3e90a962015-03-27 13:44:44 -070085 // As long as the call is not intrinsified, it is worth trying to inline.
86 if (call != nullptr && call->GetIntrinsic() == Intrinsics::kNone) {
Nicolas Geoffray79041292015-03-26 10:05:54 +000087 // We use the original invoke type to ensure the resolution of the called method
88 // works properly.
Vladimir Marko58155012015-08-19 12:49:41 +000089 if (!TryInline(call)) {
Nicolas Geoffray335005e2015-06-25 10:01:47 +010090 if (kIsDebugBuild && IsCompilingWithCoreImage()) {
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000091 std::string callee_name =
Nicolas Geoffrayef87c5d2015-01-30 12:41:14 +000092 PrettyMethod(call->GetDexMethodIndex(), *outer_compilation_unit_.GetDexFile());
Nicolas Geoffraye53798a2014-12-01 10:31:54 +000093 bool should_inline = callee_name.find("$inline$") != std::string::npos;
94 CHECK(!should_inline) << "Could not inline " << callee_name;
95 }
Guillaume "Vermeille" Sancheze918d382015-06-03 15:32:41 +010096 } else {
Nicolas Geoffray335005e2015-06-25 10:01:47 +010097 if (kIsDebugBuild && IsCompilingWithCoreImage()) {
Guillaume "Vermeille" Sancheze918d382015-06-03 15:32:41 +010098 std::string callee_name =
99 PrettyMethod(call->GetDexMethodIndex(), *outer_compilation_unit_.GetDexFile());
100 bool must_not_inline = callee_name.find("$noinline$") != std::string::npos;
101 CHECK(!must_not_inline) << "Should not have inlined " << callee_name;
102 }
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000103 }
104 }
Nicolas Geoffrayef87c5d2015-01-30 12:41:14 +0000105 instruction = next;
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000106 }
107 }
108}
109
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100110static bool IsMethodOrDeclaringClassFinal(ArtMethod* method)
Mathieu Chartier90443472015-07-16 20:32:27 -0700111 SHARED_REQUIRES(Locks::mutator_lock_) {
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100112 return method->IsFinal() || method->GetDeclaringClass()->IsFinal();
113}
114
115/**
116 * Given the `resolved_method` looked up in the dex cache, try to find
117 * the actual runtime target of an interface or virtual call.
118 * Return nullptr if the runtime target cannot be proven.
119 */
120static ArtMethod* FindVirtualOrInterfaceTarget(HInvoke* invoke, ArtMethod* resolved_method)
Mathieu Chartier90443472015-07-16 20:32:27 -0700121 SHARED_REQUIRES(Locks::mutator_lock_) {
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100122 if (IsMethodOrDeclaringClassFinal(resolved_method)) {
123 // No need to lookup further, the resolved method will be the target.
124 return resolved_method;
125 }
126
127 HInstruction* receiver = invoke->InputAt(0);
128 if (receiver->IsNullCheck()) {
129 // Due to multiple levels of inlining within the same pass, it might be that
130 // null check does not have the reference type of the actual receiver.
131 receiver = receiver->InputAt(0);
132 }
133 ReferenceTypeInfo info = receiver->GetReferenceTypeInfo();
Calin Juravle2e768302015-07-28 14:41:11 +0000134 DCHECK(info.IsValid()) << "Invalid RTI for " << receiver->DebugName();
135 if (!info.IsExact()) {
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100136 // We currently only support inlining with known receivers.
137 // TODO: Remove this check, we should be able to inline final methods
138 // on unknown receivers.
139 return nullptr;
140 } else if (info.GetTypeHandle()->IsInterface()) {
141 // Statically knowing that the receiver has an interface type cannot
142 // help us find what is the target method.
143 return nullptr;
144 } else if (!resolved_method->GetDeclaringClass()->IsAssignableFrom(info.GetTypeHandle().Get())) {
145 // The method that we're trying to call is not in the receiver's class or super classes.
146 return nullptr;
Nicolas Geoffrayab5327d2016-03-18 11:36:20 +0000147 } else if (info.GetTypeHandle()->IsErroneous()) {
148 // If the type is erroneous, do not go further, as we are going to query the vtable or
149 // imt table, that we can only safely do on non-erroneous classes.
150 return nullptr;
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100151 }
152
153 ClassLinker* cl = Runtime::Current()->GetClassLinker();
154 size_t pointer_size = cl->GetImagePointerSize();
155 if (invoke->IsInvokeInterface()) {
156 resolved_method = info.GetTypeHandle()->FindVirtualMethodForInterface(
157 resolved_method, pointer_size);
158 } else {
159 DCHECK(invoke->IsInvokeVirtual());
160 resolved_method = info.GetTypeHandle()->FindVirtualMethodForVirtual(
161 resolved_method, pointer_size);
162 }
163
164 if (resolved_method == nullptr) {
165 // The information we had on the receiver was not enough to find
166 // the target method. Since we check above the exact type of the receiver,
167 // the only reason this can happen is an IncompatibleClassChangeError.
168 return nullptr;
Alex Light9139e002015-10-09 15:59:48 -0700169 } else if (!resolved_method->IsInvokable()) {
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100170 // The information we had on the receiver was not enough to find
171 // the target method. Since we check above the exact type of the receiver,
172 // the only reason this can happen is an IncompatibleClassChangeError.
173 return nullptr;
174 } else if (IsMethodOrDeclaringClassFinal(resolved_method)) {
175 // A final method has to be the target method.
176 return resolved_method;
177 } else if (info.IsExact()) {
178 // If we found a method and the receiver's concrete type is statically
179 // known, we know for sure the target.
180 return resolved_method;
181 } else {
182 // Even if we did find a method, the receiver type was not enough to
183 // statically find the runtime target.
184 return nullptr;
185 }
186}
187
188static uint32_t FindMethodIndexIn(ArtMethod* method,
189 const DexFile& dex_file,
190 uint32_t referrer_index)
Mathieu Chartier90443472015-07-16 20:32:27 -0700191 SHARED_REQUIRES(Locks::mutator_lock_) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100192 if (IsSameDexFile(*method->GetDexFile(), dex_file)) {
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100193 return method->GetDexMethodIndex();
194 } else {
195 return method->FindDexMethodIndexInOtherDexFile(dex_file, referrer_index);
196 }
197}
198
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000199static uint32_t FindClassIndexIn(mirror::Class* cls,
200 const DexFile& dex_file,
201 Handle<mirror::DexCache> dex_cache)
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100202 SHARED_REQUIRES(Locks::mutator_lock_) {
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000203 uint32_t index = DexFile::kDexNoIndex;
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100204 if (cls->GetDexCache() == nullptr) {
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000205 DCHECK(cls->IsArrayClass()) << PrettyClass(cls);
206 index = cls->FindTypeIndexInOtherDexFile(dex_file);
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100207 } else if (cls->GetDexTypeIndex() == DexFile::kDexNoIndex16) {
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000208 DCHECK(cls->IsProxyClass()) << PrettyClass(cls);
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100209 // TODO: deal with proxy classes.
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100210 } else if (IsSameDexFile(cls->GetDexFile(), dex_file)) {
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000211 index = cls->GetDexTypeIndex();
212 } else {
213 index = cls->FindTypeIndexInOtherDexFile(dex_file);
214 }
215
216 if (index != DexFile::kDexNoIndex) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100217 // Update the dex cache to ensure the class is in. The generated code will
218 // consider it is. We make it safe by updating the dex cache, as other
219 // dex files might also load the class, and there is no guarantee the dex
220 // cache of the dex file of the class will be updated.
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000221 if (dex_cache->GetResolvedType(index) == nullptr) {
222 dex_cache->SetResolvedType(index, cls);
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100223 }
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100224 }
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000225
226 return index;
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100227}
228
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000229class ScopedProfilingInfoInlineUse {
230 public:
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000231 explicit ScopedProfilingInfoInlineUse(ArtMethod* method, Thread* self)
232 : method_(method),
233 self_(self),
234 // Fetch the profiling info ahead of using it. If it's null when fetching,
235 // we should not call JitCodeCache::DoneInlining.
236 profiling_info_(
237 Runtime::Current()->GetJit()->GetCodeCache()->NotifyCompilerUse(method, self)) {
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000238 }
239
240 ~ScopedProfilingInfoInlineUse() {
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000241 if (profiling_info_ != nullptr) {
242 size_t pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
243 DCHECK_EQ(profiling_info_, method_->GetProfilingInfo(pointer_size));
244 Runtime::Current()->GetJit()->GetCodeCache()->DoneCompilerUse(method_, self_);
245 }
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000246 }
247
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000248 ProfilingInfo* GetProfilingInfo() const { return profiling_info_; }
249
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000250 private:
251 ArtMethod* const method_;
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000252 Thread* const self_;
253 ProfilingInfo* const profiling_info_;
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000254};
255
Nicolas Geoffraye418dda2015-08-11 20:03:09 -0700256bool HInliner::TryInline(HInvoke* invoke_instruction) {
Calin Juravle175dc732015-08-25 15:42:32 +0100257 if (invoke_instruction->IsInvokeUnresolved()) {
258 return false; // Don't bother to move further if we know the method is unresolved.
259 }
260
Vladimir Marko58155012015-08-19 12:49:41 +0000261 uint32_t method_index = invoke_instruction->GetDexMethodIndex();
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000262 ScopedObjectAccess soa(Thread::Current());
Nicolas Geoffray9437b782015-03-25 10:08:51 +0000263 const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
264 VLOG(compiler) << "Try inlining " << PrettyMethod(method_index, caller_dex_file);
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000265
Nicolas Geoffray35071052015-06-09 15:43:38 +0100266 ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
267 // We can query the dex cache directly. The verifier has populated it already.
Vladimir Marko58155012015-08-19 12:49:41 +0000268 ArtMethod* resolved_method;
Andreas Gampefd2140f2015-12-23 16:30:44 -0800269 ArtMethod* actual_method = nullptr;
Vladimir Marko58155012015-08-19 12:49:41 +0000270 if (invoke_instruction->IsInvokeStaticOrDirect()) {
Nicolas Geoffraye5234232015-12-02 09:06:11 +0000271 if (invoke_instruction->AsInvokeStaticOrDirect()->IsStringInit()) {
272 VLOG(compiler) << "Not inlining a String.<init> method";
273 return false;
274 }
Vladimir Marko58155012015-08-19 12:49:41 +0000275 MethodReference ref = invoke_instruction->AsInvokeStaticOrDirect()->GetTargetMethod();
Mathieu Chartier736b5602015-09-02 14:54:11 -0700276 mirror::DexCache* const dex_cache = (&caller_dex_file == ref.dex_file)
277 ? caller_compilation_unit_.GetDexCache().Get()
278 : class_linker->FindDexCache(soa.Self(), *ref.dex_file);
279 resolved_method = dex_cache->GetResolvedMethod(
Vladimir Marko58155012015-08-19 12:49:41 +0000280 ref.dex_method_index, class_linker->GetImagePointerSize());
Andreas Gampefd2140f2015-12-23 16:30:44 -0800281 // actual_method == resolved_method for direct or static calls.
282 actual_method = resolved_method;
Vladimir Marko58155012015-08-19 12:49:41 +0000283 } else {
Mathieu Chartier736b5602015-09-02 14:54:11 -0700284 resolved_method = caller_compilation_unit_.GetDexCache().Get()->GetResolvedMethod(
Vladimir Marko58155012015-08-19 12:49:41 +0000285 method_index, class_linker->GetImagePointerSize());
Andreas Gampefd2140f2015-12-23 16:30:44 -0800286 if (resolved_method != nullptr) {
287 // Check if we can statically find the method.
288 actual_method = FindVirtualOrInterfaceTarget(invoke_instruction, resolved_method);
289 }
Vladimir Marko58155012015-08-19 12:49:41 +0000290 }
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000291
Mathieu Chartiere401d142015-04-22 13:56:20 -0700292 if (resolved_method == nullptr) {
Calin Juravle175dc732015-08-25 15:42:32 +0100293 // TODO: Can this still happen?
Nicolas Geoffray35071052015-06-09 15:43:38 +0100294 // Method cannot be resolved if it is in another dex file we do not have access to.
Nicolas Geoffray9437b782015-03-25 10:08:51 +0000295 VLOG(compiler) << "Method cannot be resolved " << PrettyMethod(method_index, caller_dex_file);
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000296 return false;
297 }
298
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100299 if (actual_method != nullptr) {
Calin Juravle69158982016-03-16 11:53:41 +0000300 bool result = TryInlineAndReplace(invoke_instruction, actual_method, /* do_rtp */ true);
301 if (result && !invoke_instruction->IsInvokeStaticOrDirect()) {
302 MaybeRecordStat(kInlinedInvokeVirtualOrInterface);
303 }
304 return result;
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100305 }
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000306
Andreas Gampefd2140f2015-12-23 16:30:44 -0800307 DCHECK(!invoke_instruction->IsInvokeStaticOrDirect());
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100308
309 // Check if we can use an inline cache.
310 ArtMethod* caller = graph_->GetArtMethod();
Calin Juravleffc87072016-04-20 14:22:09 +0100311 if (Runtime::Current()->UseJitCompilation()) {
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000312 // Under JIT, we should always know the caller.
313 DCHECK(caller != nullptr);
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000314 ScopedProfilingInfoInlineUse spiis(caller, soa.Self());
315 ProfilingInfo* profiling_info = spiis.GetProfilingInfo();
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000316 if (profiling_info != nullptr) {
317 const InlineCache& ic = *profiling_info->GetInlineCache(invoke_instruction->GetDexPc());
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000318 if (ic.IsUninitialized()) {
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000319 VLOG(compiler) << "Interface or virtual call to "
320 << PrettyMethod(method_index, caller_dex_file)
321 << " is not hit and not inlined";
322 return false;
323 } else if (ic.IsMonomorphic()) {
324 MaybeRecordStat(kMonomorphicCall);
Nicolas Geoffray93a18c52016-04-22 13:16:14 +0100325 if (outermost_graph_->IsCompilingOsr()) {
326 // If we are compiling OSR, we pretend this call is polymorphic, as we may come from the
327 // interpreter and it may have seen different receiver types.
328 return TryInlinePolymorphicCall(invoke_instruction, resolved_method, ic);
329 } else {
330 return TryInlineMonomorphicCall(invoke_instruction, resolved_method, ic);
331 }
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000332 } else if (ic.IsPolymorphic()) {
333 MaybeRecordStat(kPolymorphicCall);
334 return TryInlinePolymorphicCall(invoke_instruction, resolved_method, ic);
335 } else {
336 DCHECK(ic.IsMegamorphic());
337 VLOG(compiler) << "Interface or virtual call to "
338 << PrettyMethod(method_index, caller_dex_file)
339 << " is megamorphic and not inlined";
340 MaybeRecordStat(kMegamorphicCall);
341 return false;
342 }
Nicolas Geoffray454a4812015-06-09 10:37:32 +0100343 }
344 }
345
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100346 VLOG(compiler) << "Interface or virtual call to "
347 << PrettyMethod(method_index, caller_dex_file)
348 << " could not be statically determined";
349 return false;
350}
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000351
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000352HInstanceFieldGet* HInliner::BuildGetReceiverClass(ClassLinker* class_linker,
353 HInstruction* receiver,
354 uint32_t dex_pc) const {
355 ArtField* field = class_linker->GetClassRoot(ClassLinker::kJavaLangObject)->GetInstanceField(0);
356 DCHECK_EQ(std::string(field->GetName()), "shadow$_klass_");
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000357 HInstanceFieldGet* result = new (graph_->GetArena()) HInstanceFieldGet(
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000358 receiver,
359 Primitive::kPrimNot,
360 field->GetOffset(),
361 field->IsVolatile(),
362 field->GetDexFieldIndex(),
363 field->GetDeclaringClass()->GetDexClassDefIndex(),
364 *field->GetDexFile(),
365 handles_->NewHandle(field->GetDexCache()),
366 dex_pc);
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000367 // The class of a field is effectively final, and does not have any memory dependencies.
368 result->SetSideEffects(SideEffects::None());
369 return result;
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000370}
371
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100372bool HInliner::TryInlineMonomorphicCall(HInvoke* invoke_instruction,
373 ArtMethod* resolved_method,
374 const InlineCache& ic) {
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000375 DCHECK(invoke_instruction->IsInvokeVirtual() || invoke_instruction->IsInvokeInterface())
376 << invoke_instruction->DebugName();
377
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100378 const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
Nicolas Geoffraye4084a52016-02-18 14:43:42 +0000379 uint32_t class_index = FindClassIndexIn(
380 ic.GetMonomorphicType(), caller_dex_file, caller_compilation_unit_.GetDexCache());
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100381 if (class_index == DexFile::kDexNoIndex) {
382 VLOG(compiler) << "Call to " << PrettyMethod(resolved_method)
383 << " from inline cache is not inlined because its class is not"
384 << " accessible to the caller";
385 return false;
386 }
387
388 ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
389 size_t pointer_size = class_linker->GetImagePointerSize();
390 if (invoke_instruction->IsInvokeInterface()) {
391 resolved_method = ic.GetMonomorphicType()->FindVirtualMethodForInterface(
392 resolved_method, pointer_size);
393 } else {
394 DCHECK(invoke_instruction->IsInvokeVirtual());
395 resolved_method = ic.GetMonomorphicType()->FindVirtualMethodForVirtual(
396 resolved_method, pointer_size);
397 }
398 DCHECK(resolved_method != nullptr);
399 HInstruction* receiver = invoke_instruction->InputAt(0);
400 HInstruction* cursor = invoke_instruction->GetPrevious();
401 HBasicBlock* bb_cursor = invoke_instruction->GetBlock();
402
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000403 if (!TryInlineAndReplace(invoke_instruction, resolved_method, /* do_rtp */ false)) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100404 return false;
405 }
406
407 // We successfully inlined, now add a guard.
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100408 bool is_referrer =
409 (ic.GetMonomorphicType() == outermost_graph_->GetArtMethod()->GetDeclaringClass());
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000410 AddTypeGuard(receiver,
411 cursor,
412 bb_cursor,
413 class_index,
414 is_referrer,
415 invoke_instruction,
416 /* with_deoptimization */ true);
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100417
418 // Run type propagation to get the guard typed, and eventually propagate the
419 // type of the receiver.
Vladimir Marko456307a2016-04-19 14:12:13 +0000420 ReferenceTypePropagation rtp_fixup(graph_,
421 outer_compilation_unit_.GetDexCache(),
422 handles_,
423 /* is_first_run */ false);
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100424 rtp_fixup.Run();
425
426 MaybeRecordStat(kInlinedMonomorphicCall);
427 return true;
428}
429
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000430HInstruction* HInliner::AddTypeGuard(HInstruction* receiver,
431 HInstruction* cursor,
432 HBasicBlock* bb_cursor,
433 uint32_t class_index,
434 bool is_referrer,
435 HInstruction* invoke_instruction,
436 bool with_deoptimization) {
437 ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
438 HInstanceFieldGet* receiver_class = BuildGetReceiverClass(
439 class_linker, receiver, invoke_instruction->GetDexPc());
440
441 const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
442 // Note that we will just compare the classes, so we don't need Java semantics access checks.
443 // Also, the caller of `AddTypeGuard` must have guaranteed that the class is in the dex cache.
444 HLoadClass* load_class = new (graph_->GetArena()) HLoadClass(graph_->GetCurrentMethod(),
445 class_index,
446 caller_dex_file,
447 is_referrer,
448 invoke_instruction->GetDexPc(),
449 /* needs_access_check */ false,
450 /* is_in_dex_cache */ true);
451
452 HNotEqual* compare = new (graph_->GetArena()) HNotEqual(load_class, receiver_class);
453 // TODO: Extend reference type propagation to understand the guard.
454 if (cursor != nullptr) {
455 bb_cursor->InsertInstructionAfter(receiver_class, cursor);
456 } else {
457 bb_cursor->InsertInstructionBefore(receiver_class, bb_cursor->GetFirstInstruction());
458 }
459 bb_cursor->InsertInstructionAfter(load_class, receiver_class);
460 bb_cursor->InsertInstructionAfter(compare, load_class);
461 if (with_deoptimization) {
462 HDeoptimize* deoptimize = new (graph_->GetArena()) HDeoptimize(
463 compare, invoke_instruction->GetDexPc());
464 bb_cursor->InsertInstructionAfter(deoptimize, compare);
465 deoptimize->CopyEnvironmentFrom(invoke_instruction->GetEnvironment());
466 }
467 return compare;
468}
469
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000470bool HInliner::TryInlinePolymorphicCall(HInvoke* invoke_instruction,
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100471 ArtMethod* resolved_method,
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000472 const InlineCache& ic) {
473 DCHECK(invoke_instruction->IsInvokeVirtual() || invoke_instruction->IsInvokeInterface())
474 << invoke_instruction->DebugName();
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000475
476 if (TryInlinePolymorphicCallToSameTarget(invoke_instruction, resolved_method, ic)) {
477 return true;
478 }
479
480 ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
481 size_t pointer_size = class_linker->GetImagePointerSize();
482 const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
483
484 bool all_targets_inlined = true;
485 bool one_target_inlined = false;
486 for (size_t i = 0; i < InlineCache::kIndividualCacheSize; ++i) {
487 if (ic.GetTypeAt(i) == nullptr) {
488 break;
489 }
490 ArtMethod* method = nullptr;
491 if (invoke_instruction->IsInvokeInterface()) {
492 method = ic.GetTypeAt(i)->FindVirtualMethodForInterface(
493 resolved_method, pointer_size);
494 } else {
495 DCHECK(invoke_instruction->IsInvokeVirtual());
496 method = ic.GetTypeAt(i)->FindVirtualMethodForVirtual(
497 resolved_method, pointer_size);
498 }
499
500 HInstruction* receiver = invoke_instruction->InputAt(0);
501 HInstruction* cursor = invoke_instruction->GetPrevious();
502 HBasicBlock* bb_cursor = invoke_instruction->GetBlock();
503
Nicolas Geoffray1fe26e12016-02-18 16:55:42 +0000504 uint32_t class_index = FindClassIndexIn(
505 ic.GetTypeAt(i), caller_dex_file, caller_compilation_unit_.GetDexCache());
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000506 HInstruction* return_replacement = nullptr;
507 if (class_index == DexFile::kDexNoIndex ||
508 !TryBuildAndInline(invoke_instruction, method, &return_replacement)) {
509 all_targets_inlined = false;
510 } else {
511 one_target_inlined = true;
512 bool is_referrer = (ic.GetTypeAt(i) == outermost_graph_->GetArtMethod()->GetDeclaringClass());
513
514 // If we have inlined all targets before, and this receiver is the last seen,
515 // we deoptimize instead of keeping the original invoke instruction.
516 bool deoptimize = all_targets_inlined &&
517 (i != InlineCache::kIndividualCacheSize - 1) &&
518 (ic.GetTypeAt(i + 1) == nullptr);
Nicolas Geoffray93a18c52016-04-22 13:16:14 +0100519
520 if (outermost_graph_->IsCompilingOsr()) {
521 // We do not support HDeoptimize in OSR methods.
522 deoptimize = false;
523 }
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000524 HInstruction* compare = AddTypeGuard(
525 receiver, cursor, bb_cursor, class_index, is_referrer, invoke_instruction, deoptimize);
526 if (deoptimize) {
527 if (return_replacement != nullptr) {
528 invoke_instruction->ReplaceWith(return_replacement);
529 }
530 invoke_instruction->GetBlock()->RemoveInstruction(invoke_instruction);
531 // Because the inline cache data can be populated concurrently, we force the end of the
532 // iteration. Otherhwise, we could see a new receiver type.
533 break;
534 } else {
535 CreateDiamondPatternForPolymorphicInline(compare, return_replacement, invoke_instruction);
536 }
537 }
538 }
539
540 if (!one_target_inlined) {
541 VLOG(compiler) << "Call to " << PrettyMethod(resolved_method)
542 << " from inline cache is not inlined because none"
543 << " of its targets could be inlined";
544 return false;
545 }
546 MaybeRecordStat(kInlinedPolymorphicCall);
547
548 // Run type propagation to get the guards typed.
Vladimir Marko456307a2016-04-19 14:12:13 +0000549 ReferenceTypePropagation rtp_fixup(graph_,
550 outer_compilation_unit_.GetDexCache(),
551 handles_,
552 /* is_first_run */ false);
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000553 rtp_fixup.Run();
554 return true;
555}
556
557void HInliner::CreateDiamondPatternForPolymorphicInline(HInstruction* compare,
558 HInstruction* return_replacement,
559 HInstruction* invoke_instruction) {
560 uint32_t dex_pc = invoke_instruction->GetDexPc();
561 HBasicBlock* cursor_block = compare->GetBlock();
562 HBasicBlock* original_invoke_block = invoke_instruction->GetBlock();
563 ArenaAllocator* allocator = graph_->GetArena();
564
565 // Spit the block after the compare: `cursor_block` will now be the start of the diamond,
566 // and the returned block is the start of the then branch (that could contain multiple blocks).
567 HBasicBlock* then = cursor_block->SplitAfterForInlining(compare);
568
569 // Split the block containing the invoke before and after the invoke. The returned block
570 // of the split before will contain the invoke and will be the otherwise branch of
571 // the diamond. The returned block of the split after will be the merge block
572 // of the diamond.
573 HBasicBlock* end_then = invoke_instruction->GetBlock();
574 HBasicBlock* otherwise = end_then->SplitBeforeForInlining(invoke_instruction);
575 HBasicBlock* merge = otherwise->SplitAfterForInlining(invoke_instruction);
576
577 // If the methods we are inlining return a value, we create a phi in the merge block
578 // that will have the `invoke_instruction and the `return_replacement` as inputs.
579 if (return_replacement != nullptr) {
580 HPhi* phi = new (allocator) HPhi(
581 allocator, kNoRegNumber, 0, HPhi::ToPhiType(invoke_instruction->GetType()), dex_pc);
582 merge->AddPhi(phi);
583 invoke_instruction->ReplaceWith(phi);
584 phi->AddInput(return_replacement);
585 phi->AddInput(invoke_instruction);
586 }
587
588 // Add the control flow instructions.
589 otherwise->AddInstruction(new (allocator) HGoto(dex_pc));
590 end_then->AddInstruction(new (allocator) HGoto(dex_pc));
591 cursor_block->AddInstruction(new (allocator) HIf(compare, dex_pc));
592
593 // Add the newly created blocks to the graph.
594 graph_->AddBlock(then);
595 graph_->AddBlock(otherwise);
596 graph_->AddBlock(merge);
597
598 // Set up successor (and implictly predecessor) relations.
599 cursor_block->AddSuccessor(otherwise);
600 cursor_block->AddSuccessor(then);
601 end_then->AddSuccessor(merge);
602 otherwise->AddSuccessor(merge);
603
604 // Set up dominance information.
605 then->SetDominator(cursor_block);
606 cursor_block->AddDominatedBlock(then);
607 otherwise->SetDominator(cursor_block);
608 cursor_block->AddDominatedBlock(otherwise);
609 merge->SetDominator(cursor_block);
610 cursor_block->AddDominatedBlock(merge);
611
612 // Update the revert post order.
613 size_t index = IndexOfElement(graph_->reverse_post_order_, cursor_block);
614 MakeRoomFor(&graph_->reverse_post_order_, 1, index);
615 graph_->reverse_post_order_[++index] = then;
616 index = IndexOfElement(graph_->reverse_post_order_, end_then);
617 MakeRoomFor(&graph_->reverse_post_order_, 2, index);
618 graph_->reverse_post_order_[++index] = otherwise;
619 graph_->reverse_post_order_[++index] = merge;
620
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000621
Nicolas Geoffraya1d8ddf2016-02-29 11:46:58 +0000622 graph_->UpdateLoopAndTryInformationOfNewBlock(
623 then, original_invoke_block, /* replace_if_back_edge */ false);
624 graph_->UpdateLoopAndTryInformationOfNewBlock(
625 otherwise, original_invoke_block, /* replace_if_back_edge */ false);
626
627 // In case the original invoke location was a back edge, we need to update
628 // the loop to now have the merge block as a back edge.
629 graph_->UpdateLoopAndTryInformationOfNewBlock(
630 merge, original_invoke_block, /* replace_if_back_edge */ true);
Nicolas Geoffray916cc1d2016-02-18 11:12:31 +0000631}
632
633bool HInliner::TryInlinePolymorphicCallToSameTarget(HInvoke* invoke_instruction,
634 ArtMethod* resolved_method,
635 const InlineCache& ic) {
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000636 // This optimization only works under JIT for now.
Calin Juravleffc87072016-04-20 14:22:09 +0100637 DCHECK(Runtime::Current()->UseJitCompilation());
Roland Levillain2aba7cd2016-02-03 12:27:20 +0000638 if (graph_->GetInstructionSet() == kMips64) {
639 // TODO: Support HClassTableGet for mips64.
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000640 return false;
641 }
642 ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
643 size_t pointer_size = class_linker->GetImagePointerSize();
644
645 DCHECK(resolved_method != nullptr);
646 ArtMethod* actual_method = nullptr;
Nicolas Geoffray4f97a212016-02-25 16:17:54 +0000647 size_t method_index = invoke_instruction->IsInvokeVirtual()
648 ? invoke_instruction->AsInvokeVirtual()->GetVTableIndex()
649 : invoke_instruction->AsInvokeInterface()->GetImtIndex();
650
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000651 // Check whether we are actually calling the same method among
652 // the different types seen.
653 for (size_t i = 0; i < InlineCache::kIndividualCacheSize; ++i) {
654 if (ic.GetTypeAt(i) == nullptr) {
655 break;
656 }
657 ArtMethod* new_method = nullptr;
658 if (invoke_instruction->IsInvokeInterface()) {
Nicolas Geoffray88f288e2016-06-29 08:17:52 +0000659 new_method = ic.GetTypeAt(i)->GetEmbeddedImTableEntry(
660 method_index % mirror::Class::kImtSize, pointer_size);
Nicolas Geoffray4f97a212016-02-25 16:17:54 +0000661 if (new_method->IsRuntimeMethod()) {
662 // Bail out as soon as we see a conflict trampoline in one of the target's
663 // interface table.
664 return false;
665 }
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000666 } else {
667 DCHECK(invoke_instruction->IsInvokeVirtual());
Nicolas Geoffray4f97a212016-02-25 16:17:54 +0000668 new_method = ic.GetTypeAt(i)->GetEmbeddedVTableEntry(method_index, pointer_size);
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000669 }
Nicolas Geoffray4f97a212016-02-25 16:17:54 +0000670 DCHECK(new_method != nullptr);
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000671 if (actual_method == nullptr) {
672 actual_method = new_method;
673 } else if (actual_method != new_method) {
674 // Different methods, bailout.
Nicolas Geoffrayd9994f02016-02-11 17:35:55 +0000675 VLOG(compiler) << "Call to " << PrettyMethod(resolved_method)
676 << " from inline cache is not inlined because it resolves"
677 << " to different methods";
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000678 return false;
679 }
680 }
681
682 HInstruction* receiver = invoke_instruction->InputAt(0);
683 HInstruction* cursor = invoke_instruction->GetPrevious();
684 HBasicBlock* bb_cursor = invoke_instruction->GetBlock();
685
Nicolas Geoffray93a18c52016-04-22 13:16:14 +0100686 HInstruction* return_replacement = nullptr;
687 if (!TryBuildAndInline(invoke_instruction, actual_method, &return_replacement)) {
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000688 return false;
689 }
690
691 // We successfully inlined, now add a guard.
692 HInstanceFieldGet* receiver_class = BuildGetReceiverClass(
693 class_linker, receiver, invoke_instruction->GetDexPc());
694
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000695 Primitive::Type type = Is64BitInstructionSet(graph_->GetInstructionSet())
696 ? Primitive::kPrimLong
697 : Primitive::kPrimInt;
698 HClassTableGet* class_table_get = new (graph_->GetArena()) HClassTableGet(
699 receiver_class,
700 type,
Vladimir Markoa1de9182016-02-25 11:37:38 +0000701 invoke_instruction->IsInvokeVirtual() ? HClassTableGet::TableKind::kVTable
702 : HClassTableGet::TableKind::kIMTable,
Nicolas Geoffray4f97a212016-02-25 16:17:54 +0000703 method_index,
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000704 invoke_instruction->GetDexPc());
705
706 HConstant* constant;
707 if (type == Primitive::kPrimLong) {
708 constant = graph_->GetLongConstant(
709 reinterpret_cast<intptr_t>(actual_method), invoke_instruction->GetDexPc());
710 } else {
711 constant = graph_->GetIntConstant(
712 reinterpret_cast<intptr_t>(actual_method), invoke_instruction->GetDexPc());
713 }
714
715 HNotEqual* compare = new (graph_->GetArena()) HNotEqual(class_table_get, constant);
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000716 if (cursor != nullptr) {
717 bb_cursor->InsertInstructionAfter(receiver_class, cursor);
718 } else {
719 bb_cursor->InsertInstructionBefore(receiver_class, bb_cursor->GetFirstInstruction());
720 }
721 bb_cursor->InsertInstructionAfter(class_table_get, receiver_class);
722 bb_cursor->InsertInstructionAfter(compare, class_table_get);
Nicolas Geoffray93a18c52016-04-22 13:16:14 +0100723
724 if (outermost_graph_->IsCompilingOsr()) {
725 CreateDiamondPatternForPolymorphicInline(compare, return_replacement, invoke_instruction);
726 } else {
727 // TODO: Extend reference type propagation to understand the guard.
728 HDeoptimize* deoptimize = new (graph_->GetArena()) HDeoptimize(
729 compare, invoke_instruction->GetDexPc());
730 bb_cursor->InsertInstructionAfter(deoptimize, compare);
731 deoptimize->CopyEnvironmentFrom(invoke_instruction->GetEnvironment());
732 if (return_replacement != nullptr) {
733 invoke_instruction->ReplaceWith(return_replacement);
734 }
Nicolas Geoffray1be7cbd2016-04-29 13:56:01 +0100735 invoke_instruction->GetBlock()->RemoveInstruction(invoke_instruction);
Nicolas Geoffray93a18c52016-04-22 13:16:14 +0100736 }
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000737
738 // Run type propagation to get the guard typed.
Vladimir Marko456307a2016-04-19 14:12:13 +0000739 ReferenceTypePropagation rtp_fixup(graph_,
740 outer_compilation_unit_.GetDexCache(),
741 handles_,
742 /* is_first_run */ false);
Nicolas Geoffraya42363f2015-12-17 14:57:09 +0000743 rtp_fixup.Run();
744
745 MaybeRecordStat(kInlinedPolymorphicCall);
746
747 return true;
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100748}
749
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000750bool HInliner::TryInlineAndReplace(HInvoke* invoke_instruction, ArtMethod* method, bool do_rtp) {
751 HInstruction* return_replacement = nullptr;
752 if (!TryBuildAndInline(invoke_instruction, method, &return_replacement)) {
Nicolas Geoffrayd9facea2016-07-06 10:19:23 +0100753 if (invoke_instruction->IsInvokeInterface()) {
754 // Turn an invoke-interface into an invoke-virtual. An invoke-virtual is always
755 // better than an invoke-interface because:
756 // 1) In the best case, the interface call has one more indirection (to fetch the IMT).
757 // 2) We will not go to the conflict trampoline with an invoke-virtual.
758 // TODO: Consider sharpening once it is not dependent on the compiler driver.
759 HInvokeVirtual* new_invoke = new (graph_->GetArena()) HInvokeVirtual(
760 graph_->GetArena(),
761 invoke_instruction->GetNumberOfArguments(),
762 invoke_instruction->GetType(),
763 invoke_instruction->GetDexPc(),
764 invoke_instruction->GetDexMethodIndex(),
765 method->GetMethodIndex());
766 HInputsRef inputs = invoke_instruction->GetInputs();
767 size_t index = 0;
768 for (HInstruction* instr : inputs) {
769 new_invoke->SetArgumentAt(index++, instr);
770 }
771 invoke_instruction->GetBlock()->InsertInstructionBefore(new_invoke, invoke_instruction);
772 new_invoke->CopyEnvironmentFrom(invoke_instruction->GetEnvironment());
773 if (invoke_instruction->GetType() == Primitive::kPrimNot) {
774 new_invoke->SetReferenceTypeInfo(invoke_instruction->GetReferenceTypeInfo());
775 }
776 return_replacement = new_invoke;
777 } else {
778 // TODO: Consider sharpening an invoke virtual once it is not dependent on the
779 // compiler driver.
780 return false;
781 }
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000782 }
783 if (return_replacement != nullptr) {
784 invoke_instruction->ReplaceWith(return_replacement);
785 }
786 invoke_instruction->GetBlock()->RemoveInstruction(invoke_instruction);
David Brazdil94ab38f2016-06-21 17:48:19 +0100787 FixUpReturnReferenceType(method, return_replacement);
788 if (do_rtp && ReturnTypeMoreSpecific(invoke_instruction, return_replacement)) {
789 // Actual return value has a more specific type than the method's declared
790 // return type. Run RTP again on the outer graph to propagate it.
791 ReferenceTypePropagation(graph_,
792 outer_compilation_unit_.GetDexCache(),
793 handles_,
794 /* is_first_run */ false).Run();
795 }
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000796 return true;
797}
798
799bool HInliner::TryBuildAndInline(HInvoke* invoke_instruction,
800 ArtMethod* method,
801 HInstruction** return_replacement) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100802 const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
Jeff Haodcdc85b2015-12-04 14:06:18 -0800803
Nicolas Geoffray93a18c52016-04-22 13:16:14 +0100804 if (method->IsProxyMethod()) {
805 VLOG(compiler) << "Method " << PrettyMethod(method)
806 << " is not inlined because of unimplemented inline support for proxy methods.";
807 return false;
808 }
809
Jeff Haodcdc85b2015-12-04 14:06:18 -0800810 // Check whether we're allowed to inline. The outermost compilation unit is the relevant
811 // dex file here (though the transitivity of an inline chain would allow checking the calller).
812 if (!compiler_driver_->MayInline(method->GetDexFile(),
813 outer_compilation_unit_.GetDexFile())) {
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000814 if (TryPatternSubstitution(invoke_instruction, method, return_replacement)) {
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000815 VLOG(compiler) << "Successfully replaced pattern of invoke " << PrettyMethod(method);
816 MaybeRecordStat(kReplacedInvokeWithSimplePattern);
817 return true;
818 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800819 VLOG(compiler) << "Won't inline " << PrettyMethod(method) << " in "
820 << outer_compilation_unit_.GetDexFile()->GetLocation() << " ("
821 << caller_compilation_unit_.GetDexFile()->GetLocation() << ") from "
822 << method->GetDexFile()->GetLocation();
823 return false;
824 }
825
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100826 uint32_t method_index = FindMethodIndexIn(
827 method, caller_dex_file, invoke_instruction->GetDexMethodIndex());
828 if (method_index == DexFile::kDexNoIndex) {
829 VLOG(compiler) << "Call to "
830 << PrettyMethod(method)
831 << " cannot be inlined because unaccessible to caller";
832 return false;
833 }
834
835 bool same_dex_file = IsSameDexFile(*outer_compilation_unit_.GetDexFile(), *method->GetDexFile());
836
837 const DexFile::CodeItem* code_item = method->GetCodeItem();
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000838
839 if (code_item == nullptr) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100840 VLOG(compiler) << "Method " << PrettyMethod(method)
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000841 << " is not inlined because it is native";
842 return false;
843 }
844
Calin Juravleec748352015-07-29 13:52:12 +0100845 size_t inline_max_code_units = compiler_driver_->GetCompilerOptions().GetInlineMaxCodeUnits();
846 if (code_item->insns_size_in_code_units_ > inline_max_code_units) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100847 VLOG(compiler) << "Method " << PrettyMethod(method)
Nicolas Geoffray788f2f02016-01-22 12:41:38 +0000848 << " is too big to inline: "
849 << code_item->insns_size_in_code_units_
850 << " > "
851 << inline_max_code_units;
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000852 return false;
853 }
854
855 if (code_item->tries_size_ != 0) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100856 VLOG(compiler) << "Method " << PrettyMethod(method)
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000857 << " is not inlined because of try block";
858 return false;
859 }
860
Nicolas Geoffray250a3782016-04-20 16:27:53 +0100861 if (!method->IsCompilable()) {
862 VLOG(compiler) << "Method " << PrettyMethod(method)
863 << " has soft failures un-handled by the compiler, so it cannot be inlined";
864 }
865
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100866 if (!method->GetDeclaringClass()->IsVerified()) {
867 uint16_t class_def_idx = method->GetDeclaringClass()->GetDexClassDefIndex();
Calin Juravleffc87072016-04-20 14:22:09 +0100868 if (Runtime::Current()->UseJitCompilation() ||
Nicolas Geoffray5b82d332016-02-18 14:22:32 +0000869 !compiler_driver_->IsMethodVerifiedWithoutFailures(
870 method->GetDexMethodIndex(), class_def_idx, *method->GetDexFile())) {
Nicolas Geoffrayccc61972015-10-01 14:34:20 +0100871 VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
872 << " couldn't be verified, so it cannot be inlined";
873 return false;
874 }
Nicolas Geoffraye53798a2014-12-01 10:31:54 +0000875 }
876
Roland Levillain4c0eb422015-04-24 16:43:49 +0100877 if (invoke_instruction->IsInvokeStaticOrDirect() &&
878 invoke_instruction->AsInvokeStaticOrDirect()->IsStaticWithImplicitClinitCheck()) {
879 // Case of a static method that cannot be inlined because it implicitly
880 // requires an initialization check of its declaring class.
881 VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
882 << " is not inlined because it is static and requires a clinit"
883 << " check that cannot be emitted due to Dex cache limitations";
884 return false;
885 }
886
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000887 if (!TryBuildAndInlineHelper(invoke_instruction, method, same_dex_file, return_replacement)) {
Nicolas Geoffrayc0365b12015-03-18 18:31:52 +0000888 return false;
889 }
890
Nicolas Geoffray9437b782015-03-25 10:08:51 +0000891 VLOG(compiler) << "Successfully inlined " << PrettyMethod(method_index, caller_dex_file);
Nicolas Geoffrayc0365b12015-03-18 18:31:52 +0000892 MaybeRecordStat(kInlinedInvoke);
893 return true;
894}
895
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000896static HInstruction* GetInvokeInputForArgVRegIndex(HInvoke* invoke_instruction,
897 size_t arg_vreg_index)
898 SHARED_REQUIRES(Locks::mutator_lock_) {
899 size_t input_index = 0;
900 for (size_t i = 0; i < arg_vreg_index; ++i, ++input_index) {
901 DCHECK_LT(input_index, invoke_instruction->GetNumberOfArguments());
902 if (Primitive::Is64BitType(invoke_instruction->InputAt(input_index)->GetType())) {
903 ++i;
904 DCHECK_NE(i, arg_vreg_index);
905 }
906 }
907 DCHECK_LT(input_index, invoke_instruction->GetNumberOfArguments());
908 return invoke_instruction->InputAt(input_index);
909}
910
911// Try to recognize known simple patterns and replace invoke call with appropriate instructions.
912bool HInliner::TryPatternSubstitution(HInvoke* invoke_instruction,
913 ArtMethod* resolved_method,
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000914 HInstruction** return_replacement) {
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000915 InlineMethod inline_method;
916 if (!InlineMethodAnalyser::AnalyseMethodCode(resolved_method, &inline_method)) {
917 return false;
918 }
919
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000920 switch (inline_method.opcode) {
921 case kInlineOpNop:
922 DCHECK_EQ(invoke_instruction->GetType(), Primitive::kPrimVoid);
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000923 *return_replacement = nullptr;
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000924 break;
925 case kInlineOpReturnArg:
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000926 *return_replacement = GetInvokeInputForArgVRegIndex(invoke_instruction,
927 inline_method.d.return_data.arg);
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000928 break;
929 case kInlineOpNonWideConst:
930 if (resolved_method->GetShorty()[0] == 'L') {
931 DCHECK_EQ(inline_method.d.data, 0u);
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000932 *return_replacement = graph_->GetNullConstant();
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000933 } else {
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000934 *return_replacement = graph_->GetIntConstant(static_cast<int32_t>(inline_method.d.data));
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000935 }
936 break;
937 case kInlineOpIGet: {
938 const InlineIGetIPutData& data = inline_method.d.ifield_data;
939 if (data.method_is_static || data.object_arg != 0u) {
940 // TODO: Needs null check.
941 return false;
942 }
Vladimir Marko354efa62016-02-04 19:46:56 +0000943 Handle<mirror::DexCache> dex_cache(handles_->NewHandle(resolved_method->GetDexCache()));
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000944 HInstruction* obj = GetInvokeInputForArgVRegIndex(invoke_instruction, data.object_arg);
Vladimir Marko354efa62016-02-04 19:46:56 +0000945 HInstanceFieldGet* iget = CreateInstanceFieldGet(dex_cache, data.field_idx, obj);
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000946 DCHECK_EQ(iget->GetFieldOffset().Uint32Value(), data.field_offset);
947 DCHECK_EQ(iget->IsVolatile() ? 1u : 0u, data.is_volatile);
948 invoke_instruction->GetBlock()->InsertInstructionBefore(iget, invoke_instruction);
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000949 *return_replacement = iget;
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000950 break;
951 }
952 case kInlineOpIPut: {
953 const InlineIGetIPutData& data = inline_method.d.ifield_data;
954 if (data.method_is_static || data.object_arg != 0u) {
955 // TODO: Needs null check.
956 return false;
957 }
Vladimir Marko354efa62016-02-04 19:46:56 +0000958 Handle<mirror::DexCache> dex_cache(handles_->NewHandle(resolved_method->GetDexCache()));
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000959 HInstruction* obj = GetInvokeInputForArgVRegIndex(invoke_instruction, data.object_arg);
960 HInstruction* value = GetInvokeInputForArgVRegIndex(invoke_instruction, data.src_arg);
Vladimir Marko354efa62016-02-04 19:46:56 +0000961 HInstanceFieldSet* iput = CreateInstanceFieldSet(dex_cache, data.field_idx, obj, value);
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000962 DCHECK_EQ(iput->GetFieldOffset().Uint32Value(), data.field_offset);
963 DCHECK_EQ(iput->IsVolatile() ? 1u : 0u, data.is_volatile);
964 invoke_instruction->GetBlock()->InsertInstructionBefore(iput, invoke_instruction);
965 if (data.return_arg_plus1 != 0u) {
966 size_t return_arg = data.return_arg_plus1 - 1u;
Nicolas Geoffray55bd7492016-02-16 15:37:12 +0000967 *return_replacement = GetInvokeInputForArgVRegIndex(invoke_instruction, return_arg);
Vladimir Markobe10e8e2016-01-22 12:09:44 +0000968 }
969 break;
970 }
Vladimir Marko354efa62016-02-04 19:46:56 +0000971 case kInlineOpConstructor: {
972 const InlineConstructorData& data = inline_method.d.constructor_data;
973 // Get the indexes to arrays for easier processing.
974 uint16_t iput_field_indexes[] = {
975 data.iput0_field_index, data.iput1_field_index, data.iput2_field_index
976 };
977 uint16_t iput_args[] = { data.iput0_arg, data.iput1_arg, data.iput2_arg };
978 static_assert(arraysize(iput_args) == arraysize(iput_field_indexes), "Size mismatch");
979 // Count valid field indexes.
980 size_t number_of_iputs = 0u;
981 while (number_of_iputs != arraysize(iput_field_indexes) &&
982 iput_field_indexes[number_of_iputs] != DexFile::kDexNoIndex16) {
983 // Check that there are no duplicate valid field indexes.
984 DCHECK_EQ(0, std::count(iput_field_indexes + number_of_iputs + 1,
985 iput_field_indexes + arraysize(iput_field_indexes),
986 iput_field_indexes[number_of_iputs]));
987 ++number_of_iputs;
988 }
989 // Check that there are no valid field indexes in the rest of the array.
990 DCHECK_EQ(0, std::count_if(iput_field_indexes + number_of_iputs,
991 iput_field_indexes + arraysize(iput_field_indexes),
992 [](uint16_t index) { return index != DexFile::kDexNoIndex16; }));
993
994 // Create HInstanceFieldSet for each IPUT that stores non-zero data.
995 Handle<mirror::DexCache> dex_cache;
996 HInstruction* obj = GetInvokeInputForArgVRegIndex(invoke_instruction, /* this */ 0u);
997 bool needs_constructor_barrier = false;
998 for (size_t i = 0; i != number_of_iputs; ++i) {
999 HInstruction* value = GetInvokeInputForArgVRegIndex(invoke_instruction, iput_args[i]);
Roland Levillain1a653882016-03-18 18:05:57 +00001000 if (!value->IsConstant() || !value->AsConstant()->IsZeroBitPattern()) {
Vladimir Marko354efa62016-02-04 19:46:56 +00001001 if (dex_cache.GetReference() == nullptr) {
1002 dex_cache = handles_->NewHandle(resolved_method->GetDexCache());
1003 }
1004 uint16_t field_index = iput_field_indexes[i];
1005 HInstanceFieldSet* iput = CreateInstanceFieldSet(dex_cache, field_index, obj, value);
1006 invoke_instruction->GetBlock()->InsertInstructionBefore(iput, invoke_instruction);
1007
1008 // Check whether the field is final. If it is, we need to add a barrier.
1009 size_t pointer_size = InstructionSetPointerSize(codegen_->GetInstructionSet());
1010 ArtField* resolved_field = dex_cache->GetResolvedField(field_index, pointer_size);
1011 DCHECK(resolved_field != nullptr);
1012 if (resolved_field->IsFinal()) {
1013 needs_constructor_barrier = true;
1014 }
1015 }
1016 }
1017 if (needs_constructor_barrier) {
1018 HMemoryBarrier* barrier = new (graph_->GetArena()) HMemoryBarrier(kStoreStore, kNoDexPc);
1019 invoke_instruction->GetBlock()->InsertInstructionBefore(barrier, invoke_instruction);
1020 }
Nicolas Geoffray55bd7492016-02-16 15:37:12 +00001021 *return_replacement = nullptr;
Vladimir Marko354efa62016-02-04 19:46:56 +00001022 break;
1023 }
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001024 default:
1025 LOG(FATAL) << "UNREACHABLE";
1026 UNREACHABLE();
1027 }
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001028 return true;
1029}
1030
Vladimir Marko354efa62016-02-04 19:46:56 +00001031HInstanceFieldGet* HInliner::CreateInstanceFieldGet(Handle<mirror::DexCache> dex_cache,
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001032 uint32_t field_index,
1033 HInstruction* obj)
1034 SHARED_REQUIRES(Locks::mutator_lock_) {
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001035 size_t pointer_size = InstructionSetPointerSize(codegen_->GetInstructionSet());
1036 ArtField* resolved_field = dex_cache->GetResolvedField(field_index, pointer_size);
1037 DCHECK(resolved_field != nullptr);
1038 HInstanceFieldGet* iget = new (graph_->GetArena()) HInstanceFieldGet(
1039 obj,
1040 resolved_field->GetTypeAsPrimitiveType(),
1041 resolved_field->GetOffset(),
1042 resolved_field->IsVolatile(),
1043 field_index,
1044 resolved_field->GetDeclaringClass()->GetDexClassDefIndex(),
Vladimir Marko354efa62016-02-04 19:46:56 +00001045 *dex_cache->GetDexFile(),
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001046 dex_cache,
Vladimir Markoadda4352016-01-29 10:24:41 +00001047 // Read barrier generates a runtime call in slow path and we need a valid
1048 // dex pc for the associated stack map. 0 is bogus but valid. Bug: 26854537.
1049 /* dex_pc */ 0);
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001050 if (iget->GetType() == Primitive::kPrimNot) {
Vladimir Marko456307a2016-04-19 14:12:13 +00001051 // Use the same dex_cache that we used for field lookup as the hint_dex_cache.
1052 ReferenceTypePropagation rtp(graph_, dex_cache, handles_, /* is_first_run */ false);
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001053 rtp.Visit(iget);
1054 }
1055 return iget;
1056}
1057
Vladimir Marko354efa62016-02-04 19:46:56 +00001058HInstanceFieldSet* HInliner::CreateInstanceFieldSet(Handle<mirror::DexCache> dex_cache,
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001059 uint32_t field_index,
1060 HInstruction* obj,
1061 HInstruction* value)
1062 SHARED_REQUIRES(Locks::mutator_lock_) {
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001063 size_t pointer_size = InstructionSetPointerSize(codegen_->GetInstructionSet());
1064 ArtField* resolved_field = dex_cache->GetResolvedField(field_index, pointer_size);
1065 DCHECK(resolved_field != nullptr);
1066 HInstanceFieldSet* iput = new (graph_->GetArena()) HInstanceFieldSet(
1067 obj,
1068 value,
1069 resolved_field->GetTypeAsPrimitiveType(),
1070 resolved_field->GetOffset(),
1071 resolved_field->IsVolatile(),
1072 field_index,
1073 resolved_field->GetDeclaringClass()->GetDexClassDefIndex(),
Vladimir Marko354efa62016-02-04 19:46:56 +00001074 *dex_cache->GetDexFile(),
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001075 dex_cache,
Vladimir Markoadda4352016-01-29 10:24:41 +00001076 // Read barrier generates a runtime call in slow path and we need a valid
1077 // dex pc for the associated stack map. 0 is bogus but valid. Bug: 26854537.
1078 /* dex_pc */ 0);
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001079 return iput;
1080}
Nicolas Geoffrayd9994f02016-02-11 17:35:55 +00001081
Nicolas Geoffray55bd7492016-02-16 15:37:12 +00001082bool HInliner::TryBuildAndInlineHelper(HInvoke* invoke_instruction,
1083 ArtMethod* resolved_method,
1084 bool same_dex_file,
1085 HInstruction** return_replacement) {
Nicolas Geoffrayc0365b12015-03-18 18:31:52 +00001086 ScopedObjectAccess soa(Thread::Current());
1087 const DexFile::CodeItem* code_item = resolved_method->GetCodeItem();
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001088 const DexFile& callee_dex_file = *resolved_method->GetDexFile();
1089 uint32_t method_index = resolved_method->GetDexMethodIndex();
Calin Juravle2e768302015-07-28 14:41:11 +00001090 ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
Mathieu Chartier736b5602015-09-02 14:54:11 -07001091 Handle<mirror::DexCache> dex_cache(handles_->NewHandle(resolved_method->GetDexCache()));
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001092 DexCompilationUnit dex_compilation_unit(
Nicolas Geoffray5b82d332016-02-18 14:22:32 +00001093 caller_compilation_unit_.GetClassLoader(),
1094 class_linker,
1095 callee_dex_file,
1096 code_item,
1097 resolved_method->GetDeclaringClass()->GetDexClassDefIndex(),
1098 method_index,
1099 resolved_method->GetAccessFlags(),
1100 /* verified_method */ nullptr,
1101 dex_cache);
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001102
Calin Juravle3cd4fc82015-05-14 15:15:42 +01001103 bool requires_ctor_barrier = false;
1104
1105 if (dex_compilation_unit.IsConstructor()) {
1106 // If it's a super invocation and we already generate a barrier there's no need
1107 // to generate another one.
1108 // We identify super calls by looking at the "this" pointer. If its value is the
1109 // same as the local "this" pointer then we must have a super invocation.
1110 bool is_super_invocation = invoke_instruction->InputAt(0)->IsParameterValue()
1111 && invoke_instruction->InputAt(0)->AsParameterValue()->IsThis();
1112 if (is_super_invocation && graph_->ShouldGenerateConstructorBarrier()) {
1113 requires_ctor_barrier = false;
1114 } else {
1115 Thread* self = Thread::Current();
1116 requires_ctor_barrier = compiler_driver_->RequiresConstructorBarrier(self,
1117 dex_compilation_unit.GetDexFile(),
1118 dex_compilation_unit.GetClassDefIndex());
1119 }
1120 }
1121
Nicolas Geoffray35071052015-06-09 15:43:38 +01001122 InvokeType invoke_type = invoke_instruction->GetOriginalInvokeType();
1123 if (invoke_type == kInterface) {
1124 // We have statically resolved the dispatch. To please the class linker
1125 // at runtime, we change this call as if it was a virtual call.
1126 invoke_type = kVirtual;
1127 }
David Brazdil3f523062016-02-29 16:53:33 +00001128
1129 const int32_t caller_instruction_counter = graph_->GetCurrentInstructionId();
Nicolas Geoffraye0fe7ae2015-03-09 10:02:49 +00001130 HGraph* callee_graph = new (graph_->GetArena()) HGraph(
Nicolas Geoffray0a23d742015-05-07 11:57:35 +01001131 graph_->GetArena(),
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001132 callee_dex_file,
Nicolas Geoffray0a23d742015-05-07 11:57:35 +01001133 method_index,
Calin Juravle3cd4fc82015-05-14 15:15:42 +01001134 requires_ctor_barrier,
Mathieu Chartiere401d142015-04-22 13:56:20 -07001135 compiler_driver_->GetInstructionSet(),
Nicolas Geoffray35071052015-06-09 15:43:38 +01001136 invoke_type,
Nicolas Geoffray0a23d742015-05-07 11:57:35 +01001137 graph_->IsDebuggable(),
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +00001138 /* osr */ false,
David Brazdil3f523062016-02-29 16:53:33 +00001139 caller_instruction_counter);
Nicolas Geoffray73be1e82015-09-17 15:22:56 +01001140 callee_graph->SetArtMethod(resolved_method);
David Brazdil5e8b1372015-01-23 14:39:08 +00001141
Roland Levillaina8013fd2016-04-04 15:34:31 +01001142 // When they are needed, allocate `inline_stats` on the heap instead
1143 // of on the stack, as Clang might produce a stack frame too large
1144 // for this function, that would not fit the requirements of the
1145 // `-Wframe-larger-than` option.
1146 std::unique_ptr<OptimizingCompilerStats> inline_stats =
1147 (stats_ == nullptr) ? nullptr : MakeUnique<OptimizingCompilerStats>();
David Brazdil5e8b1372015-01-23 14:39:08 +00001148 HGraphBuilder builder(callee_graph,
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001149 &dex_compilation_unit,
1150 &outer_compilation_unit_,
Nicolas Geoffray9437b782015-03-25 10:08:51 +00001151 resolved_method->GetDexFile(),
David Brazdil86ea7ee2016-02-16 09:26:07 +00001152 *code_item,
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001153 compiler_driver_,
Roland Levillaina8013fd2016-04-04 15:34:31 +01001154 inline_stats.get(),
Mathieu Chartier736b5602015-09-02 14:54:11 -07001155 resolved_method->GetQuickenedInfo(),
David Brazdildee58d62016-04-07 09:54:26 +00001156 dex_cache,
1157 handles_);
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001158
David Brazdildee58d62016-04-07 09:54:26 +00001159 if (builder.BuildGraph() != kAnalysisSuccess) {
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001160 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001161 << " could not be built, so cannot be inlined";
1162 return false;
1163 }
1164
Nicolas Geoffray259136f2014-12-17 23:21:58 +00001165 if (!RegisterAllocator::CanAllocateRegistersFor(*callee_graph,
1166 compiler_driver_->GetInstructionSet())) {
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001167 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffray259136f2014-12-17 23:21:58 +00001168 << " cannot be inlined because of the register allocator";
1169 return false;
1170 }
1171
Nicolas Geoffraye418dda2015-08-11 20:03:09 -07001172 size_t parameter_index = 0;
1173 for (HInstructionIterator instructions(callee_graph->GetEntryBlock()->GetInstructions());
1174 !instructions.Done();
1175 instructions.Advance()) {
1176 HInstruction* current = instructions.Current();
1177 if (current->IsParameterValue()) {
1178 HInstruction* argument = invoke_instruction->InputAt(parameter_index++);
1179 if (argument->IsNullConstant()) {
1180 current->ReplaceWith(callee_graph->GetNullConstant());
1181 } else if (argument->IsIntConstant()) {
1182 current->ReplaceWith(callee_graph->GetIntConstant(argument->AsIntConstant()->GetValue()));
1183 } else if (argument->IsLongConstant()) {
1184 current->ReplaceWith(callee_graph->GetLongConstant(argument->AsLongConstant()->GetValue()));
1185 } else if (argument->IsFloatConstant()) {
1186 current->ReplaceWith(
1187 callee_graph->GetFloatConstant(argument->AsFloatConstant()->GetValue()));
1188 } else if (argument->IsDoubleConstant()) {
1189 current->ReplaceWith(
1190 callee_graph->GetDoubleConstant(argument->AsDoubleConstant()->GetValue()));
1191 } else if (argument->GetType() == Primitive::kPrimNot) {
1192 current->SetReferenceTypeInfo(argument->GetReferenceTypeInfo());
1193 current->AsParameterValue()->SetCanBeNull(argument->CanBeNull());
1194 }
1195 }
1196 }
1197
David Brazdil94ab38f2016-06-21 17:48:19 +01001198 // We have replaced formal arguments with actual arguments. If actual types
1199 // are more specific than the declared ones, run RTP again on the inner graph.
1200 if (ArgumentTypesMoreSpecific(invoke_instruction, resolved_method)) {
1201 ReferenceTypePropagation(callee_graph,
1202 dex_compilation_unit.GetDexCache(),
1203 handles_,
1204 /* is_first_run */ false).Run();
1205 }
1206
Nicolas Geoffraye418dda2015-08-11 20:03:09 -07001207 size_t number_of_instructions_budget = kMaximumNumberOfHInstructions;
Roland Levillaina3aef2e2016-04-06 17:45:58 +01001208 size_t number_of_inlined_instructions =
1209 RunOptimizations(callee_graph, code_item, dex_compilation_unit);
1210 number_of_instructions_budget += number_of_inlined_instructions;
Nicolas Geoffrayef87c5d2015-01-30 12:41:14 +00001211
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001212 // TODO: We should abort only if all predecessors throw. However,
1213 // HGraph::InlineInto currently does not handle an exit block with
1214 // a throw predecessor.
1215 HBasicBlock* exit_block = callee_graph->GetExitBlock();
1216 if (exit_block == nullptr) {
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001217 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001218 << " could not be inlined because it has an infinite loop";
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001219 return false;
1220 }
1221
1222 bool has_throw_predecessor = false;
Vladimir Marko60584552015-09-03 13:35:12 +00001223 for (HBasicBlock* predecessor : exit_block->GetPredecessors()) {
1224 if (predecessor->GetLastInstruction()->IsThrow()) {
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001225 has_throw_predecessor = true;
1226 break;
1227 }
1228 }
1229 if (has_throw_predecessor) {
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001230 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001231 << " could not be inlined because one branch always throws";
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001232 return false;
1233 }
1234
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001235 HReversePostOrderIterator it(*callee_graph);
Nicolas Geoffrayef87c5d2015-01-30 12:41:14 +00001236 it.Advance(); // Past the entry block, it does not contain instructions that prevent inlining.
Nicolas Geoffraye418dda2015-08-11 20:03:09 -07001237 size_t number_of_instructions = 0;
Nicolas Geoffray5949fa02015-12-18 10:57:10 +00001238
1239 bool can_inline_environment =
1240 total_number_of_dex_registers_ < kMaximumNumberOfCumulatedDexRegisters;
1241
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001242 for (; !it.Done(); it.Advance()) {
1243 HBasicBlock* block = it.Current();
Nicolas Geoffray788f2f02016-01-22 12:41:38 +00001244
1245 if (block->IsLoopHeader() && block->GetLoopInformation()->IsIrreducible()) {
1246 // Don't inline methods with irreducible loops, they could prevent some
1247 // optimizations to run.
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001248 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffray788f2f02016-01-22 12:41:38 +00001249 << " could not be inlined because it contains an irreducible loop";
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001250 return false;
1251 }
1252
1253 for (HInstructionIterator instr_it(block->GetInstructions());
1254 !instr_it.Done();
1255 instr_it.Advance()) {
Roland Levillaina3aef2e2016-04-06 17:45:58 +01001256 if (number_of_instructions++ == number_of_instructions_budget) {
Nicolas Geoffraye418dda2015-08-11 20:03:09 -07001257 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffray5949fa02015-12-18 10:57:10 +00001258 << " is not inlined because its caller has reached"
1259 << " its instruction budget limit.";
Nicolas Geoffraye418dda2015-08-11 20:03:09 -07001260 return false;
1261 }
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001262 HInstruction* current = instr_it.Current();
Nicolas Geoffray5949fa02015-12-18 10:57:10 +00001263 if (!can_inline_environment && current->NeedsEnvironment()) {
1264 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
1265 << " is not inlined because its caller has reached"
1266 << " its environment budget limit.";
1267 return false;
1268 }
Nicolas Geoffray276d9da2015-02-02 18:24:11 +00001269
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001270 if (!same_dex_file && current->NeedsEnvironment()) {
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001271 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001272 << " could not be inlined because " << current->DebugName()
Nicolas Geoffrayd23eeef2015-05-18 22:31:29 +01001273 << " needs an environment and is in a different dex file";
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001274 return false;
1275 }
Nicolas Geoffray9437b782015-03-25 10:08:51 +00001276
Vladimir Markodc151b22015-10-15 18:02:30 +01001277 if (!same_dex_file && current->NeedsDexCacheOfDeclaringClass()) {
Guillaume "Vermeille" Sanchezae09d2d2015-05-29 10:52:55 +01001278 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
Nicolas Geoffray9437b782015-03-25 10:08:51 +00001279 << " could not be inlined because " << current->DebugName()
1280 << " it is in a different dex file and requires access to the dex cache";
1281 return false;
1282 }
Nicolas Geoffrayd9309292015-10-31 22:21:31 +00001283
1284 if (current->IsNewInstance() &&
1285 (current->AsNewInstance()->GetEntrypoint() == kQuickAllocObjectWithAccessCheck)) {
Nicolas Geoffrayd9994f02016-02-11 17:35:55 +00001286 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
1287 << " could not be inlined because it is using an entrypoint"
1288 << " with access checks";
Nicolas Geoffrayd9309292015-10-31 22:21:31 +00001289 // Allocation entrypoint does not handle inlined frames.
1290 return false;
1291 }
1292
1293 if (current->IsNewArray() &&
1294 (current->AsNewArray()->GetEntrypoint() == kQuickAllocArrayWithAccessCheck)) {
Nicolas Geoffrayd9994f02016-02-11 17:35:55 +00001295 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
1296 << " could not be inlined because it is using an entrypoint"
1297 << " with access checks";
Nicolas Geoffrayd9309292015-10-31 22:21:31 +00001298 // Allocation entrypoint does not handle inlined frames.
1299 return false;
1300 }
1301
1302 if (current->IsUnresolvedStaticFieldGet() ||
1303 current->IsUnresolvedInstanceFieldGet() ||
1304 current->IsUnresolvedStaticFieldSet() ||
1305 current->IsUnresolvedInstanceFieldSet()) {
1306 // Entrypoint for unresolved fields does not handle inlined frames.
Nicolas Geoffrayd9994f02016-02-11 17:35:55 +00001307 VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
1308 << " could not be inlined because it is using an unresolved"
1309 << " entrypoint";
Nicolas Geoffrayd9309292015-10-31 22:21:31 +00001310 return false;
1311 }
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001312 }
1313 }
Nicolas Geoffraye418dda2015-08-11 20:03:09 -07001314 number_of_inlined_instructions_ += number_of_instructions;
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001315
David Brazdil3f523062016-02-29 16:53:33 +00001316 DCHECK_EQ(caller_instruction_counter, graph_->GetCurrentInstructionId())
1317 << "No instructions can be added to the outer graph while inner graph is being built";
1318
1319 const int32_t callee_instruction_counter = callee_graph->GetCurrentInstructionId();
1320 graph_->SetCurrentInstructionId(callee_instruction_counter);
Nicolas Geoffray55bd7492016-02-16 15:37:12 +00001321 *return_replacement = callee_graph->InlineInto(graph_, invoke_instruction);
David Brazdil3f523062016-02-29 16:53:33 +00001322
1323 DCHECK_EQ(callee_instruction_counter, callee_graph->GetCurrentInstructionId())
1324 << "No instructions can be added to the inner graph during inlining into the outer graph";
1325
Vladimir Markobe10e8e2016-01-22 12:09:44 +00001326 return true;
1327}
Calin Juravle2e768302015-07-28 14:41:11 +00001328
Roland Levillaina3aef2e2016-04-06 17:45:58 +01001329size_t HInliner::RunOptimizations(HGraph* callee_graph,
1330 const DexFile::CodeItem* code_item,
1331 const DexCompilationUnit& dex_compilation_unit) {
Nicolas Geoffray93a18c52016-04-22 13:16:14 +01001332 // Note: if the outermost_graph_ is being compiled OSR, we should not run any
1333 // optimization that could lead to a HDeoptimize. The following optimizations do not.
Roland Levillaina3aef2e2016-04-06 17:45:58 +01001334 HDeadCodeElimination dce(callee_graph, stats_);
1335 HConstantFolding fold(callee_graph);
1336 HSharpening sharpening(callee_graph, codegen_, dex_compilation_unit, compiler_driver_);
1337 InstructionSimplifier simplify(callee_graph, stats_);
1338 IntrinsicsRecognizer intrinsics(callee_graph, compiler_driver_, stats_);
1339
1340 HOptimization* optimizations[] = {
1341 &intrinsics,
1342 &sharpening,
1343 &simplify,
1344 &fold,
1345 &dce,
1346 };
1347
1348 for (size_t i = 0; i < arraysize(optimizations); ++i) {
1349 HOptimization* optimization = optimizations[i];
1350 optimization->Run();
1351 }
1352
1353 size_t number_of_inlined_instructions = 0u;
1354 if (depth_ + 1 < compiler_driver_->GetCompilerOptions().GetInlineDepthLimit()) {
1355 HInliner inliner(callee_graph,
1356 outermost_graph_,
1357 codegen_,
1358 outer_compilation_unit_,
1359 dex_compilation_unit,
1360 compiler_driver_,
1361 handles_,
1362 stats_,
1363 total_number_of_dex_registers_ + code_item->registers_size_,
1364 depth_ + 1);
1365 inliner.Run();
1366 number_of_inlined_instructions += inliner.number_of_inlined_instructions_;
1367 }
1368
1369 return number_of_inlined_instructions;
1370}
1371
David Brazdil94ab38f2016-06-21 17:48:19 +01001372static bool IsReferenceTypeRefinement(ReferenceTypeInfo declared_rti,
1373 bool declared_can_be_null,
1374 HInstruction* actual_obj)
1375 SHARED_REQUIRES(Locks::mutator_lock_) {
1376 if (declared_can_be_null && !actual_obj->CanBeNull()) {
1377 return true;
1378 }
1379
1380 ReferenceTypeInfo actual_rti = actual_obj->GetReferenceTypeInfo();
1381 return (actual_rti.IsExact() && !declared_rti.IsExact()) ||
1382 declared_rti.IsStrictSupertypeOf(actual_rti);
1383}
1384
1385ReferenceTypeInfo HInliner::GetClassRTI(mirror::Class* klass) {
1386 return ReferenceTypePropagation::IsAdmissible(klass)
1387 ? ReferenceTypeInfo::Create(handles_->NewHandle(klass))
1388 : graph_->GetInexactObjectRti();
1389}
1390
1391bool HInliner::ArgumentTypesMoreSpecific(HInvoke* invoke_instruction, ArtMethod* resolved_method) {
1392 // If this is an instance call, test whether the type of the `this` argument
1393 // is more specific than the class which declares the method.
1394 if (!resolved_method->IsStatic()) {
1395 if (IsReferenceTypeRefinement(GetClassRTI(resolved_method->GetDeclaringClass()),
1396 /* declared_can_be_null */ false,
1397 invoke_instruction->InputAt(0u))) {
1398 return true;
1399 }
1400 }
1401
1402 size_t pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
1403
1404 // Iterate over the list of parameter types and test whether any of the
1405 // actual inputs has a more specific reference type than the type declared in
1406 // the signature.
1407 const DexFile::TypeList* param_list = resolved_method->GetParameterTypeList();
1408 for (size_t param_idx = 0,
1409 input_idx = resolved_method->IsStatic() ? 0 : 1,
1410 e = (param_list == nullptr ? 0 : param_list->Size());
1411 param_idx < e;
1412 ++param_idx, ++input_idx) {
1413 HInstruction* input = invoke_instruction->InputAt(input_idx);
1414 if (input->GetType() == Primitive::kPrimNot) {
1415 mirror::Class* param_cls = resolved_method->GetDexCacheResolvedType(
1416 param_list->GetTypeItem(param_idx).type_idx_,
1417 pointer_size);
1418 if (IsReferenceTypeRefinement(GetClassRTI(param_cls),
1419 /* declared_can_be_null */ true,
1420 input)) {
1421 return true;
1422 }
1423 }
1424 }
1425
1426 return false;
1427}
1428
1429bool HInliner::ReturnTypeMoreSpecific(HInvoke* invoke_instruction,
1430 HInstruction* return_replacement) {
Alex Light68289a52015-12-15 17:30:30 -08001431 // Check the integrity of reference types and run another type propagation if needed.
David Brazdil4833f5a2015-12-16 10:37:39 +00001432 if (return_replacement != nullptr) {
1433 if (return_replacement->GetType() == Primitive::kPrimNot) {
David Brazdil94ab38f2016-06-21 17:48:19 +01001434 // Test if the return type is a refinement of the declared return type.
1435 if (IsReferenceTypeRefinement(invoke_instruction->GetReferenceTypeInfo(),
1436 /* declared_can_be_null */ true,
1437 return_replacement)) {
1438 return true;
1439 }
1440 } else if (return_replacement->IsInstanceOf()) {
1441 // Inlining InstanceOf into an If may put a tighter bound on reference types.
1442 return true;
1443 }
1444 }
1445
1446 return false;
1447}
1448
1449void HInliner::FixUpReturnReferenceType(ArtMethod* resolved_method,
1450 HInstruction* return_replacement) {
1451 if (return_replacement != nullptr) {
1452 if (return_replacement->GetType() == Primitive::kPrimNot) {
David Brazdil4833f5a2015-12-16 10:37:39 +00001453 if (!return_replacement->GetReferenceTypeInfo().IsValid()) {
1454 // Make sure that we have a valid type for the return. We may get an invalid one when
1455 // we inline invokes with multiple branches and create a Phi for the result.
1456 // TODO: we could be more precise by merging the phi inputs but that requires
1457 // some functionality from the reference type propagation.
1458 DCHECK(return_replacement->IsPhi());
1459 size_t pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
Nicolas Geoffray44fd0e52016-03-16 15:16:06 +00001460 mirror::Class* cls = resolved_method->GetReturnType(false /* resolve */, pointer_size);
David Brazdil94ab38f2016-06-21 17:48:19 +01001461 return_replacement->SetReferenceTypeInfo(GetClassRTI(cls));
Nicolas Geoffray73be1e82015-09-17 15:22:56 +01001462 }
Calin Juravlecdfed3d2015-10-26 14:05:01 +00001463 }
Calin Juravle2e768302015-07-28 14:41:11 +00001464 }
Nicolas Geoffraye53798a2014-12-01 10:31:54 +00001465}
1466
1467} // namespace art