blob: d2628bb19c97effcfbb800ef189f2ab19a2ad6e0 [file] [log] [blame]
buzbee31a4a6f2012-02-28 15:36:15 -08001/*
2 * Copyright (C) 2012 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
Ian Rogers57b86d42012-03-27 16:05:41 -070017#include "oat/runtime/oat_support_entrypoints.h"
18
buzbee31a4a6f2012-02-28 15:36:15 -080019namespace art {
20
21/*
22 * This source files contains "gen" codegen routines that should
23 * be applicable to most targets. Only mid-level support utilities
24 * and "op" calls may be used here.
25 */
buzbeefc9e6fa2012-03-23 15:14:29 -070026void genInvoke(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
27 InvokeType type, bool isRange);
buzbee31a4a6f2012-02-28 15:36:15 -080028#if defined(TARGET_ARM)
buzbee82488f52012-03-02 08:20:26 -080029LIR* opIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide);
buzbee31a4a6f2012-02-28 15:36:15 -080030#endif
31
Ian Rogersab2b55d2012-03-18 00:06:11 -070032void callRuntimeHelperImm(CompilationUnit* cUnit, int helperOffset, int arg0) {
33#if !defined(TARGET_X86)
34 int rTgt = loadHelper(cUnit, helperOffset);
35#endif
36 loadConstant(cUnit, rARG0, arg0);
buzbee31a4a6f2012-02-28 15:36:15 -080037 oatClobberCalleeSave(cUnit);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -070038#if !defined(TARGET_X86)
Ian Rogersab2b55d2012-03-18 00:06:11 -070039 opReg(cUnit, kOpBlx, rTgt);
40 oatFreeTemp(cUnit, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -070041#else
Ian Rogersab2b55d2012-03-18 00:06:11 -070042 opThreadMem(cUnit, kOpBlx, helperOffset);
43#endif
44}
45
Ian Rogers7caad772012-03-30 01:07:54 -070046void callRuntimeHelperReg(CompilationUnit* cUnit, int helperOffset, int arg0) {
47#if !defined(TARGET_X86)
48 int rTgt = loadHelper(cUnit, helperOffset);
49#endif
50 opRegCopy(cUnit, rARG0, arg0);
51 oatClobberCalleeSave(cUnit);
52#if !defined(TARGET_X86)
53 opReg(cUnit, kOpBlx, rTgt);
54 oatFreeTemp(cUnit, rTgt);
55#else
56 opThreadMem(cUnit, kOpBlx, helperOffset);
57#endif
58}
59
Ian Rogersab2b55d2012-03-18 00:06:11 -070060void callRuntimeHelperRegLocation(CompilationUnit* cUnit, int helperOffset,
61 RegLocation arg0) {
62#if !defined(TARGET_X86)
63 int rTgt = loadHelper(cUnit, helperOffset);
64#endif
65 if (arg0.wide == 0) {
66 loadValueDirectFixed(cUnit, arg0, rARG0);
67 } else {
68 loadValueDirectWideFixed(cUnit, arg0, rARG0, rARG1);
69 }
70 oatClobberCalleeSave(cUnit);
71#if !defined(TARGET_X86)
72 opReg(cUnit, kOpBlx, rTgt);
73 oatFreeTemp(cUnit, rTgt);
74#else
75 opThreadMem(cUnit, kOpBlx, helperOffset);
76#endif
77}
78
79void callRuntimeHelperImmImm(CompilationUnit* cUnit, int helperOffset,
80 int arg0, int arg1) {
81#if !defined(TARGET_X86)
82 int rTgt = loadHelper(cUnit, helperOffset);
83#endif
84 loadConstant(cUnit, rARG0, arg0);
85 loadConstant(cUnit, rARG1, arg1);
86 oatClobberCalleeSave(cUnit);
87#if !defined(TARGET_X86)
88 opReg(cUnit, kOpBlx, rTgt);
89 oatFreeTemp(cUnit, rTgt);
90#else
91 opThreadMem(cUnit, kOpBlx, helperOffset);
92#endif
93}
94
95void callRuntimeHelperImmRegLocation(CompilationUnit* cUnit, int helperOffset,
96 int arg0, RegLocation arg1) {
97#if !defined(TARGET_X86)
98 int rTgt = loadHelper(cUnit, helperOffset);
99#endif
100 if (arg1.wide == 0) {
101 loadValueDirectFixed(cUnit, arg1, rARG1);
102 } else {
103 loadValueDirectWideFixed(cUnit, arg1, rARG1, rARG2);
104 }
105 loadConstant(cUnit, rARG0, arg0);
106 oatClobberCalleeSave(cUnit);
107#if !defined(TARGET_X86)
108 opReg(cUnit, kOpBlx, rTgt);
109 oatFreeTemp(cUnit, rTgt);
110#else
111 opThreadMem(cUnit, kOpBlx, helperOffset);
112#endif
113}
114
115void callRuntimeHelperRegLocationImm(CompilationUnit* cUnit, int helperOffset,
116 RegLocation arg0, int arg1) {
117#if !defined(TARGET_X86)
118 int rTgt = loadHelper(cUnit, helperOffset);
119#endif
120 loadValueDirectFixed(cUnit, arg0, rARG0);
121 loadConstant(cUnit, rARG1, arg1);
122 oatClobberCalleeSave(cUnit);
123#if !defined(TARGET_X86)
124 opReg(cUnit, kOpBlx, rTgt);
125 oatFreeTemp(cUnit, rTgt);
126#else
127 opThreadMem(cUnit, kOpBlx, helperOffset);
128#endif
129}
130
131void callRuntimeHelperImmReg(CompilationUnit* cUnit, int helperOffset,
132 int arg0, int arg1) {
133#if !defined(TARGET_X86)
134 int rTgt = loadHelper(cUnit, helperOffset);
135#endif
136 opRegCopy(cUnit, rARG1, arg1);
137 loadConstant(cUnit, rARG0, arg0);
138 oatClobberCalleeSave(cUnit);
139#if !defined(TARGET_X86)
140 opReg(cUnit, kOpBlx, rTgt);
141 oatFreeTemp(cUnit, rTgt);
142#else
143 opThreadMem(cUnit, kOpBlx, helperOffset);
144#endif
145}
146
147void callRuntimeHelperRegImm(CompilationUnit* cUnit, int helperOffset,
148 int arg0, int arg1) {
149#if !defined(TARGET_X86)
150 int rTgt = loadHelper(cUnit, helperOffset);
151#endif
152 opRegCopy(cUnit, rARG0, arg0);
153 loadConstant(cUnit, rARG1, arg1);
154 oatClobberCalleeSave(cUnit);
155#if !defined(TARGET_X86)
156 opReg(cUnit, kOpBlx, rTgt);
157 oatFreeTemp(cUnit, rTgt);
158#else
159 opThreadMem(cUnit, kOpBlx, helperOffset);
160#endif
161}
162
163void callRuntimeHelperImmMethod(CompilationUnit* cUnit, int helperOffset,
164 int arg0) {
165#if !defined(TARGET_X86)
166 int rTgt = loadHelper(cUnit, helperOffset);
167#endif
168 loadCurrMethodDirect(cUnit, rARG1);
169 loadConstant(cUnit, rARG0, arg0);
170 oatClobberCalleeSave(cUnit);
171#if !defined(TARGET_X86)
172 opReg(cUnit, kOpBlx, rTgt);
173 oatFreeTemp(cUnit, rTgt);
174#else
175 opThreadMem(cUnit, kOpBlx, helperOffset);
176#endif
177}
178
179void callRuntimeHelperRegLocationRegLocation(CompilationUnit* cUnit,
180 int helperOffset,
181 RegLocation arg0,
182 RegLocation arg1) {
183#if !defined(TARGET_X86)
184 int rTgt = loadHelper(cUnit, helperOffset);
185#endif
186 if (arg0.wide == 0) {
187 loadValueDirectFixed(cUnit, arg0, rARG0);
188 if (arg1.wide == 0) {
189 loadValueDirectFixed(cUnit, arg1, rARG1);
190 } else {
191 loadValueDirectWideFixed(cUnit, arg1, rARG1, rARG2);
192 }
193 } else {
194 loadValueDirectWideFixed(cUnit, arg0, rARG0, rARG1);
195 if (arg1.wide == 0) {
196 loadValueDirectFixed(cUnit, arg1, rARG2);
197 } else {
Ian Rogersab2b55d2012-03-18 00:06:11 -0700198 loadValueDirectWideFixed(cUnit, arg1, rARG2, rARG3);
Ian Rogersab2b55d2012-03-18 00:06:11 -0700199 }
200 }
201 oatClobberCalleeSave(cUnit);
202#if !defined(TARGET_X86)
203 opReg(cUnit, kOpBlx, rTgt);
204 oatFreeTemp(cUnit, rTgt);
205#else
206 opThreadMem(cUnit, kOpBlx, helperOffset);
207#endif
208}
209
210void callRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset,
211 int arg0, int arg1) {
212#if !defined(TARGET_X86)
213 int rTgt = loadHelper(cUnit, helperOffset);
214#endif
215 DCHECK_NE((int)rARG0, arg1); // check copy into arg0 won't clobber arg1
216 opRegCopy(cUnit, rARG0, arg0);
217 opRegCopy(cUnit, rARG1, arg1);
218 oatClobberCalleeSave(cUnit);
219#if !defined(TARGET_X86)
220 opReg(cUnit, kOpBlx, rTgt);
221 oatFreeTemp(cUnit, rTgt);
222#else
223 opThreadMem(cUnit, kOpBlx, helperOffset);
224#endif
225}
226
227void callRuntimeHelperRegRegImm(CompilationUnit* cUnit, int helperOffset,
228 int arg0, int arg1, int arg2) {
229#if !defined(TARGET_X86)
230 int rTgt = loadHelper(cUnit, helperOffset);
231#endif
232 DCHECK_NE((int)rARG0, arg1); // check copy into arg0 won't clobber arg1
233 opRegCopy(cUnit, rARG0, arg0);
234 opRegCopy(cUnit, rARG1, arg1);
235 loadConstant(cUnit, rARG2, arg2);
236 oatClobberCalleeSave(cUnit);
237#if !defined(TARGET_X86)
238 opReg(cUnit, kOpBlx, rTgt);
239 oatFreeTemp(cUnit, rTgt);
240#else
241 opThreadMem(cUnit, kOpBlx, helperOffset);
242#endif
243}
244
245void callRuntimeHelperImmMethodRegLocation(CompilationUnit* cUnit, int helperOffset,
246 int arg0, RegLocation arg2) {
247#if !defined(TARGET_X86)
248 int rTgt = loadHelper(cUnit, helperOffset);
249#endif
250 loadValueDirectFixed(cUnit, arg2, rARG2);
251 loadCurrMethodDirect(cUnit, rARG1);
252 loadConstant(cUnit, rARG0, arg0);
253 oatClobberCalleeSave(cUnit);
254#if !defined(TARGET_X86)
255 opReg(cUnit, kOpBlx, rTgt);
256 oatFreeTemp(cUnit, rTgt);
257#else
258 opThreadMem(cUnit, kOpBlx, helperOffset);
259#endif
260}
261
262void callRuntimeHelperImmMethodImm(CompilationUnit* cUnit, int helperOffset,
263 int arg0, int arg2) {
264#if !defined(TARGET_X86)
265 int rTgt = loadHelper(cUnit, helperOffset);
266#endif
267 loadCurrMethodDirect(cUnit, rARG1);
268 loadConstant(cUnit, rARG2, arg2);
269 loadConstant(cUnit, rARG0, arg0);
270 oatClobberCalleeSave(cUnit);
271#if !defined(TARGET_X86)
272 opReg(cUnit, kOpBlx, rTgt);
273 oatFreeTemp(cUnit, rTgt);
274#else
275 opThreadMem(cUnit, kOpBlx, helperOffset);
276#endif
277}
278
279void callRuntimeHelperImmRegLocationRegLocation(CompilationUnit* cUnit,
280 int helperOffset,
281 int arg0, RegLocation arg1,
282 RegLocation arg2) {
283#if !defined(TARGET_X86)
284 int rTgt = loadHelper(cUnit, helperOffset);
285#endif
286 loadValueDirectFixed(cUnit, arg1, rARG1);
287 if (arg2.wide == 0) {
288 loadValueDirectFixed(cUnit, arg2, rARG2);
289 } else {
Ian Rogersab2b55d2012-03-18 00:06:11 -0700290 loadValueDirectWideFixed(cUnit, arg2, rARG2, rARG3);
Ian Rogersab2b55d2012-03-18 00:06:11 -0700291 }
292 loadConstant(cUnit, rARG0, arg0);
293 oatClobberCalleeSave(cUnit);
294#if !defined(TARGET_X86)
295 opReg(cUnit, kOpBlx, rTgt);
296 oatFreeTemp(cUnit, rTgt);
297#else
298 opThreadMem(cUnit, kOpBlx, helperOffset);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700299#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800300}
301
302/*
303 * Generate an kPseudoBarrier marker to indicate the boundary of special
304 * blocks.
305 */
306void genBarrier(CompilationUnit* cUnit)
307{
308 LIR* barrier = newLIR0(cUnit, kPseudoBarrier);
309 /* Mark all resources as being clobbered */
310 barrier->defMask = -1;
311}
312
buzbee31a4a6f2012-02-28 15:36:15 -0800313
314/* Generate unconditional branch instructions */
buzbee82488f52012-03-02 08:20:26 -0800315LIR* opUnconditionalBranch(CompilationUnit* cUnit, LIR* target)
buzbee31a4a6f2012-02-28 15:36:15 -0800316{
Ian Rogers680b1bd2012-03-07 20:18:49 -0800317 LIR* branch = opBranchUnconditional(cUnit, kOpUncondBr);
buzbee31a4a6f2012-02-28 15:36:15 -0800318 branch->target = (LIR*) target;
319 return branch;
320}
321
buzbee5de34942012-03-01 14:51:57 -0800322// FIXME: need to do some work to split out targets with
323// condition codes and those without
324#if defined(TARGET_ARM) || defined(TARGET_X86)
buzbee31a4a6f2012-02-28 15:36:15 -0800325LIR* genCheck(CompilationUnit* cUnit, ConditionCode cCode, MIR* mir,
326 ThrowKind kind)
327{
buzbeea2ebdd72012-03-04 14:57:06 -0800328 LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
329 mir ? mir->offset : 0);
buzbee82488f52012-03-02 08:20:26 -0800330 LIR* branch = opCondBranch(cUnit, cCode, tgt);
buzbee31a4a6f2012-02-28 15:36:15 -0800331 // Remember branch target - will process later
332 oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
333 return branch;
334}
buzbee5de34942012-03-01 14:51:57 -0800335#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800336
337LIR* genImmedCheck(CompilationUnit* cUnit, ConditionCode cCode,
338 int reg, int immVal, MIR* mir, ThrowKind kind)
339{
buzbeea2ebdd72012-03-04 14:57:06 -0800340 LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind, mir->offset);
buzbee31a4a6f2012-02-28 15:36:15 -0800341 LIR* branch;
342 if (cCode == kCondAl) {
buzbee82488f52012-03-02 08:20:26 -0800343 branch = opUnconditionalBranch(cUnit, tgt);
buzbee31a4a6f2012-02-28 15:36:15 -0800344 } else {
buzbee82488f52012-03-02 08:20:26 -0800345 branch = opCmpImmBranch(cUnit, cCode, reg, immVal, tgt);
buzbee31a4a6f2012-02-28 15:36:15 -0800346 }
347 // Remember branch target - will process later
348 oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
349 return branch;
350}
351
352/* Perform null-check on a register. */
353LIR* genNullCheck(CompilationUnit* cUnit, int sReg, int mReg, MIR* mir)
354{
355 if (!(cUnit->disableOpt & (1 << kNullCheckElimination)) &&
356 mir->optimizationFlags & MIR_IGNORE_NULL_CHECK) {
357 return NULL;
358 }
359 return genImmedCheck(cUnit, kCondEq, mReg, 0, mir, kThrowNullPointer);
360}
361
362/* Perform check on two registers */
363LIR* genRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode,
Ian Rogersb5d09b22012-03-06 22:14:17 -0800364 int reg1, int reg2, MIR* mir, ThrowKind kind)
buzbee31a4a6f2012-02-28 15:36:15 -0800365{
buzbeea2ebdd72012-03-04 14:57:06 -0800366 LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
367 mir ? mir->offset : 0, reg1, reg2);
buzbee5de34942012-03-01 14:51:57 -0800368#if defined(TARGET_MIPS)
buzbee82488f52012-03-02 08:20:26 -0800369 LIR* branch = opCmpBranch(cUnit, cCode, reg1, reg2, tgt);
buzbee5de34942012-03-01 14:51:57 -0800370#else
buzbee31a4a6f2012-02-28 15:36:15 -0800371 opRegReg(cUnit, kOpCmp, reg1, reg2);
buzbee82488f52012-03-02 08:20:26 -0800372 LIR* branch = opCondBranch(cUnit, cCode, tgt);
buzbee5de34942012-03-01 14:51:57 -0800373#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800374 // Remember branch target - will process later
375 oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
376 return branch;
377}
378
379void genCompareAndBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
380 RegLocation rlSrc1, RegLocation rlSrc2, LIR* labelList)
381{
382 ConditionCode cond;
383 rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
384 rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
Elliott Hughesadb8c672012-03-06 16:49:32 -0800385 Instruction::Code opcode = mir->dalvikInsn.opcode;
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700386 switch (opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -0800387 case Instruction::IF_EQ:
buzbee31a4a6f2012-02-28 15:36:15 -0800388 cond = kCondEq;
389 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800390 case Instruction::IF_NE:
buzbee31a4a6f2012-02-28 15:36:15 -0800391 cond = kCondNe;
392 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800393 case Instruction::IF_LT:
buzbee31a4a6f2012-02-28 15:36:15 -0800394 cond = kCondLt;
395 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800396 case Instruction::IF_GE:
buzbee31a4a6f2012-02-28 15:36:15 -0800397 cond = kCondGe;
398 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800399 case Instruction::IF_GT:
buzbee31a4a6f2012-02-28 15:36:15 -0800400 cond = kCondGt;
401 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800402 case Instruction::IF_LE:
buzbee31a4a6f2012-02-28 15:36:15 -0800403 cond = kCondLe;
404 break;
405 default:
406 cond = (ConditionCode)0;
407 LOG(FATAL) << "Unexpected opcode " << (int)opcode;
408 }
buzbee5de34942012-03-01 14:51:57 -0800409#if defined(TARGET_MIPS)
buzbee82488f52012-03-02 08:20:26 -0800410 opCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg,
411 &labelList[bb->taken->id]);
buzbee5de34942012-03-01 14:51:57 -0800412#else
413 opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
buzbee82488f52012-03-02 08:20:26 -0800414 opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
buzbee5de34942012-03-01 14:51:57 -0800415#endif
buzbee82488f52012-03-02 08:20:26 -0800416 opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
buzbee31a4a6f2012-02-28 15:36:15 -0800417}
418
419void genCompareZeroAndBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
420 RegLocation rlSrc, LIR* labelList)
421{
422 ConditionCode cond;
423 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
Elliott Hughesadb8c672012-03-06 16:49:32 -0800424 Instruction::Code opcode = mir->dalvikInsn.opcode;
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700425 switch (opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -0800426 case Instruction::IF_EQZ:
buzbee31a4a6f2012-02-28 15:36:15 -0800427 cond = kCondEq;
428 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800429 case Instruction::IF_NEZ:
buzbee31a4a6f2012-02-28 15:36:15 -0800430 cond = kCondNe;
431 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800432 case Instruction::IF_LTZ:
buzbee31a4a6f2012-02-28 15:36:15 -0800433 cond = kCondLt;
434 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800435 case Instruction::IF_GEZ:
buzbee31a4a6f2012-02-28 15:36:15 -0800436 cond = kCondGe;
437 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800438 case Instruction::IF_GTZ:
buzbee31a4a6f2012-02-28 15:36:15 -0800439 cond = kCondGt;
440 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800441 case Instruction::IF_LEZ:
buzbee31a4a6f2012-02-28 15:36:15 -0800442 cond = kCondLe;
443 break;
444 default:
445 cond = (ConditionCode)0;
446 LOG(FATAL) << "Unexpected opcode " << (int)opcode;
447 }
Ian Rogers7caad772012-03-30 01:07:54 -0700448#if defined(TARGET_MIPS) || defined(TARGET_X86)
buzbee82488f52012-03-02 08:20:26 -0800449 opCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, &labelList[bb->taken->id]);
buzbee5de34942012-03-01 14:51:57 -0800450#else
451 opRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
buzbee82488f52012-03-02 08:20:26 -0800452 opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
buzbee5de34942012-03-01 14:51:57 -0800453#endif
buzbee82488f52012-03-02 08:20:26 -0800454 opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
buzbee31a4a6f2012-02-28 15:36:15 -0800455}
456
457void genIntToLong(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
458 RegLocation rlSrc)
459{
460 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
461 if (rlSrc.location == kLocPhysReg) {
buzbee82488f52012-03-02 08:20:26 -0800462 opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
buzbee31a4a6f2012-02-28 15:36:15 -0800463 } else {
464 loadValueDirect(cUnit, rlSrc, rlResult.lowReg);
465 }
466 opRegRegImm(cUnit, kOpAsr, rlResult.highReg,
467 rlResult.lowReg, 31);
468 storeValueWide(cUnit, rlDest, rlResult);
469}
470
471void genIntNarrowing(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
472 RegLocation rlSrc)
473{
474 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
475 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
476 OpKind op = kOpInvalid;
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700477 switch (mir->dalvikInsn.opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -0800478 case Instruction::INT_TO_BYTE:
buzbee31a4a6f2012-02-28 15:36:15 -0800479 op = kOp2Byte;
480 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800481 case Instruction::INT_TO_SHORT:
buzbee31a4a6f2012-02-28 15:36:15 -0800482 op = kOp2Short;
483 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -0800484 case Instruction::INT_TO_CHAR:
buzbee31a4a6f2012-02-28 15:36:15 -0800485 op = kOp2Char;
486 break;
487 default:
488 LOG(ERROR) << "Bad int conversion type";
489 }
490 opRegReg(cUnit, op, rlResult.lowReg, rlSrc.lowReg);
491 storeValue(cUnit, rlDest, rlResult);
492}
493
494/*
495 * Let helper function take care of everything. Will call
496 * Array::AllocFromCode(type_idx, method, count);
497 * Note: AllocFromCode will handle checks for errNegativeArraySize.
498 */
499void genNewArray(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
500 RegLocation rlSrc)
501{
502 oatFlushAllRegs(cUnit); /* Everything to home location */
503 uint32_t type_idx = mir->dalvikInsn.vC;
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700504 int funcOffset;
buzbee31a4a6f2012-02-28 15:36:15 -0800505 if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
506 cUnit->dex_cache,
507 *cUnit->dex_file,
508 type_idx)) {
Ian Rogers57b86d42012-03-27 16:05:41 -0700509 funcOffset = ENTRYPOINT_OFFSET(pAllocArrayFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800510 } else {
Ian Rogers57b86d42012-03-27 16:05:41 -0700511 funcOffset= ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
buzbee31a4a6f2012-02-28 15:36:15 -0800512 }
Ian Rogersab2b55d2012-03-18 00:06:11 -0700513 callRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc);
Ian Rogersf7d9ad32012-03-13 18:45:39 -0700514 RegLocation rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -0800515 storeValue(cUnit, rlDest, rlResult);
516}
517
518/*
519 * Similar to genNewArray, but with post-allocation initialization.
520 * Verifier guarantees we're dealing with an array class. Current
521 * code throws runtime exception "bad Filled array req" for 'D' and 'J'.
522 * Current code also throws internal unimp if not 'L', '[' or 'I'.
523 */
524void genFilledNewArray(CompilationUnit* cUnit, MIR* mir, bool isRange)
525{
526 DecodedInstruction* dInsn = &mir->dalvikInsn;
527 int elems = dInsn->vA;
Ian Rogersab2b55d2012-03-18 00:06:11 -0700528 int typeIdx = dInsn->vB;
buzbee31a4a6f2012-02-28 15:36:15 -0800529 oatFlushAllRegs(cUnit); /* Everything to home location */
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700530 int funcOffset;
buzbee31a4a6f2012-02-28 15:36:15 -0800531 if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
532 cUnit->dex_cache,
533 *cUnit->dex_file,
Ian Rogersab2b55d2012-03-18 00:06:11 -0700534 typeIdx)) {
Ian Rogers57b86d42012-03-27 16:05:41 -0700535 funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800536 } else {
Ian Rogers57b86d42012-03-27 16:05:41 -0700537 funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
buzbee31a4a6f2012-02-28 15:36:15 -0800538 }
Ian Rogersab2b55d2012-03-18 00:06:11 -0700539 callRuntimeHelperImmMethodImm(cUnit, funcOffset, typeIdx, elems);
buzbeee1965672012-03-11 18:39:19 -0700540 oatFreeTemp(cUnit, rARG2);
541 oatFreeTemp(cUnit, rARG1);
buzbee31a4a6f2012-02-28 15:36:15 -0800542 /*
Elliott Hughesadb8c672012-03-06 16:49:32 -0800543 * NOTE: the implicit target for Instruction::FILLED_NEW_ARRAY is the
buzbee31a4a6f2012-02-28 15:36:15 -0800544 * return region. Because AllocFromCode placed the new array
545 * in rRET0, we'll just lock it into place. When debugger support is
546 * added, it may be necessary to additionally copy all return
547 * values to a home location in thread-local storage
548 */
549 oatLockTemp(cUnit, rRET0);
550
551 // TODO: use the correct component size, currently all supported types
552 // share array alignment with ints (see comment at head of function)
553 size_t component_size = sizeof(int32_t);
554
555 // Having a range of 0 is legal
556 if (isRange && (dInsn->vA > 0)) {
557 /*
558 * Bit of ugliness here. We're going generate a mem copy loop
559 * on the register range, but it is possible that some regs
560 * in the range have been promoted. This is unlikely, but
561 * before generating the copy, we'll just force a flush
562 * of any regs in the source range that have been promoted to
563 * home location.
564 */
565 for (unsigned int i = 0; i < dInsn->vA; i++) {
566 RegLocation loc = oatUpdateLoc(cUnit,
567 oatGetSrc(cUnit, mir, i));
568 if (loc.location == kLocPhysReg) {
569 storeBaseDisp(cUnit, rSP, oatSRegOffset(cUnit, loc.sRegLow),
570 loc.lowReg, kWord);
571 }
572 }
573 /*
574 * TUNING note: generated code here could be much improved, but
575 * this is an uncommon operation and isn't especially performance
576 * critical.
577 */
578 int rSrc = oatAllocTemp(cUnit);
579 int rDst = oatAllocTemp(cUnit);
580 int rIdx = oatAllocTemp(cUnit);
buzbee5de34942012-03-01 14:51:57 -0800581#if defined(TARGET_ARM)
buzbee31a4a6f2012-02-28 15:36:15 -0800582 int rVal = rLR; // Using a lot of temps, rLR is known free here
buzbee5de34942012-03-01 14:51:57 -0800583#else
584 int rVal = oatAllocTemp(cUnit);
585#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800586 // Set up source pointer
587 RegLocation rlFirst = oatGetSrc(cUnit, mir, 0);
Ian Rogersb5d09b22012-03-06 22:14:17 -0800588#if defined(TARGET_X86)
589 UNIMPLEMENTED(FATAL);
590#else
buzbee31a4a6f2012-02-28 15:36:15 -0800591 opRegRegImm(cUnit, kOpAdd, rSrc, rSP,
592 oatSRegOffset(cUnit, rlFirst.sRegLow));
593 // Set up the target pointer
594 opRegRegImm(cUnit, kOpAdd, rDst, rRET0,
595 Array::DataOffset(component_size).Int32Value());
Ian Rogersb5d09b22012-03-06 22:14:17 -0800596#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800597 // Set up the loop counter (known to be > 0)
598 loadConstant(cUnit, rIdx, dInsn->vA - 1);
599 // Generate the copy loop. Going backwards for convenience
600 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -0800601 // Copy next element
602 loadBaseIndexed(cUnit, rSrc, rIdx, rVal, 2, kWord);
603 storeBaseIndexed(cUnit, rDst, rIdx, rVal, 2, kWord);
604#if defined(TARGET_ARM)
605 // Combine sub & test using sub setflags encoding here
606 newLIR3(cUnit, kThumb2SubsRRI12, rIdx, rIdx, 1);
buzbee82488f52012-03-02 08:20:26 -0800607 opCondBranch(cUnit, kCondGe, target);
buzbee31a4a6f2012-02-28 15:36:15 -0800608#else
buzbee5de34942012-03-01 14:51:57 -0800609 oatFreeTemp(cUnit, rVal);
buzbee31a4a6f2012-02-28 15:36:15 -0800610 opRegImm(cUnit, kOpSub, rIdx, 1);
buzbee82488f52012-03-02 08:20:26 -0800611 opCmpImmBranch(cUnit, kCondGe, rIdx, 0, target);
buzbee31a4a6f2012-02-28 15:36:15 -0800612#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800613 } else if (!isRange) {
614 // TUNING: interleave
615 for (unsigned int i = 0; i < dInsn->vA; i++) {
616 RegLocation rlArg = loadValue(cUnit,
617 oatGetSrc(cUnit, mir, i), kCoreReg);
618 storeBaseDisp(cUnit, rRET0,
619 Array::DataOffset(component_size).Int32Value() +
620 i * 4, rlArg.lowReg, kWord);
621 // If the loadValue caused a temp to be allocated, free it
622 if (oatIsTemp(cUnit, rlArg.lowReg)) {
623 oatFreeTemp(cUnit, rlArg.lowReg);
624 }
625 }
626 }
627}
628
629void genSput(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc,
630 bool isLongOrDouble, bool isObject)
631{
632 int fieldOffset;
633 int ssbIndex;
634 bool isVolatile;
635 bool isReferrersClass;
636 uint32_t fieldIdx = mir->dalvikInsn.vB;
637
638 OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
639 *cUnit->dex_file, *cUnit->dex_cache,
640 cUnit->code_item, cUnit->method_idx,
641 cUnit->access_flags);
642
643 bool fastPath =
644 cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
645 fieldOffset, ssbIndex,
646 isReferrersClass, isVolatile, true);
647 if (fastPath && !SLOW_FIELD_PATH) {
648 DCHECK_GE(fieldOffset, 0);
649 int rBase;
buzbee31a4a6f2012-02-28 15:36:15 -0800650 if (isReferrersClass) {
651 // Fast path, static storage base is this method's class
buzbeee1965672012-03-11 18:39:19 -0700652 RegLocation rlMethod = loadCurrMethod(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -0800653 rBase = oatAllocTemp(cUnit);
buzbeee1965672012-03-11 18:39:19 -0700654 loadWordDisp(cUnit, rlMethod.lowReg,
buzbee31a4a6f2012-02-28 15:36:15 -0800655 Method::DeclaringClassOffset().Int32Value(), rBase);
Ian Rogersc6f3bb82012-03-21 20:40:33 -0700656 if (oatIsTemp(cUnit, rlMethod.lowReg)) {
657 oatFreeTemp(cUnit, rlMethod.lowReg);
658 }
buzbee31a4a6f2012-02-28 15:36:15 -0800659 } else {
660 // Medium path, static storage base in a different class which
661 // requires checks that the other class is initialized.
662 DCHECK_GE(ssbIndex, 0);
663 // May do runtime call so everything to home locations.
664 oatFlushAllRegs(cUnit);
665 // Using fixed register to sync with possible call to runtime
666 // support.
buzbeee1965672012-03-11 18:39:19 -0700667 int rMethod = rARG1;
buzbee31a4a6f2012-02-28 15:36:15 -0800668 oatLockTemp(cUnit, rMethod);
669 loadCurrMethodDirect(cUnit, rMethod);
670 rBase = rARG0;
671 oatLockTemp(cUnit, rBase);
672 loadWordDisp(cUnit, rMethod,
673 Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
674 rBase);
675 loadWordDisp(cUnit, rBase,
676 Array::DataOffset(sizeof(Object*)).Int32Value() + sizeof(int32_t*) *
677 ssbIndex, rBase);
678 // rBase now points at appropriate static storage base (Class*)
679 // or NULL if not initialized. Check for NULL and call helper if NULL.
680 // TUNING: fast path should fall through
buzbee82488f52012-03-02 08:20:26 -0800681 LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -0800682 loadConstant(cUnit, rARG0, ssbIndex);
Ian Rogersab2b55d2012-03-18 00:06:11 -0700683 callRuntimeHelperImm(cUnit,
Ian Rogers57b86d42012-03-27 16:05:41 -0700684 ENTRYPOINT_OFFSET(pInitializeStaticStorage),
Ian Rogersab2b55d2012-03-18 00:06:11 -0700685 ssbIndex);
buzbee31a4a6f2012-02-28 15:36:15 -0800686#if defined(TARGET_MIPS)
687 // For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
buzbee82488f52012-03-02 08:20:26 -0800688 opRegCopy(cUnit, rBase, rRET0);
buzbee31a4a6f2012-02-28 15:36:15 -0800689#endif
690 LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -0800691 branchOver->target = (LIR*)skipTarget;
buzbeee1965672012-03-11 18:39:19 -0700692 oatFreeTemp(cUnit, rMethod);
buzbee31a4a6f2012-02-28 15:36:15 -0800693 }
694 // rBase now holds static storage base
buzbee31a4a6f2012-02-28 15:36:15 -0800695 if (isLongOrDouble) {
696 rlSrc = oatGetSrcWide(cUnit, mir, 0, 1);
697 rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
698 } else {
699 rlSrc = oatGetSrc(cUnit, mir, 0);
700 rlSrc = loadValue(cUnit, rlSrc, kAnyReg);
701 }
702//FIXME: need to generalize the barrier call
703 if (isVolatile) {
704 oatGenMemBarrier(cUnit, kST);
705 }
706 if (isLongOrDouble) {
707 storeBaseDispWide(cUnit, rBase, fieldOffset, rlSrc.lowReg,
708 rlSrc.highReg);
709 } else {
710 storeWordDisp(cUnit, rBase, fieldOffset, rlSrc.lowReg);
711 }
712 if (isVolatile) {
713 oatGenMemBarrier(cUnit, kSY);
714 }
715 if (isObject) {
716 markGCCard(cUnit, rlSrc.lowReg, rBase);
717 }
718 oatFreeTemp(cUnit, rBase);
719 } else {
720 oatFlushAllRegs(cUnit); // Everything to home locations
Ian Rogers57b86d42012-03-27 16:05:41 -0700721 int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Static) :
722 (isObject ? ENTRYPOINT_OFFSET(pSetObjStatic)
723 : ENTRYPOINT_OFFSET(pSet32Static));
Ian Rogersab2b55d2012-03-18 00:06:11 -0700724 callRuntimeHelperImmRegLocation(cUnit, setterOffset, fieldIdx, rlSrc);
buzbee31a4a6f2012-02-28 15:36:15 -0800725 }
726}
727
728void genSget(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
729 bool isLongOrDouble, bool isObject)
730{
731 int fieldOffset;
732 int ssbIndex;
733 bool isVolatile;
734 bool isReferrersClass;
735 uint32_t fieldIdx = mir->dalvikInsn.vB;
736
737 OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
738 *cUnit->dex_file, *cUnit->dex_cache,
739 cUnit->code_item, cUnit->method_idx,
740 cUnit->access_flags);
741
742 bool fastPath =
743 cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
744 fieldOffset, ssbIndex,
745 isReferrersClass, isVolatile,
746 false);
747 if (fastPath && !SLOW_FIELD_PATH) {
748 DCHECK_GE(fieldOffset, 0);
749 int rBase;
buzbee31a4a6f2012-02-28 15:36:15 -0800750 if (isReferrersClass) {
751 // Fast path, static storage base is this method's class
buzbeee1965672012-03-11 18:39:19 -0700752 RegLocation rlMethod = loadCurrMethod(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -0800753 rBase = oatAllocTemp(cUnit);
buzbeee1965672012-03-11 18:39:19 -0700754 loadWordDisp(cUnit, rlMethod.lowReg,
buzbee31a4a6f2012-02-28 15:36:15 -0800755 Method::DeclaringClassOffset().Int32Value(), rBase);
756 } else {
757 // Medium path, static storage base in a different class which
758 // requires checks that the other class is initialized
759 DCHECK_GE(ssbIndex, 0);
760 // May do runtime call so everything to home locations.
761 oatFlushAllRegs(cUnit);
762 // Using fixed register to sync with possible call to runtime
763 // support
buzbeee1965672012-03-11 18:39:19 -0700764 int rMethod = rARG1;
buzbee31a4a6f2012-02-28 15:36:15 -0800765 oatLockTemp(cUnit, rMethod);
766 loadCurrMethodDirect(cUnit, rMethod);
767 rBase = rARG0;
768 oatLockTemp(cUnit, rBase);
769 loadWordDisp(cUnit, rMethod,
770 Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
771 rBase);
772 loadWordDisp(cUnit, rBase,
773 Array::DataOffset(sizeof(Object*)).Int32Value() +
774 sizeof(int32_t*) * ssbIndex,
775 rBase);
776 // rBase now points at appropriate static storage base (Class*)
777 // or NULL if not initialized. Check for NULL and call helper if NULL.
778 // TUNING: fast path should fall through
buzbee82488f52012-03-02 08:20:26 -0800779 LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
Ian Rogersab2b55d2012-03-18 00:06:11 -0700780 callRuntimeHelperImm(cUnit,
Ian Rogers57b86d42012-03-27 16:05:41 -0700781 ENTRYPOINT_OFFSET(pInitializeStaticStorage),
Ian Rogersab2b55d2012-03-18 00:06:11 -0700782 ssbIndex);
buzbee31a4a6f2012-02-28 15:36:15 -0800783#if defined(TARGET_MIPS)
784 // For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
buzbee82488f52012-03-02 08:20:26 -0800785 opRegCopy(cUnit, rBase, rRET0);
buzbee31a4a6f2012-02-28 15:36:15 -0800786#endif
787 LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -0800788 branchOver->target = (LIR*)skipTarget;
buzbeee1965672012-03-11 18:39:19 -0700789 oatFreeTemp(cUnit, rMethod);
buzbee31a4a6f2012-02-28 15:36:15 -0800790 }
791 // rBase now holds static storage base
buzbee31a4a6f2012-02-28 15:36:15 -0800792 rlDest = isLongOrDouble ? oatGetDestWide(cUnit, mir, 0, 1)
793 : oatGetDest(cUnit, mir, 0);
794 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
795 if (isVolatile) {
796 oatGenMemBarrier(cUnit, kSY);
797 }
798 if (isLongOrDouble) {
799 loadBaseDispWide(cUnit, NULL, rBase, fieldOffset, rlResult.lowReg,
800 rlResult.highReg, INVALID_SREG);
801 } else {
802 loadWordDisp(cUnit, rBase, fieldOffset, rlResult.lowReg);
803 }
804 oatFreeTemp(cUnit, rBase);
805 if (isLongOrDouble) {
806 storeValueWide(cUnit, rlDest, rlResult);
807 } else {
808 storeValue(cUnit, rlDest, rlResult);
809 }
810 } else {
811 oatFlushAllRegs(cUnit); // Everything to home locations
Ian Rogers57b86d42012-03-27 16:05:41 -0700812 int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Static) :
813 (isObject ? ENTRYPOINT_OFFSET(pGetObjStatic)
814 : ENTRYPOINT_OFFSET(pGet32Static));
Ian Rogersab2b55d2012-03-18 00:06:11 -0700815 callRuntimeHelperImm(cUnit, getterOffset, fieldIdx);
buzbee31a4a6f2012-02-28 15:36:15 -0800816 if (isLongOrDouble) {
Ian Rogersf7d9ad32012-03-13 18:45:39 -0700817 RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
buzbee31a4a6f2012-02-28 15:36:15 -0800818 storeValueWide(cUnit, rlDest, rlResult);
819 } else {
Ian Rogersf7d9ad32012-03-13 18:45:39 -0700820 RegLocation rlResult = oatGetReturn(cUnit, rlDest.fp);
buzbee31a4a6f2012-02-28 15:36:15 -0800821 storeValue(cUnit, rlDest, rlResult);
822 }
823 }
824}
825
826
827// Debugging routine - if null target, branch to DebugMe
828void genShowTarget(CompilationUnit* cUnit)
829{
buzbeea7678db2012-03-05 15:35:46 -0800830#if defined(TARGET_X86)
831 UNIMPLEMENTED(WARNING) << "genShowTarget";
832#else
buzbee0398c422012-03-02 15:22:47 -0800833 LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rINVOKE_TGT, 0, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -0800834 loadWordDisp(cUnit, rSELF,
Ian Rogers57b86d42012-03-27 16:05:41 -0700835 ENTRYPOINT_OFFSET(pDebugMe), rINVOKE_TGT);
buzbee31a4a6f2012-02-28 15:36:15 -0800836 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -0800837 branchOver->target = (LIR*)target;
buzbeea7678db2012-03-05 15:35:46 -0800838#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800839}
840
841void genThrowVerificationError(CompilationUnit* cUnit, MIR* mir)
842{
Ian Rogers57b86d42012-03-27 16:05:41 -0700843 callRuntimeHelperImmImm(cUnit, ENTRYPOINT_OFFSET(pThrowVerificationErrorFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -0700844 mir->dalvikInsn.vA, mir->dalvikInsn.vB);
buzbee31a4a6f2012-02-28 15:36:15 -0800845}
846
847void handleSuspendLaunchpads(CompilationUnit *cUnit)
848{
Ian Rogersab2b55d2012-03-18 00:06:11 -0700849 LIR** suspendLabel = (LIR **)cUnit->suspendLaunchpads.elemList;
buzbee31a4a6f2012-02-28 15:36:15 -0800850 int numElems = cUnit->suspendLaunchpads.numUsed;
buzbee31a4a6f2012-02-28 15:36:15 -0800851 for (int i = 0; i < numElems; i++) {
buzbeec5159d52012-03-03 11:48:39 -0800852 oatResetRegPool(cUnit);
buzbeefc9e6fa2012-03-23 15:14:29 -0700853 oatResetDefTracking(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -0800854 LIR* lab = suspendLabel[i];
855 LIR* resumeLab = (LIR*)lab->operands[0];
856 cUnit->currentDalvikOffset = lab->operands[1];
Ian Rogersab2b55d2012-03-18 00:06:11 -0700857 oatAppendLIR(cUnit, lab);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700858#if defined(TARGET_X86)
859 opThreadMem(cUnit, kOpBlx,
Ian Rogers57b86d42012-03-27 16:05:41 -0700860 ENTRYPOINT_OFFSET(pTestSuspendFromCode));
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700861#else
Ian Rogers57b86d42012-03-27 16:05:41 -0700862 int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pTestSuspendFromCode));
buzbee31a4a6f2012-02-28 15:36:15 -0800863 opReg(cUnit, kOpBlx, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700864#endif
buzbee82488f52012-03-02 08:20:26 -0800865 opUnconditionalBranch(cUnit, resumeLab);
buzbee31a4a6f2012-02-28 15:36:15 -0800866 }
867}
868
buzbeefc9e6fa2012-03-23 15:14:29 -0700869void handleIntrinsicLaunchpads(CompilationUnit *cUnit)
870{
871 LIR** intrinsicLabel = (LIR **)cUnit->intrinsicLaunchpads.elemList;
872 int numElems = cUnit->intrinsicLaunchpads.numUsed;
873 for (int i = 0; i < numElems; i++) {
874 oatResetRegPool(cUnit);
875 oatResetDefTracking(cUnit);
876 LIR* lab = intrinsicLabel[i];
877 MIR* mir = (MIR*)lab->operands[0];
878 InvokeType type = (InvokeType)lab->operands[1];
879 BasicBlock* bb = (BasicBlock*)lab->operands[3];
880 cUnit->currentDalvikOffset = mir->offset;
881 oatAppendLIR(cUnit, lab);
882 genInvoke(cUnit, bb, mir, type, false /* isRange */);
883 LIR* resumeLab = (LIR*)lab->operands[2];
884 if (resumeLab != NULL) {
885 opUnconditionalBranch(cUnit, resumeLab);
886 }
887 }
888}
889
buzbee31a4a6f2012-02-28 15:36:15 -0800890void handleThrowLaunchpads(CompilationUnit *cUnit)
891{
Ian Rogersab2b55d2012-03-18 00:06:11 -0700892 LIR** throwLabel = (LIR **)cUnit->throwLaunchpads.elemList;
buzbee31a4a6f2012-02-28 15:36:15 -0800893 int numElems = cUnit->throwLaunchpads.numUsed;
Ian Rogersab2b55d2012-03-18 00:06:11 -0700894 for (int i = 0; i < numElems; i++) {
buzbeec5159d52012-03-03 11:48:39 -0800895 oatResetRegPool(cUnit);
buzbeefc9e6fa2012-03-23 15:14:29 -0700896 oatResetDefTracking(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -0800897 LIR* lab = throwLabel[i];
898 cUnit->currentDalvikOffset = lab->operands[1];
Ian Rogersab2b55d2012-03-18 00:06:11 -0700899 oatAppendLIR(cUnit, lab);
buzbee31a4a6f2012-02-28 15:36:15 -0800900 int funcOffset = 0;
901 int v1 = lab->operands[2];
902 int v2 = lab->operands[3];
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700903 switch (lab->operands[0]) {
buzbee31a4a6f2012-02-28 15:36:15 -0800904 case kThrowNullPointer:
Ian Rogers57b86d42012-03-27 16:05:41 -0700905 funcOffset = ENTRYPOINT_OFFSET(pThrowNullPointerFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800906 break;
907 case kThrowArrayBounds:
buzbee5de34942012-03-01 14:51:57 -0800908 if (v2 != rARG0) {
buzbee82488f52012-03-02 08:20:26 -0800909 opRegCopy(cUnit, rARG0, v1);
910 opRegCopy(cUnit, rARG1, v2);
buzbee31a4a6f2012-02-28 15:36:15 -0800911 } else {
buzbee5de34942012-03-01 14:51:57 -0800912 if (v1 == rARG1) {
buzbee31a4a6f2012-02-28 15:36:15 -0800913#if defined(TARGET_ARM)
914 int rTmp = r12;
915#else
916 int rTmp = oatAllocTemp(cUnit);
917#endif
buzbee82488f52012-03-02 08:20:26 -0800918 opRegCopy(cUnit, rTmp, v1);
919 opRegCopy(cUnit, rARG1, v2);
920 opRegCopy(cUnit, rARG0, rTmp);
buzbee31a4a6f2012-02-28 15:36:15 -0800921 } else {
buzbee82488f52012-03-02 08:20:26 -0800922 opRegCopy(cUnit, rARG1, v2);
923 opRegCopy(cUnit, rARG0, v1);
buzbee31a4a6f2012-02-28 15:36:15 -0800924 }
925 }
Ian Rogers57b86d42012-03-27 16:05:41 -0700926 funcOffset = ENTRYPOINT_OFFSET(pThrowArrayBoundsFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800927 break;
928 case kThrowDivZero:
Ian Rogers57b86d42012-03-27 16:05:41 -0700929 funcOffset = ENTRYPOINT_OFFSET(pThrowDivZeroFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800930 break;
931 case kThrowVerificationError:
932 loadConstant(cUnit, rARG0, v1);
933 loadConstant(cUnit, rARG1, v2);
934 funcOffset =
Ian Rogers57b86d42012-03-27 16:05:41 -0700935 ENTRYPOINT_OFFSET(pThrowVerificationErrorFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800936 break;
937 case kThrowNoSuchMethod:
buzbee82488f52012-03-02 08:20:26 -0800938 opRegCopy(cUnit, rARG0, v1);
buzbee31a4a6f2012-02-28 15:36:15 -0800939 funcOffset =
Ian Rogers57b86d42012-03-27 16:05:41 -0700940 ENTRYPOINT_OFFSET(pThrowNoSuchMethodFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800941 break;
942 case kThrowStackOverflow:
943 funcOffset =
Ian Rogers57b86d42012-03-27 16:05:41 -0700944 ENTRYPOINT_OFFSET(pThrowStackOverflowFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -0800945 // Restore stack alignment
946 opRegImm(cUnit, kOpAdd, rSP,
947 (cUnit->numCoreSpills + cUnit->numFPSpills) * 4);
948 break;
949 default:
950 LOG(FATAL) << "Unexpected throw kind: " << lab->operands[0];
951 }
Ian Rogersab2b55d2012-03-18 00:06:11 -0700952 oatClobberCalleeSave(cUnit);
953#if !defined(TARGET_X86)
buzbee31a4a6f2012-02-28 15:36:15 -0800954 int rTgt = loadHelper(cUnit, funcOffset);
Ian Rogersab2b55d2012-03-18 00:06:11 -0700955 opReg(cUnit, kOpBlx, rTgt);
buzbee0398c422012-03-02 15:22:47 -0800956 oatFreeTemp(cUnit, rTgt);
Ian Rogersab2b55d2012-03-18 00:06:11 -0700957#else
958 opThreadMem(cUnit, kOpBlx, funcOffset);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -0700959#endif
buzbee31a4a6f2012-02-28 15:36:15 -0800960 }
961}
962
963/* Needed by the Assembler */
964void oatSetupResourceMasks(LIR* lir)
965{
966 setupResourceMasks(lir);
967}
968
buzbee16da88c2012-03-20 10:38:17 -0700969bool fastInstance(CompilationUnit* cUnit, uint32_t fieldIdx,
970 int& fieldOffset, bool& isVolatile, bool isPut)
971{
972 OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
973 *cUnit->dex_file, *cUnit->dex_cache,
974 cUnit->code_item, cUnit->method_idx,
975 cUnit->access_flags);
976 return cUnit->compiler->ComputeInstanceFieldInfo(fieldIdx, &mUnit,
977 fieldOffset, isVolatile, isPut);
978}
979
buzbee31a4a6f2012-02-28 15:36:15 -0800980void genIGet(CompilationUnit* cUnit, MIR* mir, OpSize size,
981 RegLocation rlDest, RegLocation rlObj,
982 bool isLongOrDouble, bool isObject)
983{
984 int fieldOffset;
985 bool isVolatile;
986 uint32_t fieldIdx = mir->dalvikInsn.vC;
987
buzbee16da88c2012-03-20 10:38:17 -0700988 bool fastPath = fastInstance(cUnit, fieldIdx, fieldOffset, isVolatile,
989 false);
buzbee31a4a6f2012-02-28 15:36:15 -0800990
991 if (fastPath && !SLOW_FIELD_PATH) {
992 RegLocation rlResult;
993 RegisterClass regClass = oatRegClassBySize(size);
994 DCHECK_GE(fieldOffset, 0);
995 rlObj = loadValue(cUnit, rlObj, kCoreReg);
996 if (isLongOrDouble) {
997 DCHECK(rlDest.wide);
998 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir);/* null? */
Ian Rogersb5d09b22012-03-06 22:14:17 -0800999#if defined(TARGET_X86)
1000 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1001 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir);/* null? */
1002 loadBaseDispWide(cUnit, mir, rlObj.lowReg, fieldOffset, rlResult.lowReg,
1003 rlResult.highReg, rlObj.sRegLow);
1004 if (isVolatile) {
1005 oatGenMemBarrier(cUnit, kSY);
1006 }
1007#else
buzbee31a4a6f2012-02-28 15:36:15 -08001008 int regPtr = oatAllocTemp(cUnit);
1009 opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
1010 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1011 loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
1012 if (isVolatile) {
1013 oatGenMemBarrier(cUnit, kSY);
1014 }
1015 oatFreeTemp(cUnit, regPtr);
Ian Rogersb5d09b22012-03-06 22:14:17 -08001016#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001017 storeValueWide(cUnit, rlDest, rlResult);
1018 } else {
1019 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1020 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir);/* null? */
1021 loadBaseDisp(cUnit, mir, rlObj.lowReg, fieldOffset, rlResult.lowReg,
1022 kWord, rlObj.sRegLow);
1023 if (isVolatile) {
1024 oatGenMemBarrier(cUnit, kSY);
1025 }
1026 storeValue(cUnit, rlDest, rlResult);
1027 }
1028 } else {
Ian Rogers57b86d42012-03-27 16:05:41 -07001029 int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Instance) :
1030 (isObject ? ENTRYPOINT_OFFSET(pGetObjInstance)
1031 : ENTRYPOINT_OFFSET(pGet32Instance));
Ian Rogersab2b55d2012-03-18 00:06:11 -07001032 callRuntimeHelperImmRegLocation(cUnit, getterOffset, fieldIdx, rlObj);
buzbee31a4a6f2012-02-28 15:36:15 -08001033 if (isLongOrDouble) {
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001034 RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
buzbee31a4a6f2012-02-28 15:36:15 -08001035 storeValueWide(cUnit, rlDest, rlResult);
1036 } else {
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001037 RegLocation rlResult = oatGetReturn(cUnit, rlDest.fp);
buzbee31a4a6f2012-02-28 15:36:15 -08001038 storeValue(cUnit, rlDest, rlResult);
1039 }
1040 }
1041}
1042
1043void genIPut(CompilationUnit* cUnit, MIR* mir, OpSize size, RegLocation rlSrc,
1044 RegLocation rlObj, bool isLongOrDouble, bool isObject)
1045{
1046 int fieldOffset;
1047 bool isVolatile;
1048 uint32_t fieldIdx = mir->dalvikInsn.vC;
1049
buzbee16da88c2012-03-20 10:38:17 -07001050 bool fastPath = fastInstance(cUnit, fieldIdx, fieldOffset, isVolatile,
1051 true);
buzbee31a4a6f2012-02-28 15:36:15 -08001052 if (fastPath && !SLOW_FIELD_PATH) {
1053 RegisterClass regClass = oatRegClassBySize(size);
1054 DCHECK_GE(fieldOffset, 0);
1055 rlObj = loadValue(cUnit, rlObj, kCoreReg);
1056 if (isLongOrDouble) {
1057 int regPtr;
1058 rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
1059 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir);/* null? */
1060 regPtr = oatAllocTemp(cUnit);
1061 opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
1062 if (isVolatile) {
1063 oatGenMemBarrier(cUnit, kST);
1064 }
1065 storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
1066 if (isVolatile) {
1067 oatGenMemBarrier(cUnit, kSY);
1068 }
1069 oatFreeTemp(cUnit, regPtr);
1070 } else {
1071 rlSrc = loadValue(cUnit, rlSrc, regClass);
1072 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir);/* null? */
1073 if (isVolatile) {
1074 oatGenMemBarrier(cUnit, kST);
1075 }
1076 storeBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, kWord);
1077 if (isVolatile) {
1078 oatGenMemBarrier(cUnit, kSY);
1079 }
buzbeea7c12682012-03-19 13:13:53 -07001080 if (isObject) {
1081 markGCCard(cUnit, rlSrc.lowReg, rlObj.lowReg);
1082 }
buzbee31a4a6f2012-02-28 15:36:15 -08001083 }
1084 } else {
Ian Rogers57b86d42012-03-27 16:05:41 -07001085 int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Instance) :
1086 (isObject ? ENTRYPOINT_OFFSET(pSetObjInstance)
1087 : ENTRYPOINT_OFFSET(pSet32Instance));
Ian Rogersab2b55d2012-03-18 00:06:11 -07001088 callRuntimeHelperImmRegLocationRegLocation(cUnit, setterOffset,
1089 fieldIdx, rlObj, rlSrc);
buzbee31a4a6f2012-02-28 15:36:15 -08001090 }
1091}
1092
1093void genConstClass(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
1094 RegLocation rlSrc)
1095{
1096 uint32_t type_idx = mir->dalvikInsn.vB;
buzbeee1965672012-03-11 18:39:19 -07001097 RegLocation rlMethod = loadCurrMethod(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -08001098 int resReg = oatAllocTemp(cUnit);
1099 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
1100 if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
1101 cUnit->dex_cache,
1102 *cUnit->dex_file,
1103 type_idx)) {
1104 // Call out to helper which resolves type and verifies access.
1105 // Resolved type returned in rRET0.
Ian Rogersab2b55d2012-03-18 00:06:11 -07001106 callRuntimeHelperImmReg(cUnit,
Ian Rogers57b86d42012-03-27 16:05:41 -07001107 ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001108 type_idx, rlMethod.lowReg);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001109 RegLocation rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08001110 storeValue(cUnit, rlDest, rlResult);
1111 } else {
1112 // We're don't need access checks, load type from dex cache
1113 int32_t dex_cache_offset =
1114 Method::DexCacheResolvedTypesOffset().Int32Value();
buzbeee1965672012-03-11 18:39:19 -07001115 loadWordDisp(cUnit, rlMethod.lowReg, dex_cache_offset, resReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001116 int32_t offset_of_type =
1117 Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
1118 * type_idx);
1119 loadWordDisp(cUnit, resReg, offset_of_type, rlResult.lowReg);
1120 if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(cUnit->dex_cache,
1121 type_idx) || SLOW_TYPE_PATH) {
1122 // Slow path, at runtime test if type is null and if so initialize
1123 oatFlushAllRegs(cUnit);
buzbee82488f52012-03-02 08:20:26 -08001124 LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, rlResult.lowReg, 0,
1125 NULL);
buzbee31a4a6f2012-02-28 15:36:15 -08001126 // Resolved, store and hop over following code
1127 storeValue(cUnit, rlDest, rlResult);
buzbee3d661942012-03-14 17:37:27 -07001128 /*
1129 * Because we have stores of the target value on two paths,
1130 * clobber temp tracking for the destination using the ssa name
1131 */
1132 oatClobberSReg(cUnit, rlDest.sRegLow);
buzbee82488f52012-03-02 08:20:26 -08001133 LIR* branch2 = opUnconditionalBranch(cUnit,0);
buzbee31a4a6f2012-02-28 15:36:15 -08001134 // TUNING: move slow path to end & remove unconditional branch
1135 LIR* target1 = newLIR0(cUnit, kPseudoTargetLabel);
buzbee5de34942012-03-01 14:51:57 -08001136 // Call out to helper, which will return resolved type in rARG0
Ian Rogers57b86d42012-03-27 16:05:41 -07001137 callRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001138 type_idx, rlMethod.lowReg);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001139 RegLocation rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08001140 storeValue(cUnit, rlDest, rlResult);
buzbee3d661942012-03-14 17:37:27 -07001141 /*
1142 * Because we have stores of the target value on two paths,
1143 * clobber temp tracking for the destination using the ssa name
1144 */
1145 oatClobberSReg(cUnit, rlDest.sRegLow);
buzbee31a4a6f2012-02-28 15:36:15 -08001146 // Rejoin code paths
1147 LIR* target2 = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -08001148 branch1->target = (LIR*)target1;
1149 branch2->target = (LIR*)target2;
1150 } else {
1151 // Fast path, we're done - just store result
1152 storeValue(cUnit, rlDest, rlResult);
1153 }
1154 }
1155}
Ian Rogersab2b55d2012-03-18 00:06:11 -07001156
buzbee31a4a6f2012-02-28 15:36:15 -08001157void genConstString(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
1158 RegLocation rlSrc)
1159{
1160 /* NOTE: Most strings should be available at compile time */
1161 uint32_t string_idx = mir->dalvikInsn.vB;
1162 int32_t offset_of_string = Array::DataOffset(sizeof(String*)).Int32Value() +
1163 (sizeof(String*) * string_idx);
1164 if (!cUnit->compiler->CanAssumeStringIsPresentInDexCache(
1165 cUnit->dex_cache, string_idx) || SLOW_STRING_PATH) {
1166 // slow path, resolve string if not in dex cache
1167 oatFlushAllRegs(cUnit);
1168 oatLockCallTemps(cUnit); // Using explicit registers
1169 loadCurrMethodDirect(cUnit, rARG2);
1170 loadWordDisp(cUnit, rARG2,
1171 Method::DexCacheStringsOffset().Int32Value(), rARG0);
1172 // Might call out to helper, which will return resolved string in rRET0
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001173#if !defined(TARGET_X86)
Ian Rogers57b86d42012-03-27 16:05:41 -07001174 int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode));
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001175#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001176 loadWordDisp(cUnit, rRET0, offset_of_string, rARG0);
1177 loadConstant(cUnit, rARG1, string_idx);
1178#if defined(TARGET_ARM)
1179 opRegImm(cUnit, kOpCmp, rRET0, 0); // Is resolved?
1180 genBarrier(cUnit);
1181 // For testing, always force through helper
1182 if (!EXERCISE_SLOWEST_STRING_PATH) {
buzbee82488f52012-03-02 08:20:26 -08001183 opIT(cUnit, kArmCondEq, "T");
buzbee31a4a6f2012-02-28 15:36:15 -08001184 }
buzbee82488f52012-03-02 08:20:26 -08001185 opRegCopy(cUnit, rARG0, rARG2); // .eq
buzbee31a4a6f2012-02-28 15:36:15 -08001186 opReg(cUnit, kOpBlx, rTgt); // .eq, helper(Method*, string_idx)
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001187 oatFreeTemp(cUnit, rTgt);
1188#elif defined(TARGET_MIPS)
buzbee82488f52012-03-02 08:20:26 -08001189 LIR* branch = opCmpImmBranch(cUnit, kCondNe, rRET0, 0, NULL);
1190 opRegCopy(cUnit, rARG0, rARG2); // .eq
buzbee31a4a6f2012-02-28 15:36:15 -08001191 opReg(cUnit, kOpBlx, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001192 oatFreeTemp(cUnit, rTgt);
buzbee31a4a6f2012-02-28 15:36:15 -08001193 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -08001194 branch->target = target;
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001195#else
Ian Rogers57b86d42012-03-27 16:05:41 -07001196 callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001197 rARG2, rARG1);
buzbee31a4a6f2012-02-28 15:36:15 -08001198#endif
1199 genBarrier(cUnit);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001200 storeValue(cUnit, rlDest, oatGetReturn(cUnit, false));
buzbee31a4a6f2012-02-28 15:36:15 -08001201 } else {
buzbeee1965672012-03-11 18:39:19 -07001202 RegLocation rlMethod = loadCurrMethod(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -08001203 int resReg = oatAllocTemp(cUnit);
1204 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
buzbeee1965672012-03-11 18:39:19 -07001205 loadWordDisp(cUnit, rlMethod.lowReg,
buzbee31a4a6f2012-02-28 15:36:15 -08001206 Method::DexCacheStringsOffset().Int32Value(), resReg);
1207 loadWordDisp(cUnit, resReg, offset_of_string, rlResult.lowReg);
1208 storeValue(cUnit, rlDest, rlResult);
1209 }
1210}
1211
1212/*
1213 * Let helper function take care of everything. Will
1214 * call Class::NewInstanceFromCode(type_idx, method);
1215 */
1216void genNewInstance(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest)
1217{
1218 oatFlushAllRegs(cUnit); /* Everything to home location */
1219 uint32_t type_idx = mir->dalvikInsn.vB;
1220 // alloc will always check for resolution, do we also need to verify
1221 // access because the verifier was unable to?
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001222 int funcOffset;
buzbee31a4a6f2012-02-28 15:36:15 -08001223 if (cUnit->compiler->CanAccessInstantiableTypeWithoutChecks(
1224 cUnit->method_idx, cUnit->dex_cache, *cUnit->dex_file, type_idx)) {
Ian Rogers57b86d42012-03-27 16:05:41 -07001225 funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCode);
buzbee31a4a6f2012-02-28 15:36:15 -08001226 } else {
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001227 funcOffset =
Ian Rogers57b86d42012-03-27 16:05:41 -07001228 ENTRYPOINT_OFFSET(pAllocObjectFromCodeWithAccessCheck);
buzbee31a4a6f2012-02-28 15:36:15 -08001229 }
Ian Rogersab2b55d2012-03-18 00:06:11 -07001230 callRuntimeHelperImmMethod(cUnit, funcOffset, type_idx);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001231 RegLocation rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08001232 storeValue(cUnit, rlDest, rlResult);
1233}
1234
Ian Rogersab2b55d2012-03-18 00:06:11 -07001235void genThrow(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
1236{
1237 oatFlushAllRegs(cUnit);
Ian Rogers57b86d42012-03-27 16:05:41 -07001238 callRuntimeHelperRegLocation(cUnit, ENTRYPOINT_OFFSET(pDeliverException), rlSrc);
Ian Rogersab2b55d2012-03-18 00:06:11 -07001239}
1240
buzbee31a4a6f2012-02-28 15:36:15 -08001241void genInstanceof(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
1242 RegLocation rlSrc)
1243{
1244 oatFlushAllRegs(cUnit);
1245 // May generate a call - use explicit registers
1246 oatLockCallTemps(cUnit);
1247 uint32_t type_idx = mir->dalvikInsn.vC;
buzbee5de34942012-03-01 14:51:57 -08001248 loadCurrMethodDirect(cUnit, rARG1); // rARG1 <= current Method*
buzbee31a4a6f2012-02-28 15:36:15 -08001249 int classReg = rARG2; // rARG2 will hold the Class*
1250 if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
1251 cUnit->dex_cache,
1252 *cUnit->dex_file,
1253 type_idx)) {
1254 // Check we have access to type_idx and if not throw IllegalAccessError,
buzbee5de34942012-03-01 14:51:57 -08001255 // returns Class* in rARG0
Ian Rogersab2b55d2012-03-18 00:06:11 -07001256 callRuntimeHelperImm(cUnit,
Ian Rogers57b86d42012-03-27 16:05:41 -07001257 ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001258 type_idx);
buzbee82488f52012-03-02 08:20:26 -08001259 opRegCopy(cUnit, classReg, rRET0); // Align usage with fast path
buzbee5de34942012-03-01 14:51:57 -08001260 loadValueDirectFixed(cUnit, rlSrc, rARG0); // rARG0 <= ref
buzbee31a4a6f2012-02-28 15:36:15 -08001261 } else {
buzbee5de34942012-03-01 14:51:57 -08001262 // Load dex cache entry into classReg (rARG2)
buzbee31a4a6f2012-02-28 15:36:15 -08001263 loadValueDirectFixed(cUnit, rlSrc, rARG0); // rARG0 <= ref
1264 loadWordDisp(cUnit, rARG1,
1265 Method::DexCacheResolvedTypesOffset().Int32Value(),
1266 classReg);
1267 int32_t offset_of_type =
1268 Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
1269 * type_idx);
1270 loadWordDisp(cUnit, classReg, offset_of_type, classReg);
1271 if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(
1272 cUnit->dex_cache, type_idx)) {
1273 // Need to test presence of type in dex cache at runtime
buzbee82488f52012-03-02 08:20:26 -08001274 LIR* hopBranch = opCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -08001275 // Not resolved
1276 // Call out to helper, which will return resolved type in rRET0
Ian Rogers57b86d42012-03-27 16:05:41 -07001277 callRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001278 type_idx);
buzbee82488f52012-03-02 08:20:26 -08001279 opRegCopy(cUnit, rARG2, rRET0); // Align usage with fast path
buzbee31a4a6f2012-02-28 15:36:15 -08001280 loadValueDirectFixed(cUnit, rlSrc, rARG0); /* reload Ref */
1281 // Rejoin code paths
1282 LIR* hopTarget = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -08001283 hopBranch->target = (LIR*)hopTarget;
1284 }
1285 }
1286 /* rARG0 is ref, rARG2 is class. If ref==null, use directly as bool result */
buzbee82488f52012-03-02 08:20:26 -08001287 LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, rARG0, 0, NULL);
Elliott Hughese84278b2012-03-22 10:06:53 -07001288 /* load object->klass_ */
buzbee31a4a6f2012-02-28 15:36:15 -08001289 DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
1290 loadWordDisp(cUnit, rARG0, Object::ClassOffset().Int32Value(), rARG1);
Elliott Hughese84278b2012-03-22 10:06:53 -07001291 /* rARG0 is ref, rARG1 is ref->klass_, rARG2 is class */
buzbee0398c422012-03-02 15:22:47 -08001292#if defined(TARGET_ARM)
1293 /* Uses conditional nullification */
Ian Rogers57b86d42012-03-27 16:05:41 -07001294 int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
buzbee31a4a6f2012-02-28 15:36:15 -08001295 opRegReg(cUnit, kOpCmp, rARG1, rARG2); // Same?
buzbee82488f52012-03-02 08:20:26 -08001296 opIT(cUnit, kArmCondEq, "EE"); // if-convert the test
buzbee31a4a6f2012-02-28 15:36:15 -08001297 loadConstant(cUnit, rARG0, 1); // .eq case - load true
buzbee82488f52012-03-02 08:20:26 -08001298 opRegCopy(cUnit, rARG0, rARG2); // .ne case - arg0 <= class
buzbee31a4a6f2012-02-28 15:36:15 -08001299 opReg(cUnit, kOpBlx, rTgt); // .ne case: helper(class, ref->class)
Ian Rogersab2b55d2012-03-18 00:06:11 -07001300 oatFreeTemp(cUnit, rTgt);
buzbee31a4a6f2012-02-28 15:36:15 -08001301#else
buzbee0398c422012-03-02 15:22:47 -08001302 /* Uses branchovers */
1303 loadConstant(cUnit, rARG0, 1); // assume true
1304 LIR* branchover = opCmpBranch(cUnit, kCondEq, rARG1, rARG2, NULL);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001305#if !defined(TARGET_X86)
Ian Rogers57b86d42012-03-27 16:05:41 -07001306 int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
buzbee0398c422012-03-02 15:22:47 -08001307 opRegCopy(cUnit, rARG0, rARG2); // .ne case - arg0 <= class
1308 opReg(cUnit, kOpBlx, rTgt); // .ne case: helper(class, ref->class)
Ian Rogersab2b55d2012-03-18 00:06:11 -07001309 oatFreeTemp(cUnit, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001310#else
1311 opRegCopy(cUnit, rARG0, rARG2);
Ian Rogersab2b55d2012-03-18 00:06:11 -07001312 opThreadMem(cUnit, kOpBlx,
Ian Rogers57b86d42012-03-27 16:05:41 -07001313 ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001314#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001315#endif
buzbee0398c422012-03-02 15:22:47 -08001316 oatClobberCalleeSave(cUnit);
1317 /* branch targets here */
buzbee31a4a6f2012-02-28 15:36:15 -08001318 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001319 RegLocation rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08001320 storeValue(cUnit, rlDest, rlResult);
buzbee0398c422012-03-02 15:22:47 -08001321 branch1->target = target;
1322#if !defined(TARGET_ARM)
1323 branchover->target = target;
1324#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001325}
1326
1327void genCheckCast(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
1328{
1329 oatFlushAllRegs(cUnit);
1330 // May generate a call - use explicit registers
1331 oatLockCallTemps(cUnit);
1332 uint32_t type_idx = mir->dalvikInsn.vB;
1333 loadCurrMethodDirect(cUnit, rARG1); // rARG1 <= current Method*
1334 int classReg = rARG2; // rARG2 will hold the Class*
1335 if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
1336 cUnit->dex_cache,
1337 *cUnit->dex_file,
1338 type_idx)) {
1339 // Check we have access to type_idx and if not throw IllegalAccessError,
1340 // returns Class* in rRET0
Ian Rogersab2b55d2012-03-18 00:06:11 -07001341 // InitializeTypeAndVerifyAccess(idx, method)
1342 callRuntimeHelperImmReg(cUnit,
Ian Rogers57b86d42012-03-27 16:05:41 -07001343 ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001344 type_idx, rARG1);
buzbee82488f52012-03-02 08:20:26 -08001345 opRegCopy(cUnit, classReg, rRET0); // Align usage with fast path
buzbee31a4a6f2012-02-28 15:36:15 -08001346 } else {
1347 // Load dex cache entry into classReg (rARG2)
1348 loadWordDisp(cUnit, rARG1,
1349 Method::DexCacheResolvedTypesOffset().Int32Value(),
1350 classReg);
1351 int32_t offset_of_type =
1352 Array::DataOffset(sizeof(Class*)).Int32Value() +
1353 (sizeof(Class*) * type_idx);
1354 loadWordDisp(cUnit, classReg, offset_of_type, classReg);
1355 if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(
1356 cUnit->dex_cache, type_idx)) {
1357 // Need to test presence of type in dex cache at runtime
buzbee82488f52012-03-02 08:20:26 -08001358 LIR* hopBranch = opCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -08001359 // Not resolved
buzbee5de34942012-03-01 14:51:57 -08001360 // Call out to helper, which will return resolved type in rARG0
Ian Rogersab2b55d2012-03-18 00:06:11 -07001361 // InitializeTypeFromCode(idx, method)
1362 callRuntimeHelperImmReg(cUnit,
Ian Rogers57b86d42012-03-27 16:05:41 -07001363 ENTRYPOINT_OFFSET(pInitializeTypeFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001364 type_idx, rARG1);
buzbee82488f52012-03-02 08:20:26 -08001365 opRegCopy(cUnit, classReg, rARG0); // Align usage with fast path
buzbee31a4a6f2012-02-28 15:36:15 -08001366 // Rejoin code paths
1367 LIR* hopTarget = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -08001368 hopBranch->target = (LIR*)hopTarget;
1369 }
1370 }
buzbee5de34942012-03-01 14:51:57 -08001371 // At this point, classReg (rARG2) has class
buzbee31a4a6f2012-02-28 15:36:15 -08001372 loadValueDirectFixed(cUnit, rlSrc, rARG0); // rARG0 <= ref
1373 /* Null is OK - continue */
buzbee82488f52012-03-02 08:20:26 -08001374 LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, rARG0, 0, NULL);
Elliott Hughese84278b2012-03-22 10:06:53 -07001375 /* load object->klass_ */
buzbee31a4a6f2012-02-28 15:36:15 -08001376 DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
1377 loadWordDisp(cUnit, rARG0, Object::ClassOffset().Int32Value(), rARG1);
Elliott Hughese84278b2012-03-22 10:06:53 -07001378 /* rARG1 now contains object->klass_ */
Ian Rogersab2b55d2012-03-18 00:06:11 -07001379#if defined(TARGET_MIPS) || defined(TARGET_X86)
buzbee82488f52012-03-02 08:20:26 -08001380 LIR* branch2 = opCmpBranch(cUnit, kCondEq, rARG1, classReg, NULL);
Ian Rogers57b86d42012-03-27 16:05:41 -07001381 callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pCheckCastFromCode),
Ian Rogersab2b55d2012-03-18 00:06:11 -07001382 rARG1, rARG2);
1383#else // defined(TARGET_ARM)
Ian Rogers57b86d42012-03-27 16:05:41 -07001384 int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pCheckCastFromCode));
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001385 opRegReg(cUnit, kOpCmp, rARG1, classReg);
1386 LIR* branch2 = opCondBranch(cUnit, kCondEq, NULL); /* If eq, trivial yes */
1387 opRegCopy(cUnit, rARG0, rARG1);
1388 opRegCopy(cUnit, rARG1, rARG2);
Ian Rogersab2b55d2012-03-18 00:06:11 -07001389 oatClobberCalleeSave(cUnit);
1390 opReg(cUnit, kOpBlx, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001391 oatFreeTemp(cUnit, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001392#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001393 /* branch target here */
1394 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
Ian Rogersd36c52e2012-04-09 16:29:25 -07001395 branch1->target = target;
1396 branch2->target = target;
buzbee31a4a6f2012-02-28 15:36:15 -08001397}
1398
buzbee31a4a6f2012-02-28 15:36:15 -08001399/*
1400 * Generate array store
1401 *
1402 */
1403void genArrayObjPut(CompilationUnit* cUnit, MIR* mir, RegLocation rlArray,
1404 RegLocation rlIndex, RegLocation rlSrc, int scale)
1405{
buzbee31a4a6f2012-02-28 15:36:15 -08001406 int lenOffset = Array::LengthOffset().Int32Value();
1407 int dataOffset = Array::DataOffset(sizeof(Object*)).Int32Value();
1408
Ian Rogersd36c52e2012-04-09 16:29:25 -07001409 oatFlushAllRegs(cUnit); // Use explicit registers
1410 oatLockCallTemps(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -08001411
Ian Rogersd36c52e2012-04-09 16:29:25 -07001412 int rValue = rARG0; // Register holding value
1413 int rArrayClass = rARG1; // Register holding array's Class
1414 int rArray = rARG2; // Register holding array
1415 int rIndex = rARG3; // Register holding index into array
1416
1417 loadValueDirectFixed(cUnit, rlArray, rArray); // Grab array
1418 loadValueDirectFixed(cUnit, rlSrc, rValue); // Grab value
1419 loadValueDirectFixed(cUnit, rlIndex, rIndex); // Grab index
1420
1421 genNullCheck(cUnit, rlArray.sRegLow, rArray, mir); // NPE?
1422
1423 // Store of null?
1424 LIR* null_value_check = opCmpImmBranch(cUnit, kCondEq, rValue, 0, NULL);
1425
1426 // Get the array's class.
1427 loadWordDisp(cUnit, rArray, Object::ClassOffset().Int32Value(), rArrayClass);
Ian Rogers57b86d42012-03-27 16:05:41 -07001428 callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode),
Ian Rogersd36c52e2012-04-09 16:29:25 -07001429 rValue, rArrayClass);
1430 // Redo loadValues in case they didn't survive the call.
1431 loadValueDirectFixed(cUnit, rlArray, rArray); // Reload array
1432 loadValueDirectFixed(cUnit, rlIndex, rIndex); // Reload index
1433 loadValueDirectFixed(cUnit, rlSrc, rValue); // Reload value
1434 rArrayClass = INVALID_REG;
buzbee31a4a6f2012-02-28 15:36:15 -08001435
Ian Rogersd36c52e2012-04-09 16:29:25 -07001436 // Branch here if value to be stored == null
1437 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
1438 null_value_check->target = target;
buzbee31a4a6f2012-02-28 15:36:15 -08001439
Ian Rogersb41b33b2012-03-20 14:22:54 -07001440#if defined(TARGET_X86)
Ian Rogersd36c52e2012-04-09 16:29:25 -07001441 // make an extra temp available for card mark below
1442 oatFreeTemp(cUnit, rARG1);
Ian Rogersb41b33b2012-03-20 14:22:54 -07001443 if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
1444 /* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
Ian Rogersd36c52e2012-04-09 16:29:25 -07001445 genRegMemCheck(cUnit, kCondUge, rIndex, rArray,
Ian Rogersb41b33b2012-03-20 14:22:54 -07001446 lenOffset, mir, kThrowArrayBounds);
1447 }
Ian Rogersd36c52e2012-04-09 16:29:25 -07001448 storeBaseIndexedDisp(cUnit, NULL, rArray, rIndex, scale,
1449 dataOffset, rValue, INVALID_REG, kWord,
Ian Rogersb41b33b2012-03-20 14:22:54 -07001450 INVALID_SREG);
1451#else
buzbee239c4e72012-03-16 08:42:29 -07001452 bool needsRangeCheck = (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK));
1453 int regLen = INVALID_REG;
1454 if (needsRangeCheck) {
Ian Rogersd36c52e2012-04-09 16:29:25 -07001455 regLen = rARG1;
1456 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen); // Get len
buzbee239c4e72012-03-16 08:42:29 -07001457 }
Ian Rogersd36c52e2012-04-09 16:29:25 -07001458 /* rPtr -> array data */
1459 int rPtr = oatAllocTemp(cUnit);
1460 opRegRegImm(cUnit, kOpAdd, rPtr, rArray, dataOffset);
buzbee239c4e72012-03-16 08:42:29 -07001461 if (needsRangeCheck) {
Ian Rogersd36c52e2012-04-09 16:29:25 -07001462 genRegRegCheck(cUnit, kCondCs, rIndex, regLen, mir,
buzbee31a4a6f2012-02-28 15:36:15 -08001463 kThrowArrayBounds);
buzbee31a4a6f2012-02-28 15:36:15 -08001464 }
Ian Rogersd36c52e2012-04-09 16:29:25 -07001465 storeBaseIndexed(cUnit, rPtr, rIndex, rValue, scale, kWord);
1466 oatFreeTemp(cUnit, rPtr);
Ian Rogersb41b33b2012-03-20 14:22:54 -07001467#endif
Ian Rogersd36c52e2012-04-09 16:29:25 -07001468 oatFreeTemp(cUnit, rIndex);
1469 markGCCard(cUnit, rValue, rArray);
buzbee31a4a6f2012-02-28 15:36:15 -08001470}
1471
1472/*
1473 * Generate array load
1474 */
1475void genArrayGet(CompilationUnit* cUnit, MIR* mir, OpSize size,
1476 RegLocation rlArray, RegLocation rlIndex,
1477 RegLocation rlDest, int scale)
1478{
1479 RegisterClass regClass = oatRegClassBySize(size);
1480 int lenOffset = Array::LengthOffset().Int32Value();
1481 int dataOffset;
1482 RegLocation rlResult;
1483 rlArray = loadValue(cUnit, rlArray, kCoreReg);
1484 rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001485
1486 if (size == kLong || size == kDouble) {
1487 dataOffset = Array::DataOffset(sizeof(int64_t)).Int32Value();
1488 } else {
1489 dataOffset = Array::DataOffset(sizeof(int32_t)).Int32Value();
1490 }
1491
1492 /* null object? */
1493 genNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg, mir);
1494
Ian Rogersb5d09b22012-03-06 22:14:17 -08001495#if defined(TARGET_X86)
1496 if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
1497 /* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
1498 genRegMemCheck(cUnit, kCondUge, rlIndex.lowReg, rlArray.lowReg,
1499 lenOffset, mir, kThrowArrayBounds);
1500 }
1501 if ((size == kLong) || (size == kDouble)) {
1502 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1503 loadBaseIndexedDisp(cUnit, NULL, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset,
1504 rlResult.lowReg, rlResult.highReg, size, INVALID_SREG);
buzbee31a4a6f2012-02-28 15:36:15 -08001505
Ian Rogersb5d09b22012-03-06 22:14:17 -08001506 storeValueWide(cUnit, rlDest, rlResult);
1507 } else {
1508 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1509
1510 loadBaseIndexedDisp(cUnit, NULL, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset,
1511 rlResult.lowReg, INVALID_REG, size, INVALID_SREG);
1512
1513 storeValue(cUnit, rlDest, rlResult);
1514 }
1515#else
1516 int regPtr = oatAllocTemp(cUnit);
buzbee239c4e72012-03-16 08:42:29 -07001517 bool needsRangeCheck = (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK));
1518 int regLen = INVALID_REG;
1519 if (needsRangeCheck) {
1520 regLen = oatAllocTemp(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -08001521 /* Get len */
1522 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
buzbee31a4a6f2012-02-28 15:36:15 -08001523 }
buzbee239c4e72012-03-16 08:42:29 -07001524 /* regPtr -> array data */
1525 opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
buzbee31a4a6f2012-02-28 15:36:15 -08001526 oatFreeTemp(cUnit, rlArray.lowReg);
1527 if ((size == kLong) || (size == kDouble)) {
1528 if (scale) {
1529 int rNewIndex = oatAllocTemp(cUnit);
1530 opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
1531 opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
1532 oatFreeTemp(cUnit, rNewIndex);
1533 } else {
1534 opRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
1535 }
1536 oatFreeTemp(cUnit, rlIndex.lowReg);
1537 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1538
buzbee239c4e72012-03-16 08:42:29 -07001539 if (needsRangeCheck) {
1540 // TODO: change kCondCS to a more meaningful name, is the sense of
1541 // carry-set/clear flipped?
1542 genRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, mir,
1543 kThrowArrayBounds);
1544 oatFreeTemp(cUnit, regLen);
1545 }
buzbee31a4a6f2012-02-28 15:36:15 -08001546 loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
1547
1548 oatFreeTemp(cUnit, regPtr);
1549 storeValueWide(cUnit, rlDest, rlResult);
1550 } else {
1551 rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
1552
buzbee239c4e72012-03-16 08:42:29 -07001553 if (needsRangeCheck) {
1554 // TODO: change kCondCS to a more meaningful name, is the sense of
1555 // carry-set/clear flipped?
1556 genRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, mir,
1557 kThrowArrayBounds);
1558 oatFreeTemp(cUnit, regLen);
1559 }
buzbee31a4a6f2012-02-28 15:36:15 -08001560 loadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg,
1561 scale, size);
1562
1563 oatFreeTemp(cUnit, regPtr);
1564 storeValue(cUnit, rlDest, rlResult);
1565 }
Ian Rogersb5d09b22012-03-06 22:14:17 -08001566#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001567}
1568
1569/*
1570 * Generate array store
1571 *
1572 */
1573void genArrayPut(CompilationUnit* cUnit, MIR* mir, OpSize size,
1574 RegLocation rlArray, RegLocation rlIndex,
1575 RegLocation rlSrc, int scale)
1576{
1577 RegisterClass regClass = oatRegClassBySize(size);
1578 int lenOffset = Array::LengthOffset().Int32Value();
1579 int dataOffset;
1580
1581 if (size == kLong || size == kDouble) {
1582 dataOffset = Array::DataOffset(sizeof(int64_t)).Int32Value();
1583 } else {
1584 dataOffset = Array::DataOffset(sizeof(int32_t)).Int32Value();
1585 }
1586
buzbee31a4a6f2012-02-28 15:36:15 -08001587 rlArray = loadValue(cUnit, rlArray, kCoreReg);
1588 rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
Ian Rogersb41b33b2012-03-20 14:22:54 -07001589#if !defined(TARGET_X86)
1590 int regPtr;
buzbee31a4a6f2012-02-28 15:36:15 -08001591 if (oatIsTemp(cUnit, rlArray.lowReg)) {
1592 oatClobber(cUnit, rlArray.lowReg);
1593 regPtr = rlArray.lowReg;
1594 } else {
1595 regPtr = oatAllocTemp(cUnit);
buzbee82488f52012-03-02 08:20:26 -08001596 opRegCopy(cUnit, regPtr, rlArray.lowReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001597 }
Ian Rogersb41b33b2012-03-20 14:22:54 -07001598#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001599
1600 /* null object? */
1601 genNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg, mir);
1602
Ian Rogersb41b33b2012-03-20 14:22:54 -07001603#if defined(TARGET_X86)
1604 if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
1605 /* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
1606 genRegMemCheck(cUnit, kCondUge, rlIndex.lowReg, rlArray.lowReg,
1607 lenOffset, mir, kThrowArrayBounds);
1608 }
Ian Rogersc6f3bb82012-03-21 20:40:33 -07001609 if ((size == kLong) || (size == kDouble)) {
1610 rlSrc = loadValueWide(cUnit, rlSrc, regClass);
1611 } else {
1612 rlSrc = loadValue(cUnit, rlSrc, regClass);
1613 }
Ian Rogersb41b33b2012-03-20 14:22:54 -07001614 storeBaseIndexedDisp(cUnit, NULL, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset,
1615 rlSrc.lowReg, rlSrc.highReg, size, INVALID_SREG);
1616#else
buzbee239c4e72012-03-16 08:42:29 -07001617 bool needsRangeCheck = (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK));
1618 int regLen = INVALID_REG;
1619 if (needsRangeCheck) {
1620 regLen = oatAllocTemp(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -08001621 //NOTE: max live temps(4) here.
1622 /* Get len */
1623 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
buzbee31a4a6f2012-02-28 15:36:15 -08001624 }
buzbee239c4e72012-03-16 08:42:29 -07001625 /* regPtr -> array data */
1626 opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
buzbee31a4a6f2012-02-28 15:36:15 -08001627 /* at this point, regPtr points to array, 2 live temps */
1628 if ((size == kLong) || (size == kDouble)) {
1629 //TUNING: specific wide routine that can handle fp regs
1630 if (scale) {
1631 int rNewIndex = oatAllocTemp(cUnit);
1632 opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
1633 opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
1634 oatFreeTemp(cUnit, rNewIndex);
1635 } else {
1636 opRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
1637 }
1638 rlSrc = loadValueWide(cUnit, rlSrc, regClass);
1639
buzbee239c4e72012-03-16 08:42:29 -07001640 if (needsRangeCheck) {
1641 genRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, mir,
1642 kThrowArrayBounds);
1643 oatFreeTemp(cUnit, regLen);
1644 }
1645
buzbee31a4a6f2012-02-28 15:36:15 -08001646 storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
1647
1648 oatFreeTemp(cUnit, regPtr);
1649 } else {
1650 rlSrc = loadValue(cUnit, rlSrc, regClass);
buzbee239c4e72012-03-16 08:42:29 -07001651 if (needsRangeCheck) {
1652 genRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, mir,
1653 kThrowArrayBounds);
1654 oatFreeTemp(cUnit, regLen);
1655 }
buzbee31a4a6f2012-02-28 15:36:15 -08001656 storeBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlSrc.lowReg,
1657 scale, size);
1658 }
Ian Rogersb41b33b2012-03-20 14:22:54 -07001659#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001660}
1661
1662void genLong3Addr(CompilationUnit* cUnit, MIR* mir, OpKind firstOp,
1663 OpKind secondOp, RegLocation rlDest,
1664 RegLocation rlSrc1, RegLocation rlSrc2)
1665{
1666 RegLocation rlResult;
1667#if defined(TARGET_ARM)
1668 /*
1669 * NOTE: This is the one place in the code in which we might have
1670 * as many as six live temporary registers. There are 5 in the normal
1671 * set for Arm. Until we have spill capabilities, temporarily add
1672 * lr to the temp set. It is safe to do this locally, but note that
1673 * lr is used explicitly elsewhere in the code generator and cannot
1674 * normally be used as a general temp register.
1675 */
1676 oatMarkTemp(cUnit, rLR); // Add lr to the temp pool
1677 oatFreeTemp(cUnit, rLR); // and make it available
1678#endif
1679 rlSrc1 = loadValueWide(cUnit, rlSrc1, kCoreReg);
1680 rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
1681 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
1682 // The longs may overlap - use intermediate temp if so
1683 if (rlResult.lowReg == rlSrc1.highReg) {
1684 int tReg = oatAllocTemp(cUnit);
buzbee82488f52012-03-02 08:20:26 -08001685 opRegCopy(cUnit, tReg, rlSrc1.highReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001686 opRegRegReg(cUnit, firstOp, rlResult.lowReg, rlSrc1.lowReg,
1687 rlSrc2.lowReg);
1688 opRegRegReg(cUnit, secondOp, rlResult.highReg, tReg,
1689 rlSrc2.highReg);
1690 oatFreeTemp(cUnit, tReg);
1691 } else {
1692 opRegRegReg(cUnit, firstOp, rlResult.lowReg, rlSrc1.lowReg,
1693 rlSrc2.lowReg);
1694 opRegRegReg(cUnit, secondOp, rlResult.highReg, rlSrc1.highReg,
1695 rlSrc2.highReg);
1696 }
1697 /*
1698 * NOTE: If rlDest refers to a frame variable in a large frame, the
1699 * following storeValueWide might need to allocate a temp register.
1700 * To further work around the lack of a spill capability, explicitly
1701 * free any temps from rlSrc1 & rlSrc2 that aren't still live in rlResult.
1702 * Remove when spill is functional.
1703 */
1704 freeRegLocTemps(cUnit, rlResult, rlSrc1);
1705 freeRegLocTemps(cUnit, rlResult, rlSrc2);
1706 storeValueWide(cUnit, rlDest, rlResult);
1707#if defined(TARGET_ARM)
1708 oatClobber(cUnit, rLR);
1709 oatUnmarkTemp(cUnit, rLR); // Remove lr from the temp pool
1710#endif
1711}
1712
1713
1714bool genShiftOpLong(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
1715 RegLocation rlSrc1, RegLocation rlShift)
1716{
1717 int funcOffset;
1718
Elliott Hughesb25c3f62012-03-26 16:35:06 -07001719 switch (mir->dalvikInsn.opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08001720 case Instruction::SHL_LONG:
1721 case Instruction::SHL_LONG_2ADDR:
Ian Rogers57b86d42012-03-27 16:05:41 -07001722 funcOffset = ENTRYPOINT_OFFSET(pShlLong);
buzbee31a4a6f2012-02-28 15:36:15 -08001723 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001724 case Instruction::SHR_LONG:
1725 case Instruction::SHR_LONG_2ADDR:
Ian Rogers57b86d42012-03-27 16:05:41 -07001726 funcOffset = ENTRYPOINT_OFFSET(pShrLong);
buzbee31a4a6f2012-02-28 15:36:15 -08001727 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001728 case Instruction::USHR_LONG:
1729 case Instruction::USHR_LONG_2ADDR:
Ian Rogers57b86d42012-03-27 16:05:41 -07001730 funcOffset = ENTRYPOINT_OFFSET(pUshrLong);
buzbee31a4a6f2012-02-28 15:36:15 -08001731 break;
1732 default:
1733 LOG(FATAL) << "Unexpected case";
1734 return true;
1735 }
1736 oatFlushAllRegs(cUnit); /* Send everything to home location */
Ian Rogersab2b55d2012-03-18 00:06:11 -07001737 callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlShift);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001738 RegLocation rlResult = oatGetReturnWide(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08001739 storeValueWide(cUnit, rlDest, rlResult);
1740 return false;
1741}
1742
1743
1744bool genArithOpInt(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
1745 RegLocation rlSrc1, RegLocation rlSrc2)
1746{
1747 OpKind op = kOpBkpt;
1748 bool callOut = false;
1749 bool checkZero = false;
1750 bool unary = false;
buzbee31a4a6f2012-02-28 15:36:15 -08001751 RegLocation rlResult;
1752 bool shiftOp = false;
Ian Rogersb5d09b22012-03-06 22:14:17 -08001753 int funcOffset;
1754 int retReg = rRET0;
buzbee31a4a6f2012-02-28 15:36:15 -08001755 switch (mir->dalvikInsn.opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08001756 case Instruction::NEG_INT:
buzbee31a4a6f2012-02-28 15:36:15 -08001757 op = kOpNeg;
1758 unary = true;
1759 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001760 case Instruction::NOT_INT:
buzbee31a4a6f2012-02-28 15:36:15 -08001761 op = kOpMvn;
1762 unary = true;
1763 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001764 case Instruction::ADD_INT:
1765 case Instruction::ADD_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001766 op = kOpAdd;
1767 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001768 case Instruction::SUB_INT:
1769 case Instruction::SUB_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001770 op = kOpSub;
1771 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001772 case Instruction::MUL_INT:
1773 case Instruction::MUL_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001774 op = kOpMul;
1775 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001776 case Instruction::DIV_INT:
1777 case Instruction::DIV_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001778 checkZero = true;
Ian Rogersb5d09b22012-03-06 22:14:17 -08001779 op = kOpDiv;
1780 callOut = true;
Ian Rogers57b86d42012-03-27 16:05:41 -07001781 funcOffset = ENTRYPOINT_OFFSET(pIdiv);
buzbee31a4a6f2012-02-28 15:36:15 -08001782 retReg = rRET0;
1783 break;
buzbee5de34942012-03-01 14:51:57 -08001784 /* NOTE: returns in rARG1 */
Elliott Hughesadb8c672012-03-06 16:49:32 -08001785 case Instruction::REM_INT:
1786 case Instruction::REM_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001787 checkZero = true;
Ian Rogersb5d09b22012-03-06 22:14:17 -08001788 op = kOpRem;
1789 callOut = true;
Ian Rogers57b86d42012-03-27 16:05:41 -07001790 funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
buzbee31a4a6f2012-02-28 15:36:15 -08001791 retReg = rRET1;
1792 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001793 case Instruction::AND_INT:
1794 case Instruction::AND_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001795 op = kOpAnd;
1796 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001797 case Instruction::OR_INT:
1798 case Instruction::OR_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001799 op = kOpOr;
1800 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001801 case Instruction::XOR_INT:
1802 case Instruction::XOR_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001803 op = kOpXor;
1804 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001805 case Instruction::SHL_INT:
1806 case Instruction::SHL_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001807 shiftOp = true;
1808 op = kOpLsl;
1809 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001810 case Instruction::SHR_INT:
1811 case Instruction::SHR_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001812 shiftOp = true;
1813 op = kOpAsr;
1814 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08001815 case Instruction::USHR_INT:
1816 case Instruction::USHR_INT_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08001817 shiftOp = true;
1818 op = kOpLsr;
1819 break;
1820 default:
1821 LOG(FATAL) << "Invalid word arith op: " <<
1822 (int)mir->dalvikInsn.opcode;
1823 }
1824 if (!callOut) {
buzbee31a4a6f2012-02-28 15:36:15 -08001825 if (unary) {
Ian Rogers7caad772012-03-30 01:07:54 -07001826 rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001827 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
1828 opRegReg(cUnit, op, rlResult.lowReg,
1829 rlSrc1.lowReg);
1830 } else {
buzbee31a4a6f2012-02-28 15:36:15 -08001831 if (shiftOp) {
Ian Rogers7caad772012-03-30 01:07:54 -07001832#if !defined(TARGET_X86)
1833 rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001834 int tReg = oatAllocTemp(cUnit);
1835 opRegRegImm(cUnit, kOpAnd, tReg, rlSrc2.lowReg, 31);
Ian Rogers7caad772012-03-30 01:07:54 -07001836#else
1837 // X86 doesn't require masking and must use ECX
1838 loadValueDirectFixed(cUnit, rlSrc2, rCX);
1839 int tReg = rCX;
1840#endif
1841 rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001842 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
1843 opRegRegReg(cUnit, op, rlResult.lowReg,
1844 rlSrc1.lowReg, tReg);
1845 oatFreeTemp(cUnit, tReg);
1846 } else {
Ian Rogers7caad772012-03-30 01:07:54 -07001847 rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
1848 rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
buzbee31a4a6f2012-02-28 15:36:15 -08001849 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
1850 opRegRegReg(cUnit, op, rlResult.lowReg,
1851 rlSrc1.lowReg, rlSrc2.lowReg);
1852 }
1853 }
1854 storeValue(cUnit, rlDest, rlResult);
1855 } else {
1856 RegLocation rlResult;
1857 oatFlushAllRegs(cUnit); /* Send everything to home location */
Ian Rogers55bd45f2012-04-04 17:31:20 -07001858 loadValueDirectFixed(cUnit, rlSrc2, rARG1);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001859#if !defined(TARGET_X86)
buzbee31a4a6f2012-02-28 15:36:15 -08001860 int rTgt = loadHelper(cUnit, funcOffset);
Ian Rogersab2b55d2012-03-18 00:06:11 -07001861#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001862 loadValueDirectFixed(cUnit, rlSrc1, rARG0);
1863 if (checkZero) {
1864 genImmedCheck(cUnit, kCondEq, rARG1, 0, mir, kThrowDivZero);
1865 }
Ian Rogersab2b55d2012-03-18 00:06:11 -07001866#if !defined(TARGET_X86)
1867 opReg(cUnit, kOpBlx, rTgt);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001868 oatFreeTemp(cUnit, rTgt);
1869#else
Ian Rogersab2b55d2012-03-18 00:06:11 -07001870 opThreadMem(cUnit, kOpBlx, funcOffset);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07001871#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001872 if (retReg == rRET0)
Ian Rogersf7d9ad32012-03-13 18:45:39 -07001873 rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08001874 else
1875 rlResult = oatGetReturnAlt(cUnit);
1876 storeValue(cUnit, rlDest, rlResult);
1877 }
1878 return false;
1879}
1880
1881/*
1882 * The following are the first-level codegen routines that analyze the format
1883 * of each bytecode then either dispatch special purpose codegen routines
1884 * or produce corresponding Thumb instructions directly.
1885 */
1886
1887bool isPowerOfTwo(int x)
1888{
1889 return (x & (x - 1)) == 0;
1890}
1891
1892// Returns true if no more than two bits are set in 'x'.
1893bool isPopCountLE2(unsigned int x)
1894{
1895 x &= x - 1;
1896 return (x & (x - 1)) == 0;
1897}
1898
1899// Returns the index of the lowest set bit in 'x'.
1900int lowestSetBit(unsigned int x) {
1901 int bit_posn = 0;
1902 while ((x & 0xf) == 0) {
1903 bit_posn += 4;
1904 x >>= 4;
1905 }
1906 while ((x & 1) == 0) {
1907 bit_posn++;
1908 x >>= 1;
1909 }
1910 return bit_posn;
1911}
1912
1913// Returns true if it added instructions to 'cUnit' to divide 'rlSrc' by 'lit'
1914// and store the result in 'rlDest'.
Elliott Hughesadb8c672012-03-06 16:49:32 -08001915bool handleEasyDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
buzbee31a4a6f2012-02-28 15:36:15 -08001916 RegLocation rlSrc, RegLocation rlDest, int lit)
1917{
1918 if (lit < 2 || !isPowerOfTwo(lit)) {
1919 return false;
1920 }
1921 int k = lowestSetBit(lit);
1922 if (k >= 30) {
1923 // Avoid special cases.
1924 return false;
1925 }
Elliott Hughesadb8c672012-03-06 16:49:32 -08001926 bool div = (dalvikOpcode == Instruction::DIV_INT_LIT8 ||
1927 dalvikOpcode == Instruction::DIV_INT_LIT16);
buzbee31a4a6f2012-02-28 15:36:15 -08001928 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
1929 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
1930 if (div) {
1931 int tReg = oatAllocTemp(cUnit);
1932 if (lit == 2) {
1933 // Division by 2 is by far the most common division by constant.
1934 opRegRegImm(cUnit, kOpLsr, tReg, rlSrc.lowReg, 32 - k);
1935 opRegRegReg(cUnit, kOpAdd, tReg, tReg, rlSrc.lowReg);
1936 opRegRegImm(cUnit, kOpAsr, rlResult.lowReg, tReg, k);
1937 } else {
1938 opRegRegImm(cUnit, kOpAsr, tReg, rlSrc.lowReg, 31);
1939 opRegRegImm(cUnit, kOpLsr, tReg, tReg, 32 - k);
1940 opRegRegReg(cUnit, kOpAdd, tReg, tReg, rlSrc.lowReg);
1941 opRegRegImm(cUnit, kOpAsr, rlResult.lowReg, tReg, k);
1942 }
1943 } else {
buzbee31a4a6f2012-02-28 15:36:15 -08001944 int tReg1 = oatAllocTemp(cUnit);
1945 int tReg2 = oatAllocTemp(cUnit);
1946 if (lit == 2) {
1947 opRegRegImm(cUnit, kOpLsr, tReg1, rlSrc.lowReg, 32 - k);
1948 opRegRegReg(cUnit, kOpAdd, tReg2, tReg1, rlSrc.lowReg);
Ian Rogersb41b33b2012-03-20 14:22:54 -07001949 opRegRegImm(cUnit, kOpAnd, tReg2, tReg2, lit -1);
buzbee31a4a6f2012-02-28 15:36:15 -08001950 opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg2, tReg1);
1951 } else {
1952 opRegRegImm(cUnit, kOpAsr, tReg1, rlSrc.lowReg, 31);
1953 opRegRegImm(cUnit, kOpLsr, tReg1, tReg1, 32 - k);
1954 opRegRegReg(cUnit, kOpAdd, tReg2, tReg1, rlSrc.lowReg);
Ian Rogersb41b33b2012-03-20 14:22:54 -07001955 opRegRegImm(cUnit, kOpAnd, tReg2, tReg2, lit - 1);
buzbee31a4a6f2012-02-28 15:36:15 -08001956 opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg2, tReg1);
1957 }
1958 }
1959 storeValue(cUnit, rlDest, rlResult);
1960 return true;
1961}
1962
1963void genMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
1964 RegLocation rlResult, int lit,
1965 int firstBit, int secondBit)
1966{
buzbee0398c422012-03-02 15:22:47 -08001967#if defined(TARGET_ARM)
buzbee31a4a6f2012-02-28 15:36:15 -08001968 opRegRegRegShift(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, rlSrc.lowReg,
1969 encodeShift(kArmLsl, secondBit - firstBit));
buzbee0398c422012-03-02 15:22:47 -08001970#else
1971 int tReg = oatAllocTemp(cUnit);
1972 opRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, secondBit - firstBit);
1973 opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, tReg);
1974 oatFreeTemp(cUnit, tReg);
buzbee5de34942012-03-01 14:51:57 -08001975#endif
buzbee31a4a6f2012-02-28 15:36:15 -08001976 if (firstBit != 0) {
1977 opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
1978 }
1979}
1980
1981// Returns true if it added instructions to 'cUnit' to multiply 'rlSrc' by 'lit'
1982// and store the result in 'rlDest'.
1983bool handleEasyMultiply(CompilationUnit* cUnit, RegLocation rlSrc,
1984 RegLocation rlDest, int lit)
1985{
1986 // Can we simplify this multiplication?
1987 bool powerOfTwo = false;
1988 bool popCountLE2 = false;
1989 bool powerOfTwoMinusOne = false;
1990 if (lit < 2) {
1991 // Avoid special cases.
1992 return false;
1993 } else if (isPowerOfTwo(lit)) {
1994 powerOfTwo = true;
1995 } else if (isPopCountLE2(lit)) {
1996 popCountLE2 = true;
1997 } else if (isPowerOfTwo(lit + 1)) {
1998 powerOfTwoMinusOne = true;
1999 } else {
2000 return false;
2001 }
2002 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2003 RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
2004 if (powerOfTwo) {
2005 // Shift.
2006 opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlSrc.lowReg,
2007 lowestSetBit(lit));
2008 } else if (popCountLE2) {
2009 // Shift and add and shift.
2010 int firstBit = lowestSetBit(lit);
2011 int secondBit = lowestSetBit(lit ^ (1 << firstBit));
2012 genMultiplyByTwoBitMultiplier(cUnit, rlSrc, rlResult, lit,
2013 firstBit, secondBit);
2014 } else {
2015 // Reverse subtract: (src << (shift + 1)) - src.
2016 DCHECK(powerOfTwoMinusOne);
2017 // TUNING: rsb dst, src, src lsl#lowestSetBit(lit + 1)
2018 int tReg = oatAllocTemp(cUnit);
2019 opRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, lowestSetBit(lit + 1));
2020 opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg, rlSrc.lowReg);
2021 }
2022 storeValue(cUnit, rlDest, rlResult);
2023 return true;
2024}
2025
2026bool genArithOpIntLit(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
2027 RegLocation rlSrc, int lit)
2028{
Elliott Hughesadb8c672012-03-06 16:49:32 -08002029 Instruction::Code dalvikOpcode = mir->dalvikInsn.opcode;
buzbee31a4a6f2012-02-28 15:36:15 -08002030 RegLocation rlResult;
2031 OpKind op = (OpKind)0; /* Make gcc happy */
2032 int shiftOp = false;
2033 bool isDiv = false;
2034 int funcOffset;
buzbee31a4a6f2012-02-28 15:36:15 -08002035
2036 switch (dalvikOpcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08002037 case Instruction::RSUB_INT_LIT8:
2038 case Instruction::RSUB_INT: {
buzbee31a4a6f2012-02-28 15:36:15 -08002039 int tReg;
2040 //TUNING: add support for use of Arm rsub op
2041 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2042 tReg = oatAllocTemp(cUnit);
2043 loadConstant(cUnit, tReg, lit);
2044 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
2045 opRegRegReg(cUnit, kOpSub, rlResult.lowReg,
2046 tReg, rlSrc.lowReg);
2047 storeValue(cUnit, rlDest, rlResult);
2048 return false;
2049 break;
2050 }
2051
Elliott Hughesadb8c672012-03-06 16:49:32 -08002052 case Instruction::ADD_INT_LIT8:
2053 case Instruction::ADD_INT_LIT16:
buzbee31a4a6f2012-02-28 15:36:15 -08002054 op = kOpAdd;
2055 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002056 case Instruction::MUL_INT_LIT8:
2057 case Instruction::MUL_INT_LIT16: {
buzbee31a4a6f2012-02-28 15:36:15 -08002058 if (handleEasyMultiply(cUnit, rlSrc, rlDest, lit)) {
2059 return false;
2060 }
2061 op = kOpMul;
2062 break;
2063 }
Elliott Hughesadb8c672012-03-06 16:49:32 -08002064 case Instruction::AND_INT_LIT8:
2065 case Instruction::AND_INT_LIT16:
buzbee31a4a6f2012-02-28 15:36:15 -08002066 op = kOpAnd;
2067 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002068 case Instruction::OR_INT_LIT8:
2069 case Instruction::OR_INT_LIT16:
buzbee31a4a6f2012-02-28 15:36:15 -08002070 op = kOpOr;
2071 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002072 case Instruction::XOR_INT_LIT8:
2073 case Instruction::XOR_INT_LIT16:
buzbee31a4a6f2012-02-28 15:36:15 -08002074 op = kOpXor;
2075 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002076 case Instruction::SHL_INT_LIT8:
buzbee31a4a6f2012-02-28 15:36:15 -08002077 lit &= 31;
2078 shiftOp = true;
2079 op = kOpLsl;
2080 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002081 case Instruction::SHR_INT_LIT8:
buzbee31a4a6f2012-02-28 15:36:15 -08002082 lit &= 31;
2083 shiftOp = true;
2084 op = kOpAsr;
2085 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002086 case Instruction::USHR_INT_LIT8:
buzbee31a4a6f2012-02-28 15:36:15 -08002087 lit &= 31;
2088 shiftOp = true;
2089 op = kOpLsr;
2090 break;
2091
Elliott Hughesadb8c672012-03-06 16:49:32 -08002092 case Instruction::DIV_INT_LIT8:
2093 case Instruction::DIV_INT_LIT16:
2094 case Instruction::REM_INT_LIT8:
2095 case Instruction::REM_INT_LIT16:
buzbee31a4a6f2012-02-28 15:36:15 -08002096 if (lit == 0) {
2097 genImmedCheck(cUnit, kCondAl, 0, 0, mir, kThrowDivZero);
2098 return false;
2099 }
2100 if (handleEasyDivide(cUnit, dalvikOpcode, rlSrc, rlDest, lit)) {
2101 return false;
2102 }
2103 oatFlushAllRegs(cUnit); /* Everything to home location */
2104 loadValueDirectFixed(cUnit, rlSrc, rARG0);
2105 oatClobber(cUnit, rARG0);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002106 if ((dalvikOpcode == Instruction::DIV_INT_LIT8) ||
2107 (dalvikOpcode == Instruction::DIV_INT_LIT16)) {
Ian Rogers57b86d42012-03-27 16:05:41 -07002108 funcOffset = ENTRYPOINT_OFFSET(pIdiv);
buzbee31a4a6f2012-02-28 15:36:15 -08002109 isDiv = true;
2110 } else {
Ian Rogers57b86d42012-03-27 16:05:41 -07002111 funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
buzbee31a4a6f2012-02-28 15:36:15 -08002112 isDiv = false;
2113 }
Ian Rogersab2b55d2012-03-18 00:06:11 -07002114 callRuntimeHelperRegImm(cUnit, funcOffset, rARG0, lit);
buzbee31a4a6f2012-02-28 15:36:15 -08002115 if (isDiv)
Ian Rogersf7d9ad32012-03-13 18:45:39 -07002116 rlResult = oatGetReturn(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08002117 else
2118 rlResult = oatGetReturnAlt(cUnit);
2119 storeValue(cUnit, rlDest, rlResult);
2120 return false;
2121 break;
2122 default:
2123 return true;
2124 }
2125 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2126 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
2127 // Avoid shifts by literal 0 - no support in Thumb. Change to copy
2128 if (shiftOp && (lit == 0)) {
buzbee82488f52012-03-02 08:20:26 -08002129 opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
buzbee31a4a6f2012-02-28 15:36:15 -08002130 } else {
2131 opRegRegImm(cUnit, op, rlResult.lowReg, rlSrc.lowReg, lit);
2132 }
2133 storeValue(cUnit, rlDest, rlResult);
2134 return false;
2135}
2136
2137bool genArithOpLong(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
2138 RegLocation rlSrc1, RegLocation rlSrc2)
2139{
2140 RegLocation rlResult;
2141 OpKind firstOp = kOpBkpt;
2142 OpKind secondOp = kOpBkpt;
2143 bool callOut = false;
2144 bool checkZero = false;
2145 int funcOffset;
2146 int retReg = rRET0;
2147
2148 switch (mir->dalvikInsn.opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08002149 case Instruction::NOT_LONG:
buzbee31a4a6f2012-02-28 15:36:15 -08002150 rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
2151 rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
2152 // Check for destructive overlap
2153 if (rlResult.lowReg == rlSrc2.highReg) {
2154 int tReg = oatAllocTemp(cUnit);
buzbee82488f52012-03-02 08:20:26 -08002155 opRegCopy(cUnit, tReg, rlSrc2.highReg);
buzbee31a4a6f2012-02-28 15:36:15 -08002156 opRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
2157 opRegReg(cUnit, kOpMvn, rlResult.highReg, tReg);
2158 oatFreeTemp(cUnit, tReg);
2159 } else {
2160 opRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
2161 opRegReg(cUnit, kOpMvn, rlResult.highReg, rlSrc2.highReg);
2162 }
2163 storeValueWide(cUnit, rlDest, rlResult);
2164 return false;
2165 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002166 case Instruction::ADD_LONG:
2167 case Instruction::ADD_LONG_2ADDR:
Ian Rogers7caad772012-03-30 01:07:54 -07002168#if defined(TARGET_MIPS) || defined(TARGET_X86)
buzbeec5159d52012-03-03 11:48:39 -08002169 return genAddLong(cUnit, mir, rlDest, rlSrc1, rlSrc2);
2170#else
buzbee31a4a6f2012-02-28 15:36:15 -08002171 firstOp = kOpAdd;
2172 secondOp = kOpAdc;
2173 break;
buzbeec5159d52012-03-03 11:48:39 -08002174#endif
Elliott Hughesadb8c672012-03-06 16:49:32 -08002175 case Instruction::SUB_LONG:
2176 case Instruction::SUB_LONG_2ADDR:
Ian Rogers7caad772012-03-30 01:07:54 -07002177#if defined(TARGET_MIPS) || defined(TARGET_X86)
buzbeec5159d52012-03-03 11:48:39 -08002178 return genSubLong(cUnit, mir, rlDest, rlSrc1, rlSrc2);
Ian Rogers7caad772012-03-30 01:07:54 -07002179#else
buzbee31a4a6f2012-02-28 15:36:15 -08002180 firstOp = kOpSub;
2181 secondOp = kOpSbc;
2182 break;
Ian Rogers7caad772012-03-30 01:07:54 -07002183#endif
Elliott Hughesadb8c672012-03-06 16:49:32 -08002184 case Instruction::MUL_LONG:
2185 case Instruction::MUL_LONG_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08002186 callOut = true;
2187 retReg = rRET0;
Ian Rogers57b86d42012-03-27 16:05:41 -07002188 funcOffset = ENTRYPOINT_OFFSET(pLmul);
buzbee31a4a6f2012-02-28 15:36:15 -08002189 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002190 case Instruction::DIV_LONG:
2191 case Instruction::DIV_LONG_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08002192 callOut = true;
2193 checkZero = true;
2194 retReg = rRET0;
Ian Rogers57b86d42012-03-27 16:05:41 -07002195 funcOffset = ENTRYPOINT_OFFSET(pLdivmod);
buzbee31a4a6f2012-02-28 15:36:15 -08002196 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002197 case Instruction::REM_LONG:
2198 case Instruction::REM_LONG_2ADDR:
buzbee31a4a6f2012-02-28 15:36:15 -08002199 callOut = true;
2200 checkZero = true;
Ian Rogers55bd45f2012-04-04 17:31:20 -07002201 funcOffset = ENTRYPOINT_OFFSET(pLdiv);
2202#if defined(TARGET_ARM)
2203 /* NOTE - result is in rARG2/rARG3 instead of rRET0/rRET1 */
buzbee31a4a6f2012-02-28 15:36:15 -08002204 retReg = rARG2;
Ian Rogers55bd45f2012-04-04 17:31:20 -07002205#else
2206 retReg = rRET0;
2207#endif
buzbee31a4a6f2012-02-28 15:36:15 -08002208 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002209 case Instruction::AND_LONG_2ADDR:
2210 case Instruction::AND_LONG:
Ian Rogersc6f3bb82012-03-21 20:40:33 -07002211#if defined(TARGET_X86)
Ian Rogers7caad772012-03-30 01:07:54 -07002212 return genAndLong(cUnit, mir, rlDest, rlSrc1, rlSrc2);
2213#else
buzbee31a4a6f2012-02-28 15:36:15 -08002214 firstOp = kOpAnd;
2215 secondOp = kOpAnd;
2216 break;
Ian Rogers7caad772012-03-30 01:07:54 -07002217#endif
Elliott Hughesadb8c672012-03-06 16:49:32 -08002218 case Instruction::OR_LONG:
2219 case Instruction::OR_LONG_2ADDR:
Ian Rogersc6f3bb82012-03-21 20:40:33 -07002220#if defined(TARGET_X86)
Ian Rogers7caad772012-03-30 01:07:54 -07002221 return genOrLong(cUnit, mir, rlDest, rlSrc1, rlSrc2);
2222#else
buzbee31a4a6f2012-02-28 15:36:15 -08002223 firstOp = kOpOr;
2224 secondOp = kOpOr;
2225 break;
Ian Rogers7caad772012-03-30 01:07:54 -07002226#endif
Elliott Hughesadb8c672012-03-06 16:49:32 -08002227 case Instruction::XOR_LONG:
2228 case Instruction::XOR_LONG_2ADDR:
Ian Rogersc6f3bb82012-03-21 20:40:33 -07002229#if defined(TARGET_X86)
Ian Rogers7caad772012-03-30 01:07:54 -07002230 return genXorLong(cUnit, mir, rlDest, rlSrc1, rlSrc2);
2231#else
buzbee31a4a6f2012-02-28 15:36:15 -08002232 firstOp = kOpXor;
2233 secondOp = kOpXor;
2234 break;
Ian Rogers7caad772012-03-30 01:07:54 -07002235#endif
Elliott Hughesadb8c672012-03-06 16:49:32 -08002236 case Instruction::NEG_LONG: {
buzbeec5159d52012-03-03 11:48:39 -08002237 return genNegLong(cUnit, mir, rlDest, rlSrc2);
buzbee31a4a6f2012-02-28 15:36:15 -08002238 }
2239 default:
2240 LOG(FATAL) << "Invalid long arith op";
2241 }
2242 if (!callOut) {
2243 genLong3Addr(cUnit, mir, firstOp, secondOp, rlDest, rlSrc1, rlSrc2);
2244 } else {
buzbee31a4a6f2012-02-28 15:36:15 -08002245 oatFlushAllRegs(cUnit); /* Send everything to home location */
2246 if (checkZero) {
2247 loadValueDirectWideFixed(cUnit, rlSrc2, rARG2, rARG3);
Ian Rogersc6f3bb82012-03-21 20:40:33 -07002248#if !defined(TARGET_X86)
Ian Rogersab2b55d2012-03-18 00:06:11 -07002249 int rTgt = loadHelper(cUnit, funcOffset);
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07002250#endif
buzbee31a4a6f2012-02-28 15:36:15 -08002251 int tReg = oatAllocTemp(cUnit);
2252#if defined(TARGET_ARM)
2253 newLIR4(cUnit, kThumb2OrrRRRs, tReg, rARG2, rARG3, 0);
2254 oatFreeTemp(cUnit, tReg);
2255 genCheck(cUnit, kCondEq, mir, kThrowDivZero);
2256#else
2257 opRegRegReg(cUnit, kOpOr, tReg, rARG2, rARG3);
Ian Rogersb5d09b22012-03-06 22:14:17 -08002258#endif
buzbee5de34942012-03-01 14:51:57 -08002259 genImmedCheck(cUnit, kCondEq, tReg, 0, mir, kThrowDivZero);
buzbee31a4a6f2012-02-28 15:36:15 -08002260 oatFreeTemp(cUnit, tReg);
Ian Rogersc6f3bb82012-03-21 20:40:33 -07002261 loadValueDirectWideFixed(cUnit, rlSrc1, rARG0, rARG1);
Ian Rogersab2b55d2012-03-18 00:06:11 -07002262#if !defined(TARGET_X86)
2263 opReg(cUnit, kOpBlx, rTgt);
2264 oatFreeTemp(cUnit, rTgt);
Ian Rogersc6f3bb82012-03-21 20:40:33 -07002265#else
2266 opThreadMem(cUnit, kOpBlx, funcOffset);
Ian Rogersb5d09b22012-03-06 22:14:17 -08002267#endif
Ian Rogersab2b55d2012-03-18 00:06:11 -07002268 } else {
2269 callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset,
2270 rlSrc1, rlSrc2);
buzbee31a4a6f2012-02-28 15:36:15 -08002271 }
buzbee31a4a6f2012-02-28 15:36:15 -08002272 // Adjust return regs in to handle case of rem returning rARG2/rARG3
2273 if (retReg == rRET0)
Ian Rogersf7d9ad32012-03-13 18:45:39 -07002274 rlResult = oatGetReturnWide(cUnit, false);
buzbee31a4a6f2012-02-28 15:36:15 -08002275 else
2276 rlResult = oatGetReturnWideAlt(cUnit);
2277 storeValueWide(cUnit, rlDest, rlResult);
2278 }
2279 return false;
2280}
2281
2282bool genConversionCall(CompilationUnit* cUnit, MIR* mir, int funcOffset,
2283 int srcSize, int tgtSize)
2284{
2285 /*
2286 * Don't optimize the register usage since it calls out to support
2287 * functions
2288 */
2289 RegLocation rlSrc;
2290 RegLocation rlDest;
2291 oatFlushAllRegs(cUnit); /* Send everything to home location */
buzbee31a4a6f2012-02-28 15:36:15 -08002292 if (srcSize == 1) {
2293 rlSrc = oatGetSrc(cUnit, mir, 0);
2294 loadValueDirectFixed(cUnit, rlSrc, rARG0);
2295 } else {
2296 rlSrc = oatGetSrcWide(cUnit, mir, 0, 1);
2297 loadValueDirectWideFixed(cUnit, rlSrc, rARG0, rARG1);
2298 }
Ian Rogersab2b55d2012-03-18 00:06:11 -07002299 callRuntimeHelperRegLocation(cUnit, funcOffset, rlSrc);
buzbee31a4a6f2012-02-28 15:36:15 -08002300 if (tgtSize == 1) {
2301 RegLocation rlResult;
2302 rlDest = oatGetDest(cUnit, mir, 0);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07002303 rlResult = oatGetReturn(cUnit, rlDest.fp);
buzbee31a4a6f2012-02-28 15:36:15 -08002304 storeValue(cUnit, rlDest, rlResult);
2305 } else {
2306 RegLocation rlResult;
2307 rlDest = oatGetDestWide(cUnit, mir, 0, 1);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07002308 rlResult = oatGetReturnWide(cUnit, rlDest.fp);
buzbee31a4a6f2012-02-28 15:36:15 -08002309 storeValueWide(cUnit, rlDest, rlResult);
2310 }
2311 return false;
2312}
2313
2314void genNegFloat(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
2315bool genArithOpFloatPortable(CompilationUnit* cUnit, MIR* mir,
2316 RegLocation rlDest, RegLocation rlSrc1,
2317 RegLocation rlSrc2)
2318{
2319 RegLocation rlResult;
2320 int funcOffset;
2321
2322 switch (mir->dalvikInsn.opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08002323 case Instruction::ADD_FLOAT_2ADDR:
2324 case Instruction::ADD_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002325 funcOffset = ENTRYPOINT_OFFSET(pFadd);
buzbee31a4a6f2012-02-28 15:36:15 -08002326 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002327 case Instruction::SUB_FLOAT_2ADDR:
2328 case Instruction::SUB_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002329 funcOffset = ENTRYPOINT_OFFSET(pFsub);
buzbee31a4a6f2012-02-28 15:36:15 -08002330 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002331 case Instruction::DIV_FLOAT_2ADDR:
2332 case Instruction::DIV_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002333 funcOffset = ENTRYPOINT_OFFSET(pFdiv);
buzbee31a4a6f2012-02-28 15:36:15 -08002334 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002335 case Instruction::MUL_FLOAT_2ADDR:
2336 case Instruction::MUL_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002337 funcOffset = ENTRYPOINT_OFFSET(pFmul);
buzbee31a4a6f2012-02-28 15:36:15 -08002338 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002339 case Instruction::REM_FLOAT_2ADDR:
2340 case Instruction::REM_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002341 funcOffset = ENTRYPOINT_OFFSET(pFmodf);
buzbee31a4a6f2012-02-28 15:36:15 -08002342 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002343 case Instruction::NEG_FLOAT: {
buzbee31a4a6f2012-02-28 15:36:15 -08002344 genNegFloat(cUnit, rlDest, rlSrc1);
2345 return false;
2346 }
2347 default:
2348 return true;
2349 }
2350 oatFlushAllRegs(cUnit); /* Send everything to home location */
Ian Rogersab2b55d2012-03-18 00:06:11 -07002351 callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlSrc2);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07002352 rlResult = oatGetReturn(cUnit, true);
buzbee31a4a6f2012-02-28 15:36:15 -08002353 storeValue(cUnit, rlDest, rlResult);
2354 return false;
2355}
2356
2357void genNegDouble(CompilationUnit* cUnit, RegLocation rlDst, RegLocation rlSrc);
2358bool genArithOpDoublePortable(CompilationUnit* cUnit, MIR* mir,
2359 RegLocation rlDest, RegLocation rlSrc1,
2360 RegLocation rlSrc2)
2361{
2362 RegLocation rlResult;
2363 int funcOffset;
2364
2365 switch (mir->dalvikInsn.opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08002366 case Instruction::ADD_DOUBLE_2ADDR:
2367 case Instruction::ADD_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002368 funcOffset = ENTRYPOINT_OFFSET(pDadd);
buzbee31a4a6f2012-02-28 15:36:15 -08002369 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002370 case Instruction::SUB_DOUBLE_2ADDR:
2371 case Instruction::SUB_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002372 funcOffset = ENTRYPOINT_OFFSET(pDsub);
buzbee31a4a6f2012-02-28 15:36:15 -08002373 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002374 case Instruction::DIV_DOUBLE_2ADDR:
2375 case Instruction::DIV_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002376 funcOffset = ENTRYPOINT_OFFSET(pDdiv);
buzbee31a4a6f2012-02-28 15:36:15 -08002377 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002378 case Instruction::MUL_DOUBLE_2ADDR:
2379 case Instruction::MUL_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002380 funcOffset = ENTRYPOINT_OFFSET(pDmul);
buzbee31a4a6f2012-02-28 15:36:15 -08002381 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002382 case Instruction::REM_DOUBLE_2ADDR:
2383 case Instruction::REM_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002384 funcOffset = ENTRYPOINT_OFFSET(pFmod);
buzbee31a4a6f2012-02-28 15:36:15 -08002385 break;
Elliott Hughesadb8c672012-03-06 16:49:32 -08002386 case Instruction::NEG_DOUBLE: {
buzbee31a4a6f2012-02-28 15:36:15 -08002387 genNegDouble(cUnit, rlDest, rlSrc1);
2388 return false;
2389 }
2390 default:
2391 return true;
2392 }
2393 oatFlushAllRegs(cUnit); /* Send everything to home location */
Ian Rogersab2b55d2012-03-18 00:06:11 -07002394 callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlSrc2);
Ian Rogersf7d9ad32012-03-13 18:45:39 -07002395 rlResult = oatGetReturnWide(cUnit, true);
buzbee31a4a6f2012-02-28 15:36:15 -08002396 storeValueWide(cUnit, rlDest, rlResult);
2397 return false;
2398}
2399
2400bool genConversionPortable(CompilationUnit* cUnit, MIR* mir)
2401{
Elliott Hughesadb8c672012-03-06 16:49:32 -08002402 Instruction::Code opcode = mir->dalvikInsn.opcode;
buzbee31a4a6f2012-02-28 15:36:15 -08002403
2404 switch (opcode) {
Elliott Hughesadb8c672012-03-06 16:49:32 -08002405 case Instruction::INT_TO_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002406 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pI2f),
buzbee31a4a6f2012-02-28 15:36:15 -08002407 1, 1);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002408 case Instruction::FLOAT_TO_INT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002409 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pF2iz),
buzbee31a4a6f2012-02-28 15:36:15 -08002410 1, 1);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002411 case Instruction::DOUBLE_TO_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002412 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pD2f),
buzbee31a4a6f2012-02-28 15:36:15 -08002413 2, 1);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002414 case Instruction::FLOAT_TO_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002415 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pF2d),
buzbee31a4a6f2012-02-28 15:36:15 -08002416 1, 2);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002417 case Instruction::INT_TO_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002418 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pI2d),
buzbee31a4a6f2012-02-28 15:36:15 -08002419 1, 2);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002420 case Instruction::DOUBLE_TO_INT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002421 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pD2iz),
buzbee31a4a6f2012-02-28 15:36:15 -08002422 2, 1);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002423 case Instruction::FLOAT_TO_LONG:
Ian Rogers57b86d42012-03-27 16:05:41 -07002424 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pF2l),
2425 1, 2);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002426 case Instruction::LONG_TO_FLOAT:
Ian Rogers57b86d42012-03-27 16:05:41 -07002427 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pL2f),
buzbee31a4a6f2012-02-28 15:36:15 -08002428 2, 1);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002429 case Instruction::DOUBLE_TO_LONG:
Ian Rogers57b86d42012-03-27 16:05:41 -07002430 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pD2l),
2431 2, 2);
Elliott Hughesadb8c672012-03-06 16:49:32 -08002432 case Instruction::LONG_TO_DOUBLE:
Ian Rogers57b86d42012-03-27 16:05:41 -07002433 return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pL2d),
buzbee31a4a6f2012-02-28 15:36:15 -08002434 2, 2);
2435 default:
2436 return true;
2437 }
2438 return false;
2439}
2440
2441/*
2442 * Generate callout to updateDebugger. Note that we're overloading
2443 * the use of rSUSPEND here. When the debugger is active, this
2444 * register holds the address of the update function. So, if it's
2445 * non-null, we call out to it.
2446 *
2447 * Note also that rRET0 and rRET1 must be preserved across this
2448 * code. This must be handled by the stub.
2449 */
2450void genDebuggerUpdate(CompilationUnit* cUnit, int32_t offset)
2451{
2452 // Following DCHECK verifies that dPC is in range of single load immediate
2453 DCHECK((offset == DEBUGGER_METHOD_ENTRY) ||
2454 (offset == DEBUGGER_METHOD_EXIT) || ((offset & 0xffff) == offset));
2455 oatClobberCalleeSave(cUnit);
2456#if defined(TARGET_ARM)
2457 opRegImm(cUnit, kOpCmp, rSUSPEND, 0);
buzbee82488f52012-03-02 08:20:26 -08002458 opIT(cUnit, kArmCondNe, "T");
buzbee31a4a6f2012-02-28 15:36:15 -08002459 loadConstant(cUnit, rARG2, offset); // arg2 <- Entry code
2460 opReg(cUnit, kOpBlx, rSUSPEND);
Ian Rogersb5d09b22012-03-06 22:14:17 -08002461#elif defined(TARGET_X86)
2462 UNIMPLEMENTED(FATAL);
buzbee31a4a6f2012-02-28 15:36:15 -08002463#else
buzbee82488f52012-03-02 08:20:26 -08002464 LIR* branch = opCmpImmBranch(cUnit, kCondEq, rSUSPEND, 0, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -08002465 loadConstant(cUnit, rARG2, offset);
2466 opReg(cUnit, kOpBlx, rSUSPEND);
2467 LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
buzbee31a4a6f2012-02-28 15:36:15 -08002468 branch->target = (LIR*)target;
2469#endif
2470 oatFreeTemp(cUnit, rARG2);
2471}
2472
2473/* Check if we need to check for pending suspend request */
2474void genSuspendTest(CompilationUnit* cUnit, MIR* mir)
2475{
2476 if (NO_SUSPEND || (mir->optimizationFlags & MIR_IGNORE_SUSPEND_CHECK)) {
2477 return;
2478 }
2479 oatFlushAllRegs(cUnit);
buzbee31a4a6f2012-02-28 15:36:15 -08002480 if (cUnit->genDebugger) {
2481 // If generating code for the debugger, always check for suspension
Ian Rogers6cbb2bd2012-03-16 13:45:30 -07002482#if defined(TARGET_X86)
2483 UNIMPLEMENTED(FATAL);
2484#else
Ian Rogers57b86d42012-03-27 16:05:41 -07002485 int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pTestSuspendFromCode));
buzbee86a4bce2012-03-06 18:15:00 -08002486 opReg(cUnit, kOpBlx, rTgt);
2487 // Refresh rSUSPEND
2488 loadWordDisp(cUnit, rSELF,
Ian Rogers57b86d42012-03-27 16:05:41 -07002489 ENTRYPOINT_OFFSET(pUpdateDebuggerFromCode),
buzbee86a4bce2012-03-06 18:15:00 -08002490 rSUSPEND);
Ian Rogersb5d09b22012-03-06 22:14:17 -08002491#endif
buzbee31a4a6f2012-02-28 15:36:15 -08002492 } else {
Ian Rogersb5d09b22012-03-06 22:14:17 -08002493 LIR* branch = NULL;
buzbee31a4a6f2012-02-28 15:36:15 -08002494#if defined(TARGET_ARM)
2495 // In non-debug case, only check periodically
2496 newLIR2(cUnit, kThumbSubRI8, rSUSPEND, 1);
buzbee82488f52012-03-02 08:20:26 -08002497 branch = opCondBranch(cUnit, kCondEq, NULL);
Ian Rogersb5d09b22012-03-06 22:14:17 -08002498#elif defined(TARGET_X86)
2499 newLIR2(cUnit, kX86Cmp32TI, Thread::SuspendCountOffset().Int32Value(), 0);
2500 branch = opCondBranch(cUnit, kCondNe, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -08002501#else
2502 opRegImm(cUnit, kOpSub, rSUSPEND, 1);
buzbee82488f52012-03-02 08:20:26 -08002503 branch = opCmpImmBranch(cUnit, kCondEq, rSUSPEND, 0, NULL);
buzbee31a4a6f2012-02-28 15:36:15 -08002504#endif
buzbee86a4bce2012-03-06 18:15:00 -08002505 LIR* retLab = newLIR0(cUnit, kPseudoTargetLabel);
2506 LIR* target = rawLIR(cUnit, cUnit->currentDalvikOffset,
2507 kPseudoSuspendTarget, (intptr_t)retLab, mir->offset);
2508 branch->target = (LIR*)target;
2509 oatInsertGrowableList(cUnit, &cUnit->suspendLaunchpads, (intptr_t)target);
buzbee31a4a6f2012-02-28 15:36:15 -08002510 }
buzbee31a4a6f2012-02-28 15:36:15 -08002511}
2512
buzbeefead2932012-03-30 14:02:01 -07002513/* Check if we need to check for pending suspend request */
2514void genSuspendTestAndBranch(CompilationUnit* cUnit, MIR* mir, LIR* target)
2515{
2516 if (NO_SUSPEND || (mir->optimizationFlags & MIR_IGNORE_SUSPEND_CHECK)) {
2517 opUnconditionalBranch(cUnit, target);
2518 return;
2519 }
2520 if (cUnit->genDebugger) {
2521 genSuspendTest(cUnit, mir);
2522 opUnconditionalBranch(cUnit, target);
2523 } else {
2524#if defined(TARGET_ARM)
2525 // In non-debug case, only check periodically
2526 newLIR2(cUnit, kThumbSubRI8, rSUSPEND, 1);
2527 opCondBranch(cUnit, kCondNe, target);
2528#elif defined(TARGET_X86)
2529 newLIR2(cUnit, kX86Cmp32TI, Thread::SuspendCountOffset().Int32Value(), 0);
2530 opCondBranch(cUnit, kCondEq, target);
2531#else
2532 opRegImm(cUnit, kOpSub, rSUSPEND, 1);
2533 opCmpImmBranch(cUnit, kCondNe, rSUSPEND, 0, target);
2534#endif
2535 LIR* launchPad = rawLIR(cUnit, cUnit->currentDalvikOffset,
2536 kPseudoSuspendTarget, (intptr_t)target, mir->offset);
2537 oatFlushAllRegs(cUnit);
2538 opUnconditionalBranch(cUnit, launchPad);
2539 oatInsertGrowableList(cUnit, &cUnit->suspendLaunchpads, (intptr_t)launchPad);
2540 }
2541}
2542
buzbee31a4a6f2012-02-28 15:36:15 -08002543} // namespace art