1 /* 2 * This file was generated automatically by gen-template.py for 'armv7-a'. 3 * 4 * --> DO NOT EDIT <-- 5 */ 6 7 /* File: armv5te/header.S */ 8 /* 9 * Copyright (C) 2008 The Android Open Source Project 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 */ 23 24 #if defined(WITH_JIT) 25 26 /* 27 * ARMv5 definitions and declarations. 28 */ 29 30 /* 31 ARM EABI general notes: 32 33 r0-r3 hold first 4 args to a method; they are not preserved across method calls 34 r4-r8 are available for general use 35 r9 is given special treatment in some situations, but not for us 36 r10 (sl) seems to be generally available 37 r11 (fp) is used by gcc (unless -fomit-frame-pointer is set) 38 r12 (ip) is scratch -- not preserved across method calls 39 r13 (sp) should be managed carefully in case a signal arrives 40 r14 (lr) must be preserved 41 r15 (pc) can be tinkered with directly 42 43 r0 holds returns of <= 4 bytes 44 r0-r1 hold returns of 8 bytes, low word in r0 45 46 Callee must save/restore r4+ (except r12) if it modifies them. 47 48 Stack is "full descending". Only the arguments that don't fit in the first 4 49 registers are placed on the stack. "sp" points at the first stacked argument 50 (i.e. the 5th arg). 51 52 VFP: single-precision results in s0, double-precision results in d0. 53 54 In the EABI, "sp" must be 64-bit aligned on entry to a function, and any 55 64-bit quantities (long long, double) must be 64-bit aligned. 56 */ 57 58 /* 59 JIT and ARM notes: 60 61 The following registers have fixed assignments: 62 63 reg nick purpose 64 r5 rFP interpreted frame pointer, used for accessing locals and args 65 r6 rSELF thread pointer 66 67 The following registers have fixed assignments in mterp but are scratch 68 registers in compiled code 69 70 reg nick purpose 71 r4 rPC interpreted program counter, used for fetching instructions 72 r7 rINST first 16-bit code unit of current instruction 73 r8 rIBASE interpreted instruction base pointer, used for computed goto 74 75 Macros are provided for common operations. Each macro MUST emit only 76 one instruction to make instruction-counting easier. They MUST NOT alter 77 unspecified registers or condition codes. 78 */ 79 80 /* single-purpose registers, given names for clarity */ 81 #define rPC r4 82 #define rFP r5 83 #define rSELF r6 84 #define rINST r7 85 #define rIBASE r8 86 87 /* 88 * Given a frame pointer, find the stack save area. 89 * 90 * In C this is "((StackSaveArea*)(_fp) -1)". 91 */ 92 #define SAVEAREA_FROM_FP(_reg, _fpreg) \ 93 sub _reg, _fpreg, #sizeofStackSaveArea 94 95 #define EXPORT_PC() \ 96 str rPC, [rFP, #(-sizeofStackSaveArea + offStackSaveArea_currentPc)] 97 98 /* 99 * This is a #include, not a %include, because we want the C pre-processor 100 * to expand the macros into assembler assignment statements. 101 */ 102 #include "../../../mterp/common/asm-constants.h" 103 104 /* File: armv5te-vfp/platform.S */ 105 /* 106 * =========================================================================== 107 * CPU-version-specific defines and utility 108 * =========================================================================== 109 */ 110 111 112 .global dvmCompilerTemplateStart 113 .type dvmCompilerTemplateStart, %function 114 .text 115 116 dvmCompilerTemplateStart: 117 118 /* ------------------------------ */ 119 .balign 4 120 .global dvmCompiler_TEMPLATE_CMP_LONG 121 dvmCompiler_TEMPLATE_CMP_LONG: 122 /* File: armv5te/TEMPLATE_CMP_LONG.S */ 123 /* 124 * Compare two 64-bit values. Puts 0, 1, or -1 into the destination 125 * register based on the results of the comparison. 126 * 127 * We load the full values with LDM, but in practice many values could 128 * be resolved by only looking at the high word. This could be made 129 * faster or slower by splitting the LDM into a pair of LDRs. 130 * 131 * If we just wanted to set condition flags, we could do this: 132 * subs ip, r0, r2 133 * sbcs ip, r1, r3 134 * subeqs ip, r0, r2 135 * Leaving { <0, 0, >0 } in ip. However, we have to set it to a specific 136 * integer value, which we can do with 2 conditional mov/mvn instructions 137 * (set 1, set -1; if they're equal we already have 0 in ip), giving 138 * us a constant 5-cycle path plus a branch at the end to the 139 * instruction epilogue code. The multi-compare approach below needs 140 * 2 or 3 cycles + branch if the high word doesn't match, 6 + branch 141 * in the worst case (the 64-bit values are equal). 142 */ 143 /* cmp-long vAA, vBB, vCC */ 144 cmp r1, r3 @ compare (vBB+1, vCC+1) 145 blt .LTEMPLATE_CMP_LONG_less @ signed compare on high part 146 bgt .LTEMPLATE_CMP_LONG_greater 147 subs r0, r0, r2 @ r0<- r0 - r2 148 bxeq lr 149 bhi .LTEMPLATE_CMP_LONG_greater @ unsigned compare on low part 150 .LTEMPLATE_CMP_LONG_less: 151 mvn r0, #0 @ r0<- -1 152 bx lr 153 .LTEMPLATE_CMP_LONG_greater: 154 mov r0, #1 @ r0<- 1 155 bx lr 156 157 /* ------------------------------ */ 158 .balign 4 159 .global dvmCompiler_TEMPLATE_RETURN 160 dvmCompiler_TEMPLATE_RETURN: 161 /* File: armv5te/TEMPLATE_RETURN.S */ 162 /* 163 * Unwind a frame from the Dalvik stack for compiled OP_RETURN_XXX. 164 * If the stored value in returnAddr 165 * is non-zero, the caller is compiled by the JIT thus return to the 166 * address in the code cache following the invoke instruction. Otherwise 167 * return to the special dvmJitToInterpNoChain entry point. 168 */ 169 #if defined(TEMPLATE_INLINE_PROFILING) 170 stmfd sp!, {r0-r2,lr} @ preserve live registers 171 mov r0, r6 172 @ r0=rSELF 173 mov lr, pc 174 ldr pc, .LdvmFastMethodTraceExit 175 ldmfd sp!, {r0-r2,lr} @ restore live registers 176 #endif 177 SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) 178 ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame 179 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 180 ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc 181 #if !defined(WITH_SELF_VERIFICATION) 182 ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret 183 #else 184 mov r9, #0 @ disable chaining 185 #endif 186 ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] 187 @ r2<- method we're returning to 188 cmp r2, #0 @ break frame? 189 #if !defined(WITH_SELF_VERIFICATION) 190 beq 1f @ bail to interpreter 191 #else 192 blxeq lr @ punt to interpreter and compare state 193 #endif 194 ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S 195 mov rFP, r10 @ publish new FP 196 ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz 197 198 str r2, [rSELF, #offThread_method]@ self->method = newSave->method 199 ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex 200 str rFP, [rSELF, #offThread_curFrame] @ curFrame = fp 201 add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) 202 str r0, [rSELF, #offThread_methodClassDex] 203 cmp r8, #0 @ check the break flags 204 movne r9, #0 @ clear the chaining cell address 205 str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not 206 cmp r9, #0 @ chaining cell exists? 207 blxne r9 @ jump to the chaining cell 208 #if defined(WITH_JIT_TUNING) 209 mov r0, #kCallsiteInterpreted 210 #endif 211 mov pc, r1 @ callsite is interpreted 212 1: 213 mov r0, #0 214 str r0, [rSELF, #offThread_inJitCodeCache] @ reset inJitCodeCache 215 stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() 216 ldr r2, .LdvmMterpStdBail @ defined in footer.S 217 mov r0, rSELF @ Expecting rSELF in r0 218 blx r2 @ exit the interpreter 219 220 /* ------------------------------ */ 221 .balign 4 222 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT 223 dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: 224 /* File: armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S */ 225 /* 226 * For polymorphic callsites - setup the Dalvik frame and load Dalvik PC 227 * into rPC then jump to dvmJitToInterpNoChain to dispatch the 228 * runtime-resolved callee. 229 */ 230 @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite 231 ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize 232 ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize 233 ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd 234 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 235 add r3, r1, #1 @ Thumb addr is odd 236 SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area 237 sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) 238 SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area 239 sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) 240 cmp r10, r9 @ bottom < interpStackEnd? 241 bxlo lr @ return to raise stack overflow excep. 242 @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite 243 ldr r9, [r0, #offMethod_clazz] @ r9<- method->clazz 244 ldr r10, [r0, #offMethod_accessFlags] @ r10<- methodToCall->accessFlags 245 str rPC, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 246 str rPC, [r1, #(offStackSaveArea_savedPc - sizeofStackSaveArea)] 247 ldr rPC, [r0, #offMethod_insns] @ rPC<- methodToCall->insns 248 249 250 @ set up newSaveArea 251 str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] 252 str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] 253 str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] 254 cmp r8, #0 @ breakFlags != 0 255 bxne lr @ bail to the interpreter 256 tst r10, #ACC_NATIVE 257 #if !defined(WITH_SELF_VERIFICATION) 258 bne .LinvokeNative 259 #else 260 bxne lr @ bail to the interpreter 261 #endif 262 263 ldr r10, .LdvmJitToInterpTraceSelectNoChain 264 ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex 265 266 @ Update "thread" values for the new method 267 str r0, [rSELF, #offThread_method] @ self->method = methodToCall 268 str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... 269 mov rFP, r1 @ fp = newFp 270 str rFP, [rSELF, #offThread_curFrame] @ curFrame = newFp 271 #if defined(TEMPLATE_INLINE_PROFILING) 272 stmfd sp!, {r0-r3} @ preserve r0-r3 273 mov r1, r6 274 @ r0=methodToCall, r1=rSELF 275 mov lr, pc 276 ldr pc, .LdvmFastMethodTraceEnter 277 ldmfd sp!, {r0-r3} @ restore r0-r3 278 #endif 279 280 @ Start executing the callee 281 #if defined(WITH_JIT_TUNING) 282 mov r0, #kInlineCacheMiss 283 #endif 284 mov pc, r10 @ dvmJitToInterpTraceSelectNoChain 285 286 /* ------------------------------ */ 287 .balign 4 288 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN 289 dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: 290 /* File: armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S */ 291 /* 292 * For monomorphic callsite, setup the Dalvik frame and return to the 293 * Thumb code through the link register to transfer control to the callee 294 * method through a dedicated chaining cell. 295 */ 296 @ r0 = methodToCall, r1 = returnCell, r2 = methodToCall->outsSize 297 @ rPC = dalvikCallsite, r7 = methodToCall->registersSize 298 @ methodToCall is guaranteed to be non-native 299 .LinvokeChain: 300 ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd 301 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 302 add r3, r1, #1 @ Thumb addr is odd 303 SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area 304 sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) 305 SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area 306 add r12, lr, #2 @ setup the punt-to-interp address 307 sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) 308 cmp r10, r9 @ bottom < interpStackEnd? 309 bxlo r12 @ return to raise stack overflow excep. 310 @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite 311 ldr r9, [r0, #offMethod_clazz] @ r9<- method->clazz 312 str rPC, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 313 str rPC, [r1, #(offStackSaveArea_savedPc - sizeofStackSaveArea)] 314 315 @ set up newSaveArea 316 str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] 317 str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] 318 str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] 319 cmp r8, #0 @ breakFlags != 0 320 bxne r12 @ bail to the interpreter 321 322 ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex 323 324 @ Update "thread" values for the new method 325 str r0, [rSELF, #offThread_method] @ self->method = methodToCall 326 str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... 327 mov rFP, r1 @ fp = newFp 328 str rFP, [rSELF, #offThread_curFrame] @ curFrame = newFp 329 #if defined(TEMPLATE_INLINE_PROFILING) 330 stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers 331 mov r1, r6 332 @ r0=methodToCall, r1=rSELF 333 mov lr, pc 334 ldr pc, .LdvmFastMethodTraceEnter 335 ldmfd sp!, {r0-r2,lr} @ restore registers 336 #endif 337 338 bx lr @ return to the callee-chaining cell 339 340 /* ------------------------------ */ 341 .balign 4 342 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN 343 dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: 344 /* File: armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S */ 345 /* 346 * For polymorphic callsite, check whether the cached class pointer matches 347 * the current one. If so setup the Dalvik frame and return to the 348 * Thumb code through the link register to transfer control to the callee 349 * method through a dedicated chaining cell. 350 * 351 * The predicted chaining cell is declared in ArmLIR.h with the 352 * following layout: 353 * 354 * typedef struct PredictedChainingCell { 355 * u4 branch; 356 * const ClassObject *clazz; 357 * const Method *method; 358 * u4 counter; 359 * } PredictedChainingCell; 360 * 361 * Upon returning to the callsite: 362 * - lr : to branch to the chaining cell 363 * - lr+2: to punt to the interpreter 364 * - lr+4: to fully resolve the callee and may rechain. 365 * r3 <- class 366 * r9 <- counter 367 */ 368 @ r0 = this, r1 = returnCell, r2 = predictedChainCell, rPC = dalvikCallsite 369 ldr r3, [r0, #offObject_clazz] @ r3 <- this->class 370 ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz 371 ldr r0, [r2, #8] @ r0 <- predictedChainCell->method 372 ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount 373 cmp r3, r8 @ predicted class == actual class? 374 #if defined(WITH_JIT_TUNING) 375 ldr r7, .LdvmICHitCount 376 #if defined(WORKAROUND_CORTEX_A9_745320) 377 /* Don't use conditional loads if the HW defect exists */ 378 bne 101f 379 ldr r10, [r7, #0] 380 101: 381 #else 382 ldreq r10, [r7, #0] 383 #endif 384 add r10, r10, #1 385 streq r10, [r7, #0] 386 #endif 387 ldreqh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize 388 ldreqh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize 389 beq .LinvokeChain @ predicted chain is valid 390 ldr r7, [r3, #offClassObject_vtable] @ r7 <- this->class->vtable 391 cmp r8, #0 @ initialized class or not 392 moveq r1, #0 393 subne r1, r9, #1 @ count-- 394 strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread 395 add lr, lr, #4 @ return to fully-resolve landing pad 396 /* 397 * r1 <- count 398 * r2 <- &predictedChainCell 399 * r3 <- this->class 400 * r4 <- dPC 401 * r7 <- this->class->vtable 402 */ 403 bx lr 404 405 /* ------------------------------ */ 406 .balign 4 407 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE 408 dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: 409 /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ 410 @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite 411 @ r7 = methodToCall->registersSize 412 ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd 413 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 414 add r3, r1, #1 @ Thumb addr is odd 415 SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area 416 sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) 417 SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area 418 cmp r10, r9 @ bottom < interpStackEnd? 419 bxlo lr @ return to raise stack overflow excep. 420 @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite 421 str rPC, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 422 str rPC, [r1, #(offStackSaveArea_savedPc - sizeofStackSaveArea)] 423 424 @ set up newSaveArea 425 str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] 426 str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] 427 str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] 428 cmp r8, #0 @ breakFlags != 0 429 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc 430 #if !defined(WITH_SELF_VERIFICATION) 431 bxne lr @ bail to the interpreter 432 #else 433 bx lr @ bail to interpreter unconditionally 434 #endif 435 436 @ go ahead and transfer control to the native code 437 ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... 438 mov r2, #0 439 str r1, [rSELF, #offThread_curFrame] @ curFrame = newFp 440 str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache 441 str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] 442 @ newFp->localRefCookie=top 443 SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area 444 445 mov r2, r0 @ arg2<- methodToCall 446 mov r0, r1 @ arg0<- newFP 447 add r1, rSELF, #offThread_retval @ arg1<- &retval 448 mov r3, rSELF @ arg3<- self 449 #if defined(TEMPLATE_INLINE_PROFILING) 450 @ r2=methodToCall, r6=rSELF 451 stmfd sp!, {r2,r6} @ to be consumed after JNI return 452 stmfd sp!, {r0-r3} @ preserve r0-r3 453 mov r0, r2 454 mov r1, r6 455 @ r0=JNIMethod, r1=rSELF 456 mov lr, pc 457 ldr pc, .LdvmFastMethodTraceEnter 458 ldmfd sp!, {r0-r3} @ restore r0-r3 459 #endif 460 461 blx r8 @ off to the native code 462 463 #if defined(TEMPLATE_INLINE_PROFILING) 464 ldmfd sp!, {r0-r1} @ restore r2 and r6 465 @ r0=JNIMethod, r1=rSELF 466 mov lr, pc 467 ldr pc, .LdvmFastNativeMethodTraceExit 468 #endif 469 @ native return; r10=newSaveArea 470 @ equivalent to dvmPopJniLocals 471 ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret 472 ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top 473 ldr r1, [rSELF, #offThread_exception] @ check for exception 474 str rFP, [rSELF, #offThread_curFrame] @ curFrame = fp 475 cmp r1, #0 @ null? 476 str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top 477 ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 478 479 @ r0 = dalvikCallsitePC 480 bne .LhandleException @ no, handle exception 481 482 str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly 483 cmp r2, #0 @ return chaining cell still exists? 484 bxne r2 @ yes - go ahead 485 486 @ continue executing the next instruction through the interpreter 487 ldr r1, .LdvmJitToInterpTraceSelectNoChain @ defined in footer.S 488 add rPC, r0, #6 @ reconstruct new rPC (advance 6 bytes) 489 #if defined(WITH_JIT_TUNING) 490 mov r0, #kCallsiteInterpreted 491 #endif 492 mov pc, r1 493 494 /* ------------------------------ */ 495 .balign 4 496 .global dvmCompiler_TEMPLATE_MUL_LONG 497 dvmCompiler_TEMPLATE_MUL_LONG: 498 /* File: armv5te/TEMPLATE_MUL_LONG.S */ 499 /* 500 * Signed 64-bit integer multiply. 501 * 502 * For JIT: op1 in r0/r1, op2 in r2/r3, return in r0/r1 503 * 504 * Consider WXxYZ (r1r0 x r3r2) with a long multiply: 505 * WX 506 * x YZ 507 * -------- 508 * ZW ZX 509 * YW YX 510 * 511 * The low word of the result holds ZX, the high word holds 512 * (ZW+YX) + (the high overflow from ZX). YW doesn't matter because 513 * it doesn't fit in the low 64 bits. 514 * 515 * Unlike most ARM math operations, multiply instructions have 516 * restrictions on using the same register more than once (Rd and Rm 517 * cannot be the same). 518 */ 519 /* mul-long vAA, vBB, vCC */ 520 mul ip, r2, r1 @ ip<- ZxW 521 umull r9, r10, r2, r0 @ r9/r10 <- ZxX 522 mla r2, r0, r3, ip @ r2<- YxX + (ZxW) 523 add r10, r2, r10 @ r10<- r10 + low(ZxW + (YxX)) 524 mov r0,r9 525 mov r1,r10 526 bx lr 527 528 /* ------------------------------ */ 529 .balign 4 530 .global dvmCompiler_TEMPLATE_SHL_LONG 531 dvmCompiler_TEMPLATE_SHL_LONG: 532 /* File: armv5te/TEMPLATE_SHL_LONG.S */ 533 /* 534 * Long integer shift. This is different from the generic 32/64-bit 535 * binary operations because vAA/vBB are 64-bit but vCC (the shift 536 * distance) is 32-bit. Also, Dalvik requires us to ignore all but the low 537 * 6 bits. 538 */ 539 /* shl-long vAA, vBB, vCC */ 540 and r2, r2, #63 @ r2<- r2 & 0x3f 541 mov r1, r1, asl r2 @ r1<- r1 << r2 542 rsb r3, r2, #32 @ r3<- 32 - r2 543 orr r1, r1, r0, lsr r3 @ r1<- r1 | (r0 << (32-r2)) 544 subs ip, r2, #32 @ ip<- r2 - 32 545 movpl r1, r0, asl ip @ if r2 >= 32, r1<- r0 << (r2-32) 546 mov r0, r0, asl r2 @ r0<- r0 << r2 547 bx lr 548 549 /* ------------------------------ */ 550 .balign 4 551 .global dvmCompiler_TEMPLATE_SHR_LONG 552 dvmCompiler_TEMPLATE_SHR_LONG: 553 /* File: armv5te/TEMPLATE_SHR_LONG.S */ 554 /* 555 * Long integer shift. This is different from the generic 32/64-bit 556 * binary operations because vAA/vBB are 64-bit but vCC (the shift 557 * distance) is 32-bit. Also, Dalvik requires us to ignore all but the low 558 * 6 bits. 559 */ 560 /* shr-long vAA, vBB, vCC */ 561 and r2, r2, #63 @ r0<- r0 & 0x3f 562 mov r0, r0, lsr r2 @ r0<- r2 >> r2 563 rsb r3, r2, #32 @ r3<- 32 - r2 564 orr r0, r0, r1, asl r3 @ r0<- r0 | (r1 << (32-r2)) 565 subs ip, r2, #32 @ ip<- r2 - 32 566 movpl r0, r1, asr ip @ if r2 >= 32, r0<-r1 >> (r2-32) 567 mov r1, r1, asr r2 @ r1<- r1 >> r2 568 bx lr 569 570 /* ------------------------------ */ 571 .balign 4 572 .global dvmCompiler_TEMPLATE_USHR_LONG 573 dvmCompiler_TEMPLATE_USHR_LONG: 574 /* File: armv5te/TEMPLATE_USHR_LONG.S */ 575 /* 576 * Long integer shift. This is different from the generic 32/64-bit 577 * binary operations because vAA/vBB are 64-bit but vCC (the shift 578 * distance) is 32-bit. Also, Dalvik requires us to ignore all but the low 579 * 6 bits. 580 */ 581 /* ushr-long vAA, vBB, vCC */ 582 and r2, r2, #63 @ r0<- r0 & 0x3f 583 mov r0, r0, lsr r2 @ r0<- r2 >> r2 584 rsb r3, r2, #32 @ r3<- 32 - r2 585 orr r0, r0, r1, asl r3 @ r0<- r0 | (r1 << (32-r2)) 586 subs ip, r2, #32 @ ip<- r2 - 32 587 movpl r0, r1, lsr ip @ if r2 >= 32, r0<-r1 >>> (r2-32) 588 mov r1, r1, lsr r2 @ r1<- r1 >>> r2 589 bx lr 590 591 /* ------------------------------ */ 592 .balign 4 593 .global dvmCompiler_TEMPLATE_ADD_FLOAT_VFP 594 dvmCompiler_TEMPLATE_ADD_FLOAT_VFP: 595 /* File: armv5te-vfp/TEMPLATE_ADD_FLOAT_VFP.S */ 596 /* File: armv5te-vfp/fbinop.S */ 597 /* 598 * Generic 32-bit floating point operation. Provide an "instr" line that 599 * specifies an instruction that performs s2 = s0 op s1. 600 * 601 * On entry: 602 * r0 = target dalvik register address 603 * r1 = op1 address 604 * r2 = op2 address 605 */ 606 flds s0,[r1] 607 flds s1,[r2] 608 fadds s2, s0, s1 609 fsts s2,[r0] 610 bx lr 611 612 613 /* ------------------------------ */ 614 .balign 4 615 .global dvmCompiler_TEMPLATE_SUB_FLOAT_VFP 616 dvmCompiler_TEMPLATE_SUB_FLOAT_VFP: 617 /* File: armv5te-vfp/TEMPLATE_SUB_FLOAT_VFP.S */ 618 /* File: armv5te-vfp/fbinop.S */ 619 /* 620 * Generic 32-bit floating point operation. Provide an "instr" line that 621 * specifies an instruction that performs s2 = s0 op s1. 622 * 623 * On entry: 624 * r0 = target dalvik register address 625 * r1 = op1 address 626 * r2 = op2 address 627 */ 628 flds s0,[r1] 629 flds s1,[r2] 630 fsubs s2, s0, s1 631 fsts s2,[r0] 632 bx lr 633 634 635 /* ------------------------------ */ 636 .balign 4 637 .global dvmCompiler_TEMPLATE_MUL_FLOAT_VFP 638 dvmCompiler_TEMPLATE_MUL_FLOAT_VFP: 639 /* File: armv5te-vfp/TEMPLATE_MUL_FLOAT_VFP.S */ 640 /* File: armv5te-vfp/fbinop.S */ 641 /* 642 * Generic 32-bit floating point operation. Provide an "instr" line that 643 * specifies an instruction that performs s2 = s0 op s1. 644 * 645 * On entry: 646 * r0 = target dalvik register address 647 * r1 = op1 address 648 * r2 = op2 address 649 */ 650 flds s0,[r1] 651 flds s1,[r2] 652 fmuls s2, s0, s1 653 fsts s2,[r0] 654 bx lr 655 656 657 /* ------------------------------ */ 658 .balign 4 659 .global dvmCompiler_TEMPLATE_DIV_FLOAT_VFP 660 dvmCompiler_TEMPLATE_DIV_FLOAT_VFP: 661 /* File: armv5te-vfp/TEMPLATE_DIV_FLOAT_VFP.S */ 662 /* File: armv5te-vfp/fbinop.S */ 663 /* 664 * Generic 32-bit floating point operation. Provide an "instr" line that 665 * specifies an instruction that performs s2 = s0 op s1. 666 * 667 * On entry: 668 * r0 = target dalvik register address 669 * r1 = op1 address 670 * r2 = op2 address 671 */ 672 flds s0,[r1] 673 flds s1,[r2] 674 fdivs s2, s0, s1 675 fsts s2,[r0] 676 bx lr 677 678 679 /* ------------------------------ */ 680 .balign 4 681 .global dvmCompiler_TEMPLATE_ADD_DOUBLE_VFP 682 dvmCompiler_TEMPLATE_ADD_DOUBLE_VFP: 683 /* File: armv5te-vfp/TEMPLATE_ADD_DOUBLE_VFP.S */ 684 /* File: armv5te-vfp/fbinopWide.S */ 685 /* 686 * Generic 64-bit floating point operation. Provide an "instr" line that 687 * specifies an instruction that performs s2 = s0 op s1. 688 * 689 * On entry: 690 * r0 = target dalvik register address 691 * r1 = op1 address 692 * r2 = op2 address 693 */ 694 fldd d0,[r1] 695 fldd d1,[r2] 696 faddd d2, d0, d1 697 fstd d2,[r0] 698 bx lr 699 700 701 /* ------------------------------ */ 702 .balign 4 703 .global dvmCompiler_TEMPLATE_SUB_DOUBLE_VFP 704 dvmCompiler_TEMPLATE_SUB_DOUBLE_VFP: 705 /* File: armv5te-vfp/TEMPLATE_SUB_DOUBLE_VFP.S */ 706 /* File: armv5te-vfp/fbinopWide.S */ 707 /* 708 * Generic 64-bit floating point operation. Provide an "instr" line that 709 * specifies an instruction that performs s2 = s0 op s1. 710 * 711 * On entry: 712 * r0 = target dalvik register address 713 * r1 = op1 address 714 * r2 = op2 address 715 */ 716 fldd d0,[r1] 717 fldd d1,[r2] 718 fsubd d2, d0, d1 719 fstd d2,[r0] 720 bx lr 721 722 723 /* ------------------------------ */ 724 .balign 4 725 .global dvmCompiler_TEMPLATE_MUL_DOUBLE_VFP 726 dvmCompiler_TEMPLATE_MUL_DOUBLE_VFP: 727 /* File: armv5te-vfp/TEMPLATE_MUL_DOUBLE_VFP.S */ 728 /* File: armv5te-vfp/fbinopWide.S */ 729 /* 730 * Generic 64-bit floating point operation. Provide an "instr" line that 731 * specifies an instruction that performs s2 = s0 op s1. 732 * 733 * On entry: 734 * r0 = target dalvik register address 735 * r1 = op1 address 736 * r2 = op2 address 737 */ 738 fldd d0,[r1] 739 fldd d1,[r2] 740 fmuld d2, d0, d1 741 fstd d2,[r0] 742 bx lr 743 744 745 /* ------------------------------ */ 746 .balign 4 747 .global dvmCompiler_TEMPLATE_DIV_DOUBLE_VFP 748 dvmCompiler_TEMPLATE_DIV_DOUBLE_VFP: 749 /* File: armv5te-vfp/TEMPLATE_DIV_DOUBLE_VFP.S */ 750 /* File: armv5te-vfp/fbinopWide.S */ 751 /* 752 * Generic 64-bit floating point operation. Provide an "instr" line that 753 * specifies an instruction that performs s2 = s0 op s1. 754 * 755 * On entry: 756 * r0 = target dalvik register address 757 * r1 = op1 address 758 * r2 = op2 address 759 */ 760 fldd d0,[r1] 761 fldd d1,[r2] 762 fdivd d2, d0, d1 763 fstd d2,[r0] 764 bx lr 765 766 767 /* ------------------------------ */ 768 .balign 4 769 .global dvmCompiler_TEMPLATE_DOUBLE_TO_FLOAT_VFP 770 dvmCompiler_TEMPLATE_DOUBLE_TO_FLOAT_VFP: 771 /* File: armv5te-vfp/TEMPLATE_DOUBLE_TO_FLOAT_VFP.S */ 772 /* File: armv5te-vfp/funopNarrower.S */ 773 /* 774 * Generic 64bit-to-32bit floating point unary operation. Provide an 775 * "instr" line that specifies an instruction that performs "s0 = op d0". 776 * 777 * For: double-to-int, double-to-float 778 * 779 * On entry: 780 * r0 = target dalvik register address 781 * r1 = src dalvik register address 782 */ 783 /* unop vA, vB */ 784 fldd d0, [r1] @ d0<- vB 785 fcvtsd s0, d0 @ s0<- op d0 786 fsts s0, [r0] @ vA<- s0 787 bx lr 788 789 790 /* ------------------------------ */ 791 .balign 4 792 .global dvmCompiler_TEMPLATE_DOUBLE_TO_INT_VFP 793 dvmCompiler_TEMPLATE_DOUBLE_TO_INT_VFP: 794 /* File: armv5te-vfp/TEMPLATE_DOUBLE_TO_INT_VFP.S */ 795 /* File: armv5te-vfp/funopNarrower.S */ 796 /* 797 * Generic 64bit-to-32bit floating point unary operation. Provide an 798 * "instr" line that specifies an instruction that performs "s0 = op d0". 799 * 800 * For: double-to-int, double-to-float 801 * 802 * On entry: 803 * r0 = target dalvik register address 804 * r1 = src dalvik register address 805 */ 806 /* unop vA, vB */ 807 fldd d0, [r1] @ d0<- vB 808 ftosizd s0, d0 @ s0<- op d0 809 fsts s0, [r0] @ vA<- s0 810 bx lr 811 812 813 /* ------------------------------ */ 814 .balign 4 815 .global dvmCompiler_TEMPLATE_FLOAT_TO_DOUBLE_VFP 816 dvmCompiler_TEMPLATE_FLOAT_TO_DOUBLE_VFP: 817 /* File: armv5te-vfp/TEMPLATE_FLOAT_TO_DOUBLE_VFP.S */ 818 /* File: armv5te-vfp/funopWider.S */ 819 /* 820 * Generic 32bit-to-64bit floating point unary operation. Provide an 821 * "instr" line that specifies an instruction that performs "d0 = op s0". 822 * 823 * For: int-to-double, float-to-double 824 * 825 * On entry: 826 * r0 = target dalvik register address 827 * r1 = src dalvik register address 828 */ 829 /* unop vA, vB */ 830 flds s0, [r1] @ s0<- vB 831 fcvtds d0, s0 @ d0<- op s0 832 fstd d0, [r0] @ vA<- d0 833 bx lr 834 835 836 /* ------------------------------ */ 837 .balign 4 838 .global dvmCompiler_TEMPLATE_FLOAT_TO_INT_VFP 839 dvmCompiler_TEMPLATE_FLOAT_TO_INT_VFP: 840 /* File: armv5te-vfp/TEMPLATE_FLOAT_TO_INT_VFP.S */ 841 /* File: armv5te-vfp/funop.S */ 842 /* 843 * Generic 32bit-to-32bit floating point unary operation. Provide an 844 * "instr" line that specifies an instruction that performs "s1 = op s0". 845 * 846 * For: float-to-int, int-to-float 847 * 848 * On entry: 849 * r0 = target dalvik register address 850 * r1 = src dalvik register address 851 */ 852 /* unop vA, vB */ 853 flds s0, [r1] @ s0<- vB 854 ftosizs s1, s0 @ s1<- op s0 855 fsts s1, [r0] @ vA<- s1 856 bx lr 857 858 859 /* ------------------------------ */ 860 .balign 4 861 .global dvmCompiler_TEMPLATE_INT_TO_DOUBLE_VFP 862 dvmCompiler_TEMPLATE_INT_TO_DOUBLE_VFP: 863 /* File: armv5te-vfp/TEMPLATE_INT_TO_DOUBLE_VFP.S */ 864 /* File: armv5te-vfp/funopWider.S */ 865 /* 866 * Generic 32bit-to-64bit floating point unary operation. Provide an 867 * "instr" line that specifies an instruction that performs "d0 = op s0". 868 * 869 * For: int-to-double, float-to-double 870 * 871 * On entry: 872 * r0 = target dalvik register address 873 * r1 = src dalvik register address 874 */ 875 /* unop vA, vB */ 876 flds s0, [r1] @ s0<- vB 877 fsitod d0, s0 @ d0<- op s0 878 fstd d0, [r0] @ vA<- d0 879 bx lr 880 881 882 /* ------------------------------ */ 883 .balign 4 884 .global dvmCompiler_TEMPLATE_INT_TO_FLOAT_VFP 885 dvmCompiler_TEMPLATE_INT_TO_FLOAT_VFP: 886 /* File: armv5te-vfp/TEMPLATE_INT_TO_FLOAT_VFP.S */ 887 /* File: armv5te-vfp/funop.S */ 888 /* 889 * Generic 32bit-to-32bit floating point unary operation. Provide an 890 * "instr" line that specifies an instruction that performs "s1 = op s0". 891 * 892 * For: float-to-int, int-to-float 893 * 894 * On entry: 895 * r0 = target dalvik register address 896 * r1 = src dalvik register address 897 */ 898 /* unop vA, vB */ 899 flds s0, [r1] @ s0<- vB 900 fsitos s1, s0 @ s1<- op s0 901 fsts s1, [r0] @ vA<- s1 902 bx lr 903 904 905 /* ------------------------------ */ 906 .balign 4 907 .global dvmCompiler_TEMPLATE_CMPG_DOUBLE_VFP 908 dvmCompiler_TEMPLATE_CMPG_DOUBLE_VFP: 909 /* File: armv5te-vfp/TEMPLATE_CMPG_DOUBLE_VFP.S */ 910 /* 911 * Compare two floating-point values. Puts 0, 1, or -1 into the 912 * destination register based on the results of the comparison. 913 * 914 * int compare(x, y) { 915 * if (x == y) { 916 * return 0; 917 * } else if (x < y) { 918 * return -1; 919 * } else if (x > y) { 920 * return 1; 921 * } else { 922 * return 1; 923 * } 924 * } 925 * 926 * On entry: 927 * r0 = &op1 [vBB] 928 * r1 = &op2 [vCC] 929 */ 930 /* op vAA, vBB, vCC */ 931 fldd d0, [r0] @ d0<- vBB 932 fldd d1, [r1] @ d1<- vCC 933 fcmpd d0, d1 @ compare (vBB, vCC) 934 mov r0, #1 @ r0<- 1 (default) 935 fmstat @ export status flags 936 mvnmi r0, #0 @ (less than) r0<- -1 937 moveq r0, #0 @ (equal) r0<- 0 938 bx lr 939 940 /* ------------------------------ */ 941 .balign 4 942 .global dvmCompiler_TEMPLATE_CMPL_DOUBLE_VFP 943 dvmCompiler_TEMPLATE_CMPL_DOUBLE_VFP: 944 /* File: armv5te-vfp/TEMPLATE_CMPL_DOUBLE_VFP.S */ 945 /* 946 * Compare two floating-point values. Puts 0, 1, or -1 into the 947 * destination register based on the results of the comparison. 948 * 949 * int compare(x, y) { 950 * if (x == y) { 951 * return 0; 952 * } else if (x > y) { 953 * return 1; 954 * } else if (x < y) { 955 * return -1; 956 * } else { 957 * return -1; 958 * } 959 * } 960 * On entry: 961 * r0 = &op1 [vBB] 962 * r1 = &op2 [vCC] 963 */ 964 /* op vAA, vBB, vCC */ 965 fldd d0, [r0] @ d0<- vBB 966 fldd d1, [r1] @ d1<- vCC 967 fcmped d0, d1 @ compare (vBB, vCC) 968 mvn r0, #0 @ r0<- -1 (default) 969 fmstat @ export status flags 970 movgt r0, #1 @ (greater than) r0<- 1 971 moveq r0, #0 @ (equal) r0<- 0 972 bx lr 973 974 /* ------------------------------ */ 975 .balign 4 976 .global dvmCompiler_TEMPLATE_CMPG_FLOAT_VFP 977 dvmCompiler_TEMPLATE_CMPG_FLOAT_VFP: 978 /* File: armv5te-vfp/TEMPLATE_CMPG_FLOAT_VFP.S */ 979 /* 980 * Compare two floating-point values. Puts 0, 1, or -1 into the 981 * destination register based on the results of the comparison. 982 * 983 * int compare(x, y) { 984 * if (x == y) { 985 * return 0; 986 * } else if (x < y) { 987 * return -1; 988 * } else if (x > y) { 989 * return 1; 990 * } else { 991 * return 1; 992 * } 993 * } 994 * On entry: 995 * r0 = &op1 [vBB] 996 * r1 = &op2 [vCC] 997 */ 998 /* op vAA, vBB, vCC */ 999 flds s0, [r0] @ d0<- vBB 1000 flds s1, [r1] @ d1<- vCC 1001 fcmps s0, s1 @ compare (vBB, vCC) 1002 mov r0, #1 @ r0<- 1 (default) 1003 fmstat @ export status flags 1004 mvnmi r0, #0 @ (less than) r0<- -1 1005 moveq r0, #0 @ (equal) r0<- 0 1006 bx lr 1007 1008 /* ------------------------------ */ 1009 .balign 4 1010 .global dvmCompiler_TEMPLATE_CMPL_FLOAT_VFP 1011 dvmCompiler_TEMPLATE_CMPL_FLOAT_VFP: 1012 /* File: armv5te-vfp/TEMPLATE_CMPL_FLOAT_VFP.S */ 1013 /* 1014 * Compare two floating-point values. Puts 0, 1, or -1 into the 1015 * destination register based on the results of the comparison. 1016 * 1017 * int compare(x, y) { 1018 * if (x == y) { 1019 * return 0; 1020 * } else if (x > y) { 1021 * return 1; 1022 * } else if (x < y) { 1023 * return -1; 1024 * } else { 1025 * return -1; 1026 * } 1027 * } 1028 * On entry: 1029 * r0 = &op1 [vBB] 1030 * r1 = &op2 [vCC] 1031 */ 1032 /* op vAA, vBB, vCC */ 1033 flds s0, [r0] @ d0<- vBB 1034 flds s1, [r1] @ d1<- vCC 1035 fcmps s0, s1 @ compare (vBB, vCC) 1036 mvn r0, #0 @ r0<- -1 (default) 1037 fmstat @ export status flags 1038 movgt r0, #1 @ (greater than) r0<- 1 1039 moveq r0, #0 @ (equal) r0<- 0 1040 bx lr 1041 1042 /* ------------------------------ */ 1043 .balign 4 1044 .global dvmCompiler_TEMPLATE_SQRT_DOUBLE_VFP 1045 dvmCompiler_TEMPLATE_SQRT_DOUBLE_VFP: 1046 /* File: armv5te-vfp/TEMPLATE_SQRT_DOUBLE_VFP.S */ 1047 /* 1048 * 64-bit floating point vfp sqrt operation. 1049 * If the result is a NaN, bail out to library code to do 1050 * the right thing. 1051 * 1052 * On entry: 1053 * r2 src addr of op1 1054 * On exit: 1055 * r0,r1 = res 1056 */ 1057 fldd d0, [r2] 1058 fsqrtd d1, d0 1059 fcmpd d1, d1 1060 fmstat 1061 fmrrd r0, r1, d1 1062 bxeq lr @ Result OK - return 1063 ldr r2, .Lsqrt 1064 fmrrd r0, r1, d0 @ reload orig operand 1065 bx r2 @ tail call to sqrt library routine 1066 1067 .Lsqrt: 1068 .word sqrt 1069 1070 /* ------------------------------ */ 1071 .balign 4 1072 .global dvmCompiler_TEMPLATE_THROW_EXCEPTION_COMMON 1073 dvmCompiler_TEMPLATE_THROW_EXCEPTION_COMMON: 1074 /* File: armv5te/TEMPLATE_THROW_EXCEPTION_COMMON.S */ 1075 /* 1076 * Throw an exception from JIT'ed code. 1077 * On entry: 1078 * r0 Dalvik PC that raises the exception 1079 */ 1080 b .LhandleException 1081 1082 /* ------------------------------ */ 1083 .balign 4 1084 .global dvmCompiler_TEMPLATE_MEM_OP_DECODE 1085 dvmCompiler_TEMPLATE_MEM_OP_DECODE: 1086 /* File: armv5te-vfp/TEMPLATE_MEM_OP_DECODE.S */ 1087 #if defined(WITH_SELF_VERIFICATION) 1088 /* 1089 * This handler encapsulates heap memory ops for selfVerification mode. 1090 * 1091 * The call to the handler is inserted prior to a heap memory operation. 1092 * This handler then calls a function to decode the memory op, and process 1093 * it accordingly. Afterwards, the handler changes the return address to 1094 * skip the memory op so it never gets executed. 1095 */ 1096 vpush {d0-d15} @ save out all fp registers 1097 push {r0-r12,lr} @ save out all registers 1098 ldr r2, .LdvmSelfVerificationMemOpDecode @ defined in footer.S 1099 mov r0, lr @ arg0 <- link register 1100 mov r1, sp @ arg1 <- stack pointer 1101 blx r2 @ decode and handle the mem op 1102 pop {r0-r12,lr} @ restore all registers 1103 vpop {d0-d15} @ restore all fp registers 1104 bx lr @ return to compiled code 1105 #endif 1106 1107 /* ------------------------------ */ 1108 .balign 4 1109 .global dvmCompiler_TEMPLATE_STRING_COMPARETO 1110 dvmCompiler_TEMPLATE_STRING_COMPARETO: 1111 /* File: armv5te/TEMPLATE_STRING_COMPARETO.S */ 1112 /* 1113 * String's compareTo. 1114 * 1115 * Requires r0/r1 to have been previously checked for null. Will 1116 * return negative if this's string is < comp, 0 if they are the 1117 * same and positive if >. 1118 * 1119 * IMPORTANT NOTE: 1120 * 1121 * This code relies on hard-coded offsets for string objects, and must be 1122 * kept in sync with definitions in UtfString.h. See asm-constants.h 1123 * 1124 * On entry: 1125 * r0: this object pointer 1126 * r1: comp object pointer 1127 * 1128 */ 1129 1130 mov r2, r0 @ this to r2, opening up r0 for return value 1131 subs r0, r2, r1 @ Same? 1132 bxeq lr 1133 1134 ldr r4, [r2, #STRING_FIELDOFF_OFFSET] 1135 ldr r9, [r1, #STRING_FIELDOFF_OFFSET] 1136 ldr r7, [r2, #STRING_FIELDOFF_COUNT] 1137 ldr r10, [r1, #STRING_FIELDOFF_COUNT] 1138 ldr r2, [r2, #STRING_FIELDOFF_VALUE] 1139 ldr r1, [r1, #STRING_FIELDOFF_VALUE] 1140 1141 /* 1142 * At this point, we have: 1143 * value: r2/r1 1144 * offset: r4/r9 1145 * count: r7/r10 1146 * We're going to compute 1147 * r11 <- countDiff 1148 * r10 <- minCount 1149 */ 1150 subs r11, r7, r10 1151 movls r10, r7 1152 1153 /* Now, build pointers to the string data */ 1154 add r2, r2, r4, lsl #1 1155 add r1, r1, r9, lsl #1 1156 /* 1157 * Note: data pointers point to previous element so we can use pre-index 1158 * mode with base writeback. 1159 */ 1160 add r2, #16-2 @ offset to contents[-1] 1161 add r1, #16-2 @ offset to contents[-1] 1162 1163 /* 1164 * At this point we have: 1165 * r2: *this string data 1166 * r1: *comp string data 1167 * r10: iteration count for comparison 1168 * r11: value to return if the first part of the string is equal 1169 * r0: reserved for result 1170 * r3, r4, r7, r8, r9, r12 available for loading string data 1171 */ 1172 1173 subs r10, #2 1174 blt do_remainder2 1175 1176 /* 1177 * Unroll the first two checks so we can quickly catch early mismatch 1178 * on long strings (but preserve incoming alignment) 1179 */ 1180 1181 ldrh r3, [r2, #2]! 1182 ldrh r4, [r1, #2]! 1183 ldrh r7, [r2, #2]! 1184 ldrh r8, [r1, #2]! 1185 subs r0, r3, r4 1186 subeqs r0, r7, r8 1187 bxne lr 1188 cmp r10, #28 1189 bgt do_memcmp16 1190 subs r10, #3 1191 blt do_remainder 1192 1193 loopback_triple: 1194 ldrh r3, [r2, #2]! 1195 ldrh r4, [r1, #2]! 1196 ldrh r7, [r2, #2]! 1197 ldrh r8, [r1, #2]! 1198 ldrh r9, [r2, #2]! 1199 ldrh r12,[r1, #2]! 1200 subs r0, r3, r4 1201 subeqs r0, r7, r8 1202 subeqs r0, r9, r12 1203 bxne lr 1204 subs r10, #3 1205 bge loopback_triple 1206 1207 do_remainder: 1208 adds r10, #3 1209 beq returnDiff 1210 1211 loopback_single: 1212 ldrh r3, [r2, #2]! 1213 ldrh r4, [r1, #2]! 1214 subs r0, r3, r4 1215 bxne lr 1216 subs r10, #1 1217 bne loopback_single 1218 1219 returnDiff: 1220 mov r0, r11 1221 bx lr 1222 1223 do_remainder2: 1224 adds r10, #2 1225 bne loopback_single 1226 mov r0, r11 1227 bx lr 1228 1229 /* Long string case */ 1230 do_memcmp16: 1231 mov r4, lr 1232 ldr lr, .Lmemcmp16 1233 mov r7, r11 1234 add r0, r2, #2 1235 add r1, r1, #2 1236 mov r2, r10 1237 blx lr 1238 cmp r0, #0 1239 bxne r4 1240 mov r0, r7 1241 bx r4 1242 1243 .Lmemcmp16: 1244 .word __memcmp16 1245 1246 /* ------------------------------ */ 1247 .balign 4 1248 .global dvmCompiler_TEMPLATE_STRING_INDEXOF 1249 dvmCompiler_TEMPLATE_STRING_INDEXOF: 1250 /* File: armv5te/TEMPLATE_STRING_INDEXOF.S */ 1251 /* 1252 * String's indexOf. 1253 * 1254 * Requires r0 to have been previously checked for null. Will 1255 * return index of match of r1 in r0. 1256 * 1257 * IMPORTANT NOTE: 1258 * 1259 * This code relies on hard-coded offsets for string objects, and must be 1260 * kept in sync wth definitions in UtfString.h See asm-constants.h 1261 * 1262 * On entry: 1263 * r0: string object pointer 1264 * r1: char to match 1265 * r2: Starting offset in string data 1266 */ 1267 1268 ldr r7, [r0, #STRING_FIELDOFF_OFFSET] 1269 ldr r8, [r0, #STRING_FIELDOFF_COUNT] 1270 ldr r0, [r0, #STRING_FIELDOFF_VALUE] 1271 1272 /* 1273 * At this point, we have: 1274 * r0: object pointer 1275 * r1: char to match 1276 * r2: starting offset 1277 * r7: offset 1278 * r8: string length 1279 */ 1280 1281 /* Build pointer to start of string data */ 1282 add r0, #16 1283 add r0, r0, r7, lsl #1 1284 1285 /* Save a copy of starting data in r7 */ 1286 mov r7, r0 1287 1288 /* Clamp start to [0..count] */ 1289 cmp r2, #0 1290 movlt r2, #0 1291 cmp r2, r8 1292 movgt r2, r8 1293 1294 /* Build pointer to start of data to compare and pre-bias */ 1295 add r0, r0, r2, lsl #1 1296 sub r0, #2 1297 1298 /* Compute iteration count */ 1299 sub r8, r2 1300 1301 /* 1302 * At this point we have: 1303 * r0: start of data to test 1304 * r1: chat to compare 1305 * r8: iteration count 1306 * r7: original start of string 1307 * r3, r4, r9, r10, r11, r12 available for loading string data 1308 */ 1309 1310 subs r8, #4 1311 blt indexof_remainder 1312 1313 indexof_loop4: 1314 ldrh r3, [r0, #2]! 1315 ldrh r4, [r0, #2]! 1316 ldrh r10, [r0, #2]! 1317 ldrh r11, [r0, #2]! 1318 cmp r3, r1 1319 beq match_0 1320 cmp r4, r1 1321 beq match_1 1322 cmp r10, r1 1323 beq match_2 1324 cmp r11, r1 1325 beq match_3 1326 subs r8, #4 1327 bge indexof_loop4 1328 1329 indexof_remainder: 1330 adds r8, #4 1331 beq indexof_nomatch 1332 1333 indexof_loop1: 1334 ldrh r3, [r0, #2]! 1335 cmp r3, r1 1336 beq match_3 1337 subs r8, #1 1338 bne indexof_loop1 1339 1340 indexof_nomatch: 1341 mov r0, #-1 1342 bx lr 1343 1344 match_0: 1345 sub r0, #6 1346 sub r0, r7 1347 asr r0, r0, #1 1348 bx lr 1349 match_1: 1350 sub r0, #4 1351 sub r0, r7 1352 asr r0, r0, #1 1353 bx lr 1354 match_2: 1355 sub r0, #2 1356 sub r0, r7 1357 asr r0, r0, #1 1358 bx lr 1359 match_3: 1360 sub r0, r7 1361 asr r0, r0, #1 1362 bx lr 1363 1364 /* ------------------------------ */ 1365 .balign 4 1366 .global dvmCompiler_TEMPLATE_INTERPRET 1367 dvmCompiler_TEMPLATE_INTERPRET: 1368 /* File: armv5te/TEMPLATE_INTERPRET.S */ 1369 /* 1370 * This handler transfers control to the interpeter without performing 1371 * any lookups. It may be called either as part of a normal chaining 1372 * operation, or from the transition code in header.S. We distinquish 1373 * the two cases by looking at the link register. If called from a 1374 * translation chain, it will point to the chaining Dalvik PC -3. 1375 * On entry: 1376 * lr - if NULL: 1377 * r1 - the Dalvik PC to begin interpretation. 1378 * else 1379 * [lr, #3] contains Dalvik PC to begin interpretation 1380 * rSELF - pointer to thread 1381 * rFP - Dalvik frame pointer 1382 */ 1383 cmp lr, #0 1384 #if defined(WORKAROUND_CORTEX_A9_745320) 1385 /* Don't use conditional loads if the HW defect exists */ 1386 beq 101f 1387 ldr r1,[lr, #3] 1388 101: 1389 #else 1390 ldrne r1,[lr, #3] 1391 #endif 1392 ldr r2, .LinterpPunt 1393 mov r0, r1 @ set Dalvik PC 1394 bx r2 1395 @ doesn't return 1396 1397 .LinterpPunt: 1398 .word dvmJitToInterpPunt 1399 1400 /* ------------------------------ */ 1401 .balign 4 1402 .global dvmCompiler_TEMPLATE_MONITOR_ENTER 1403 dvmCompiler_TEMPLATE_MONITOR_ENTER: 1404 /* File: armv5te/TEMPLATE_MONITOR_ENTER.S */ 1405 /* 1406 * Call out to the runtime to lock an object. Because this thread 1407 * may have been suspended in THREAD_MONITOR state and the Jit's 1408 * translation cache subsequently cleared, we cannot return directly. 1409 * Instead, unconditionally transition to the interpreter to resume. 1410 * 1411 * On entry: 1412 * r0 - self pointer 1413 * r1 - the object (which has already been null-checked by the caller 1414 * r4 - the Dalvik PC of the following instruction. 1415 */ 1416 ldr r2, .LdvmLockObject 1417 mov r3, #0 @ Record that we're not returning 1418 str r3, [r0, #offThread_inJitCodeCache] 1419 blx r2 @ dvmLockObject(self, obj) 1420 ldr r2, .LdvmJitToInterpNoChain 1421 @ Bail to interpreter - no chain [note - r4 still contains rPC] 1422 #if defined(WITH_JIT_TUNING) 1423 mov r0, #kHeavyweightMonitor 1424 #endif 1425 bx r2 1426 1427 /* ------------------------------ */ 1428 .balign 4 1429 .global dvmCompiler_TEMPLATE_MONITOR_ENTER_DEBUG 1430 dvmCompiler_TEMPLATE_MONITOR_ENTER_DEBUG: 1431 /* File: armv5te/TEMPLATE_MONITOR_ENTER_DEBUG.S */ 1432 /* 1433 * To support deadlock prediction, this version of MONITOR_ENTER 1434 * will always call the heavyweight dvmLockObject, check for an 1435 * exception and then bail out to the interpreter. 1436 * 1437 * On entry: 1438 * r0 - self pointer 1439 * r1 - the object (which has already been null-checked by the caller 1440 * r4 - the Dalvik PC of the following instruction. 1441 * 1442 */ 1443 ldr r2, .LdvmLockObject 1444 mov r3, #0 @ Record that we're not returning 1445 str r3, [r0, #offThread_inJitCodeCache] 1446 blx r2 @ dvmLockObject(self, obj) 1447 @ test for exception 1448 ldr r1, [rSELF, #offThread_exception] 1449 cmp r1, #0 1450 beq 1f 1451 ldr r2, .LhandleException 1452 sub r0, r4, #2 @ roll dPC back to this monitor instruction 1453 bx r2 1454 1: 1455 @ Bail to interpreter - no chain [note - r4 still contains rPC] 1456 #if defined(WITH_JIT_TUNING) 1457 mov r0, #kHeavyweightMonitor 1458 #endif 1459 ldr pc, .LdvmJitToInterpNoChain 1460 1461 /* ------------------------------ */ 1462 .balign 4 1463 .global dvmCompiler_TEMPLATE_PERIODIC_PROFILING 1464 dvmCompiler_TEMPLATE_PERIODIC_PROFILING: 1465 /* File: armv5te/TEMPLATE_PERIODIC_PROFILING.S */ 1466 /* 1467 * Increment profile counter for this trace, and decrement 1468 * sample counter. If sample counter goes below zero, turn 1469 * off profiling. 1470 * 1471 * On entry 1472 * (lr-11) is address of pointer to counter. Note: the counter 1473 * actually exists 10 bytes before the return target, but because 1474 * we are arriving from thumb mode, lr will have its low bit set. 1475 */ 1476 ldr r0, [lr,#-11] 1477 ldr r1, [rSELF, #offThread_pProfileCountdown] 1478 ldr r2, [r0] @ get counter 1479 ldr r3, [r1] @ get countdown timer 1480 add r2, #1 1481 subs r2, #1 1482 blt .LTEMPLATE_PERIODIC_PROFILING_disable_profiling 1483 str r2, [r0] 1484 str r3, [r1] 1485 bx lr 1486 1487 .LTEMPLATE_PERIODIC_PROFILING_disable_profiling: 1488 mov r4, lr @ preserve lr 1489 ldr r0, .LdvmJitTraceProfilingOff 1490 blx r0 1491 bx r4 1492 1493 /* ------------------------------ */ 1494 .balign 4 1495 .global dvmCompiler_TEMPLATE_RETURN_PROF 1496 dvmCompiler_TEMPLATE_RETURN_PROF: 1497 /* File: armv5te/TEMPLATE_RETURN_PROF.S */ 1498 #define TEMPLATE_INLINE_PROFILING 1499 /* File: armv5te/TEMPLATE_RETURN.S */ 1500 /* 1501 * Unwind a frame from the Dalvik stack for compiled OP_RETURN_XXX. 1502 * If the stored value in returnAddr 1503 * is non-zero, the caller is compiled by the JIT thus return to the 1504 * address in the code cache following the invoke instruction. Otherwise 1505 * return to the special dvmJitToInterpNoChain entry point. 1506 */ 1507 #if defined(TEMPLATE_INLINE_PROFILING) 1508 stmfd sp!, {r0-r2,lr} @ preserve live registers 1509 mov r0, r6 1510 @ r0=rSELF 1511 mov lr, pc 1512 ldr pc, .LdvmFastMethodTraceExit 1513 ldmfd sp!, {r0-r2,lr} @ restore live registers 1514 #endif 1515 SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) 1516 ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame 1517 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 1518 ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc 1519 #if !defined(WITH_SELF_VERIFICATION) 1520 ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret 1521 #else 1522 mov r9, #0 @ disable chaining 1523 #endif 1524 ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] 1525 @ r2<- method we're returning to 1526 cmp r2, #0 @ break frame? 1527 #if !defined(WITH_SELF_VERIFICATION) 1528 beq 1f @ bail to interpreter 1529 #else 1530 blxeq lr @ punt to interpreter and compare state 1531 #endif 1532 ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S 1533 mov rFP, r10 @ publish new FP 1534 ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz 1535 1536 str r2, [rSELF, #offThread_method]@ self->method = newSave->method 1537 ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex 1538 str rFP, [rSELF, #offThread_curFrame] @ curFrame = fp 1539 add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) 1540 str r0, [rSELF, #offThread_methodClassDex] 1541 cmp r8, #0 @ check the break flags 1542 movne r9, #0 @ clear the chaining cell address 1543 str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not 1544 cmp r9, #0 @ chaining cell exists? 1545 blxne r9 @ jump to the chaining cell 1546 #if defined(WITH_JIT_TUNING) 1547 mov r0, #kCallsiteInterpreted 1548 #endif 1549 mov pc, r1 @ callsite is interpreted 1550 1: 1551 mov r0, #0 1552 str r0, [rSELF, #offThread_inJitCodeCache] @ reset inJitCodeCache 1553 stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() 1554 ldr r2, .LdvmMterpStdBail @ defined in footer.S 1555 mov r0, rSELF @ Expecting rSELF in r0 1556 blx r2 @ exit the interpreter 1557 1558 #undef TEMPLATE_INLINE_PROFILING 1559 1560 /* ------------------------------ */ 1561 .balign 4 1562 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF 1563 dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: 1564 /* File: armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT_PROF.S */ 1565 #define TEMPLATE_INLINE_PROFILING 1566 /* File: armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S */ 1567 /* 1568 * For polymorphic callsites - setup the Dalvik frame and load Dalvik PC 1569 * into rPC then jump to dvmJitToInterpNoChain to dispatch the 1570 * runtime-resolved callee. 1571 */ 1572 @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite 1573 ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize 1574 ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize 1575 ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd 1576 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 1577 add r3, r1, #1 @ Thumb addr is odd 1578 SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area 1579 sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) 1580 SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area 1581 sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) 1582 cmp r10, r9 @ bottom < interpStackEnd? 1583 bxlo lr @ return to raise stack overflow excep. 1584 @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite 1585 ldr r9, [r0, #offMethod_clazz] @ r9<- method->clazz 1586 ldr r10, [r0, #offMethod_accessFlags] @ r10<- methodToCall->accessFlags 1587 str rPC, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 1588 str rPC, [r1, #(offStackSaveArea_savedPc - sizeofStackSaveArea)] 1589 ldr rPC, [r0, #offMethod_insns] @ rPC<- methodToCall->insns 1590 1591 1592 @ set up newSaveArea 1593 str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] 1594 str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] 1595 str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] 1596 cmp r8, #0 @ breakFlags != 0 1597 bxne lr @ bail to the interpreter 1598 tst r10, #ACC_NATIVE 1599 #if !defined(WITH_SELF_VERIFICATION) 1600 bne .LinvokeNative 1601 #else 1602 bxne lr @ bail to the interpreter 1603 #endif 1604 1605 ldr r10, .LdvmJitToInterpTraceSelectNoChain 1606 ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex 1607 1608 @ Update "thread" values for the new method 1609 str r0, [rSELF, #offThread_method] @ self->method = methodToCall 1610 str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... 1611 mov rFP, r1 @ fp = newFp 1612 str rFP, [rSELF, #offThread_curFrame] @ curFrame = newFp 1613 #if defined(TEMPLATE_INLINE_PROFILING) 1614 stmfd sp!, {r0-r3} @ preserve r0-r3 1615 mov r1, r6 1616 @ r0=methodToCall, r1=rSELF 1617 mov lr, pc 1618 ldr pc, .LdvmFastMethodTraceEnter 1619 ldmfd sp!, {r0-r3} @ restore r0-r3 1620 #endif 1621 1622 @ Start executing the callee 1623 #if defined(WITH_JIT_TUNING) 1624 mov r0, #kInlineCacheMiss 1625 #endif 1626 mov pc, r10 @ dvmJitToInterpTraceSelectNoChain 1627 1628 #undef TEMPLATE_INLINE_PROFILING 1629 1630 /* ------------------------------ */ 1631 .balign 4 1632 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF 1633 dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: 1634 /* File: armv5te/TEMPLATE_INVOKE_METHOD_CHAIN_PROF.S */ 1635 #define TEMPLATE_INLINE_PROFILING 1636 /* File: armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S */ 1637 /* 1638 * For monomorphic callsite, setup the Dalvik frame and return to the 1639 * Thumb code through the link register to transfer control to the callee 1640 * method through a dedicated chaining cell. 1641 */ 1642 @ r0 = methodToCall, r1 = returnCell, r2 = methodToCall->outsSize 1643 @ rPC = dalvikCallsite, r7 = methodToCall->registersSize 1644 @ methodToCall is guaranteed to be non-native 1645 .LinvokeChainProf: 1646 ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd 1647 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 1648 add r3, r1, #1 @ Thumb addr is odd 1649 SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area 1650 sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) 1651 SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area 1652 add r12, lr, #2 @ setup the punt-to-interp address 1653 sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) 1654 cmp r10, r9 @ bottom < interpStackEnd? 1655 bxlo r12 @ return to raise stack overflow excep. 1656 @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite 1657 ldr r9, [r0, #offMethod_clazz] @ r9<- method->clazz 1658 str rPC, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 1659 str rPC, [r1, #(offStackSaveArea_savedPc - sizeofStackSaveArea)] 1660 1661 @ set up newSaveArea 1662 str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] 1663 str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] 1664 str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] 1665 cmp r8, #0 @ breakFlags != 0 1666 bxne r12 @ bail to the interpreter 1667 1668 ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex 1669 1670 @ Update "thread" values for the new method 1671 str r0, [rSELF, #offThread_method] @ self->method = methodToCall 1672 str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... 1673 mov rFP, r1 @ fp = newFp 1674 str rFP, [rSELF, #offThread_curFrame] @ curFrame = newFp 1675 #if defined(TEMPLATE_INLINE_PROFILING) 1676 stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers 1677 mov r1, r6 1678 @ r0=methodToCall, r1=rSELF 1679 mov lr, pc 1680 ldr pc, .LdvmFastMethodTraceEnter 1681 ldmfd sp!, {r0-r2,lr} @ restore registers 1682 #endif 1683 1684 bx lr @ return to the callee-chaining cell 1685 1686 #undef TEMPLATE_INLINE_PROFILING 1687 1688 /* ------------------------------ */ 1689 .balign 4 1690 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF 1691 dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: 1692 /* File: armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF.S */ 1693 #define TEMPLATE_INLINE_PROFILING 1694 /* File: armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S */ 1695 /* 1696 * For polymorphic callsite, check whether the cached class pointer matches 1697 * the current one. If so setup the Dalvik frame and return to the 1698 * Thumb code through the link register to transfer control to the callee 1699 * method through a dedicated chaining cell. 1700 * 1701 * The predicted chaining cell is declared in ArmLIR.h with the 1702 * following layout: 1703 * 1704 * typedef struct PredictedChainingCell { 1705 * u4 branch; 1706 * const ClassObject *clazz; 1707 * const Method *method; 1708 * u4 counter; 1709 * } PredictedChainingCell; 1710 * 1711 * Upon returning to the callsite: 1712 * - lr : to branch to the chaining cell 1713 * - lr+2: to punt to the interpreter 1714 * - lr+4: to fully resolve the callee and may rechain. 1715 * r3 <- class 1716 * r9 <- counter 1717 */ 1718 @ r0 = this, r1 = returnCell, r2 = predictedChainCell, rPC = dalvikCallsite 1719 ldr r3, [r0, #offObject_clazz] @ r3 <- this->class 1720 ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz 1721 ldr r0, [r2, #8] @ r0 <- predictedChainCell->method 1722 ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount 1723 cmp r3, r8 @ predicted class == actual class? 1724 #if defined(WITH_JIT_TUNING) 1725 ldr r7, .LdvmICHitCount 1726 #if defined(WORKAROUND_CORTEX_A9_745320) 1727 /* Don't use conditional loads if the HW defect exists */ 1728 bne 101f 1729 ldr r10, [r7, #0] 1730 101: 1731 #else 1732 ldreq r10, [r7, #0] 1733 #endif 1734 add r10, r10, #1 1735 streq r10, [r7, #0] 1736 #endif 1737 ldreqh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize 1738 ldreqh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize 1739 beq .LinvokeChainProf @ predicted chain is valid 1740 ldr r7, [r3, #offClassObject_vtable] @ r7 <- this->class->vtable 1741 cmp r8, #0 @ initialized class or not 1742 moveq r1, #0 1743 subne r1, r9, #1 @ count-- 1744 strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread 1745 add lr, lr, #4 @ return to fully-resolve landing pad 1746 /* 1747 * r1 <- count 1748 * r2 <- &predictedChainCell 1749 * r3 <- this->class 1750 * r4 <- dPC 1751 * r7 <- this->class->vtable 1752 */ 1753 bx lr 1754 1755 #undef TEMPLATE_INLINE_PROFILING 1756 1757 /* ------------------------------ */ 1758 .balign 4 1759 .global dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF 1760 dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: 1761 /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE_PROF.S */ 1762 #define TEMPLATE_INLINE_PROFILING 1763 /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ 1764 @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite 1765 @ r7 = methodToCall->registersSize 1766 ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd 1767 ldrb r8, [rSELF, #offThread_breakFlags] @ r8<- breakFlags 1768 add r3, r1, #1 @ Thumb addr is odd 1769 SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area 1770 sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) 1771 SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area 1772 cmp r10, r9 @ bottom < interpStackEnd? 1773 bxlo lr @ return to raise stack overflow excep. 1774 @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite 1775 str rPC, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 1776 str rPC, [r1, #(offStackSaveArea_savedPc - sizeofStackSaveArea)] 1777 1778 @ set up newSaveArea 1779 str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] 1780 str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] 1781 str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] 1782 cmp r8, #0 @ breakFlags != 0 1783 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc 1784 #if !defined(WITH_SELF_VERIFICATION) 1785 bxne lr @ bail to the interpreter 1786 #else 1787 bx lr @ bail to interpreter unconditionally 1788 #endif 1789 1790 @ go ahead and transfer control to the native code 1791 ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... 1792 mov r2, #0 1793 str r1, [rSELF, #offThread_curFrame] @ curFrame = newFp 1794 str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache 1795 str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] 1796 @ newFp->localRefCookie=top 1797 SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area 1798 1799 mov r2, r0 @ arg2<- methodToCall 1800 mov r0, r1 @ arg0<- newFP 1801 add r1, rSELF, #offThread_retval @ arg1<- &retval 1802 mov r3, rSELF @ arg3<- self 1803 #if defined(TEMPLATE_INLINE_PROFILING) 1804 @ r2=methodToCall, r6=rSELF 1805 stmfd sp!, {r2,r6} @ to be consumed after JNI return 1806 stmfd sp!, {r0-r3} @ preserve r0-r3 1807 mov r0, r2 1808 mov r1, r6 1809 @ r0=JNIMethod, r1=rSELF 1810 mov lr, pc 1811 ldr pc, .LdvmFastMethodTraceEnter 1812 ldmfd sp!, {r0-r3} @ restore r0-r3 1813 #endif 1814 1815 blx r8 @ off to the native code 1816 1817 #if defined(TEMPLATE_INLINE_PROFILING) 1818 ldmfd sp!, {r0-r1} @ restore r2 and r6 1819 @ r0=JNIMethod, r1=rSELF 1820 mov lr, pc 1821 ldr pc, .LdvmFastNativeMethodTraceExit 1822 #endif 1823 @ native return; r10=newSaveArea 1824 @ equivalent to dvmPopJniLocals 1825 ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret 1826 ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top 1827 ldr r1, [rSELF, #offThread_exception] @ check for exception 1828 str rFP, [rSELF, #offThread_curFrame] @ curFrame = fp 1829 cmp r1, #0 @ null? 1830 str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top 1831 ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] 1832 1833 @ r0 = dalvikCallsitePC 1834 bne .LhandleException @ no, handle exception 1835 1836 str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly 1837 cmp r2, #0 @ return chaining cell still exists? 1838 bxne r2 @ yes - go ahead 1839 1840 @ continue executing the next instruction through the interpreter 1841 ldr r1, .LdvmJitToInterpTraceSelectNoChain @ defined in footer.S 1842 add rPC, r0, #6 @ reconstruct new rPC (advance 6 bytes) 1843 #if defined(WITH_JIT_TUNING) 1844 mov r0, #kCallsiteInterpreted 1845 #endif 1846 mov pc, r1 1847 1848 #undef TEMPLATE_INLINE_PROFILING 1849 1850 .size dvmCompilerTemplateStart, .-dvmCompilerTemplateStart 1851 /* File: armv5te/footer.S */ 1852 /* 1853 * =========================================================================== 1854 * Common subroutines and data 1855 * =========================================================================== 1856 */ 1857 1858 .text 1859 .align 2 1860 .LinvokeNative: 1861 @ Prep for the native call 1862 @ r1 = newFP, r0 = methodToCall 1863 mov r2, #0 1864 ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... 1865 str r2, [rSELF, #offThread_inJitCodeCache] @ not in jit code cache 1866 str r1, [rSELF, #offThread_curFrame] @ curFrame = newFp 1867 str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] 1868 @ newFp->localRefCookie=top 1869 ldrh lr, [rSELF, #offThread_subMode] 1870 SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area 1871 1872 mov r2, r0 @ r2<- methodToCall 1873 mov r0, r1 @ r0<- newFP 1874 add r1, rSELF, #offThread_retval @ r1<- &retval 1875 mov r3, rSELF @ arg3<- self 1876 ands lr, #kSubModeMethodTrace 1877 beq 121f @ hop if not profiling 1878 @ r2: methodToCall, r6: rSELF 1879 stmfd sp!, {r2,r6} 1880 stmfd sp!, {r0-r3} 1881 mov r0, r2 1882 mov r1, r6 1883 mov lr, pc 1884 ldr pc, .LdvmFastMethodTraceEnter 1885 ldmfd sp!, {r0-r3} 1886 1887 mov lr, pc 1888 ldr pc, [r2, #offMethod_nativeFunc] 1889 1890 ldmfd sp!, {r0-r1} 1891 mov lr, pc 1892 ldr pc, .LdvmFastNativeMethodTraceExit 1893 b 212f 1894 121: 1895 mov lr, pc 1896 ldr pc, [r2, #offMethod_nativeFunc] 1897 212: 1898 1899 @ native return; r10=newSaveArea 1900 @ equivalent to dvmPopJniLocals 1901 ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret 1902 ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top 1903 ldr r1, [rSELF, #offThread_exception] @ check for exception 1904 str rFP, [rSELF, #offThread_curFrame] @ curFrame = fp 1905 cmp r1, #0 @ null? 1906 str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top 1907 ldr r0, [r10, #offStackSaveArea_savedPc] @ reload rPC 1908 1909 @ r0 = dalvikCallsitePC 1910 bne .LhandleException @ no, handle exception 1911 1912 str r2, [rSELF, #offThread_inJitCodeCache] @ set the new mode 1913 cmp r2, #0 @ return chaining cell still exists? 1914 bxne r2 @ yes - go ahead 1915 1916 @ continue executing the next instruction through the interpreter 1917 ldr r1, .LdvmJitToInterpTraceSelectNoChain @ defined in footer.S 1918 add rPC, r0, #6 @ reconstruct new rPC (advance 6 bytes) 1919 #if defined(WITH_JIT_TUNING) 1920 mov r0, #kCallsiteInterpreted 1921 #endif 1922 mov pc, r1 1923 1924 /* 1925 * On entry: 1926 * r0 Faulting Dalvik PC 1927 */ 1928 .LhandleException: 1929 #if defined(WITH_SELF_VERIFICATION) 1930 ldr pc, .LdeadFood @ should not see this under self-verification mode 1931 .LdeadFood: 1932 .word 0xdeadf00d 1933 #endif 1934 mov r2, #0 1935 str r2, [rSELF, #offThread_inJitCodeCache] @ in interpreter land 1936 ldr r1, .LdvmMterpCommonExceptionThrown @ PIC way of getting &func 1937 ldr rIBASE, .LdvmAsmInstructionStart @ same as above 1938 mov rPC, r0 @ reload the faulting Dalvik address 1939 mov pc, r1 @ branch to dvmMterpCommonExceptionThrown 1940 1941 .align 2 1942 .LdvmAsmInstructionStart: 1943 .word dvmAsmInstructionStart 1944 .LdvmJitToInterpNoChainNoProfile: 1945 .word dvmJitToInterpNoChainNoProfile 1946 .LdvmJitToInterpTraceSelectNoChain: 1947 .word dvmJitToInterpTraceSelectNoChain 1948 .LdvmJitToInterpNoChain: 1949 .word dvmJitToInterpNoChain 1950 .LdvmMterpStdBail: 1951 .word dvmMterpStdBail 1952 .LdvmMterpCommonExceptionThrown: 1953 .word dvmMterpCommonExceptionThrown 1954 .LdvmLockObject: 1955 .word dvmLockObject 1956 .LdvmJitTraceProfilingOff: 1957 .word dvmJitTraceProfilingOff 1958 #if defined(WITH_JIT_TUNING) 1959 .LdvmICHitCount: 1960 .word gDvmICHitCount 1961 #endif 1962 #if defined(WITH_SELF_VERIFICATION) 1963 .LdvmSelfVerificationMemOpDecode: 1964 .word dvmSelfVerificationMemOpDecode 1965 #endif 1966 .LdvmFastMethodTraceEnter: 1967 .word dvmFastMethodTraceEnter 1968 .LdvmFastNativeMethodTraceExit: 1969 .word dvmFastNativeMethodTraceExit 1970 .LdvmFastMethodTraceExit: 1971 .word dvmFastMethodTraceExit 1972 .L__aeabi_cdcmple: 1973 .word __aeabi_cdcmple 1974 .L__aeabi_cfcmple: 1975 .word __aeabi_cfcmple 1976 1977 .global dmvCompilerTemplateEnd 1978 dmvCompilerTemplateEnd: 1979 1980 #endif /* WITH_JIT */ 1981 1982
