| /* |
| * =========================================================================== |
| * Common subroutines and data |
| * =========================================================================== |
| */ |
| |
| .text |
| .align 2 |
| |
| #if defined(WITH_JIT) |
| #if defined(WITH_SELF_VERIFICATION) |
| |
| /* |
| * "longjmp" to a translation after single-stepping. Before returning |
| * to translation, must save state for self-verification. |
| */ |
| .global dvmJitResumeTranslation # (Thread* self, u4* dFP) |
| dvmJitResumeTranslation: |
| move rSELF, a0 # restore self |
| move rPC, a1 # restore Dalvik pc |
| move rFP, a2 # restore Dalvik fp |
| lw rBIX, offThread_jitResumeNPC(rSELF) |
| sw zero, offThread_jitResumeNPC(rSELF) # reset resume address |
| lw sp, offThread_jitResumeNSP(rSELF) # cut back native stack |
| b jitSVShadowRunStart # resume as if cache hit |
| # expects resume addr in rBIX |
| |
| .global dvmJitToInterpPunt |
| dvmJitToInterpPunt: |
| li a2, kSVSPunt # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpSingleStep |
| dvmJitToInterpSingleStep: |
| move rPC, a0 # set up dalvik pc |
| EXPORT_PC() |
| sw ra, offThread_jitResumeNPC(rSELF) |
| sw a1, offThread_jitResumeDPC(rSELF) |
| li a2, kSVSSingleStep # a2 <- interpreter entry point |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpNoChainNoProfile |
| dvmJitToInterpNoChainNoProfile: |
| move a0, rPC # pass our target PC |
| li a2, kSVSNoProfile # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpTraceSelectNoChain |
| dvmJitToInterpTraceSelectNoChain: |
| move a0, rPC # pass our target PC |
| li a2, kSVSTraceSelect # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpTraceSelect |
| dvmJitToInterpTraceSelect: |
| lw a0, 0(ra) # pass our target PC |
| li a2, kSVSTraceSelect # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpBackwardBranch |
| dvmJitToInterpBackwardBranch: |
| lw a0, 0(ra) # pass our target PC |
| li a2, kSVSBackwardBranch # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpNormal |
| dvmJitToInterpNormal: |
| lw a0, 0(ra) # pass our target PC |
| li a2, kSVSNormal # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| |
| .global dvmJitToInterpNoChain |
| dvmJitToInterpNoChain: |
| move a0, rPC # pass our target PC |
| li a2, kSVSNoChain # a2 <- interpreter entry point |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| b jitSVShadowRunEnd # doesn't return |
| #else /* WITH_SELF_VERIFICATION */ |
| |
| |
| /* |
| * "longjmp" to a translation after single-stepping. |
| */ |
| .global dvmJitResumeTranslation # (Thread* self, u4* dFP) |
| dvmJitResumeTranslation: |
| move rSELF, a0 # restore self |
| move rPC, a1 # restore Dalvik pc |
| move rFP, a2 # restore Dalvik fp |
| lw a0, offThread_jitResumeNPC(rSELF) |
| sw zero, offThread_jitResumeNPC(rSELF) # reset resume address |
| lw sp, offThread_jitResumeNSP(rSELF) # cut back native stack |
| jr a0 # resume translation |
| |
| |
| /* |
| * Return from the translation cache to the interpreter when the compiler is |
| * having issues translating/executing a Dalvik instruction. We have to skip |
| * the code cache lookup otherwise it is possible to indefinitely bouce |
| * between the interpreter and the code cache if the instruction that fails |
| * to be compiled happens to be at a trace start. |
| */ |
| .global dvmJitToInterpPunt |
| dvmJitToInterpPunt: |
| lw gp, STACK_OFFSET_GP(sp) |
| move rPC, a0 |
| #if defined(WITH_JIT_TUNING) |
| move a0, ra |
| JAL(dvmBumpPunt) |
| #endif |
| EXPORT_PC() |
| sw zero, offThread_inJitCodeCache(rSELF) # Back to the interp land |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| FETCH_INST() |
| GET_INST_OPCODE(t0) |
| GOTO_OPCODE(t0) |
| |
| /* |
| * Return to the interpreter to handle a single instruction. |
| * On entry: |
| * rPC <= Dalvik PC of instrucion to interpret |
| * a1 <= Dalvik PC of resume instruction |
| * ra <= resume point in translation |
| */ |
| |
| .global dvmJitToInterpSingleStep |
| dvmJitToInterpSingleStep: |
| lw gp, STACK_OFFSET_GP(sp) |
| move rPC, a0 # set up dalvik pc |
| EXPORT_PC() |
| sw ra, offThread_jitResumeNPC(rSELF) |
| sw sp, offThread_jitResumeNSP(rSELF) |
| sw a1, offThread_jitResumeDPC(rSELF) |
| li a1, 1 |
| sw a1, offThread_singleStepCount(rSELF) # just step once |
| move a0, rSELF |
| li a1, kSubModeCountedStep |
| JAL(dvmEnableSubMode) # (self, subMode) |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| FETCH_INST() |
| GET_INST_OPCODE(t0) |
| GOTO_OPCODE(t0) |
| /* |
| * Return from the translation cache and immediately request |
| * a translation for the exit target. Commonly used for callees. |
| */ |
| .global dvmJitToInterpTraceSelectNoChain |
| dvmJitToInterpTraceSelectNoChain: |
| lw gp, STACK_OFFSET_GP(sp) |
| #if defined(WITH_JIT_TUNING) |
| JAL(dvmBumpNoChain) |
| #endif |
| move a0, rPC |
| move a1, rSELF |
| JAL(dvmJitGetTraceAddrThread) # (pc, self) |
| move a0, v0 |
| sw a0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag |
| move a1, rPC # arg1 of translation may need this |
| move ra, zero # in case target is HANDLER_INTERPRET |
| beqz a0, 2f # 0 means translation does not exist |
| jr a0 |
| |
| /* |
| * Return from the translation cache and immediately request |
| * a translation for the exit target. Commonly used following |
| * invokes. |
| */ |
| .global dvmJitToInterpTraceSelect |
| dvmJitToInterpTraceSelect: |
| lw gp, STACK_OFFSET_GP(sp) |
| lw rPC, (ra) # get our target PC |
| subu rINST, ra, 8 # save start of chain branch |
| move a0, rPC |
| move a1, rSELF |
| JAL(dvmJitGetTraceAddrThread) # @ (pc, self) |
| sw v0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag |
| beqz v0, 2f |
| move a0, v0 |
| move a1, rINST |
| JAL(dvmJitChain) # v0 <- dvmJitChain(codeAddr, chainAddr) |
| move a1, rPC # arg1 of translation may need this |
| move ra, zero # in case target is HANDLER_INTERPRET |
| move a0, v0 |
| beqz a0, toInterpreter # didn't chain - resume with interpreter |
| |
| jr a0 # continue native execution |
| |
| /* No translation, so request one if profiling isn't disabled */ |
| 2: |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| lw a0, offThread_pJitProfTable(rSELF) |
| FETCH_INST() |
| li t0, kJitTSelectRequestHot |
| movn a2, t0, a0 # ask for trace selection |
| bnez a0, common_selectTrace |
| GET_INST_OPCODE(t0) |
| GOTO_OPCODE(t0) |
| |
| /* |
| * Return from the translation cache to the interpreter. |
| * The return was done with a BLX from thumb mode, and |
| * the following 32-bit word contains the target rPC value. |
| * Note that lr (r14) will have its low-order bit set to denote |
| * its thumb-mode origin. |
| * |
| * We'll need to stash our lr origin away, recover the new |
| * target and then check to see if there is a translation available |
| * for our new target. If so, we do a translation chain and |
| * go back to native execution. Otherwise, it's back to the |
| * interpreter (after treating this entry as a potential |
| * trace start). |
| */ |
| .global dvmJitToInterpNormal |
| dvmJitToInterpNormal: |
| lw gp, STACK_OFFSET_GP(sp) |
| lw rPC, (ra) # get our target PC |
| subu rINST, ra, 8 # save start of chain branch |
| #if defined(WITH_JIT_TUNING) |
| JAL(dvmBumpNormal) |
| #endif |
| move a0, rPC |
| move a1, rSELF |
| JAL(dvmJitGetTraceAddrThread) # @ (pc, self) |
| move a0, v0 |
| sw a0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag |
| beqz a0, toInterpreter # go if not, otherwise do chain |
| move a1, rINST |
| JAL(dvmJitChain) # v0 <- dvmJitChain(codeAddr, chainAddr) |
| move a1, rPC # arg1 of translation may need this |
| move ra, zero # in case target is HANDLER_INTERPRET |
| move a0, v0 |
| beqz a0, toInterpreter # didn't chain - resume with interpreter |
| |
| jr a0 # continue native execution |
| |
| /* |
| * Return from the translation cache to the interpreter to do method invocation. |
| * Check if translation exists for the callee, but don't chain to it. |
| */ |
| .global dvmJitToInterpNoChainNoProfile |
| dvmJitToInterpNoChainNoProfile: |
| #if defined(WITH_JIT_TUNING) |
| JAL(dvmBumpNoChain) |
| #endif |
| move a0, rPC |
| move a1, rSELF |
| JAL(dvmJitGetTraceAddrThread) # (pc, self) |
| move a0, v0 |
| sw a0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag |
| move a1, rPC # arg1 of translation may need this |
| move ra, zero # in case target is HANDLER_INTERPRET |
| beqz a0, footer235 |
| |
| jr a0 # continue native execution if so |
| footer235: |
| EXPORT_PC() |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| FETCH_INST() |
| GET_INST_OPCODE(t0) # extract opcode from rINST |
| GOTO_OPCODE(t0) # jump to next instruction |
| |
| /* |
| * Return from the translation cache to the interpreter to do method invocation. |
| * Check if translation exists for the callee, but don't chain to it. |
| */ |
| |
| .global dvmJitToInterpNoChain |
| dvmJitToInterpNoChain: |
| lw gp, STACK_OFFSET_GP(sp) |
| #if defined(WITH_JIT_TUNING) |
| JAL(dvmBumpNoChain) |
| #endif |
| move a0, rPC |
| move a1, rSELF |
| JAL(dvmJitGetTraceAddrThread) # (pc, self) |
| move a0, v0 |
| sw a0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag |
| move a1, rPC # arg1 of translation may need this |
| move ra, zero # in case target is HANDLER_INTERPRET |
| beqz a0, 1f |
| jr a0 # continue native execution if so |
| 1: |
| #endif /* WITH_SELF_VERIFICATION */ |
| |
| /* |
| * No translation, restore interpreter regs and start interpreting. |
| * rSELF & rFP were preserved in the translated code, and rPC has |
| * already been restored by the time we get here. We'll need to set |
| * up rIBASE & rINST, and load the address of the JitTable into r0. |
| */ |
| |
| toInterpreter: |
| EXPORT_PC() |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| FETCH_INST() |
| lw a0, offThread_pJitProfTable(rSELF) |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| # NOTE: intended fallthrough |
| |
| /* |
| * Similar to common_updateProfile, but tests for null pJitProfTable |
| * r0 holds pJifProfTAble, rINST is loaded, rPC is current and |
| * rIBASE has been recently refreshed. |
| */ |
| |
| common_testUpdateProfile: |
| |
| beqz a0, 4f |
| |
| /* |
| * Common code to update potential trace start counter, and initiate |
| * a trace-build if appropriate. |
| * On entry here: |
| * r0 <= pJitProfTable (verified non-NULL) |
| * rPC <= Dalvik PC |
| * rINST <= next instruction |
| */ |
| common_updateProfile: |
| srl a3, rPC, 12 # cheap, but fast hash function |
| xor a3, a3, rPC |
| andi a3, a3, JIT_PROF_SIZE-1 # eliminate excess bits |
| addu t1, a0, a3 |
| lbu a1, (t1) # get counter |
| GET_INST_OPCODE(t0) |
| subu a1, a1, 1 # decrement counter |
| sb a1, (t1) # and store it |
| beqz a1, 1f |
| GOTO_OPCODE(t0) # if not threshold, fallthrough otherwise |
| 1: |
| /* Looks good, reset the counter */ |
| lw a1, offThread_jitThreshold(rSELF) |
| sb a1, (t1) |
| EXPORT_PC() |
| move a0, rPC |
| move a1, rSELF |
| JAL(dvmJitGetTraceAddrThread) # (pc, self) |
| move a0, v0 |
| sw v0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag |
| move a1, rPC # arg1 of translation may need this |
| move ra, zero # in case target is HANDLER_INTERPRET |
| |
| #if !defined(WITH_SELF_VERIFICATION) |
| li t0, kJitTSelectRequest # ask for trace selection |
| movz a2, t0, a0 |
| beqz a0, common_selectTrace |
| jr a0 # jump to the translation |
| #else |
| |
| bne a0, zero, skip_ask_for_trace_selection |
| li a2, kJitTSelectRequest # ask for trace selection |
| j common_selectTrace |
| |
| skip_ask_for_trace_selection: |
| /* |
| * At this point, we have a target translation. However, if |
| * that translation is actually the interpret-only pseudo-translation |
| * we want to treat it the same as no translation. |
| */ |
| move rBIX, a0 # save target |
| jal dvmCompilerGetInterpretTemplate |
| # special case? |
| bne v0, rBIX, jitSVShadowRunStart # set up self verification shadow space |
| # Need to clear the inJitCodeCache flag |
| sw zero, offThread_inJitCodeCache(rSELF) # back to the interp land |
| GET_INST_OPCODE(t0) |
| GOTO_OPCODE(t0) |
| /* no return */ |
| #endif |
| |
| /* |
| * On entry: |
| * r2 is jit state. |
| */ |
| |
| common_selectTrace: |
| lhu a0, offThread_subMode(rSELF) |
| andi a0, (kSubModeJitTraceBuild | kSubModeJitSV) |
| bnez a0, 3f # already doing JIT work, continue |
| sw a2, offThread_jitState(rSELF) |
| move a0, rSELF |
| |
| /* |
| * Call out to validate trace-building request. If successful, |
| * rIBASE will be swapped to to send us into single-stepping trace |
| * building mode, so we need to refresh before we continue. |
| */ |
| |
| EXPORT_PC() |
| SAVE_PC_TO_SELF() |
| SAVE_FP_TO_SELF() |
| JAL(dvmJitCheckTraceRequest) |
| 3: |
| FETCH_INST() |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| 4: |
| GET_INST_OPCODE(t0) # extract opcode from rINST |
| GOTO_OPCODE(t0) |
| /* no return */ |
| #endif |
| |
| #if defined(WITH_SELF_VERIFICATION) |
| |
| /* |
| * Save PC and registers to shadow memory for self verification mode |
| * before jumping to native translation. |
| * On entry: |
| * rPC, rFP, rSELF: the values that they should contain |
| * r10: the address of the target translation. |
| */ |
| jitSVShadowRunStart: |
| move a0, rPC # r0 <- program counter |
| move a1, rFP # r1 <- frame pointer |
| move a2, rSELF # r2 <- InterpState pointer |
| move a3, rBIX # r3 <- target translation |
| jal dvmSelfVerificationSaveState # save registers to shadow space |
| lw rFP, offShadowSpace_shadowFP(v0) # rFP <- fp in shadow space |
| jr rBIX # jump to the translation |
| |
| /* |
| * Restore PC, registers, and interpState to original values |
| * before jumping back to the interpreter. |
| */ |
| jitSVShadowRunEnd: |
| move a1, rFP # pass ending fp |
| move a3, rSELF # pass self ptr for convenience |
| jal dvmSelfVerificationRestoreState # restore pc and fp values |
| LOAD_PC_FP_FROM_SELF() # restore pc, fp |
| lw a1, offShadowSpace_svState(a0) # get self verification state |
| beq a1, zero, 1f # check for punt condition |
| |
| # Setup SV single-stepping |
| move a0, rSELF |
| li a1, kSubModeJitSV |
| JAL(dvmEnableSubMode) # (self, subMode) |
| li a2, kJitSelfVerification # ask for self verification |
| sw a2, offThread_jitState(rSELF) |
| # Intentional fallthrough |
| |
| 1: |
| # exit to interpreter without check |
| EXPORT_PC() |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| FETCH_INST() |
| GET_INST_OPCODE(t0) |
| GOTO_OPCODE(t0) |
| #endif |
| |
| /* |
| * The equivalent of "goto bail", this calls through the "bail handler". |
| * It will end this interpreter activation, and return to the caller |
| * of dvmMterpStdRun. |
| * |
| * State registers will be saved to the "thread" area before bailing |
| * debugging purposes |
| */ |
| .ent common_gotoBail |
| common_gotoBail: |
| SAVE_PC_FP_TO_SELF() # export state to "thread" |
| move a0, rSELF # a0 <- self ptr |
| b dvmMterpStdBail # call(self, changeInterp) |
| .end common_gotoBail |
| |
| /* |
| * The JIT's invoke method needs to remember the callsite class and |
| * target pair. Save them here so that they are available to |
| * dvmCheckJit following the interpretation of this invoke. |
| */ |
| #if defined(WITH_JIT) |
| save_callsiteinfo: |
| beqz rOBJ, 1f |
| lw rOBJ, offObject_clazz(rOBJ) |
| 1: |
| sw a0, offThread_methodToCall(rSELF) |
| sw rOBJ, offThread_callsiteClass(rSELF) |
| jr ra |
| #endif |
| |
| /* |
| * Common code for method invocation with range. |
| * |
| * On entry: |
| * a0 is "Method* methodToCall", the method we're trying to call |
| */ |
| common_invokeMethodRange: |
| .LinvokeNewRange: |
| #if defined(WITH_JIT) |
| lhu a1, offThread_subMode(rSELF) |
| andi a1, kSubModeJitTraceBuild |
| beqz a1, 1f |
| JAL(save_callsiteinfo) |
| #endif |
| # prepare to copy args to "outs" area of current frame |
| 1: |
| GET_OPA(a2) |
| SAVEAREA_FROM_FP(rBIX, rFP) # rBIX <- stack save area |
| beqz a2, .LinvokeArgsDone |
| FETCH(a1, 2) # a1 <- CCCC |
| .LinvokeRangeArgs: |
| # a0=methodToCall, a1=CCCC, a2=count, rBIX=outs |
| # (very few methods have > 10 args; could unroll for common cases) |
| EAS2(a3, rFP, a1) |
| sll t0, a2, 2 |
| subu rBIX, rBIX, t0 |
| |
| 1: |
| lw a1, 0(a3) |
| addu a3, a3, 4 |
| subu a2, a2, 1 |
| sw a1, 0(rBIX) |
| addu rBIX, 4 |
| bnez a2, 1b |
| b .LinvokeArgsDone |
| |
| /* |
| * Common code for method invocation without range. |
| * |
| * On entry: |
| * a0 is "Method* methodToCall", "rOBJ is this" |
| */ |
| common_invokeMethodNoRange: |
| .LinvokeNewNoRange: |
| #if defined(WITH_JIT) |
| lhu a1, offThread_subMode(rSELF) |
| andi a1, kSubModeJitTraceBuild |
| beqz a1, 1f |
| JAL(save_callsiteinfo) |
| #endif |
| |
| # prepare to copy args to "outs" area of current frame |
| 1: |
| GET_OPB(a2) |
| SAVEAREA_FROM_FP(rBIX, rFP) |
| beqz a2, .LinvokeArgsDone |
| FETCH(a1, 2) |
| |
| # a0=methodToCall, a1=GFED, a2=count, |
| .LinvokeNonRange: |
| beq a2, 0, 0f |
| beq a2, 1, 1f |
| beq a2, 2, 2f |
| beq a2, 3, 3f |
| beq a2, 4, 4f |
| beq a2, 5, 5f |
| |
| 5: |
| and t0, rINST, 0x0f00 |
| ESRN(t2, rFP, t0, 6) |
| lw a3, (t2) |
| subu rBIX, 4 |
| sw a3, 0(rBIX) |
| |
| 4: |
| and t0, a1, 0xf000 |
| ESRN(t2, rFP, t0, 10) |
| lw a3, (t2) |
| subu rBIX, 4 |
| sw a3, 0(rBIX) |
| |
| 3: |
| and t0, a1, 0x0f00 |
| ESRN(t2, rFP, t0, 6) |
| lw a3, (t2) |
| subu rBIX, 4 |
| sw a3, 0(rBIX) |
| |
| 2: |
| and t0, a1, 0x00f0 |
| ESRN(t2, rFP, t0, 2) |
| lw a3, (t2) |
| subu rBIX, 4 |
| sw a3, 0(rBIX) |
| |
| 1: |
| and t0, a1, 0x000f |
| EASN(t2, rFP, t0, 2) |
| lw a3, (t2) |
| subu rBIX, 4 |
| sw a3, 0(rBIX) |
| |
| 0: |
| #fall through .LinvokeArgsDone |
| |
| |
| .LinvokeArgsDone: # a0=methodToCall |
| lhu rOBJ, offMethod_registersSize(a0) |
| lhu a3, offMethod_outsSize(a0) |
| lw a2, offMethod_insns(a0) |
| lw rINST, offMethod_clazz(a0) |
| # find space for the new stack frame, check for overflow |
| SAVEAREA_FROM_FP(a1, rFP) # a1 <- stack save area |
| sll t0, rOBJ, 2 # a1 <- newFp (old savearea - regsSize) |
| subu a1, a1, t0 |
| SAVEAREA_FROM_FP(rBIX, a1) |
| lw rOBJ, offThread_interpStackEnd(rSELF) # t3 <- interpStackEnd |
| sll t2, a3, 2 |
| subu t0, rBIX, t2 |
| lhu ra, offThread_subMode(rSELF) |
| lw a3, offMethod_accessFlags(a0) # a3 <- methodToCall->accessFlags |
| bltu t0, rOBJ, .LstackOverflow # yes, this frame will overflow stack |
| |
| |
| # set up newSaveArea |
| #ifdef EASY_GDB |
| SAVEAREA_FROM_FP(t0, rFP) |
| sw t0, offStackSaveArea_prevSave(rBIX) |
| #endif |
| sw rFP, (offStackSaveArea_prevFrame)(rBIX) |
| sw rPC, (offStackSaveArea_savedPc)(rBIX) |
| #if defined(WITH_JIT) |
| sw zero, (offStackSaveArea_returnAddr)(rBIX) |
| #endif |
| sw a0, (offStackSaveArea_method)(rBIX) |
| # Profiling? |
| bnez ra, 2f |
| 1: |
| and t2, a3, ACC_NATIVE |
| bnez t2, .LinvokeNative |
| lhu rOBJ, (a2) # rOBJ -< load Inst from New PC |
| lw a3, offClassObject_pDvmDex(rINST) |
| move rPC, a2 # Publish new rPC |
| # Update state values for the new method |
| # a0=methodToCall, a1=newFp, a3=newMethodClass, rOBJ=newINST |
| sw a0, offThread_method(rSELF) |
| sw a3, offThread_methodClassDex(rSELF) |
| li a2, 1 |
| sw a2, offThread_debugIsMethodEntry(rSELF) |
| |
| #if defined(WITH_JIT) |
| lw a0, offThread_pJitProfTable(rSELF) |
| move rFP, a1 # fp = newFp |
| GET_PREFETCHED_OPCODE(t0, rOBJ) # extract prefetched opcode from rOBJ |
| move rINST, rOBJ # publish new rINST |
| sw a1, offThread_curFrame(rSELF) |
| bnez a0, common_updateProfile |
| GOTO_OPCODE(t0) |
| #else |
| move rFP, a1 |
| GET_PREFETCHED_OPCODE(t0, rOBJ) |
| move rINST, rOBJ |
| sw a1, offThread_curFrame(rSELF) |
| GOTO_OPCODE(t0) |
| #endif |
| |
| 2: |
| # Profiling - record method entry. a0: methodToCall |
| STACK_STORE(a0, 0) |
| STACK_STORE(a1, 4) |
| STACK_STORE(a2, 8) |
| STACK_STORE(a3, 12) |
| sw rPC, offThread_pc(rSELF) # update interpSave.pc |
| move a1, a0 |
| move a0, rSELF |
| JAL(dvmReportInvoke) |
| STACK_LOAD(a3, 12) # restore a0-a3 |
| STACK_LOAD(a2, 8) |
| STACK_LOAD(a1, 4) |
| STACK_LOAD(a0, 0) |
| b 1b |
| .LinvokeNative: |
| # Prep for the native call |
| # a0=methodToCall, a1=newFp, rBIX=newSaveArea |
| lhu ra, offThread_subMode(rSELF) |
| lw t3, offThread_jniLocal_topCookie(rSELF) |
| sw a1, offThread_curFrame(rSELF) |
| sw t3, offStackSaveArea_localRefCookie(rBIX) # newFp->localRefCookie=top |
| move a2, a0 |
| move a0, a1 |
| addu a1, rSELF, offThread_retval |
| move a3, rSELF |
| #ifdef ASSIST_DEBUGGER |
| /* insert fake function header to help gdb find the stack frame */ |
| b .Lskip |
| .ent dalvik_mterp |
| dalvik_mterp: |
| STACK_STORE_FULL() |
| .Lskip: |
| #endif |
| bnez ra, 11f # Any special SubModes active? |
| lw t9, offMethod_nativeFunc(a2) |
| jalr t9 |
| lw gp, STACK_OFFSET_GP(sp) |
| 7: |
| # native return; rBIX=newSaveArea |
| # equivalent to dvmPopJniLocals |
| lw a0, offStackSaveArea_localRefCookie(rBIX) |
| lw a1, offThread_exception(rSELF) |
| sw rFP, offThread_curFrame(rSELF) |
| sw a0, offThread_jniLocal_topCookie(rSELF) # new top <- old top |
| bnez a1, common_exceptionThrown |
| |
| FETCH_ADVANCE_INST(3) |
| GET_INST_OPCODE(t0) |
| GOTO_OPCODE(t0) |
| 11: |
| # a0=newFp, a1=&retval, a2=methodToCall, a3=self, ra=subModes |
| SCRATCH_STORE(a0, 0) |
| SCRATCH_STORE(a1, 4) |
| SCRATCH_STORE(a2, 8) |
| SCRATCH_STORE(a3, 12) |
| move a0, a2 # a0 <- methodToCall |
| move a1, rSELF |
| move a2, rFP |
| JAL(dvmReportPreNativeInvoke) # (methodToCall, self, fp) |
| SCRATCH_LOAD(a3, 12) # restore a0-a3 |
| SCRATCH_LOAD(a2, 8) |
| SCRATCH_LOAD(a1, 4) |
| SCRATCH_LOAD(a0, 0) |
| |
| # Call the native method |
| lw t9, offMethod_nativeFunc(a2) # t9<-methodToCall->nativeFunc |
| jalr t9 |
| lw gp, STACK_OFFSET_GP(sp) |
| |
| # Restore the pre-call arguments |
| SCRATCH_LOAD(a3, 12) # restore a0-a3 |
| SCRATCH_LOAD(a2, 8) |
| SCRATCH_LOAD(a1, 4) |
| SCRATCH_LOAD(a0, 0) |
| |
| # Finish up any post-invoke subMode requirements |
| move a0, a2 |
| move a1, rSELF |
| move a2, rFP |
| JAL(dvmReportPostNativeInvoke) # (methodToCall, self, fp) |
| b 7b |
| |
| |
| .LstackOverflow: # a0=methodToCall |
| move a1, a0 # a1 <- methodToCall |
| move a0, rSELF # a0 <- self |
| JAL(dvmHandleStackOverflow) # dvmHandleStackOverflow(self, methodToCall) |
| b common_exceptionThrown |
| #ifdef ASSIST_DEBUGGER |
| .end dalvik_mterp |
| #endif |
| |
| /* |
| * Common code for method invocation, calling through "glue code". |
| * |
| * TODO: now that we have range and non-range invoke handlers, this |
| * needs to be split into two. Maybe just create entry points |
| * that set r9 and jump here? |
| * |
| * On entry: |
| * r0 is "Method* methodToCall", the method we're trying to call |
| * r9 is "bool methodCallRange", indicating if this is a /range variant |
| */ |
| |
| /* |
| * Common code for handling a return instruction. |
| * |
| * This does not return. |
| */ |
| common_returnFromMethod: |
| .LreturnNew: |
| lhu t0, offThread_subMode(rSELF) |
| SAVEAREA_FROM_FP(a0, rFP) |
| lw rOBJ, offStackSaveArea_savedPc(a0) # rOBJ = saveArea->savedPc |
| bnez t0, 19f |
| 14: |
| lw rFP, offStackSaveArea_prevFrame(a0) # fp = saveArea->prevFrame |
| lw a2, (offStackSaveArea_method - sizeofStackSaveArea)(rFP) |
| # a2<- method we're returning to |
| # is this a break frame? |
| beqz a2, common_gotoBail # break frame, bail out completely |
| |
| lw rBIX, offMethod_clazz(a2) # rBIX<- method->clazz |
| lw rIBASE, offThread_curHandlerTable(rSELF) # refresh rIBASE |
| PREFETCH_ADVANCE_INST(rINST, rOBJ, 3) # advance rOBJ, update new rINST |
| sw a2, offThread_method(rSELF) # self->method = newSave->method |
| lw a1, offClassObject_pDvmDex(rBIX) # r1<- method->clazz->pDvmDex |
| sw rFP, offThread_curFrame(rSELF) # curFrame = fp |
| #if defined(WITH_JIT) |
| lw rBIX, offStackSaveArea_returnAddr(a0) |
| move rPC, rOBJ # publish new rPC |
| sw a1, offThread_methodClassDex(rSELF) |
| sw rBIX, offThread_inJitCodeCache(rSELF) # may return to JIT'ed land |
| beqz rBIX, 15f # caller is compiled code |
| move t9, rBIX |
| jalr t9 |
| lw gp, STACK_OFFSET_GP(sp) |
| 15: |
| GET_INST_OPCODE(t0) # extract opcode from rINST |
| GOTO_OPCODE(t0) # jump to next instruction |
| #else |
| GET_INST_OPCODE(t0) # extract opcode from rINST |
| move rPC, rOBJ # publish new rPC |
| sw a1, offThread_methodClassDex(rSELF) |
| GOTO_OPCODE(t0) |
| #endif |
| |
| 19: |
| # Handle special actions |
| # On entry, a0: StackSaveArea |
| lw a1, offStackSaveArea_prevFrame(a0) # a1<- prevFP |
| sw rPC, offThread_pc(rSELF) # update interpSave.pc |
| sw a1, offThread_curFrame(rSELF) # update interpSave.curFrame |
| move a0, rSELF |
| JAL(dvmReportReturn) |
| SAVEAREA_FROM_FP(a0, rFP) # restore StackSaveArea |
| b 14b |
| |
| .if 0 |
| /* |
| * Return handling, calls through "glue code". |
| */ |
| .LreturnOld: |
| SAVE_PC_FP_TO_SELF() # export state |
| move a0, rSELF # arg to function |
| JAL(dvmMterp_returnFromMethod) |
| b common_resumeAfterGlueCall |
| .endif |
| |
| /* |
| * Somebody has thrown an exception. Handle it. |
| * |
| * If the exception processing code returns to us (instead of falling |
| * out of the interpreter), continue with whatever the next instruction |
| * now happens to be. |
| * |
| * This does not return. |
| */ |
| .global dvmMterpCommonExceptionThrown |
| dvmMterpCommonExceptionThrown: |
| common_exceptionThrown: |
| .LexceptionNew: |
| |
| EXPORT_PC() |
| move a0, rSELF |
| JAL(dvmCheckSuspendPending) |
| lw rOBJ, offThread_exception(rSELF) |
| move a1, rSELF |
| move a0, rOBJ |
| JAL(dvmAddTrackedAlloc) |
| lhu a2, offThread_subMode(rSELF) |
| sw zero, offThread_exception(rSELF) |
| |
| # Special subMode? |
| bnez a2, 7f # any special subMode handling needed? |
| 8: |
| /* set up args and a local for "&fp" */ |
| sw rFP, 20(sp) # store rFP => tmp |
| addu t0, sp, 20 # compute &tmp |
| sw t0, STACK_OFFSET_ARG04(sp) # save it in arg4 as per ABI |
| li a3, 0 # a3 <- false |
| lw a1, offThread_method(rSELF) |
| move a0, rSELF |
| lw a1, offMethod_insns(a1) |
| move a2, rOBJ |
| subu a1, rPC, a1 |
| sra a1, a1, 1 |
| |
| /* call, r0 gets catchRelPc (a code-unit offset) */ |
| JAL(dvmFindCatchBlock) # call(self, relPc, exc, scan?, &fp) |
| lw rFP, 20(sp) # retrieve the updated rFP |
| |
| /* update frame pointer and check result from dvmFindCatchBlock */ |
| move a0, v0 |
| bltz v0, .LnotCaughtLocally |
| |
| /* fix earlier stack overflow if necessary; Preserve a0 */ |
| lbu a1, offThread_stackOverflowed(rSELF) |
| beqz a1, 1f |
| move rBIX, a0 |
| move a0, rSELF |
| move a1, rOBJ |
| JAL(dvmCleanupStackOverflow) |
| move a0, rBIX |
| |
| 1: |
| |
| /* adjust locals to match self->interpSave.curFrame and updated PC */ |
| SAVEAREA_FROM_FP(a1, rFP) # a1<- new save area |
| lw a1, offStackSaveArea_method(a1) |
| sw a1, offThread_method(rSELF) |
| lw a2, offMethod_clazz(a1) |
| lw a3, offMethod_insns(a1) |
| lw a2, offClassObject_pDvmDex(a2) |
| EAS1(rPC, a3, a0) |
| sw a2, offThread_methodClassDex(rSELF) |
| |
| /* release the tracked alloc on the exception */ |
| move a0, rOBJ |
| move a1, rSELF |
| JAL(dvmReleaseTrackedAlloc) |
| |
| /* restore the exception if the handler wants it */ |
| lw rIBASE, offThread_curHandlerTable(rSELF) |
| FETCH_INST() |
| GET_INST_OPCODE(t0) |
| bne t0, OP_MOVE_EXCEPTION, 2f |
| sw rOBJ, offThread_exception(rSELF) |
| 2: |
| GOTO_OPCODE(t0) |
| |
| # Manage debugger bookkeeping |
| 7: |
| sw rPC, offThread_pc(rSELF) |
| sw rFP, offThread_curFrame(rSELF) |
| move a0, rSELF |
| move a1, rOBJ |
| JAL(dvmReportExceptionThrow) |
| b 8b |
| |
| .LnotCaughtLocally: # rOBJ = exception |
| /* fix stack overflow if necessary */ |
| lbu a1, offThread_stackOverflowed(rSELF) |
| beqz a1, 3f |
| move a0, rSELF |
| move a1, rOBJ |
| JAL(dvmCleanupStackOverflow) # dvmCleanupStackOverflow(self, exception) |
| |
| 3: |
| # may want to show "not caught locally" debug messages here |
| #if DVM_SHOW_EXCEPTION >= 2 |
| /* call __android_log_print(prio, tag, format, ...) */ |
| /* "Exception %s from %s:%d not caught locally" */ |
| lw a0, offThread_method(rSELF) |
| lw a1, offMethod_insns(a0) |
| subu a1, rPC, a1 |
| sra a1, a1, 1 |
| JAL(dvmLineNumFromPC) |
| sw v0, 20(sp) |
| # dvmGetMethodSourceFile(method) |
| lw a0, offThread_method(rSELF) |
| JAL(dvmGetMethodSourceFile) |
| sw v0, 16(sp) |
| # exception->clazz->descriptor |
| lw a3, offObject_clazz(rOBJ) |
| lw a3, offClassObject_descriptor(a3) |
| la a2, .LstrExceptionNotCaughtLocally |
| la a1, .LstrLogTag |
| li a0, 3 |
| JAL(__android_log_print) |
| #endif |
| sw rOBJ, offThread_exception(rSELF) |
| move a0, rOBJ |
| move a1, rSELF |
| JAL(dvmReleaseTrackedAlloc) |
| b common_gotoBail |
| |
| /* |
| * Exception handling, calls through "glue code". |
| */ |
| .if 0 |
| .LexceptionOld: |
| SAVE_PC_TO_SELF() # export state |
| SAVE_FP_TO_SELF() |
| move a0, rSELF # arg to function |
| JAL(dvmMterp_exceptionThrown) |
| b common_resumeAfterGlueCall |
| .endif |
| |
| #if defined(WITH_JIT) |
| /* |
| * If the JIT is actively building a trace we need to make sure |
| * that the field is fully resolved before including the current |
| * instruction. |
| * |
| * On entry: |
| * rBIX: &dvmDex->pResFields[field] |
| * a0: field pointer (must preserve) |
| */ |
| common_verifyField: |
| lhu a3, offThread_subMode(rSELF) |
| andi a3, kSubModeJitTraceBuild |
| bnez a3, 1f # Not building trace, continue |
| jr ra |
| 1: |
| lw a1, (rBIX) |
| beqz a1, 2f # resolution complete ? |
| jr ra |
| 2: |
| SCRATCH_STORE(a0, 0) |
| SCRATCH_STORE(a1, 4) |
| SCRATCH_STORE(a2, 8) |
| SCRATCH_STORE(a3, 12) |
| SCRATCH_STORE(ra, 16) |
| move a0, rSELF |
| move a1, rPC |
| JAL(dvmJitEndTraceSelect) #(self,pc) end trace before this inst) |
| SCRATCH_LOAD(a0, 0) |
| SCRATCH_LOAD(a1, 4) |
| SCRATCH_LOAD(a2, 8) |
| SCRATCH_LOAD(a3, 12) |
| SCRATCH_LOAD(ra, 16) |
| jr ra # return |
| #endif |
| |
| /* |
| * After returning from a "glued" function, pull out the updated |
| * values and start executing at the next instruction. |
| */ |
| common_resumeAfterGlueCall: |
| LOAD_PC_FP_FROM_SELF() # pull rPC and rFP out of thread |
| lw rIBASE, offThread_curHandlerTable(rSELF) # refresh |
| FETCH_INST() # load rINST from rPC |
| GET_INST_OPCODE(t0) # extract opcode from rINST |
| GOTO_OPCODE(t0) # jump to next instruction |
| |
| /* |
| * Invalid array index. Note that our calling convention is strange; we use a1 |
| * and a3 because those just happen to be the registers all our callers are |
| * using. We move a3 before calling the C function, but a1 happens to match. |
| * a1: index |
| * a3: size |
| */ |
| common_errArrayIndex: |
| EXPORT_PC() |
| move a0, a3 |
| JAL(dvmThrowArrayIndexOutOfBoundsException) |
| b common_exceptionThrown |
| |
| /* |
| * Integer divide or mod by zero. |
| */ |
| common_errDivideByZero: |
| EXPORT_PC() |
| la a0, .LstrDivideByZero |
| JAL(dvmThrowArithmeticException) |
| b common_exceptionThrown |
| |
| /* |
| * Attempt to allocate an array with a negative size. |
| * On entry: length in a1 |
| */ |
| common_errNegativeArraySize: |
| EXPORT_PC() |
| move a0, a1 # arg0 <- len |
| JAL(dvmThrowNegativeArraySizeException) # (len) |
| b common_exceptionThrown |
| |
| /* |
| * Invocation of a non-existent method. |
| * On entry: method name in a1 |
| */ |
| common_errNoSuchMethod: |
| EXPORT_PC() |
| move a0, a1 |
| JAL(dvmThrowNoSuchMethodError) |
| b common_exceptionThrown |
| |
| /* |
| * We encountered a null object when we weren't expecting one. We |
| * export the PC, throw a NullPointerException, and goto the exception |
| * processing code. |
| */ |
| common_errNullObject: |
| EXPORT_PC() |
| li a0, 0 |
| JAL(dvmThrowNullPointerException) |
| b common_exceptionThrown |
| |
| /* |
| * For debugging, cause an immediate fault. The source address will be in ra. Use a jal to jump here. |
| */ |
| common_abort: |
| lw zero,-4(zero) # generate SIGSEGV |
| |
| /* |
| * Spit out a "we were here", preserving all registers. |
| */ |
| .macro SQUEAK num |
| common_squeak\num: |
| STACK_STORE_RA(); |
| la a0, .LstrSqueak |
| LOAD_IMM(a1, \num); |
| JAL(printf); |
| STACK_LOAD_RA(); |
| RETURN; |
| .endm |
| |
| SQUEAK 0 |
| SQUEAK 1 |
| SQUEAK 2 |
| SQUEAK 3 |
| SQUEAK 4 |
| SQUEAK 5 |
| |
| /* |
| * Spit out the number in a0, preserving registers. |
| */ |
| common_printNum: |
| STACK_STORE_RA() |
| MOVE_REG(a1, a0) |
| la a0, .LstrSqueak |
| JAL(printf) |
| STACK_LOAD_RA() |
| RETURN |
| |
| /* |
| * Print a newline, preserving registers. |
| */ |
| common_printNewline: |
| STACK_STORE_RA() |
| la a0, .LstrNewline |
| JAL(printf) |
| STACK_LOAD_RA() |
| RETURN |
| |
| /* |
| * Print the 32-bit quantity in a0 as a hex value, preserving registers. |
| */ |
| common_printHex: |
| STACK_STORE_RA() |
| MOVE_REG(a1, a0) |
| la a0, .LstrPrintHex |
| JAL(printf) |
| STACK_LOAD_RA() |
| RETURN; |
| |
| /* |
| * Print the 64-bit quantity in a0-a1, preserving registers. |
| */ |
| common_printLong: |
| STACK_STORE_RA() |
| MOVE_REG(a3, a1) |
| MOVE_REG(a2, a0) |
| la a0, .LstrPrintLong |
| JAL(printf) |
| STACK_LOAD_RA() |
| RETURN; |
| |
| /* |
| * Print full method info. Pass the Method* in a0. Preserves regs. |
| */ |
| common_printMethod: |
| STACK_STORE_RA() |
| JAL(dvmMterpPrintMethod) |
| STACK_LOAD_RA() |
| RETURN |
| |
| /* |
| * Call a C helper function that dumps regs and possibly some |
| * additional info. Requires the C function to be compiled in. |
| */ |
| .if 0 |
| common_dumpRegs: |
| STACK_STORE_RA() |
| JAL(dvmMterpDumpMipsRegs) |
| STACK_LOAD_RA() |
| RETURN |
| .endif |
| |
| /* |
| * Zero-terminated ASCII string data. |
| */ |
| .data |
| |
| .LstrBadEntryPoint: |
| .asciiz "Bad entry point %d\n" |
| .LstrDivideByZero: |
| .asciiz "divide by zero" |
| .LstrFilledNewArrayNotImpl: |
| .asciiz "filled-new-array only implemented for 'int'" |
| .LstrLogTag: |
| .asciiz "mterp" |
| .LstrExceptionNotCaughtLocally: |
| .asciiz "Exception %s from %s:%d not caught locally\n" |
| |
| .LstrNewline: |
| .asciiz "\n" |
| .LstrSqueak: |
| .asciiz "<%d>" |
| .LstrPrintHex: |
| .asciiz "<0x%x>" |
| .LstrPrintLong: |
| .asciiz "<%lld>" |
