Lines Matching full:cunit
30 static void markCard(CompilationUnit *cUnit, int valReg, int tgtAddrReg)
32 int regCardBase = dvmCompilerAllocTemp(cUnit);
33 int regCardNo = dvmCompilerAllocTemp(cUnit);
34 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondEq, valReg, 0);
35 loadWordDisp(cUnit, r6SELF, offsetof(Thread, cardTable),
37 opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, GC_CARD_SHIFT);
38 storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
40 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
43 dvmCompilerFreeTemp(cUnit, regCardBase);
44 dvmCompilerFreeTemp(cUnit, regCardNo);
47 static bool genConversionCall(CompilationUnit *cUnit, MIR *mir, void *funct,
56 dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */
58 rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
59 loadValueDirectFixed(cUnit, rlSrc, r0);
61 rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
62 loadValueDirectWideFixed(cUnit, rlSrc, r0, r1);
64 LOAD_FUNC_ADDR(cUnit, r2, (int)funct);
65 opReg(cUnit, kOpBlx, r2);
66 dvmCompilerClobberCallRegs(cUnit);
69 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
70 rlResult = dvmCompilerGetReturn(cUnit);
71 storeValue(cUnit, rlDest, rlResult);
74 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
75 rlResult = dvmCompilerGetReturnWide(cUnit);
76 storeValueWide(cUnit, rlDest, rlResult);
81 static bool genArithOpFloatPortable(CompilationUnit *cUnit, MIR *mir,
110 genNegFloat(cUnit, rlDest, rlSrc1);
116 dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */
117 loadValueDirectFixed(cUnit, rlSrc1, r0);
118 loadValueDirectFixed(cUnit, rlSrc2, r1);
119 LOAD_FUNC_ADDR(cUnit, r2, (int)funct);
120 opReg(cUnit, kOpBlx, r2);
121 dvmCompilerClobberCallRegs(cUnit);
122 rlResult = dvmCompilerGetReturn(cUnit);
123 storeValue(cUnit, rlDest, rlResult);
127 static bool genArithOpDoublePortable(CompilationUnit *cUnit, MIR *mir,
156 genNegDouble(cUnit, rlDest, rlSrc1);
162 dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */
163 LOAD_FUNC_ADDR(cUnit, r14lr, (int)funct);
164 loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
165 loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
166 opReg(cUnit, kOpBlx, r14lr);
167 dvmCompilerClobberCallRegs(cUnit);
168 rlResult = dvmCompilerGetReturnWide(cUnit);
169 storeValueWide(cUnit, rlDest, rlResult);
171 cUnit->usesLinkRegister = true;
176 static bool genConversionPortable(CompilationUnit *cUnit, MIR *mir)
182 return genConversionCall(cUnit, mir, (void*)__aeabi_i2f, 1, 1);
184 return genConversionCall(cUnit, mir, (void*)__aeabi_f2iz, 1, 1);
186 return genConversionCall(cUnit, mir, (void*)__aeabi_d2f, 2, 1);
188 return genConversionCall(cUnit, mir, (void*)__aeabi_f2d, 1, 2);
190 return genConversionCall(cUnit, mir, (void*)__aeabi_i2d, 1, 2);
192 return genConversionCall(cUnit, mir, (void*)__aeabi_d2iz, 2, 1);
194 return genConversionCall(cUnit, mir, (void*)dvmJitf2l, 1, 2);
196 return genConversionCall(cUnit, mir, (void*)__aeabi_l2f, 2, 1);
198 return genConversionCall(cUnit, mir, (void*)dvmJitd2l, 2, 2);
200 return genConversionCall(cUnit, mir, (void*)__aeabi_l2d, 2, 2);
244 static void selfVerificationBranchInsertPass(CompilationUnit *cUnit)
249 for (thisLIR = (ArmLIR *) cUnit->firstLIRInsn;
250 thisLIR != (ArmLIR *) cUnit->lastLIRInsn;
261 if (cUnit->usesLinkRegister) {
262 genSelfVerificationPreBranch(cUnit, thisLIR);
274 if (cUnit->usesLinkRegister) {
275 genSelfVerificationPostBranch(cUnit, thisLIR);
283 static ArmLIR *genConditionalBranch(CompilationUnit *cUnit,
287 ArmLIR *branch = opCondBranch(cUnit, cond);
293 static inline ArmLIR *genTrap(CompilationUnit *cUnit, int dOffset,
296 ArmLIR *branch = opNone(cUnit, kOpUncondBr);
297 return genCheckCommon(cUnit, dOffset, branch, pcrLabel);
301 static void genIGetWide(CompilationUnit *cUnit, MIR *mir, int fieldOffset)
303 RegLocation rlObj = dvmCompilerGetSrc(cUnit, mir, 0);
304 RegLocation rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
306 rlObj = loadValue(cUnit, rlObj, kCoreReg);
307 int regPtr = dvmCompilerAllocTemp(cUnit);
311 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
313 opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
314 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
317 loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
320 dvmCompilerFreeTemp(cUnit, regPtr);
321 storeValueWide(cUnit, rlDest, rlResult);
325 static void genIPutWide(CompilationUnit *cUnit, MIR *mir, int fieldOffset)
327 RegLocation rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
328 RegLocation rlObj = dvmCompilerGetSrc(cUnit, mir, 2);
329 rlObj = loadValue(cUnit, rlObj, kCoreReg);
331 rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
332 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
334 regPtr = dvmCompilerAllocTemp(cUnit);
335 opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
338 storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
341 dvmCompilerFreeTemp(cUnit, regPtr);
348 static void genIGet(CompilationUnit *cUnit, MIR *mir, OpSize size,
353 RegLocation rlObj = dvmCompilerGetSrc(cUnit, mir, 0);
354 RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0);
355 rlObj = loadValue(cUnit, rlObj, kCoreReg);
356 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);
357 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
361 loadBaseDisp(cUnit, mir, rlObj.lowReg, fieldOffset, rlResult.lowReg,
365 dvmCompilerGenMemBarrier(cUnit, kSY);
368 storeValue(cUnit, rlDest, rlResult);
375 static void genIPut(CompilationUnit *cUnit, MIR *mir, OpSize size,
379 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
380 RegLocation rlObj = dvmCompilerGetSrc(cUnit, mir, 1);
381 rlObj = loadValue(cUnit, rlObj, kCoreReg);
382 rlSrc = loadValue(cUnit, rlSrc, regClass);
383 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
387 dvmCompilerGenMemBarrier(cUnit, kST);
390 storeBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, size);
393 dvmCompilerGenMemBarrier(cUnit, kSY);
397 markCard(cUnit, rlSrc.lowReg, rlObj.lowReg);
405 static void genArrayGet(CompilationUnit *cUnit, MIR *mir, OpSize size,
413 rlArray = loadValue(cUnit, rlArray, kCoreReg);
414 rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
421 pcrLabel = genNullCheck(cUnit, rlArray.sRegLow,
425 regPtr = dvmCompilerAllocTemp(cUnit);
428 int regLen = dvmCompilerAllocTemp(cUnit);
430 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
432 opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
433 genBoundsCheck(cUnit, rlIndex.lowReg, regLen, mir->offset,
435 dvmCompilerFreeTemp(cUnit, regLen);
438 opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
442 int rNewIndex = dvmCompilerAllocTemp(cUnit);
443 opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
444 opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
445 dvmCompilerFreeTemp(cUnit, rNewIndex);
447 cUnit, kOpAdd, regPtr, rlIndex.lowReg);
449 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);
452 loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
455 dvmCompilerFreeTemp(cUnit, regPtr);
456 storeValueWide(cUnit, rlDest, rlResult);
458 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);
461 loadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg,
465 dvmCompilerFreeTemp(cUnit, regPtr);
466 storeValue(cUnit, rlDest, rlResult);
474 static void genArrayPut(CompilationUnit *cUnit, MIR *mir, OpSize size,
483 rlArray = loadValue(cUnit, rlArray, kCoreReg);
484 rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
486 if (dvmCompilerIsTemp(cUnit, rlArray.lowReg)) {
487 dvmCompilerClobber(cUnit, rlArray.lowReg);
490 regPtr = dvmCompilerAllocTemp(cUnit);
491 genRegCopy(cUnit, regPtr, rlArray.lowReg);
498 pcrLabel = genNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg,
503 int regLen = dvmCompilerAllocTemp(cUnit);
506 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
508 opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
509 genBoundsCheck(cUnit, rlIndex.lowReg, regLen, mir->offset,
511 dvmCompilerFreeTemp(cUnit, regLen);
514 opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
520 int rNewIndex = dvmCompilerAllocTemp(cUnit);
521 opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
522 opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
523 dvmCompilerFreeTemp(cUnit, rNewIndex);
525 opRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
527 rlSrc = loadValueWide(cUnit, rlSrc, regClass);
530 storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
533 dvmCompilerFreeTemp(cUnit, regPtr);
535 rlSrc = loadValue(cUnit, rlSrc, regClass);
538 storeBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlSrc.lowReg,
549 static void genArrayObjectPut(CompilationUnit *cUnit, MIR *mir,
556 dvmCompilerFlushAllRegs(cUnit);
563 loadValueDirectFixed(cUnit, rlArray, regArray);
564 loadValueDirectFixed(cUnit, rlIndex, regIndex);
570 pcrLabel = genNullCheck(cUnit, rlArray.sRegLow, regArray,
576 loadWordDisp(cUnit, regArray, lenOffset, regLen);
578 opRegRegImm(cUnit, kOpAdd, regPtr, regArray, dataOffset);
579 genBoundsCheck(cUnit, regIndex, regLen, mir->offset,
583 opRegRegImm(cUnit, kOpAdd, regPtr, regArray, dataOffset);
587 loadValueDirectFixed(cUnit, rlSrc, r0);
588 LOAD_FUNC_ADDR(cUnit, r2, (int)dvmCanPutArrayElement);
591 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondEq, r0, 0);
594 loadWordDisp(cUnit, regArray, offsetof(Object, clazz), r1);
595 loadWordDisp(cUnit, r0, offsetof(Object, clazz), r0);
596 opReg(cUnit, kOpBlx, r2);
597 dvmCompilerClobberCallRegs(cUnit);
604 dvmCompilerLockTemp(cUnit, regPtr); // r4PC
605 dvmCompilerLockTemp(cUnit, regIndex); // r7
606 dvmCompilerLockTemp(cUnit, r0);
607 dvmCompilerLockTemp(cUnit, r1);
610 genRegImmCheck(cUnit, kArmCondEq, r0, 0, mir->offset, pcrLabel);
613 loadValueDirectFixed(cUnit, rlSrc, r0);
614 loadValueDirectFixed(cUnit, rlArray, r1);
616 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
621 storeBaseIndexed(cUnit, regPtr, regIndex, r0,
625 dvmCompilerFreeTemp(cUnit, regPtr);
626 dvmCompilerFreeTemp(cUnit, regIndex);
629 markCard(cUnit, r0, r1);
632 static bool genShiftOpLong(CompilationUnit *cUnit, MIR *mir,
642 loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
643 loadValueDirect(cUnit, rlShift, r2);
647 genDispatchToHandler(cUnit, TEMPLATE_SHL_LONG);
651 genDispatchToHandler(cUnit, TEMPLATE_SHR_LONG);
655 genDispatchToHandler(cUnit, TEMPLATE_USHR_LONG);
660 rlResult = dvmCompilerGetReturnWide(cUnit);
661 storeValueWide(cUnit, rlDest, rlResult);
665 static bool genArithOpLong(CompilationUnit *cUnit, MIR *mir,
679 rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
680 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
681 opRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
682 opRegReg(cUnit, kOpMvn, rlResult.highReg, rlSrc2.highReg);
683 storeValueWide(cUnit, rlDest, rlResult);
698 genMulLong(cUnit, rlDest, rlSrc1, rlSrc2);
732 int tReg = dvmCompilerAllocTemp(cUnit);
733 rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
734 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
735 loadConstantNoClobber(cUnit, tReg, 0);
736 opRegRegReg(cUnit, kOpSub, rlResult.lowReg,
738 opRegReg(cUnit, kOpSbc, tReg, rlSrc2.highReg);
739 genRegCopy(cUnit, rlResult.highReg, tReg);
740 storeValueWide(cUnit, rlDest, rlResult);
745 dvmCompilerAbort(cUnit);
748 genLong3Addr(cUnit, mir, firstOp, secondOp, rlDest, rlSrc1, rlSrc2);
751 dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */
752 loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
753 loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
754 LOAD_FUNC_ADDR(cUnit, r14lr, (int) callTgt);
757 opRegRegReg(cUnit, kOpOr, tReg, r2, r3);
758 genRegImmCheck(cUnit, kArmCondEq, tReg, 0, mir->offset, NULL);
760 opReg(cUnit, kOpBlx, r14lr);
761 dvmCompilerClobberCallRegs(cUnit);
763 rlResult = dvmCompilerGetReturnWide(cUnit);
765 rlResult = dvmCompilerGetReturnWideAlt(cUnit);
766 storeValueWide(cUnit, rlDest, rlResult);
768 cUnit->usesLinkRegister = true;
774 static bool genArithOpInt(CompilationUnit *cUnit, MIR *mir,
853 dvmCompilerAbort(cUnit);
856 rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
858 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
859 opRegReg(cUnit, op, rlResult.lowReg,
862 rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
864 int tReg = dvmCompilerAllocTemp(cUnit);
865 opRegRegImm(cUnit, kOpAnd, tReg, rlSrc2.lowReg, 31);
866 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
867 opRegRegReg(cUnit, op, rlResult.lowReg,
869 dvmCompilerFreeTemp(cUnit, tReg);
871 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
872 opRegRegReg(cUnit, op, rlResult.lowReg,
876 storeValue(cUnit, rlDest, rlResult);
879 dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */
880 loadValueDirectFixed(cUnit, rlSrc2, r1);
881 LOAD_FUNC_ADDR(cUnit, r2, (int) callTgt);
882 loadValueDirectFixed(cUnit, rlSrc1, r0);
884 genNullCheck(cUnit, rlSrc2.sRegLow, r1, mir->offset, NULL);
886 opReg(cUnit, kOpBlx, r2);
887 dvmCompilerClobberCallRegs(cUnit);
889 rlResult = dvmCompilerGetReturn(cUnit);
891 rlResult = dvmCompilerGetReturnAlt(cUnit);
892 storeValue(cUnit, rlDest, rlResult);
897 static bool genArithOp(CompilationUnit *cUnit, MIR *mir)
905 rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0);
906 rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1);
908 rlSrc1 = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
909 rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 2);
911 rlSrc1 = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
912 rlSrc2 = dvmCompilerGetSrcWide(cUnit, mir, 2, 3);
916 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
919 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
923 return genArithOpLong(cUnit,mir, rlDest, rlSrc1, rlSrc2);
926 return genArithOpLong(cUnit,mir, rlDest, rlSrc1, rlSrc2);
929 return genShiftOpLong(cUnit,mir, rlDest, rlSrc1, rlSrc2);
932 return genShiftOpLong(cUnit,mir, rlDest, rlSrc1, rlSrc2);
935 return genArithOpInt(cUnit,mir, rlDest, rlSrc1, rlSrc2);
938 return genArithOpInt(cUnit,mir, rlDest, rlSrc1, rlSrc2);
941 return genArithOpFloat(cUnit,mir, rlDest, rlSrc1, rlSrc2);
944 return genArithOpFloat(cUnit, mir, rlDest, rlSrc1, rlSrc2);
947 return genArithOpDouble(cUnit,mir, rlDest, rlSrc1, rlSrc2);
950 return genArithOpDouble(cUnit,mir, rlDest, rlSrc1, rlSrc2);
956 static ArmLIR *genUnconditionalBranch(CompilationUnit *cUnit, ArmLIR *target)
958 ArmLIR *branch = opNone(cUnit, kOpUncondBr);
964 static void genReturnCommon(CompilationUnit *cUnit, MIR *mir)
966 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
971 int dPC = (int) (cUnit->method->insns + mir->offset);
973 ArmLIR *branch = genUnconditionalBranch(cUnit, NULL);
980 dvmInsertGrowableList(&cUnit->pcReconstructionList, (intptr_t) pcrLabel);
985 static void genProcessArgsNoRange(CompilationUnit *cUnit, MIR *mir,
999 dvmCompilerLockAllTemps(cUnit);
1002 rlArg = dvmCompilerGetSrc(cUnit, mir, numDone++);
1003 loadValueDirectFixed(cUnit, rlArg, i);
1007 opRegRegImm(cUnit, kOpSub, r7, r5FP,
1011 *pcrLabel = genNullCheck(cUnit, dvmCompilerSSASrc(mir, 0), r0,
1014 storeMultiple(cUnit, r7, regMask);
1018 static void genProcessArgsRange(CompilationUnit *cUnit, MIR *mir,
1033 dvmCompilerLockAllTemps(cUnit);
1039 opRegRegImm(cUnit, kOpAdd, r4PC, r5FP, srcOffset);
1046 if (numArgs != 0) loadMultiple(cUnit, r4PC, regMask);
1048 opRegRegImm(cUnit, kOpSub, r7, r5FP,
1052 *pcrLabel = genNullCheck(cUnit, dvmCompilerSSASrc(mir, 0), r0,
1066 opImm(cUnit, kOpPush, (1 << r0 | 1 << r5FP));
1069 loadConstant(cUnit, 5, ((numArgs - 4) >> 2) << 2);
1070 loopLabel = newLIR0(cUnit, kArmPseudoTargetLabel);
1073 storeMultiple(cUnit, r7, regMask);
1078 loadMultiple(cUnit, r4PC, regMask);
1081 opRegImm(cUnit, kOpSub, r5FP, 4);
1082 genConditionalBranch(cUnit, kArmCondNe, loopLabel);
1087 if (numArgs != 0) storeMultiple(cUnit, r7, regMask);
1096 loadMultiple(cUnit, r4PC, regMask);
1099 opImm(cUnit, kOpPop, (1 << r0 | 1 << r5FP));
1103 storeMultiple(cUnit, r7, regMask);
1111 static void genInvokeSingletonCommon(CompilationUnit *cUnit, MIR *mir,
1121 dvmCompilerLockAllTemps(cUnit);
1125 ArmLIR *addrRetChain = opRegRegImm(cUnit, kOpAdd, r1, r15pc, 0);
1128 loadConstant(cUnit, r4PC,
1129 (int) (cUnit->method->insns + mir->offset));
1133 loadConstant(cUnit, r7, calleeMethod->registersSize);
1142 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
1150 loadConstant(cUnit, r2, calleeMethod->outsSize);
1151 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
1158 genUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
1161 genTrap(cUnit, mir->offset, pcrLabel);
1184 static void genInvokeVirtualCommon(CompilationUnit *cUnit, MIR *mir,
1196 dvmCompilerLockAllTemps(cUnit);
1207 loadConstant(cUnit, r4PC,
1208 (int) (cUnit->method->insns + mir->offset));
1211 ArmLIR *addrRetChain = opRegRegImm(cUnit, kOpAdd, r1, r15pc, 0);
1215 ArmLIR *predictedChainingCell = opRegRegImm(cUnit, kOpAdd, r2, r15pc, 0);
1218 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
1223 genUnconditionalBranch(cUnit, predChainingCell);
1230 int dPC = (int) (cUnit->method->insns + mir->offset);
1236 dvmInsertGrowableList(&cUnit->pcReconstructionList,
1241 genUnconditionalBranch(cUnit, pcrLabel);
1253 loadWordDisp(cUnit, r7, methodIndex * 4, r0);
1256 ArmLIR *bypassRechaining = genCmpImmBranch(cUnit, kArmCondGt, r1, 0);
1258 LOAD_FUNC_ADDR(cUnit, r7, (int) dvmJitToPatchPredictedChain);
1260 genRegCopy(cUnit, r1, r6SELF);
1271 opReg(cUnit, kOpBlx, r7);
1274 addrRetChain = opRegRegImm(cUnit, kOpAdd, r1, r15pc, 0);
1283 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
1290 genTrap(cUnit, mir->offset, pcrLabel);
1294 static void genInvokeVirtualWholeMethod(CompilationUnit *cUnit,
1300 dvmCompilerLockAllTemps(cUnit);
1302 loadClassPointer(cUnit, r1, (int) callsiteInfo);
1304 loadWordDisp(cUnit, r0, offsetof(Object, clazz), r2);
1306 opRegReg(cUnit, kOpCmp, r1, r2);
1311 ArmLIR *classCheck = opCondBranch(cUnit, kArmCondNe);
1314 loadConstant(cUnit, r0, (int) (cUnit->method->insns + mir->offset));
1316 newLIR2(cUnit, kThumbBl1, (int) calleeAddr, (int) calleeAddr);
1317 newLIR2(cUnit, kThumbBl2, (int) calleeAddr, (int) calleeAddr);
1318 genUnconditionalBranch(cUnit, retChainingCell);
1321 ArmLIR *slowPathLabel = newLIR0(cUnit, kArmPseudoTargetLabel);
1327 cUnit->printMe = true;
1330 static void genInvokeSingletonWholeMethod(CompilationUnit *cUnit,
1336 loadConstant(cUnit, r0, (int) (cUnit->method->insns + mir->offset));
1338 newLIR2(cUnit, kThumbBl1, (int) calleeAddr, (int) calleeAddr);
1339 newLIR2(cUnit, kThumbBl2, (int) calleeAddr, (int) calleeAddr);
1340 genUnconditionalBranch(cUnit, retChainingCell);
1343 cUnit->printMe = true;
1347 static void genPuntToInterp(CompilationUnit *cUnit, unsigned int offset)
1350 dvmCompilerFlushAllRegs(cUnit);
1351 loadConstant(cUnit, r0, (int) (cUnit->method->insns + offset));
1352 loadWordDisp(cUnit, r6SELF, offsetof(Thread,
1354 opReg(cUnit, kOpBlx, r1);
1361 static void genInterpSingleStep(CompilationUnit *cUnit, MIR *mir)
1367 if (cUnit
1368 cUnit->quitLoopMode = true;
1377 dvmCompilerFlushAllRegs(cUnit);
1380 genPuntToInterp(cUnit, mir->offset);
1385 loadWordDisp(cUnit, r6SELF, entryAddr, r2);
1387 loadConstant(cUnit, r0, (int) (cUnit->method->insns + mir->offset));
1389 loadConstant(cUnit, r1, (int) (cUnit->method->insns + mir->next->offset));
1390 opReg(cUnit, kOpBlx, r2);
1405 static void genMonitorPortable(CompilationUnit *cUnit, MIR *mir)
1408 genExportPC(cUnit, mir);
1409 dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */
1410 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
1411 loadValueDirectFixed(cUnit, rlSrc, r1);
1412 genRegCopy(cUnit, r0, r6SELF);
1413 genNullCheck(cUnit, rlSrc.sRegLow, r1, mir->offset, NULL);
1416 loadConstant(cUnit, r4PC, (int)(cUnit->method->insns + mir->offset +
1418 genDispatchToHandler(cUnit, TEMPLATE_MONITOR_ENTER);
1420 LOAD_FUNC_ADDR(cUnit, r2, (int)dvmUnlockObject);
1422 opReg(cUnit, kOpBlx, r2);
1424 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
1425 loadConstant(cUnit, r0,
1426 (int) (cUnit->method->insns + mir->offset +
1428 genDispatchToHandler(cUnit, TEMPLATE_THROW_EXCEPTION_COMMON);
1429 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
1432 dvmCompilerClobberCallRegs(cUnit);
1441 static void genSuspendPoll(CompilationUnit *cUnit, MIR *mir)
1443 int rTemp = dvmCompilerAllocTemp(cUnit);
1445 ld = loadBaseDisp(cUnit, NULL, r6SELF,
1449 genRegImmCheck(cUnit, kArmCondNe, rTemp, 0, mir->offset, NULL);
1458 static bool handleFmt10t_Fmt20t_Fmt30t(CompilationUnit *cUnit, MIR *mir,
1465 (gDvmJit.genSuspendPoll || cUnit->jitMode == kJitLoop)) {
1466 genSuspendPoll(cUnit, mir);
1476 cUnit->nextCodegenBlock = bb->taken;
1479 genUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
1484 static bool handleFmt10x(CompilationUnit *cUnit, MIR *mir)
1493 dvmCompilerGenMemBarrier(cUnit, kST);
1496 genReturnCommon(cUnit,mir);
1512 static bool handleFmt11n_Fmt31i(CompilationUnit *cUnit, MIR *mir)
1517 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
1519 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1525 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
1526 loadConstantNoClobber(cUnit, rlResult.lowReg, mir->dalvikInsn.vB);
1527 storeValue(cUnit, rlDest, rlResult);
1533 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
1534 loadConstantNoClobber(cUnit, rlResult.lowReg, mir->dalvikInsn.vB);
1535 opRegRegImm(cUnit, kOpAsr, rlResult.highReg,
1537 storeValueWide(cUnit, rlDest, rlResult);
1546 static bool handleFmt21h(CompilationUnit *cUnit, MIR *mir)
1551 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
1553 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1555 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
1559 loadConstantNoClobber(cUnit, rlResult.lowReg,
1561 storeValue(cUnit, rlDest, rlResult);
1565 loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
1567 storeValueWide(cUnit, rlDest, rlResult);
1576 static bool handleFmt20bc(CompilationUnit *cUnit, MIR *mir)
1579 genInterpSingleStep(cUnit, mir);
1583 static bool handleFmt21c_Fmt31c(CompilationUnit *cUnit, MIR *mir)
1593 (cUnit->method->clazz->pDvmDex->pResStrings[mir->dalvikInsn.vB]);
1601 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1602 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
1603 loadConstantNoClobber(cUnit, rlResult.lowReg, (int) strPtr );
1604 storeValue(cUnit, rlDest, rlResult);
1609 (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
1617 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1618 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
1619 loadConstantNoClobber(cUnit, rlResult.lowReg, (int) classPtr );
1620 storeValue(cUnit, rlDest, rlResult);
1632 int tReg = dvmCompilerAllocTemp(cUnit);
1635 mir->meta.calleeMethod : cUnit->method;
1662 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1663 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
1664 loadConstant(cUnit, tReg, (int) fieldPtr + valOffset);
1667 dvmCompilerGenMemBarrier(cUnit, kSY);
1670 loadWordDisp(cUnit, tReg, 0, rlResult.lowReg);
1673 storeValue(cUnit, rlDest, rlResult);
1679 mir->meta.calleeMethod : cUnit->method;
1689 int tReg = dvmCompilerAllocTemp(cUnit);
1690 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
1691 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
1692 loadConstant(cUnit, tReg, (int) fieldPtr + valOffset);
1695 loadPair(cUnit, tReg, rlResult.lowReg, rlResult.highReg);
1698 storeValueWide(cUnit, rlDest, rlResult);
1710 int tReg = dvmCompilerAllocTemp(cUnit);
1715 mir->meta.calleeMethod : cUnit->method;
1737 rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
1738 rlSrc = loadValue(cUnit, rlSrc, kAnyReg);
1739 loadConstant(cUnit, tReg, (int) fieldPtr);
1741 objHead = dvmCompilerAllocTemp(cUnit);
1742 loadWordDisp(cUnit, tReg, OFFSETOF_MEMBER(Field, clazz), objHead);
1745 dvmCompilerGenMemBarrier(cUnit, kST);
1748 storeWordDisp(cUnit, tReg, valOffset ,rlSrc.lowReg);
1749 dvmCompilerFreeTemp(cUnit, tReg);
1752 dvmCompilerGenMemBarrier(cUnit, kSY);
1756 markCard(cUnit, rlSrc.lowReg, objHead);
1757 dvmCompilerFreeTemp(cUnit, objHead);
1763 int tReg = dvmCompilerAllocTemp(cUnit);
1766 mir->meta.calleeMethod : cUnit->method;
1776 rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
1777 rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
1778 loadConstant(cUnit, tReg, (int) fieldPtr + valOffset);
1781 storePair(cUnit, tReg, rlSrc.lowReg, rlSrc.highReg);
1791 (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
1804 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
1805 genExportPC(cUnit, mir);
1806 LOAD_FUNC_ADDR(cUnit, r2, (int)dvmAllocObject);
1807 loadConstant(cUnit, r0, (int) classPtr);
1808 loadConstant(cUnit, r1, ALLOC_DONT_TRACK);
1809 opReg(cUnit, kOpBlx, r2);
1810 cUnit);
1812 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
1816 loadConstant(cUnit, r0,
1817 (int) (cUnit->method->insns + mir->offset));
1818 genDispatchToHandler(cUnit, TEMPLATE_THROW_EXCEPTION_COMMON);
1821 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
1824 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1825 rlResult = dvmCompilerGetReturn(cUnit);
1826 storeValue(cUnit, rlDest, rlResult);
1835 (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
1847 genInterpSingleStep(cUnit, mir);
1850 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
1851 loadConstant(cUnit, r1, (int) classPtr );
1852 rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
1853 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
1855 ArmLIR *branch1 = genCmpImmBranch(cUnit, kArmCondEq,
1864 loadWordDisp(cUnit, rlSrc.lowReg, offsetof(Object, clazz), r0);
1865 LOAD_FUNC_ADDR(cUnit, r2, (int)dvmInstanceofNonTrivial);
1866 opRegReg(cUnit, kOpCmp, r0, r1);
1867 ArmLIR *branch2 = opCondBranch(cUnit, kArmCondEq);
1868 opReg(cUnit, kOpBlx, r2);
1869 dvmCompilerClobberCallRegs(cUnit);
1875 genZeroCheck(cUnit, r0, mir->offset, NULL);
1877 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
1885 genInterpSingleStep(cUnit, mir);
1908 static bool handleFmt11x(CompilationUnit *cUnit, MIR *mir)
1915 int resetReg = dvmCompilerAllocTemp(cUnit);
1916 RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1917 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
1918 loadWordDisp(cUnit, r6SELF, exOffset, rlResult.lowReg);
1919 loadConstant(cUnit, resetReg, 0);
1920 storeWordDisp(cUnit, r6SELF, exOffset, resetReg);
1921 storeValue(cUnit, rlDest, rlResult);
1929 RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0);
1932 storeValue(cUnit, rlDest, rlSrc);
1939 RegLocation rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
1942 storeValueWide(cUnit, rlDest, rlSrc);
1946 RegLocation rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
1949 storeValueWide(cUnit, rlDest, rlSrc);
1950 genReturnCommon(cUnit,mir);
1955 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
1958 storeValue(cUnit, rlDest, rlSrc);
1959 genReturnCommon(cUnit, mir);
1964 genMonitor(cUnit, mir);
1967 genInterpSingleStep(cUnit, mir);
1975 static bool handleFmt12x(CompilationUnit *cUnit, MIR *mir)
1983 return genArithOp( cUnit, mir );
1987 rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
1989 rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
1991 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
1993 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
2006 return genConversion(cUnit, mir);
2009 return genArithOpInt(cUnit, mir, rlDest, rlSrc, rlSrc);
2012 return genArithOpLong(cUnit, mir, rlDest, rlSrc, rlSrc);
2014 return genArithOpFloat(cUnit, mir, rlDest, rlSrc, rlSrc);
2016 return genArithOpDouble(cUnit, mir, rlDest, rlSrc, rlSrc);
2018 storeValueWide(cUnit, rlDest, rlSrc);
2021 rlSrc = dvmCompilerUpdateLoc(cUnit, rlSrc);
2022 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2025 genRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
2027 loadValueDirect(cUnit, rlSrc, rlResult.lowReg);
2029 opRegRegImm(cUnit, kOpAsr, rlResult.highReg,
2031 storeValueWide(cUnit, rlDest, rlResult);
2034 rlSrc = dvmCompilerUpdateLocWide(cUnit, rlSrc);
2035 rlSrc = dvmCompilerWideToNarrow(cUnit, rlSrc);
2039 storeValue(cUnit, rlDest, rlSrc);
2042 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2043 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2044 opRegReg(cUnit, kOp2Byte, rlResult.lowReg, rlSrc.lowReg);
2045 storeValue(cUnit, rlDest, rlResult);
2048 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2049 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2050 opRegReg(cUnit, kOp2Short, rlResult.lowReg, rlSrc.lowReg);
2051 storeValue(cUnit, rlDest, rlResult);
2054 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2055 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2056 opRegReg(cUnit, kOp2Char, rlResult.lowReg, rlSrc.lowReg);
2057 storeValue(cUnit, rlDest, rlResult);
2061 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2062 genNullCheck(cUnit, rlSrc.sRegLow, rlSrc.lowReg,
2064 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2065 loadWordDisp(cUnit, rlSrc.lowReg, lenOffset,
2067 storeValue(cUnit, rlDest, rlResult);
2076 static bool handleFmt21s(CompilationUnit *cUnit, MIR *mir)
2083 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
2084 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2085 loadConstantNoClobber(cUnit, rlResult.lowReg, BBBB);
2087 opRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
2088 storeValueWide(cUnit, rlDest, rlResult);
2090 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
2091 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
2092 loadConstantNoClobber(cUnit, rlResult.lowReg, BBBB);
2093 storeValue(cUnit, rlDest, rlResult);
2100 static bool handleFmt21t(CompilationUnit *cUnit, MIR *mir, BasicBlock *bb,
2109 (gDvmJit.genSuspendPoll || cUnit->jitMode == kJitLoop)) {
2110 genSuspendPoll(cUnit, mir);
2113 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
2114 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2116 opRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
2141 dvmCompilerAbort(cUnit);
2143 genConditionalBranch(cUnit, cond, &labelList[bb->taken->id]);
2145 genUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
2175 // Returns true if it added instructions to 'cUnit' to divide 'rlSrc' by 'lit'
2177 static bool handleEasyDivide(CompilationUnit *cUnit, Opcode dalvikOpcode,
2189 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2190 RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2192 int tReg = dvmCompilerAllocTemp(cUnit);
2195 opRegRegImm(cUnit, kOpLsr, tReg, rlSrc.lowReg, 32 - k);
2196 opRegRegReg(cUnit, kOpAdd, tReg, tReg, rlSrc.lowReg);
2197 opRegRegImm(cUnit, kOpAsr, rlResult.lowReg, tReg, k);
2199 opRegRegImm(cUnit, kOpAsr, tReg, rlSrc.lowReg, 31);
2200 opRegRegImm(cUnit, kOpLsr, tReg, tReg, 32 - k);
2201 opRegRegReg(cUnit, kOpAdd, tReg, tReg, rlSrc.lowReg);
2202 opRegRegImm(cUnit, kOpAsr, rlResult.lowReg, tReg, k);
2205 int cReg = dvmCompilerAllocTemp(cUnit);
2206 loadConstant(cUnit, cReg, lit - 1);
2207 int tReg1 = dvmCompilerAllocTemp(cUnit);
2208 int tReg2 = dvmCompilerAllocTemp(cUnit);
2210 opRegRegImm(cUnit, kOpLsr, tReg1, rlSrc.lowReg, 32 - k);
2211 opRegRegReg(cUnit, kOpAdd, tReg2, tReg1, rlSrc.lowReg);
2212 opRegRegReg(cUnit, kOpAnd, tReg2, tReg2, cReg);
2213 opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg2, tReg1);
2215 opRegRegImm(cUnit, kOpAsr, tReg1, rlSrc.lowReg, 31);
2216 opRegRegImm(cUnit, kOpLsr, tReg1, tReg1, 32 - k);
2217 opRegRegReg(cUnit, kOpAdd, tReg2, tReg1, rlSrc.lowReg);
2218 opRegRegReg(cUnit, kOpAnd, tReg2, tReg2, cReg);
2219 opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg2, tReg1);
2222 storeValue(cUnit, rlDest, rlResult);
2226 // Returns true if it added instructions to 'cUnit' to multiply 'rlSrc' by 'lit'
2228 static bool handleEasyMultiply(CompilationUnit *cUnit,
2247 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2248 RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2251 opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlSrc.lowReg,
2257 genMultiplyByTwoBitMultiplier(cUnit, rlSrc, rlResult, lit,
2263 int tReg = dvmCompilerAllocTemp(cUnit);
2264 opRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, lowestSetBit(lit + 1));
2265 opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg, rlSrc.lowReg);
2267 storeValue(cUnit, rlDest, rlResult);
2271 static bool handleFmt22b_Fmt22s(CompilationUnit *cUnit, MIR *mir)
2274 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
2275 RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0);
2287 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2288 tReg = dvmCompilerAllocTemp(cUnit);
2289 loadConstant(cUnit, tReg, lit);
2290 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2291 opRegRegReg(cUnit, kOpSub, rlResult.lowReg,
2293 storeValue(cUnit, rlDest, rlResult);
2304 if (handleEasyMultiply(cUnit, rlSrc, rlDest, lit)) {
2344 genInterpSingleStep(cUnit, mir);
2347 if (handleEasyDivide(cUnit, dalvikOpcode, rlSrc, rlDest, lit)) {
2350 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
2351 loadValueDirectFixed(cUnit, rlSrc, r0);
2352 dvmCompilerClobber(cUnit, r0);
2355 LOAD_FUNC_ADDR(cUnit, r2, (int)__aeabi_idiv);
2358 LOAD_FUNC_ADDR(cUnit, r2, (int)__aeabi_idivmod);
2361 loadConstant(cUnit, r1, lit);
2362 opReg(cUnit, kOpBlx, r2);
2363 dvmCompilerClobberCallRegs(cUnit);
2365 rlResult = dvmCompilerGetReturn(cUnit);
2367 rlResult = dvmCompilerGetReturnAlt(cUnit);
2368 storeValue(cUnit, rlDest, rlResult);
2374 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
2375 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
2378 genRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
2380 opRegRegImm(cUnit, op, rlResult.lowReg, rlSrc.lowReg, lit);
2382 storeValue(cUnit, rlDest, rlResult);
2386 static bool handleFmt22c(CompilationUnit *cUnit, MIR *mir)
2421 mir->meta.calleeMethod : cUnit->method;
2446 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
2447 RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0);
2450 (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vC]);
2458 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
2459 genExportPC(cUnit, mir);
2460 loadValueDirectFixed(cUnit, rlSrc, r1); /* Len */
2461 loadConstant(cUnit, r0, (int) classPtr );
2462 LOAD_FUNC_ADDR(cUnit, r3, (int)dvmAllocArrayByClass);
2467 genRegImmCheck(cUnit, kArmCondMi, r1, 0, mir->offset, NULL);
2468 loadConstant(cUnit, r2, ALLOC_DONT_TRACK);
2469 opReg(cUnit, kOpBlx, r3);
2470 dvmCompilerClobberCallRegs(cUnit);
2472 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
2476 loadConstant(cUnit, r0,
2477 (int) (cUnit->method->insns + mir->offset));
2478 genDispatchToHandler(cUnit, TEMPLATE_THROW_EXCEPTION_COMMON);
2481 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
2484 rlResult = dvmCompilerGetReturn(cUnit);
2485 storeValue(cUnit, rlDest, rlResult);
2490 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
2491 RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0);
2494 (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vC]);
2506 genInterpSingleStep(cUnit, mir);
2509 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
2510 loadValueDirectFixed(cUnit, rlSrc, r0); /* Ref */
2511 loadConstant(cUnit, r2, (int) classPtr );
2513 ArmLIR *branch1 = genCmpImmBranch(cUnit, kArmCondEq, r0, 0);
2515 loadWordDisp(cUnit, r0, offsetof(Object, clazz), r1);
2517 LOAD_FUNC_ADDR(cUnit, r3, (int)dvmInstanceofNonTrivial);
2518 loadConstant(cUnit, r0, 1); /* Assume true */
2519 opRegReg(cUnit, kOpCmp, r1, r2);
2520 ArmLIR *branch2 = opCondBranch(cUnit, kArmCondEq);
2521 genRegCopy(cUnit, r0, r1);
2522 genRegCopy(cUnit, r1, r2);
2523 opReg(cUnit, kOpBlx, r3);
2524 dvmCompilerClobberCallRegs(cUnit);
2526 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
2528 rlResult = dvmCompilerGetReturn(cUnit);
2529 storeValue(cUnit, rlDest, rlResult);
2535 genIGetWide(cUnit, mir, fieldOffset);
2545 genIGet(cUnit, mir, kWord, fieldOffset, isVolatile);
2548 genIPutWide(cUnit, mir, fieldOffset);
2556 genIPut(cUnit, mir, kWord, fieldOffset, false, isVolatile);
2560 genIPut(cUnit, mir, kWord, fieldOffset, true, isVolatile);
2564 genInterpSingleStep(cUnit, mir);
2572 static bool handleFmt22cs(CompilationUnit *cUnit, MIR *mir)
2579 genIGet(cUnit, mir, kWord, fieldOffset, false);
2582 genIPut(cUnit, mir, kWord, fieldOffset, false, false);
2585 genIPut(cUnit, mir, kWord, fieldOffset, true, false);
2588 genIGetWide(cUnit, mir, fieldOffset);
2591 genIPutWide(cUnit, mir, fieldOffset);
2601 static bool handleFmt22t(CompilationUnit *cUnit, MIR *mir, BasicBlock *bb,
2610 (gDvmJit.genSuspendPoll || cUnit->jitMode == kJitLoop)) {
2611 genSuspendPoll(cUnit, mir);
2614 RegLocation rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0);
2615 RegLocation rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1);
2617 rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
2618 rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
2620 opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
2644 dvmCompilerAbort(cUnit);
2646 genConditionalBranch(cUnit, cond, &labelList[bb->taken->id]);
2648 genUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
2652 static bool handleFmt22x_Fmt32x(CompilationUnit *cUnit, MIR *mir)
2661 storeValue(cUnit, dvmCompilerGetDest(cUnit, mir, 0),
2662 dvmCompilerGetSrc(cUnit, mir, 0));
2667 storeValueWide(cUnit, dvmCompilerGetDestWide(cUnit, mir, 0, 1),
2668 dvmCompilerGetSrcWide(cUnit, mir, 0, 1));
2677 static bool handleFmt23x(CompilationUnit *cUnit, MIR *mir)
2685 return genArithOp( cUnit, mir );
2691 rlDest = dvmCompilerGetSrc(cUnit, mir, 0);
2692 rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 1);
2693 rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 2);
2696 rlDest = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
2697 rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 2);
2698 rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 3);
2703 cUnit, mir, 0, 1);
2704 rlSrc2 = dvmCompilerGetSrcWide(cUnit, mir, 2, 3);
2707 rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0);
2708 rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1);
2711 rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
2714 rlDest = dvmCompilerGetDest(cUnit, mir, 0);
2724 return genCmpFP(cUnit, mir, rlDest, rlSrc1, rlSrc2);
2726 genCmpLong(cUnit, mir, rlDest, rlSrc1, rlSrc2);
2729 genArrayGet(cUnit, mir, kLong, rlSrc1, rlSrc2, rlDest, 3);
2733 genArrayGet(cUnit, mir, kWord, rlSrc1, rlSrc2, rlDest, 2);
2736 genArrayGet(cUnit, mir, kUnsignedByte, rlSrc1, rlSrc2, rlDest, 0);
2739 genArrayGet(cUnit, mir, kSignedByte, rlSrc1, rlSrc2, rlDest, 0);
2742 genArrayGet(cUnit, mir, kUnsignedHalf, rlSrc1, rlSrc2, rlDest, 1);
2745 genArrayGet(cUnit, mir, kSignedHalf, rlSrc1, rlSrc2, rlDest, 1);
2748 genArrayPut(cUnit, mir, kLong, rlSrc1, rlSrc2, rlDest, 3);
2751 genArrayPut(cUnit, mir, kWord, rlSrc1, rlSrc2, rlDest, 2);
2754 genArrayObjectPut(cUnit, mir, rlSrc1, rlSrc2, rlDest, 2);
2758 genArrayPut(cUnit, mir, kUnsignedHalf, rlSrc1, rlSrc2, rlDest, 1);
2762 genArrayPut(cUnit, mir, kUnsignedByte, rlSrc1, rlSrc2, rlDest, 0);
2900 static bool handleFmt31t(CompilationUnit *cUnit, MIR *mir)
2905 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
2907 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
2908 genExportPC(cUnit, mir);
2909 loadValueDirectFixed(cUnit, rlSrc, r0);
2910 LOAD_FUNC_ADDR(cUnit, r2, (int)dvmInterpHandleFillArrayData);
2911 loadConstant(cUnit, r1,
2912 (int) (cUnit->method->insns + mir->offset + mir->dalvikInsn.vB));
2913 opReg(cUnit, kOpBlx, r2);
2914 dvmCompilerClobberCallRegs(cUnit);
2916 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
2917 loadConstant(cUnit, r0,
2918 (int) (cUnit->method->insns + mir->offset));
2919 genDispatchToHandler(cUnit, TEMPLATE_THROW_EXCEPTION_COMMON);
2920 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
2932 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
2933 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
2934 loadValueDirectFixed(cUnit, rlSrc, r1);
2935 dvmCompilerLockAllTemps(cUnit);
2937 LOAD_FUNC_ADDR(cUnit, r4PC, (int)findPackedSwitchIndex);
2939 LOAD_FUNC_ADDR(cUnit, r4PC, (int)findSparseSwitchIndex);
2942 loadConstant(cUnit, r0,
2943 (int) (cUnit->method->insns + mir->offset + mir->dalvikInsn.vB));
2945 opRegReg(cUnit, kOpMov, r2, r15pc);
2946 opReg(cUnit, kOpBlx, r4PC);
2947 dvmCompilerClobberCallRegs(cUnit);
2949 opRegReg(cUnit, kOpMov, r15pc, r0);
2963 static void genLandingPadForMispredictedCallee(CompilationUnit *cUnit, MIR *mir,
2975 genUnconditionalBranch(cUnit, &labelList[fallThrough->id]);
2978 dvmCompilerResetRegPool(cUnit);
2979 dvmCompilerClobberAllRegs(cUnit);
2980 dvmCompilerResetNullCheck(cUnit);
2983 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
2989 static bool handleFmt35c_3rc(CompilationUnit *cUnit, MIR *mir,
3013 cUnit->method->clazz->pDvmDex->pResMethods[dInsn->vB]->
3022 genLandingPadForMispredictedCallee(cUnit, mir, bb, labelList);
3026 genProcessArgsNoRange(cUnit, mir, dInsn, &pcrLabel);
3028 genProcessArgsRange(cUnit, mir, dInsn, &pcrLabel);
3030 genInvokeVirtualCommon(cUnit, mir, methodIndex,
3044 assert(calleeMethod == cUnit->method->clazz->super->vtable[
3045 cUnit->method->clazz->pDvmDex->
3049 genProcessArgsNoRange(cUnit, mir, dInsn, &pcrLabel);
3051 genProcessArgsRange(cUnit, mir, dInsn, &pcrLabel);
3057 genInvokeSingletonWholeMethod(cUnit, mir, calleeAddr,
3061 loadConstant(cUnit, r0, (int) calleeMethod);
3063 genInvokeSingletonCommon(cUnit, mir, bb, labelList, pcrLabel,
3074 cUnit->method->clazz->pDvmDex->pResMethods[dInsn->vB]);
3077 genProcessArgsNoRange(cUnit, mir, dInsn, &pcrLabel);
3079 genProcessArgsRange(cUnit, mir, dInsn, &pcrLabel);
3082 loadConstant(cUnit, r0, (int) calleeMethod);
3084 genInvokeSingletonCommon(cUnit, mir, bb, labelList, pcrLabel,
3094 cUnit->method->clazz->pDvmDex->pResMethods[dInsn->vB]);
3097 genProcessArgsNoRange(cUnit, mir, dInsn,
3100 genProcessArgsRange(cUnit, mir, dInsn,
3107 genInvokeSingletonWholeMethod(cUnit, mir, calleeAddr,
3111 loadConstant(cUnit, r0, (int) calleeMethod);
3113 genInvokeSingletonCommon(cUnit, mir, bb, labelList, pcrLabel,
3199 genLandingPadForMispredictedCallee(cUnit, mir, bb, labelList);
3203 genProcessArgsNoRange(cUnit, mir, dInsn, &pcrLabel);
3205 genProcessArgsRange(cUnit, mir, dInsn, &pcrLabel);
3210 loadConstant(cUnit, r4PC,
3211 (int) (cUnit->method->insns + mir->offset));
3215 opRegRegImm(cUnit, kOpAdd, r1, r15pc, 0);
3220 opRegRegImm(cUnit, kOpAdd, r2, r15pc, 0);
3223 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
3228 genUnconditionalBranch(cUnit, predChainingCell);
3235 int dPC = (int) (cUnit->method->insns + mir->offset);
3241 dvmInsertGrowableList(&cUnit->pcReconstructionList,
3246 genUnconditionalBranch(cUnit, pcrLabel);
3258 genRegCopy(cUnit, r8, r1);
3259 genRegCopy(cUnit, r9, r2);
3260 genRegCopy(cUnit, r10, r3);
3263 genRegCopy(cUnit, r0, r3);
3266 loadConstant(cUnit, r1, dInsn->vB);
3269 loadConstant(cUnit, r2, (int) cUnit->method);
3272 loadConstant(cUnit, r3, (int) cUnit->method->clazz->pDvmDex);
3274 LOAD_FUNC_ADDR(cUnit, r7,
3276 opReg(cUnit, kOpBlx, r7);
3279 dvmCompilerClobberCallRegs(cUnit);
3281 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
3285 loadConstant(cUnit, r0,
3286 (int) (cUnit->method->insns + mir->offset));
3287 genDispatchToHandler(cUnit, TEMPLATE_THROW_EXCEPTION_COMMON);
3290 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
3294 genRegCopy(cUnit, r1, r8);
3297 ArmLIR *bypassRechaining = genCmpImmBranch(cUnit, kArmCondGt,
3300 LOAD_FUNC_ADDR(cUnit, r7, (int) dvmJitToPatchPredictedChain);
3302 genRegCopy(cUnit, r1, r6SELF);
3303 genRegCopy(cUnit, r2, r9);
3304 genRegCopy(cUnit, r3, r10);
3315 opReg(cUnit, kOpBlx, r7);
3318 addrRetChain = opRegRegImm(cUnit, kOpAdd, r1, r15pc, 0);
3328 genDispatchToHandler(cUnit, gDvmJit.methodTraceSupport ?
3335 genTrap(cUnit, mir->offset, pcrLabel);
3342 genInterpSingleStep(cUnit, mir);
3351 static bool handleFmt35ms_3rms(CompilationUnit *cUnit, MIR *mir,
3375 genLandingPadForMispredictedCallee(cUnit, mir, bb, labelList);
3379 genProcessArgsNoRange(cUnit, mir, dInsn, &pcrLabel);
3381 genProcessArgsRange(cUnit, mir, dInsn, &pcrLabel);
3388 genInvokeVirtualWholeMethod(cUnit, mir, calleeAddr,
3392 genInvokeVirtualCommon(cUnit, mir, methodIndex,
3404 cUnit->method->clazz->super->vtable[dInsn->vB]);
3407 genProcessArgsNoRange(cUnit, mir, dInsn, &pcrLabel);
3409 genProcessArgsRange(cUnit, mir, dInsn, &pcrLabel);
3412 loadConstant(cUnit, r0, (int) calleeMethod);
3414 genInvokeSingletonCommon(cUnit, mir, bb, labelList, pcrLabel,
3430 static bool genInlinedCompareTo(CompilationUnit *cUnit, MIR *mir)
3433 return handleExecuteInlineC(cUnit, mir);
3436 RegLocation rlThis = dvmCompilerGetSrc(cUnit, mir, 0);
3437 RegLocation rlComp = dvmCompilerGetSrc(cUnit, mir, 1);
3439 loadValueDirectFixed(cUnit, rlThis, r0);
3440 loadValueDirectFixed(cUnit, rlComp, r1);
3442 rollback = genNullCheck(cUnit, rlThis.sRegLow, r0, mir->offset, NULL);
3443 genNullCheck(cUnit, rlComp.sRegLow, r1, mir->offset, rollback);
3449 genDispatchToHandler(cUnit, TEMPLATE_STRING_COMPARETO);
3450 storeValue(cUnit, inlinedTarget(cUnit, mir, false),
3451 dvmCompilerGetReturn(cUnit));
3456 static bool genInlinedFastIndexOf(CompilationUnit *cUnit, MIR *mir)
3459 return handleExecuteInlineC(cUnit, mir);
3461 RegLocation rlThis = dvmCompilerGetSrc(cUnit, mir, 0);
3462 RegLocation rlChar = dvmCompilerGetSrc(cUnit, mir, 1);
3464 loadValueDirectFixed(cUnit, rlThis, r0);
3465 loadValueDirectFixed(cUnit, rlChar, r1);
3466 RegLocation rlStart = dvmCompilerGetSrc(cUnit, mir, 2);
3467 loadValueDirectFixed(cUnit, rlStart, r2);
3469 genNullCheck(cUnit, rlThis.sRegLow, r0, mir->offset, NULL);
3470 genDispatchToHandler(cUnit, TEMPLATE_STRING_INDEXOF);
3471 storeValue(cUnit, inlinedTarget(cUnit, mir, false),
3472 dvmCompilerGetReturn(cUnit));
3478 static bool genInlinedStringIsEmptyOrLength(CompilationUnit *cUnit, MIR *mir,
3482 RegLocation rlObj = dvmCompilerGetSrc(cUnit, mir, 0);
3483 RegLocation rlDest = inlinedTarget(cUnit, mir, false);
3484 rlObj = loadValue(cUnit, rlObj, kCoreReg);
3485 RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
3486 genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset, NULL);
3487 loadWordDisp(cUnit, rlObj.lowReg, gDvm.offJavaLangString_count,
3491 int tReg = dvmCompilerAllocTemp(cUnit);
3492 opRegReg(cUnit, kOpNeg, tReg, rlResult.lowReg);
3493 opRegRegReg(cUnit, kOpAdc, rlResult.lowReg, rlResult.lowReg, tReg);
3495 storeValue(cUnit, rlDest, rlResult);
3499 static bool genInlinedStringLength(CompilationUnit *cUnit, MIR *mir)
3501 return genInlinedStringIsEmptyOrLength(cUnit, mir, false);
3504 static bool genInlinedStringIsEmpty(CompilationUnit *cUnit, MIR *mir)
3506 return genInlinedStringIsEmptyOrLength(cUnit, mir, true);
3509 static bool genInlinedStringCharAt(CompilationUnit *cUnit, MIR *mir)
3512 RegLocation rlObj = dvmCompilerGetSrc(cUnit, mir, 0);
3513 RegLocation rlIdx = dvmCompilerGetSrc(cUnit, mir, 1);
3514 RegLocation rlDest = inlinedTarget(cUnit, mir, false);
3516 rlObj = loadValue(cUnit, rlObj, kCoreReg);
3517 rlIdx = loadValue(cUnit, rlIdx, kCoreReg);
3518 int regMax = dvmCompilerAllocTemp(cUnit);
3519 int regOff = dvmCompilerAllocTemp(cUnit);
3520 int regPtr = dvmCompilerAllocTemp(cUnit);
3521 ArmLIR *pcrLabel = genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg,
3523 loadWordDisp(cUnit, rlObj.lowReg, gDvm.offJavaLangString_count, regMax);
3524 loadWordDisp(cUnit, rlObj.lowReg, gDvm.offJavaLangString_offset, regOff);
3525 loadWordDisp(cUnit, rlObj.lowReg, gDvm.offJavaLangString_value, regPtr);
3526 genBoundsCheck(cUnit
3527 dvmCompilerFreeTemp(cUnit, regMax);
3528 opRegImm(cUnit, kOpAdd, regPtr, contents);
3529 opRegReg(cUnit, kOpAdd, regOff, rlIdx.lowReg);
3530 rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
3531 loadBaseIndexed(cUnit, regPtr, regOff, rlResult.lowReg, 1, kUnsignedHalf);
3532 storeValue(cUnit, rlDest, rlResult);
3536 static bool genInlinedAbsInt(CompilationUnit *cUnit, MIR *mir)
3538 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
3539 rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
3540 RegLocation rlDest = inlinedTarget(cUnit, mir, false);
3541 RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
3542 int signReg = dvmCompilerAllocTemp(cUnit);
3548 opRegRegImm(cUnit, kOpAsr, signReg, rlSrc.lowReg, 31);
3549 opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, signReg);
3550 opRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
3551 storeValue(cUnit, rlDest, rlResult);
3555 static bool genInlinedAbsLong(CompilationUnit *cUnit, MIR *mir)
3557 RegLocation rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
3558 RegLocation rlDest = inlinedTargetWide(cUnit, mir, false);
3559 rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
3560 RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
3561 int signReg = dvmCompilerAllocTemp(cUnit);
3568 opRegRegImm(cUnit, kOpAsr, signReg, rlSrc.highReg, 31);
3569 opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, signReg);
3570 opRegRegReg(cUnit, kOpAdc, rlResult.highReg, rlSrc.highReg, signReg);
3571 opRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
3572 opRegReg(cUnit, kOpXor, rlResult.highReg, signReg);
3573 storeValueWide(cUnit, rlDest, rlResult);
3577 static bool genInlinedIntFloatConversion(CompilationUnit *cUnit, MIR *mir)
3580 RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
3581 RegLocation rlDest = inlinedTarget(cUnit, mir, false);
3582 storeValue(cUnit, rlDest, rlSrc);
3586 static bool genInlinedLongDoubleConversion(CompilationUnit *cUnit, MIR *mir)
3589 RegLocation rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
3590 RegLocation rlDest = inlinedTargetWide(cUnit, mir, false);
3591 storeValueWide(cUnit, rlDest, rlSrc);
3600 static bool handleExecuteInlineC(CompilationUnit *cUnit, MIR *mir)
3608 dvmCompilerAbort(cUnit);
3610 dvmCompilerFlushAllRegs(cUnit); /* Everything to home location */
3611 dvmCompilerClobberCallRegs(cUnit);
3612 dvmCompilerClobber(cUnit, r4PC);
3613 dvmCompilerClobber(cUnit, r7);
3615 opRegRegImm(cUnit, kOpAdd, r4PC, r6SELF, offset);
3616 opImm(cUnit, kOpPush, (1<<r4PC) | (1<<r7));
3617 LOAD_FUNC_ADDR(cUnit, r4PC, fn);
3618 genExportPC(cUnit, mir);
3620 loadValueDirect(cUnit, dvmCompilerGetSrc(cUnit, mir, i), i);
3622 opReg(cUnit, kOpBlx, r4PC);
3623 opRegImm(cUnit, kOpAdd, r13sp, 8);
3625 ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
3626 loadConstant(cUnit, r0, (int) (cUnit->method->insns + mir->offset));
3627 genDispatchToHandler(cUnit, TEMPLATE_THROW_EXCEPTION_COMMON);
3628 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
3638 static bool handleExecuteInline(CompilationUnit *cUnit, MIR *mir)
3650 return genInlinedStringCharAt(cUnit, mir);
3652 return genInlinedStringLength(cUnit, mir);
3654 return genInlinedStringIsEmpty(cUnit, mir);
3656 return genInlinedCompareTo(cUnit, mir);
3658 return genInlinedFastIndexOf(cUnit, mir);
3662 return genInlinedAbsInt(cUnit, mir);
3665 return genInlinedAbsLong(cUnit, mir);
3668 return genInlinedMinMaxInt(cUnit, mir, true);
3671 return genInlinedMinMaxInt(cUnit, mir, false);
3674 return genInlineSqrt(cUnit, mir);
3677 return genInlinedAbsFloat(cUnit, mir);
3680 return genInlinedAbsDouble(cUnit, mir);
3684 return genInlinedIntFloatConversion(cUnit, mir);
3687 return genInlinedLongDoubleConversion(cUnit, mir);
3698 return handleExecuteInlineC(cUnit, mir);
3700 dvmCompilerAbort(cUnit);
3704 static bool handleFmt51l(CompilationUnit *cUnit, MIR *mir)
3707 RegLocation rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
3708 RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
3709 loadConstantNoClobber(cUnit, rlResult.lowReg,
3711 loadConstantNoClobber(cUnit, rlResult.highReg,
3713 storeValueWide(cUnit, rlDest, rlResult);
3735 static void insertChainingSwitch(CompilationUnit *cUnit)
3737 ArmLIR *branch = newLIR0(cUnit, kThumbBUncond);
3738 newLIR2(cUnit, kThumbOrr, r0, r0);
3739 ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
3745 static void handleNormalChainingCell(CompilationUnit *cUnit,
3752 insertChainingSwitch(cUnit);
3753 newLIR3(cUnit, kThumbLdrRRI5, r0, r6SELF,
3756 newLIR1(cUnit, kThumbBlxR, r0);
3757 addWordData(cUnit, NULL, (int) (cUnit->method->insns + offset));
3764 static void handleHotChainingCell(CompilationUnit *cUnit,
3771 insertChainingSwitch(cUnit);
3772 newLIR3(cUnit, kThumbLdrRRI5, r0, r6SELF,
3775 newLIR1(cUnit, kThumbBlxR, r0);
3776 addWordData(cUnit, NULL, (int) (cUnit->method->insns + offset));
3780 static void handleBackwardBranchChainingCell(CompilationUnit *cUnit,
3787 insertChainingSwitch(cUnit);
3789 newLIR3(cUnit, kThumbLdrRRI5, r0, r6SELF,
3793 newLIR3(cUnit, kThumbLdrRRI5, r0, r6SELF,
3796 newLIR1(cUnit, kThumbBlxR, r0);
3797 addWordData(cUnit, NULL, (int) (cUnit->method->insns + offset));
3801 static void handleInvokeSingletonChainingCell(CompilationUnit *cUnit,
3808 insertChainingSwitch(cUnit);
3809 newLIR3(cUnit, kThumbLdrRRI5, r0, r6SELF,
3812 newLIR1(cUnit, kThumbBlxR, r0);
3813 addWordData(cUnit, NULL, (int) (callee->insns));
3817 static void handleInvokePredictedChainingCell(CompilationUnit *cUnit)
3821 addWordData(cUnit, NULL, PREDICTED_CHAIN_BX_PAIR_INIT);
3823 addWordData(cUnit, NULL, PREDICTED_CHAIN_CLAZZ_INIT);
3825 addWordData(cUnit, NULL, PREDICTED_CHAIN_METHOD_INIT);
3830 addWordData(cUnit, NULL, PREDICTED_CHAIN_COUNTER_INIT);
3834 static void handlePCReconstruction(CompilationUnit *cUnit,
3838 (ArmLIR **) cUnit->pcReconstructionList.elemList;
3839 int numElems = cUnit->pcReconstructionList.numUsed;
3847 newLIR0(cUnit, kThumbUndefined);
3851 dvmCompilerAppendLIR(cUnit, (LIR *) pcrLabel[i]);
3853 loadConstant(cUnit, r0, pcrLabel[i]->operands[0]);
3854 genUnconditionalBranch(cUnit, targetLabel);
3875 static void genHoistedChecksForCountUpLoop(CompilationUnit *cUnit, MIR *mir)
3887 RegLocation rlArray = cUnit->regLocation[mir->dalvikInsn.vA];
3888 RegLocation rlIdxEnd = cUnit->regLocation[mir->dalvikInsn.vC];
3891 rlArray = loadValue(cUnit, rlArray, kCoreReg);
3892 rlIdxEnd = loadValue(cUnit, rlIdxEnd, kCoreReg);
3893 genRegImmCheck(cUnit, kArmCondEq, rlArray.lowReg, 0, 0,
3894 (ArmLIR *) cUnit->loopAnalysis->branchToPCR);
3897 regLength = dvmCompilerAllocTemp(cUnit);
3898 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLength);
3910 int tReg = dvmCompilerAllocTemp(cUnit);
3911 opRegRegImm(cUnit, kOpAdd, tReg, rlIdxEnd.lowReg, delta);
3913 dvmCompilerFreeTemp(cUnit, tReg);
3916 genRegRegCheck(cUnit, kArmCondGe, rlIdxEnd.lowReg, regLength, 0,
3917 (ArmLIR *) cUnit->loopAnalysis->branchToPCR);
3928 static void genHoistedChecksForCountDownLoop(CompilationUnit *cUnit, MIR *mir)
3932 const int regLength = dvmCompilerAllocTemp(cUnit);
3934 RegLocation rlArray = cUnit->regLocation[mir->dalvikInsn.vA];
3935 RegLocation rlIdxInit = cUnit->regLocation[mir->dalvikInsn.vB];
3938 rlArray = loadValue(cUnit, rlArray, kCoreReg);
3939 rlIdxInit = loadValue(cUnit, rlIdxInit, kCoreReg);
3940 genRegImmCheck(cUnit, kArmCondEq, rlArray.lowReg, 0, 0,
3941 (ArmLIR *) cUnit->loopAnalysis->branchToPCR);
3944 loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLength);
3947 int tReg = dvmCompilerAllocTemp(cUnit);
3948 opRegRegImm(cUnit, kOpAdd, tReg, rlIdxInit.lowReg, maxC);
3950 dvmCompilerFreeTemp(cUnit, tReg);
3954 genRegRegCheck(cUnit, kArmCondGe, rlIdxInit.lowReg, regLength, 0,
3955 (ArmLIR *) cUnit->loopAnalysis->branchToPCR);
3962 static void genHoistedLowerBoundCheck(CompilationUnit *cUnit, MIR *mir)
3966 RegLocation rlIdx = cUnit->regLocation[mir->dalvikInsn.vA];
3969 rlIdx = loadValue(cUnit, rlIdx, kCoreReg);
3972 genRegImmCheck(cUnit, kArmCondLt, rlIdx.lowReg, -minC, 0,
3973 (ArmLIR *) cUnit->loopAnalysis->branchToPCR);
4060 static void genValidationForPredictedInline(CompilationUnit *cUnit, MIR *mir)
4063 RegLocation rlThis = cUnit->regLocation[mir->dalvikInsn.vC];
4065 rlThis = loadValue(cUnit, rlThis, kCoreReg);
4066 int regPredictedClass = dvmCompilerAllocTemp(cUnit);
4067 loadClassPointer(cUnit, regPredictedClass, (int) callsiteInfo);
4068 genNullCheck(cUnit, rlThis.sRegLow, rlThis.lowReg, mir->offset,
4070 int regActualClass = dvmCompilerAllocTemp(cUnit);
4071 loadWordDisp(cUnit, rlThis.lowReg, offsetof(Object, clazz), regActualClass);
4072 opRegReg(cUnit, kOpCmp, regPredictedClass, regActualClass);
4077 callsiteInfo->misPredBranchOver = (LIR *) opCondBranch(cUnit, kArmCondNe);
4081 static void handleExtendedMIR(CompilationUnit *cUnit, MIR *mir)
4087 newLIR1(cUnit, kArmPseudoExtended, (int) msg);
4091 char *ssaString = dvmCompilerGetSSAString(cUnit, mir->ssaRep);
4092 newLIR1(cUnit, kArmPseudoSSARep, (int) ssaString);
4096 genHoistedChecksForCountUpLoop(cUnit, mir);
4100 genHoistedChecksForCountDownLoop(cUnit, mir);
4104 genHoistedLowerBoundCheck(cUnit, mir);
4108 genUnconditionalBranch(cUnit,
4109 (ArmLIR *) cUnit->loopAnalysis->branchToPCR);
4113 genValidationForPredictedInline(cUnit, mir);
4128 static void setupLoopEntryBlock(CompilationUnit *cUnit, BasicBlock *entry,
4135 (int) (cUnit->method->insns + entry->startOffset);
4138 dvmInsertGrowableList(&cUnit->pcReconstructionList, (intptr_t) pcrLabel);
4148 cUnit->loopAnalysis->branchToBody = (LIR *) branchToBody;
4154 cUnit->loopAnalysis->branchToPCR = (LIR *) branchToPCR;
4184 void dvmCompilerMIR2LIR(CompilationUnit *cUnit)
4188 (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR) * cUnit->numBlocks, true);
4201 dvmCompilerDataFlowAnalysisDispatcher(cUnit, dvmCompilerClearVisitedFlag,
4205 dvmGrowableListIteratorInit(&cUnit->blockList, &iterator);
4208 cUnit->profileCodeSize = genTraceProfileEntry(cUnit);
4222 newLIR0(cUnit, kArmPseudoPseudoAlign4);
4228 dvmCompilerAppendLIR(cUnit, (LIR *) &labelList[i]);
4236 setupLoopEntryBlock(cUnit, bb,
4246 dvmCompilerResetRegPool(cUnit);
4247 dvmCompilerClobberAllRegs(cUnit);
4248 dvmCompilerResetNullCheck(cUnit);
4291 handlePCReconstruction(cUnit,
4292 &labelList[cUnit->puntBlock->id]);
4296 if (cUnit->pcReconstructionList.numUsed) {
4297 loadWordDisp(cUnit, r6SELF, offsetof(Thread,
4300 opReg(cUnit, kOpBlx, r1);
4322 for (BasicBlock *nextBB = bb; nextBB != NULL; nextBB = cUnit->nextCodegenBlock) {
4325 cUnit->nextCodegenBlock = NULL;
4329 dvmCompilerResetRegPool(cUnit);
4331 dvmCompilerClobberAllRegs(cUnit);
4335 dvmCompilerResetDefTracking(cUnit);
4339 handleExtendedMIR(cUnit, mir);
4363 if (headLIR == NULL || cUnit->printMe == true) {
4365 newLIR2(cUnit, kArmPseudoDalvikByteCodeBoundary,
4380 if (cUnit->printMe && mir->ssaRep) {
4381 char *ssaString = dvmCompilerGetSSAString(cUnit,
4383 newLIR1(cUnit, kArmPseudoSSARep, (int) ssaString);
4397 if (singleStepMe || cUnit->allSingleStep) {
4399 genInterpSingleStep(cUnit, mir);
4406 notHandled = handleFmt10t_Fmt20t_Fmt30t(cUnit,
4410 notHandled = handleFmt10x(cUnit, mir);
4414 notHandled = handleFmt11n_Fmt31i(cUnit, mir);
4417 notHandled = handleFmt11x(cUnit, mir);
4420 notHandled = handleFmt12x(cUnit, mir);
4423 notHandled = handleFmt20bc(cUnit, mir);
4427 notHandled = handleFmt21c_Fmt31c(cUnit, mir);
4430 notHandled = handleFmt21h(cUnit, mir);
4433 notHandled = handleFmt21s(cUnit, mir);
4436 notHandled = handleFmt21t(cUnit, mir, bb,
4441 notHandled = handleFmt22b_Fmt22s(cUnit, mir);
4444 notHandled = handleFmt22c(cUnit, mir);
4447 notHandled = handleFmt22cs(cUnit, mir);
4450 notHandled = handleFmt22t(cUnit, mir, bb,
4455 notHandled = handleFmt22x_Fmt32x(cUnit, mir);
4458 notHandled = handleFmt23x(cUnit, mir);
4461 notHandled = handleFmt31t(cUnit, mir);
4465 notHandled = handleFmt35c_3rc(cUnit, mir, bb,
4470 notHandled = handleFmt35ms_3rms(cUnit, mir, bb,
4475 notHandled = handleExecuteInline(cUnit, mir);
4478 notHandled = handleFmt51l(cUnit, mir);
4490 dvmCompilerAbort(cUnit);
4497 dvmCompilerAppendLIR(cUnit,
4498 (LIR *) cUnit->loopAnalysis->branchToBody);
4499 dvmCompilerAppendLIR(cUnit,
4500 (LIR *) cUnit->loopAnalysis->branchToPCR);
4508 dvmCompilerApplyLocalOptimizations(cUnit, (LIR *) headLIR,
4509 cUnit->lastLIRInsn);
4520 genUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
4529 cUnit->numChainingCells[i] = chainingListByType[i].numUsed;
4532 if (cUnit->numChainingCells[i] == 0)
4536 cUnit->firstChainingLIR[i] = (LIR *) &labelList[blockIdList[0]];
4541 (BasicBlock *) dvmGrowableListGetElement(&cUnit->blockList,
4545 newLIR0(cUnit, kArmPseudoPseudoAlign4);
4548 dvmCompilerAppendLIR(cUnit, (LIR *) &labelList[blockId]);
4553 handleNormalChainingCell(cUnit, chainingBlock->startOffset);
4556 handleInvokeSingletonChainingCell(cUnit,
4560 handleInvokePredictedChainingCell(cUnit);
4563 handleHotChainingCell(cUnit, chainingBlock->startOffset);
4566 handleBackwardBranchChainingCell(cUnit,
4571 dvmCompilerAbort(cUnit);
4577 cUnit->chainingCellBottom = (LIR *) newLIR0(cUnit, kArmChainingCellBottom);
4583 if (cUnit->switchOverflowPad) {
4584 loadConstant(cUnit, r0, (int) cUnit->switchOverflowPad);
4585 loadWordDisp(cUnit, r6SELF, offsetof(Thread,
4587 opRegReg(cUnit, kOpAdd, r1, r1);
4588 opRegRegReg(cUnit, kOpAdd, r4PC, r0, r1);
4590 loadConstant(cUnit, r0, kSwitchOverflow);
4592 opReg(cUnit, kOpBlx, r2);
4595 dvmCompilerApplyGlobalOptimizations(cUnit);
4598 selfVerificationBranchInsertPass(cUnit);
4729 ArmLIR* dvmCompilerRegCopyNoInsert(CompilationUnit *cUnit, int rDest, int rSrc)
4731 return genRegCopyNoInsert(cUnit, rDest, rSrc);
4735 ArmLIR* dvmCompilerRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
4737 return genRegCopy(cUnit, rDest, rSrc);
4741 void dvmCompilerRegCopyWide(CompilationUnit *cUnit, int destLo, int destHi,
4744 genRegCopyWide(cUnit, destLo, destHi, srcLo, srcHi);
4747 void dvmCompilerFlushRegImpl(CompilationUnit *cUnit, int rBase,
4750 storeBaseDisp(cUnit, rBase, displacement, rSrc, size);
4753 void dvmCompilerFlushRegWideImpl(CompilationUnit *cUnit, int rBase,
4756 storeBaseDispWide(cUnit, rBase, displacement, rSrcLo, rSrcHi);
