1 /*
2 * Copyright (C) 2010 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 "Dalvik.h"
18 #include "Dataflow.h"
19 #include "libdex/DexOpcodes.h"
20
21 /* Convert the reg id from the callee to the original id passed by the caller */
convertRegId(const DecodedInstruction * invoke,const Method * calleeMethod,int calleeRegId,bool isRange)22 static inline u4 convertRegId(const DecodedInstruction *invoke,
23 const Method *calleeMethod,
24 int calleeRegId, bool isRange)
25 {
26 /* The order in the original arg passing list */
27 int rank = calleeRegId -
28 (calleeMethod->registersSize - calleeMethod->insSize);
29 assert(rank >= 0);
30 if (!isRange) {
31 return invoke->arg[rank];
32 } else {
33 return invoke->vC + rank;
34 }
35 }
36
inlineGetter(CompilationUnit * cUnit,const Method * calleeMethod,MIR * invokeMIR,BasicBlock * invokeBB,bool isPredicted,bool isRange)37 static bool inlineGetter(CompilationUnit *cUnit,
38 const Method *calleeMethod,
39 MIR *invokeMIR,
40 BasicBlock *invokeBB,
41 bool isPredicted,
42 bool isRange)
43 {
44 BasicBlock *moveResultBB = invokeBB->fallThrough;
45 MIR *moveResultMIR = moveResultBB->firstMIRInsn;
46 MIR *newGetterMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
47 DecodedInstruction getterInsn;
48
49 dexDecodeInstruction(calleeMethod->insns, &getterInsn);
50
51 if (!dvmCompilerCanIncludeThisInstruction(calleeMethod, &getterInsn))
52 return false;
53
54 /*
55 * Some getters (especially invoked through interface) are not followed
56 * by a move result.
57 */
58 if ((moveResultMIR == NULL) ||
59 (moveResultMIR->dalvikInsn.opcode != OP_MOVE_RESULT &&
60 moveResultMIR->dalvikInsn.opcode != OP_MOVE_RESULT_OBJECT &&
61 moveResultMIR->dalvikInsn.opcode != OP_MOVE_RESULT_WIDE)) {
62 return false;
63 }
64
65 int dfFlags = dvmCompilerDataFlowAttributes[getterInsn.opcode];
66
67 /* Expecting vA to be the destination register */
68 if (dfFlags & (DF_UA | DF_UA_WIDE)) {
69 LOGE("opcode %d has DF_UA set (not expected)", getterInsn.opcode);
70 dvmAbort();
71 }
72
73 if (dfFlags & DF_UB) {
74 getterInsn.vB = convertRegId(&invokeMIR->dalvikInsn, calleeMethod,
75 getterInsn.vB, isRange);
76 }
77
78 if (dfFlags & DF_UC) {
79 getterInsn.vC = convertRegId(&invokeMIR->dalvikInsn, calleeMethod,
80 getterInsn.vC, isRange);
81 }
82
83 getterInsn.vA = moveResultMIR->dalvikInsn.vA;
84
85 /* Now setup the Dalvik instruction with converted src/dst registers */
86 newGetterMIR->dalvikInsn = getterInsn;
87
88 newGetterMIR->width = dexGetWidthFromOpcode(getterInsn.opcode);
89
90 newGetterMIR->OptimizationFlags |= MIR_CALLEE;
91
92 /*
93 * If the getter instruction is about to raise any exception, punt to the
94 * interpreter and re-execute the invoke.
95 */
96 newGetterMIR->offset = invokeMIR->offset;
97
98 newGetterMIR->meta.calleeMethod = calleeMethod;
99
100 dvmCompilerInsertMIRAfter(invokeBB, invokeMIR, newGetterMIR);
101
102 if (isPredicted) {
103 MIR *invokeMIRSlow = (MIR *)dvmCompilerNew(sizeof(MIR), true);
104 *invokeMIRSlow = *invokeMIR;
105 invokeMIR->dalvikInsn.opcode = (Opcode)kMirOpCheckInlinePrediction;
106
107 /* Use vC to denote the first argument (ie this) */
108 if (!isRange) {
109 invokeMIR->dalvikInsn.vC = invokeMIRSlow->dalvikInsn.arg[0];
110 }
111
112 moveResultMIR->OptimizationFlags |= MIR_INLINED_PRED;
113
114 dvmCompilerInsertMIRAfter(invokeBB, newGetterMIR, invokeMIRSlow);
115 invokeMIRSlow->OptimizationFlags |= MIR_INLINED_PRED;
116 #if defined(WITH_JIT_TUNING)
117 gDvmJit.invokePolyGetterInlined++;
118 #endif
119 } else {
120 invokeMIR->OptimizationFlags |= MIR_INLINED;
121 moveResultMIR->OptimizationFlags |= MIR_INLINED;
122 #if defined(WITH_JIT_TUNING)
123 gDvmJit.invokeMonoGetterInlined++;
124 #endif
125 }
126
127 return true;
128 }
129
inlineSetter(CompilationUnit * cUnit,const Method * calleeMethod,MIR * invokeMIR,BasicBlock * invokeBB,bool isPredicted,bool isRange)130 static bool inlineSetter(CompilationUnit *cUnit,
131 const Method *calleeMethod,
132 MIR *invokeMIR,
133 BasicBlock *invokeBB,
134 bool isPredicted,
135 bool isRange)
136 {
137 MIR *newSetterMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
138 DecodedInstruction setterInsn;
139
140 dexDecodeInstruction(calleeMethod->insns, &setterInsn);
141
142 if (!dvmCompilerCanIncludeThisInstruction(calleeMethod, &setterInsn))
143 return false;
144
145 int dfFlags = dvmCompilerDataFlowAttributes[setterInsn.opcode];
146
147 if (dfFlags & (DF_UA | DF_UA_WIDE)) {
148 setterInsn.vA = convertRegId(&invokeMIR->dalvikInsn, calleeMethod,
149 setterInsn.vA, isRange);
150
151 }
152
153 if (dfFlags & DF_UB) {
154 setterInsn.vB = convertRegId(&invokeMIR->dalvikInsn, calleeMethod,
155 setterInsn.vB, isRange);
156
157 }
158
159 if (dfFlags & DF_UC) {
160 setterInsn.vC = convertRegId(&invokeMIR->dalvikInsn, calleeMethod,
161 setterInsn.vC, isRange);
162 }
163
164 /* Now setup the Dalvik instruction with converted src/dst registers */
165 newSetterMIR->dalvikInsn = setterInsn;
166
167 newSetterMIR->width = dexGetWidthFromOpcode(setterInsn.opcode);
168
169 newSetterMIR->OptimizationFlags |= MIR_CALLEE;
170
171 /*
172 * If the setter instruction is about to raise any exception, punt to the
173 * interpreter and re-execute the invoke.
174 */
175 newSetterMIR->offset = invokeMIR->offset;
176
177 newSetterMIR->meta.calleeMethod = calleeMethod;
178
179 dvmCompilerInsertMIRAfter(invokeBB, invokeMIR, newSetterMIR);
180
181 if (isPredicted) {
182 MIR *invokeMIRSlow = (MIR *)dvmCompilerNew(sizeof(MIR), true);
183 *invokeMIRSlow = *invokeMIR;
184 invokeMIR->dalvikInsn.opcode = (Opcode)kMirOpCheckInlinePrediction;
185
186 /* Use vC to denote the first argument (ie this) */
187 if (!isRange) {
188 invokeMIR->dalvikInsn.vC = invokeMIRSlow->dalvikInsn.arg[0];
189 }
190
191 dvmCompilerInsertMIRAfter(invokeBB, newSetterMIR, invokeMIRSlow);
192 invokeMIRSlow->OptimizationFlags |= MIR_INLINED_PRED;
193 #if defined(WITH_JIT_TUNING)
194 gDvmJit.invokePolySetterInlined++;
195 #endif
196 } else {
197 /*
198 * The invoke becomes no-op so it needs an explicit branch to jump to
199 * the chaining cell.
200 */
201 invokeBB->needFallThroughBranch = true;
202 invokeMIR->OptimizationFlags |= MIR_INLINED;
203 #if defined(WITH_JIT_TUNING)
204 gDvmJit.invokeMonoSetterInlined++;
205 #endif
206 }
207
208 return true;
209 }
210
tryInlineSingletonCallsite(CompilationUnit * cUnit,const Method * calleeMethod,MIR * invokeMIR,BasicBlock * invokeBB,bool isRange)211 static bool tryInlineSingletonCallsite(CompilationUnit *cUnit,
212 const Method *calleeMethod,
213 MIR *invokeMIR,
214 BasicBlock *invokeBB,
215 bool isRange)
216 {
217 /* Not a Java method */
218 if (dvmIsNativeMethod(calleeMethod)) return false;
219
220 CompilerMethodStats *methodStats =
221 dvmCompilerAnalyzeMethodBody(calleeMethod, true);
222
223 /* Empty callee - do nothing */
224 if (methodStats->attributes & METHOD_IS_EMPTY) {
225 /* The original invoke instruction is effectively turned into NOP */
226 invokeMIR->OptimizationFlags |= MIR_INLINED;
227 /*
228 * Need to insert an explicit branch to catch the falling knife (into
229 * the PC reconstruction or chaining cell).
230 */
231 invokeBB->needFallThroughBranch = true;
232 return true;
233 }
234
235 if (methodStats->attributes & METHOD_IS_GETTER) {
236 return inlineGetter(cUnit, calleeMethod, invokeMIR, invokeBB, false,
237 isRange);
238 } else if (methodStats->attributes & METHOD_IS_SETTER) {
239 return inlineSetter(cUnit, calleeMethod, invokeMIR, invokeBB, false,
240 isRange);
241 }
242 return false;
243 }
244
inlineEmptyVirtualCallee(CompilationUnit * cUnit,const Method * calleeMethod,MIR * invokeMIR,BasicBlock * invokeBB)245 static bool inlineEmptyVirtualCallee(CompilationUnit *cUnit,
246 const Method *calleeMethod,
247 MIR *invokeMIR,
248 BasicBlock *invokeBB)
249 {
250 MIR *invokeMIRSlow = (MIR *)dvmCompilerNew(sizeof(MIR), true);
251 *invokeMIRSlow = *invokeMIR;
252 invokeMIR->dalvikInsn.opcode = (Opcode)kMirOpCheckInlinePrediction;
253
254 dvmCompilerInsertMIRAfter(invokeBB, invokeMIR, invokeMIRSlow);
255 invokeMIRSlow->OptimizationFlags |= MIR_INLINED_PRED;
256 return true;
257 }
258
tryInlineVirtualCallsite(CompilationUnit * cUnit,const Method * calleeMethod,MIR * invokeMIR,BasicBlock * invokeBB,bool isRange)259 static bool tryInlineVirtualCallsite(CompilationUnit *cUnit,
260 const Method *calleeMethod,
261 MIR *invokeMIR,
262 BasicBlock *invokeBB,
263 bool isRange)
264 {
265 /* Not a Java method */
266 if (dvmIsNativeMethod(calleeMethod)) return false;
267
268 CompilerMethodStats *methodStats =
269 dvmCompilerAnalyzeMethodBody(calleeMethod, true);
270
271 /* Empty callee - do nothing by checking the clazz pointer */
272 if (methodStats->attributes & METHOD_IS_EMPTY) {
273 return inlineEmptyVirtualCallee(cUnit, calleeMethod, invokeMIR,
274 invokeBB);
275 }
276
277 if (methodStats->attributes & METHOD_IS_GETTER) {
278 return inlineGetter(cUnit, calleeMethod, invokeMIR, invokeBB, true,
279 isRange);
280 } else if (methodStats->attributes & METHOD_IS_SETTER) {
281 return inlineSetter(cUnit, calleeMethod, invokeMIR, invokeBB, true,
282 isRange);
283 }
284 return false;
285 }
286
287
dvmCompilerInlineMIR(CompilationUnit * cUnit,JitTranslationInfo * info)288 void dvmCompilerInlineMIR(CompilationUnit *cUnit, JitTranslationInfo *info)
289 {
290 bool isRange = false;
291 GrowableListIterator iterator;
292
293 dvmGrowableListIteratorInit(&cUnit->blockList, &iterator);
294 /*
295 * Analyze the basic block containing an invoke to see if it can be inlined
296 */
297 while (true) {
298 BasicBlock *bb = (BasicBlock *) dvmGrowableListIteratorNext(&iterator);
299 if (bb == NULL) break;
300 if (bb->blockType != kDalvikByteCode)
301 continue;
302 MIR *lastMIRInsn = bb->lastMIRInsn;
303 Opcode opcode = lastMIRInsn->dalvikInsn.opcode;
304 int flags = (int)dexGetFlagsFromOpcode(opcode);
305
306 /* No invoke - continue */
307 if ((flags & kInstrInvoke) == 0)
308 continue;
309
310 /* Disable inlining when doing method tracing */
311 if (gDvmJit.methodTraceSupport)
312 continue;
313
314 /*
315 * If the invoke itself is selected for single stepping, don't bother
316 * to inline it.
317 */
318 if (SINGLE_STEP_OP(opcode))
319 continue;
320
321 const Method *calleeMethod;
322
323 switch (opcode) {
324 case OP_INVOKE_SUPER:
325 case OP_INVOKE_DIRECT:
326 case OP_INVOKE_STATIC:
327 case OP_INVOKE_SUPER_QUICK:
328 calleeMethod = lastMIRInsn->meta.callsiteInfo->method;
329 break;
330 case OP_INVOKE_SUPER_RANGE:
331 case OP_INVOKE_DIRECT_RANGE:
332 case OP_INVOKE_STATIC_RANGE:
333 case OP_INVOKE_SUPER_QUICK_RANGE:
334 isRange = true;
335 calleeMethod = lastMIRInsn->meta.callsiteInfo->method;
336 break;
337 default:
338 calleeMethod = NULL;
339 break;
340 }
341
342 if (calleeMethod) {
343 bool inlined = tryInlineSingletonCallsite(cUnit, calleeMethod,
344 lastMIRInsn, bb, isRange);
345 if (!inlined &&
346 !(gDvmJit.disableOpt & (1 << kMethodJit)) &&
347 !dvmIsNativeMethod(calleeMethod)) {
348 CompilerMethodStats *methodStats =
349 dvmCompilerAnalyzeMethodBody(calleeMethod, true);
350 if ((methodStats->attributes & METHOD_IS_LEAF) &&
351 !(methodStats->attributes & METHOD_CANNOT_COMPILE)) {
352 /* Callee has been previously compiled */
353 if (dvmJitGetMethodAddr(calleeMethod->insns)) {
354 lastMIRInsn->OptimizationFlags |= MIR_INVOKE_METHOD_JIT;
355 } else {
356 /* Compile the callee first */
357 dvmCompileMethod(calleeMethod, info);
358 if (dvmJitGetMethodAddr(calleeMethod->insns)) {
359 lastMIRInsn->OptimizationFlags |=
360 MIR_INVOKE_METHOD_JIT;
361 } else {
362 methodStats->attributes |= METHOD_CANNOT_COMPILE;
363 }
364 }
365 }
366 }
367 return;
368 }
369
370 switch (opcode) {
371 case OP_INVOKE_VIRTUAL:
372 case OP_INVOKE_VIRTUAL_QUICK:
373 case OP_INVOKE_INTERFACE:
374 isRange = false;
375 calleeMethod = lastMIRInsn->meta.callsiteInfo->method;
376 break;
377 case OP_INVOKE_VIRTUAL_RANGE:
378 case OP_INVOKE_VIRTUAL_QUICK_RANGE:
379 case OP_INVOKE_INTERFACE_RANGE:
380 isRange = true;
381 calleeMethod = lastMIRInsn->meta.callsiteInfo->method;
382 break;
383 default:
384 break;
385 }
386
387 if (calleeMethod) {
388 bool inlined = tryInlineVirtualCallsite(cUnit, calleeMethod,
389 lastMIRInsn, bb, isRange);
390 if (!inlined &&
391 !(gDvmJit.disableOpt & (1 << kMethodJit)) &&
392 !dvmIsNativeMethod(calleeMethod)) {
393 CompilerMethodStats *methodStats =
394 dvmCompilerAnalyzeMethodBody(calleeMethod, true);
395 if ((methodStats->attributes & METHOD_IS_LEAF) &&
396 !(methodStats->attributes & METHOD_CANNOT_COMPILE)) {
397 /* Callee has been previously compiled */
398 if (dvmJitGetMethodAddr(calleeMethod->insns)) {
399 lastMIRInsn->OptimizationFlags |= MIR_INVOKE_METHOD_JIT;
400 } else {
401 /* Compile the callee first */
402 dvmCompileMethod(calleeMethod, info);
403 if (dvmJitGetMethodAddr(calleeMethod->insns)) {
404 lastMIRInsn->OptimizationFlags |=
405 MIR_INVOKE_METHOD_JIT;
406 } else {
407 methodStats->attributes |= METHOD_CANNOT_COMPILE;
408 }
409 }
410 }
411 }
412 return;
413 }
414 }
415 }
416