diff options
| author | Elliott Hughes <enh@google.com> | 2012-07-17 15:11:25 -0700 |
|---|---|---|
| committer | Elliott Hughes <enh@google.com> | 2012-07-17 15:11:25 -0700 |
| commit | ba1195e1f17456a9a0acab6e122b49f65134fc1f (patch) | |
| tree | 711303d3452ceb2c94e6662ba83ea1e1e0749afc /vm/mterp | |
| parent | ad8bebe4a097a3fdcb4d858dbedf49a1904acfee (diff) | |
| download | android_dalvik-ba1195e1f17456a9a0acab6e122b49f65134fc1f.tar.gz android_dalvik-ba1195e1f17456a9a0acab6e122b49f65134fc1f.tar.bz2 android_dalvik-ba1195e1f17456a9a0acab6e122b49f65134fc1f.zip | |
Remove some dead code in the MIPS stuff, and run rebuild.sh.
Change-Id: I7c3226efe97e6e5678b757eb2350d0eeb2efd8b5
Diffstat (limited to 'vm/mterp')
| -rw-r--r-- | vm/mterp/config-mips | 3 | ||||
| -rw-r--r-- | vm/mterp/out/InterpAsm-mips.S | 11343 | ||||
| -rw-r--r-- | vm/mterp/out/InterpC-mips.cpp | 385 |
3 files changed, 110 insertions, 11621 deletions
diff --git a/vm/mterp/config-mips b/vm/mterp/config-mips index 8c5085887..0dc80e89b 100644 --- a/vm/mterp/config-mips +++ b/vm/mterp/config-mips @@ -50,9 +50,6 @@ op-start mips # OP_BREAKPOINT needs explicit testing op OP_BREAKPOINT c -# OP_DISPATCH_FF needs explicit testing - op OP_DISPATCH_FF c - op-end # "helper" code for C; include if you use any of the C stubs (this generates diff --git a/vm/mterp/out/InterpAsm-mips.S b/vm/mterp/out/InterpAsm-mips.S index 734ae9115..98837fdc1 100644 --- a/vm/mterp/out/InterpAsm-mips.S +++ b/vm/mterp/out/InterpAsm-mips.S @@ -9191,3725 +9191,13 @@ dalvik_inst: /* ------------------------------ */ .balign 128 -.L_OP_DISPATCH_FF: /* 0xff */ - /* (stub) */ - SAVE_PC_TO_SELF() # only need to export PC and FP - SAVE_FP_TO_SELF() - move a0, rSELF # self is first arg to function - JAL(dvmMterp_OP_DISPATCH_FF) # call - LOAD_PC_FROM_SELF() # retrieve updated values - LOAD_FP_FROM_SELF() - FETCH_INST() # load next instruction from rPC - GET_INST_OPCODE(t0) # ...trim down to just the opcode - GOTO_OPCODE(t0) # ...and jump to the handler -/* ------------------------------ */ - .balign 128 -.L_OP_CONST_CLASS_JUMBO: /* 0x100 */ -/* File: mips/OP_CONST_CLASS_JUMBO.S */ - /* const-class/jumbo vBBBB, Class@AAAAAAAA */ - FETCH(a0, 1) # a0<- aaaa (lo) - LOAD_rSELF_methodClassDex(a2) # a2 <- self->methodClassDex - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResClasses(a2, a2) # a2 <- dvmDex->pResClasses - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - FETCH(rOBJ, 3) # rOBJ<- BBBB - LOAD_eas2(v0, a2, a1) # v0 <- pResClasses[BBBB] - - bnez v0, .LOP_CONST_CLASS_JUMBO_resolve # v0!=0 => resolved-ok - /* - * Continuation if the Class has not yet been resolved. - * a1: AAAAAAAA (Class ref) - * rOBJ: target register - */ - EXPORT_PC() - LOAD_rSELF_method(a0) # a0 <- self->method - li a2, 1 # a2 <- true - LOAD_base_offMethod_clazz(a0, a0) # a0 <- method->clazz - JAL(dvmResolveClass) # v0 <- Class reference - # failed==0? - beqz v0, common_exceptionThrown # yup, handle the exception - -.LOP_CONST_CLASS_JUMBO_resolve: - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(v0, rOBJ, t0) # vBBBB <- v0 - - - -/* ------------------------------ */ - .balign 128 -.L_OP_CHECK_CAST_JUMBO: /* 0x101 */ -/* File: mips/OP_CHECK_CAST_JUMBO.S */ - /* - * Check to see if a cast from one class to another is allowed. - */ - /* check-cast/ jumbo vBBBB, class #AAAAAAAA */ - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a3, 3) # a3<- BBBB - sll a2,a2,16 - or a2, a0, a2 # a2<- AAAAaaaa - - GET_VREG(rOBJ, a3) # rOBJ<- object - LOAD_rSELF_methodClassDex(a0) # a0<- pDvmDex - LOAD_base_offDvmDex_pResClasses(a0, a0) # a0<- pDvmDex->pResClasses - # is object null? - beqz rOBJ, .LOP_CHECK_CAST_JUMBO_okay # null obj, cast always succeeds - LOAD_eas2(a1, a0, a2) # a1<- resolved class - LOAD_base_offObject_clazz(a0, rOBJ) # a0<- obj->clazz - # have we resolved this before? - beqz a1, .LOP_CHECK_CAST_JUMBO_resolve # not resolved, do it now -.LOP_CHECK_CAST_JUMBO_resolved: - # same class (trivial success)? - bne a0, a1, .LOP_CHECK_CAST_JUMBO_fullcheck # no, do full check - b .LOP_CHECK_CAST_JUMBO_okay # yes, finish up - - /* - * Trivial test failed, need to perform full check. This is common. - * a0 holds obj->clazz - * a1 holds class resolved from BBBB - * rOBJ holds object - */ -.LOP_CHECK_CAST_JUMBO_fullcheck: - move rBIX,a1 # avoid ClassObject getting clobbered - JAL(dvmInstanceofNonTrivial) # v0<- boolean result - # failed? - bnez v0, .LOP_CHECK_CAST_JUMBO_okay # no, success - b .LOP_CHECK_CAST_JUMBO_castfailure - - -/* ------------------------------ */ - .balign 128 -.L_OP_INSTANCE_OF_JUMBO: /* 0x102 */ -/* File: mips/OP_INSTANCE_OF_JUMBO.S */ - /* - * Check to see if an object reference is an instance of a class. - * - * Most common situation is a non-null object, being compared against - * an already-resolved class. - * - * TODO: convert most of this into a common subroutine, shared with - * OP_INSTANCE_OF.S. - */ - /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */ - FETCH(a3, 4) # a3<- vCCCC - FETCH(rOBJ, 3) # rOBJ<- vBBBB - GET_VREG(a0, a3) # a0 <- vCCCC (object) - LOAD_rSELF_methodClassDex(a2) # a2 <- pDvmDex - # is object null? - beqz a0, .LOP_INSTANCE_OF_JUMBO_store # null obj, not an instance, store a0 - FETCH(a1, 1) # r1<- aaaa (lo) - FETCH(a3, 2) # r3<- AAAA (hi) - LOAD_base_offDvmDex_pResClasses(a2, a2) # a2 <- pDvmDex->pResClasses - sll a3,a3,16 - or a3, a1, a3 # a3<- AAAAaaaa - - LOAD_eas2(a1, a2, a3) # a1 <- resolved class - LOAD_base_offObject_clazz(a0, a0) # a0 <- obj->clazz - # have we resolved this before? - beqz a1, .LOP_INSTANCE_OF_JUMBO_resolve # not resolved, do it now - b .LOP_INSTANCE_OF_JUMBO_resolved # resolved, continue - - -/* ------------------------------ */ - .balign 128 -.L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ -/* File: mips/OP_NEW_INSTANCE_JUMBO.S */ - /* - * Create a new instance of a class. - */ - /* new-instance/jumbo vBBBB, class@AAAAAAAA */ - FETCH(a0, 1) # a0<- aaaa (lo)DvmDex - FETCH(a1, 2) # a1<- AAAA (hi)BBB - LOAD_base_offDvmDex_pResClasses(a3, a3) # a3 <- pDvmDex->pResClasses - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, a3, a1) # a0 <- resolved class -#if defined(WITH_JIT) - EAS2(rBIX, a3, a1) # rBIX <- &resolved_class -#endif - EXPORT_PC() # req'd for init, resolve, alloc - # already resolved? - beqz a0, .LOP_NEW_INSTANCE_JUMBO_resolve # no, resolve it now -.LOP_NEW_INSTANCE_JUMBO_resolved: # a0=class - lbu a1, offClassObject_status(a0) # a1 <- ClassStatus enum - # has class been initialized? - li t0, CLASS_INITIALIZED - move rOBJ, a0 # save a0 - bne a1, t0, .LOP_NEW_INSTANCE_JUMBO_needinit # no, init class now - -.LOP_NEW_INSTANCE_JUMBO_initialized: # a0=class - LOAD_base_offClassObject_accessFlags(a3, a0) # a3 <- clazz->accessFlags - li a1, ALLOC_DONT_TRACK # flags for alloc call - # a0=class - JAL(dvmAllocObject) # v0 <- new object - FETCH(a3, 3) # a3<- BBBB -#if defined(WITH_JIT) - /* - * The JIT needs the class to be fully resolved before it can - * include this instruction in a trace. - */ - lhu a1, offThread_subMode(rSELF) - beqz v0, common_exceptionThrown # yes, handle the exception - and a1, kSubModeJitTraceBuild # under construction? - bnez a1, .LOP_NEW_INSTANCE_JUMBO_jitCheck -#else - # failed? - beqz v0, common_exceptionThrown # yes, handle the exception -#endif - b .LOP_NEW_INSTANCE_JUMBO_continue - - -/* ------------------------------ */ - .balign 128 -.L_OP_NEW_ARRAY_JUMBO: /* 0x104 */ -/* File: mips/OP_NEW_ARRAY_JUMBO.S */ - /* - * Allocate an array of objects, specified with the array class - * and a count. - * - * The verifier guarantees that this is an array class, so we don't - * check for it here. - */ - /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */ - FETCH(a2, 1) # a2<- aaaa (lo) - FETCH(a3, 2) # a3<- AAAA (hi) - FETCH(a0, 4) # a0<- vCCCC - sll a3,a3,16 # - or a2, a2, a3 # a2<- AAAAaaaa - - LOAD_rSELF_methodClassDex(a3) # a3 <- pDvmDex - GET_VREG(a1, a0) # a1 <- vCCCC (array length) - LOAD_base_offDvmDex_pResClasses(a3, a3) # a3 <- pDvmDex->pResClasses - LOAD_eas2(a0, a3, a2) # a0 <- resolved class - # check length - bltz a1, common_errNegativeArraySize # negative length, bail - len in a1 - EXPORT_PC() # req'd for resolve, alloc - # already resolved? - beqz a0, .LOP_NEW_ARRAY_JUMBO_resolve # not resolved, - b .LOP_NEW_ARRAY_JUMBO_finish - -/* ------------------------------ */ - .balign 128 -.L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ -/* File: mips/OP_FILLED_NEW_ARRAY_JUMBO.S */ - /* - * Create a new array with elements filled from registers. - * - * TODO: convert most of this into a common subroutine, shared with - * OP_FILLED_NEW_ARRAY.S. - */ - /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - - LOAD_rSELF_methodClassDex(a3) # a3 <- pDvmDex - FETCH(a0, 1) # r0<- aaaa (lo) - FETCH(a1, 2) # r1<- AAAA (hi) - LOAD_base_offDvmDex_pResClasses(a3, a3) # a3 <- pDvmDex->pResClasses - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, a3, a1) # a0 <- resolved class - GET_OPA(rOBJ) # rOBJ <- AA or BA - EXPORT_PC() # need for resolve and alloc - # already resolved? - bnez a0, .LOP_FILLED_NEW_ARRAY_JUMBO_continue # yes, continue on - LOAD_rSELF_method(a3) # a3 <- self->method - li a2, 0 # a2 <- false - LOAD_base_offMethod_clazz(a0, a3) # a0 <- method->clazz - JAL(dvmResolveClass) # v0 <- call(clazz, ref) - move a0, v0 - # got null? - beqz v0, common_exceptionThrown # yes, handle exception - b .LOP_FILLED_NEW_ARRAY_JUMBO_continue - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_JUMBO: /* 0x106 */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_JUMBO_resolved # resolved, continue - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_WIDE_JUMBO: /* 0x107 */ -/* File: mips/OP_IGET_WIDE_JUMBO.S */ - /* - * Jumbo 64-bit instance field get. - */ - /* iget-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[CCCC], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_WIDE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_WIDE_JUMBO_resolved # resolved, continue - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_OBJECT_JUMBO: /* 0x108 */ -/* File: mips/OP_IGET_OBJECT_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_OBJECT_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_OBJECT_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ -/* File: mips/OP_IGET_BOOLEAN_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_BOOLEAN_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_BOOLEAN_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_BYTE_JUMBO: /* 0x10a */ -/* File: mips/OP_IGET_BYTE_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_BYTE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_BYTE_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_CHAR_JUMBO: /* 0x10b */ -/* File: mips/OP_IGET_CHAR_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_CHAR_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_CHAR_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_SHORT_JUMBO: /* 0x10c */ -/* File: mips/OP_IGET_SHORT_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_SHORT_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_SHORT_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_JUMBO: /* 0x10d */ -/* File: mips/OP_IPUT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - * - * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo, - * iput-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_JUMBO_resolved # resolved, continue - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_WIDE_JUMBO: /* 0x10e */ -/* File: mips/OP_IPUT_WIDE_JUMBO.S */ - /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_WIDE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_WIDE_JUMBO_resolved # resolved, continue - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ -/* File: mips/OP_IPUT_OBJECT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - */ - /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a1,a1,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_OBJECT_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_OBJECT_JUMBO_resolved - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ -/* File: mips/OP_IPUT_BOOLEAN_JUMBO.S */ -/* File: mips/OP_IPUT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - * - * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo, - * iput-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_BOOLEAN_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_BOOLEAN_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_BYTE_JUMBO: /* 0x111 */ -/* File: mips/OP_IPUT_BYTE_JUMBO.S */ -/* File: mips/OP_IPUT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - * - * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo, - * iput-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_BYTE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_BYTE_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_CHAR_JUMBO: /* 0x112 */ -/* File: mips/OP_IPUT_CHAR_JUMBO.S */ -/* File: mips/OP_IPUT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - * - * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo, - * iput-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_CHAR_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_CHAR_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_SHORT_JUMBO: /* 0x113 */ -/* File: mips/OP_IPUT_SHORT_JUMBO.S */ -/* File: mips/OP_IPUT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - * - * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo, - * iput-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_SHORT_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_SHORT_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_JUMBO: /* 0x114 */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_JUMBO_finish # resume - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_WIDE_JUMBO: /* 0x115 */ -/* File: mips/OP_SGET_WIDE_JUMBO.S */ - /* - * Jumbo 64-bit SGET handler. - */ - /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(a2, a2) # a2 <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, a2, a1) # a0 <- resolved StaticField ptr - # is resolved entry null? - bnez a0, .LOP_SGET_WIDE_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * - * Returns StaticField pointer in v0. - */ - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # a0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception - b .LOP_SGET_WIDE_JUMBO_finish # resume - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_OBJECT_JUMBO: /* 0x116 */ -/* File: mips/OP_SGET_OBJECT_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_OBJECT_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_OBJECT_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ -/* File: mips/OP_SGET_BOOLEAN_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_BOOLEAN_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_BOOLEAN_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_BYTE_JUMBO: /* 0x118 */ -/* File: mips/OP_SGET_BYTE_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_BYTE_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_BYTE_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_CHAR_JUMBO: /* 0x119 */ -/* File: mips/OP_SGET_CHAR_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_CHAR_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_CHAR_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_SHORT_JUMBO: /* 0x11a */ -/* File: mips/OP_SGET_SHORT_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_SHORT_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_SHORT_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_JUMBO: /* 0x11b */ -/* File: mips/OP_SPUT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler. - * - * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, - * sput-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_JUMBO_finish # is resolved entry null? - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_JUMBO_finish # resume - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_WIDE_JUMBO: /* 0x11c */ -/* File: mips/OP_SPUT_WIDE_JUMBO.S */ - /* - * Jumbo 64-bit SPUT handler. - */ - /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - FETCH(rOBJ, 3) # rOBJ<- BBBB solved StaticField ptr - EAS2(rOBJ, rFP, t0) # rOBJ<- &fp[BBBB] - # is resolved entry null? - beqz a2, .LOP_SPUT_WIDE_JUMBO_resolve # yes, do resolve -.LOP_SPUT_WIDE_JUMBO_finish: # field ptr in a2, BBBB in rOBJ - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - LOAD64(a0, a1, rOBJ) # a0/a1 <- vBBBB/vBBBB+1 - GET_INST_OPCODE(rBIX) # extract opcode from rINST - .if 0 - addu a2, offStaticField_value # a2<- pointer to data - JAL(dvmQuasiAtomicSwap64Sync) # stores a0/a1 into addr a2 - .else - STORE64_off(a0, a1, a2, offStaticField_value) # field <- vBBBB/vBBBB+1 - .endif - GOTO_OPCODE(rBIX) # jump to next instruction - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ -/* File: mips/OP_SPUT_OBJECT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler for objects - */ - /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1,a0,a1 # a1<- AAAAaaaa - - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_OBJECT_JUMBO_finish # is resolved entry null? - - /* Continuation if the field has not yet been resolved. - * a1: BBBB field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_OBJECT_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ -/* File: mips/OP_SPUT_BOOLEAN_JUMBO.S */ -/* File: mips/OP_SPUT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler. - * - * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, - * sput-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_BOOLEAN_JUMBO_finish # is resolved entry null? - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_BOOLEAN_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_BYTE_JUMBO: /* 0x11f */ -/* File: mips/OP_SPUT_BYTE_JUMBO.S */ -/* File: mips/OP_SPUT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler. - * - * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, - * sput-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_BYTE_JUMBO_finish # is resolved entry null? - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_BYTE_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_CHAR_JUMBO: /* 0x120 */ -/* File: mips/OP_SPUT_CHAR_JUMBO.S */ -/* File: mips/OP_SPUT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler. - * - * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, - * sput-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_CHAR_JUMBO_finish # is resolved entry null? - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_CHAR_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_SHORT_JUMBO: /* 0x121 */ -/* File: mips/OP_SPUT_SHORT_JUMBO.S */ -/* File: mips/OP_SPUT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler. - * - * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, - * sput-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_SHORT_JUMBO_finish # is resolved entry null? - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_SHORT_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ -/* File: mips/OP_INVOKE_VIRTUAL_JUMBO.S */ - /* - * Handle a virtual method call. - */ - /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a3) # a3 <- pDvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResMethods(a3, a3) # a3 <- pDvmDex->pResMethods - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, a3, a1) # a0 <- resolved baseMethod - EXPORT_PC() # must export for invoke - # already resolved? - bnez a0, .LOP_INVOKE_VIRTUAL_JUMBO_continue # yes, continue on - - LOAD_rSELF_method(a3) # a3 <- self->method - LOAD_base_offMethod_clazz(a0, a3) # a0 <- method->clazz - li a2, METHOD_VIRTUAL # resolver method type - JAL(dvmResolveMethod) # v0 <- call(clazz, ref, flags) - move a0, v0 - # got null? - bnez v0, .LOP_INVOKE_VIRTUAL_JUMBO_continue # no, continue - b common_exceptionThrown # yes, handle exception - -/* ------------------------------ */ - .balign 128 -.L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ -/* File: mips/OP_INVOKE_SUPER_JUMBO.S */ - /* - * Handle a "super" method call. - */ - /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - FETCH(t0, 4) # t0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- pDvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResMethods(a3, a3) # a3 <- pDvmDex->pResMethods - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - GET_VREG(rOBJ, t0) # rOBJ <- "this" ptr - LOAD_eas2(a0, a3, a1) # a0 <- resolved baseMethod - # null "this"? - LOAD_rSELF_method(t1) # t1 <- current method - beqz rOBJ, common_errNullObject # null "this", throw exception - # cmp a0, 0; already resolved? - LOAD_base_offMethod_clazz(rBIX, t1) # rBIX <- method->clazz - EXPORT_PC() # must export for invoke - bnez a0, .LOP_INVOKE_SUPER_JUMBO_continue # resolved, continue on - - move a0, rBIX # a0 <- method->clazz - li a2, METHOD_VIRTUAL # resolver method type - JAL(dvmResolveMethod) # v0 <- call(clazz, ref, flags) - move a0, v0 - # got null? - beqz v0, common_exceptionThrown # yes, handle exception - b .LOP_INVOKE_SUPER_JUMBO_continue - -/* ------------------------------ */ - .balign 128 -.L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ -/* File: mips/OP_INVOKE_DIRECT_JUMBO.S */ - /* - * Handle a direct method call. - * - * (We could defer the "is 'this' pointer null" test to the common - * method invocation code, and use a flag to indicate that static - * calls don't count. If we do this as part of copying the arguments - * out we could avoiding loading the first arg twice.) - * - */ - /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a3) # a3 <- pDvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResMethods(a3, a3) # a3 <- pDvmDex->pResMethods - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - FETCH(rBIX, 4) # rBIX <- GFED or CCCC - LOAD_eas2(a0, a3, a1) # a0 <- resolved methodToCall - .if (!0) - and rBIX, rBIX, 15 # rBIX <- D (or stays CCCC) - .endif - EXPORT_PC() # must export for invoke - GET_VREG(rOBJ, rBIX) # rOBJ <- "this" ptr - # already resolved? - bnez a0, 1f # resolved, call the function - - lw a3, offThread_method(rSELF) # a3 <- self->method - LOAD_base_offMethod_clazz(a0, a3) # a0 <- method->clazz - li a2, METHOD_DIRECT # resolver method type - JAL(dvmResolveMethod) # v0 <- call(clazz, ref, flags) - move a0, v0 - # got null? - beqz v0, common_exceptionThrown # yes, handle exception - -1: - bnez rOBJ, common_invokeMethodJumbo # a0=method, rOBJ="this" - b common_errNullObject # yes, throw exception - - - - -/* ------------------------------ */ - .balign 128 -.L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ -/* File: mips/OP_INVOKE_STATIC_JUMBO.S */ - /* - * Handle a static method call. - */ - /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a3) # a3 <- pDvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResMethods(a3, a3) # a3 <- pDvmDex->pResMethods - sll a1,a1,16 - or a1, a0, a1 # r1<- AAAAaaaa - li rOBJ, 0 # null "this" in delay slot - LOAD_eas2(a0, a3, a1) # a0 <- resolved methodToCall -#if defined(WITH_JIT) - EAS2(rBIX, a3, a1) # rBIX<- &resolved_metherToCall -#endif - EXPORT_PC() # must export for invoke - # already resolved? - bnez a0, common_invokeMethodJumboNoThis # (a0 = method) - b .LOP_INVOKE_STATIC_JUMBO_resolve - -/* ------------------------------ */ - .balign 128 -.L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ -/* File: mips/OP_INVOKE_INTERFACE_JUMBO.S */ - /* - * Handle an interface method call. - */ - /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - FETCH(a2, 4) # a2<- CCCC - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - EXPORT_PC() # must export for invoke - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - GET_VREG(rOBJ, a2) # rOBJ <- first arg ("this") - LOAD_rSELF_methodClassDex(a3) # a3 <- methodClassDex - LOAD_rSELF_method(a2) # a2 <- method - # null obj? - beqz rOBJ, common_errNullObject # yes, fail - LOAD_base_offObject_clazz(a0, rOBJ) # a0 <- thisPtr->clazz - JAL(dvmFindInterfaceMethodInCache) # v0 <- call(class, ref, method, dex) - move a0, v0 - # failed? - beqz v0, common_exceptionThrown # yes, handle exception - b common_invokeMethodJumbo # (a0=method, rOBJ="this") - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_27FF: /* 0x127 */ -/* File: mips/OP_UNUSED_27FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_28FF: /* 0x128 */ -/* File: mips/OP_UNUSED_28FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_29FF: /* 0x129 */ -/* File: mips/OP_UNUSED_29FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_2AFF: /* 0x12a */ -/* File: mips/OP_UNUSED_2AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_2BFF: /* 0x12b */ -/* File: mips/OP_UNUSED_2BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_2CFF: /* 0x12c */ -/* File: mips/OP_UNUSED_2CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_2DFF: /* 0x12d */ -/* File: mips/OP_UNUSED_2DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_2EFF: /* 0x12e */ -/* File: mips/OP_UNUSED_2EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_2FFF: /* 0x12f */ -/* File: mips/OP_UNUSED_2FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_30FF: /* 0x130 */ -/* File: mips/OP_UNUSED_30FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_31FF: /* 0x131 */ -/* File: mips/OP_UNUSED_31FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_32FF: /* 0x132 */ -/* File: mips/OP_UNUSED_32FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_33FF: /* 0x133 */ -/* File: mips/OP_UNUSED_33FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_34FF: /* 0x134 */ -/* File: mips/OP_UNUSED_34FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_35FF: /* 0x135 */ -/* File: mips/OP_UNUSED_35FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_36FF: /* 0x136 */ -/* File: mips/OP_UNUSED_36FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_37FF: /* 0x137 */ -/* File: mips/OP_UNUSED_37FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_38FF: /* 0x138 */ -/* File: mips/OP_UNUSED_38FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_39FF: /* 0x139 */ -/* File: mips/OP_UNUSED_39FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_3AFF: /* 0x13a */ -/* File: mips/OP_UNUSED_3AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_3BFF: /* 0x13b */ -/* File: mips/OP_UNUSED_3BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_3CFF: /* 0x13c */ -/* File: mips/OP_UNUSED_3CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_3DFF: /* 0x13d */ -/* File: mips/OP_UNUSED_3DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_3EFF: /* 0x13e */ -/* File: mips/OP_UNUSED_3EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_3FFF: /* 0x13f */ -/* File: mips/OP_UNUSED_3FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_40FF: /* 0x140 */ -/* File: mips/OP_UNUSED_40FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_41FF: /* 0x141 */ -/* File: mips/OP_UNUSED_41FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_42FF: /* 0x142 */ -/* File: mips/OP_UNUSED_42FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_43FF: /* 0x143 */ -/* File: mips/OP_UNUSED_43FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_44FF: /* 0x144 */ -/* File: mips/OP_UNUSED_44FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_45FF: /* 0x145 */ -/* File: mips/OP_UNUSED_45FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_46FF: /* 0x146 */ -/* File: mips/OP_UNUSED_46FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_47FF: /* 0x147 */ -/* File: mips/OP_UNUSED_47FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_48FF: /* 0x148 */ -/* File: mips/OP_UNUSED_48FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_49FF: /* 0x149 */ -/* File: mips/OP_UNUSED_49FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_4AFF: /* 0x14a */ -/* File: mips/OP_UNUSED_4AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_4BFF: /* 0x14b */ -/* File: mips/OP_UNUSED_4BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_4CFF: /* 0x14c */ -/* File: mips/OP_UNUSED_4CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_4DFF: /* 0x14d */ -/* File: mips/OP_UNUSED_4DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_4EFF: /* 0x14e */ -/* File: mips/OP_UNUSED_4EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_4FFF: /* 0x14f */ -/* File: mips/OP_UNUSED_4FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_50FF: /* 0x150 */ -/* File: mips/OP_UNUSED_50FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_51FF: /* 0x151 */ -/* File: mips/OP_UNUSED_51FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_52FF: /* 0x152 */ -/* File: mips/OP_UNUSED_52FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_53FF: /* 0x153 */ -/* File: mips/OP_UNUSED_53FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_54FF: /* 0x154 */ -/* File: mips/OP_UNUSED_54FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_55FF: /* 0x155 */ -/* File: mips/OP_UNUSED_55FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_56FF: /* 0x156 */ -/* File: mips/OP_UNUSED_56FF.S */ +.L_OP_UNUSED_FF: /* 0xff */ +/* File: mips/OP_UNUSED_FF.S */ /* File: mips/unused.S */ BAL(common_abort) -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_57FF: /* 0x157 */ -/* File: mips/OP_UNUSED_57FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_58FF: /* 0x158 */ -/* File: mips/OP_UNUSED_58FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_59FF: /* 0x159 */ -/* File: mips/OP_UNUSED_59FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_5AFF: /* 0x15a */ -/* File: mips/OP_UNUSED_5AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_5BFF: /* 0x15b */ -/* File: mips/OP_UNUSED_5BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_5CFF: /* 0x15c */ -/* File: mips/OP_UNUSED_5CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_5DFF: /* 0x15d */ -/* File: mips/OP_UNUSED_5DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_5EFF: /* 0x15e */ -/* File: mips/OP_UNUSED_5EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_5FFF: /* 0x15f */ -/* File: mips/OP_UNUSED_5FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_60FF: /* 0x160 */ -/* File: mips/OP_UNUSED_60FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_61FF: /* 0x161 */ -/* File: mips/OP_UNUSED_61FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_62FF: /* 0x162 */ -/* File: mips/OP_UNUSED_62FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_63FF: /* 0x163 */ -/* File: mips/OP_UNUSED_63FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_64FF: /* 0x164 */ -/* File: mips/OP_UNUSED_64FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_65FF: /* 0x165 */ -/* File: mips/OP_UNUSED_65FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_66FF: /* 0x166 */ -/* File: mips/OP_UNUSED_66FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_67FF: /* 0x167 */ -/* File: mips/OP_UNUSED_67FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_68FF: /* 0x168 */ -/* File: mips/OP_UNUSED_68FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_69FF: /* 0x169 */ -/* File: mips/OP_UNUSED_69FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_6AFF: /* 0x16a */ -/* File: mips/OP_UNUSED_6AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_6BFF: /* 0x16b */ -/* File: mips/OP_UNUSED_6BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_6CFF: /* 0x16c */ -/* File: mips/OP_UNUSED_6CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_6DFF: /* 0x16d */ -/* File: mips/OP_UNUSED_6DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_6EFF: /* 0x16e */ -/* File: mips/OP_UNUSED_6EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_6FFF: /* 0x16f */ -/* File: mips/OP_UNUSED_6FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_70FF: /* 0x170 */ -/* File: mips/OP_UNUSED_70FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_71FF: /* 0x171 */ -/* File: mips/OP_UNUSED_71FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_72FF: /* 0x172 */ -/* File: mips/OP_UNUSED_72FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_73FF: /* 0x173 */ -/* File: mips/OP_UNUSED_73FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_74FF: /* 0x174 */ -/* File: mips/OP_UNUSED_74FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_75FF: /* 0x175 */ -/* File: mips/OP_UNUSED_75FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_76FF: /* 0x176 */ -/* File: mips/OP_UNUSED_76FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_77FF: /* 0x177 */ -/* File: mips/OP_UNUSED_77FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_78FF: /* 0x178 */ -/* File: mips/OP_UNUSED_78FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_79FF: /* 0x179 */ -/* File: mips/OP_UNUSED_79FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_7AFF: /* 0x17a */ -/* File: mips/OP_UNUSED_7AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_7BFF: /* 0x17b */ -/* File: mips/OP_UNUSED_7BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_7CFF: /* 0x17c */ -/* File: mips/OP_UNUSED_7CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_7DFF: /* 0x17d */ -/* File: mips/OP_UNUSED_7DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_7EFF: /* 0x17e */ -/* File: mips/OP_UNUSED_7EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_7FFF: /* 0x17f */ -/* File: mips/OP_UNUSED_7FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_80FF: /* 0x180 */ -/* File: mips/OP_UNUSED_80FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_81FF: /* 0x181 */ -/* File: mips/OP_UNUSED_81FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_82FF: /* 0x182 */ -/* File: mips/OP_UNUSED_82FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_83FF: /* 0x183 */ -/* File: mips/OP_UNUSED_83FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_84FF: /* 0x184 */ -/* File: mips/OP_UNUSED_84FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_85FF: /* 0x185 */ -/* File: mips/OP_UNUSED_85FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_86FF: /* 0x186 */ -/* File: mips/OP_UNUSED_86FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_87FF: /* 0x187 */ -/* File: mips/OP_UNUSED_87FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_88FF: /* 0x188 */ -/* File: mips/OP_UNUSED_88FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_89FF: /* 0x189 */ -/* File: mips/OP_UNUSED_89FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_8AFF: /* 0x18a */ -/* File: mips/OP_UNUSED_8AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_8BFF: /* 0x18b */ -/* File: mips/OP_UNUSED_8BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_8CFF: /* 0x18c */ -/* File: mips/OP_UNUSED_8CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_8DFF: /* 0x18d */ -/* File: mips/OP_UNUSED_8DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_8EFF: /* 0x18e */ -/* File: mips/OP_UNUSED_8EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_8FFF: /* 0x18f */ -/* File: mips/OP_UNUSED_8FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_90FF: /* 0x190 */ -/* File: mips/OP_UNUSED_90FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_91FF: /* 0x191 */ -/* File: mips/OP_UNUSED_91FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_92FF: /* 0x192 */ -/* File: mips/OP_UNUSED_92FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_93FF: /* 0x193 */ -/* File: mips/OP_UNUSED_93FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_94FF: /* 0x194 */ -/* File: mips/OP_UNUSED_94FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_95FF: /* 0x195 */ -/* File: mips/OP_UNUSED_95FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_96FF: /* 0x196 */ -/* File: mips/OP_UNUSED_96FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_97FF: /* 0x197 */ -/* File: mips/OP_UNUSED_97FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_98FF: /* 0x198 */ -/* File: mips/OP_UNUSED_98FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_99FF: /* 0x199 */ -/* File: mips/OP_UNUSED_99FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_9AFF: /* 0x19a */ -/* File: mips/OP_UNUSED_9AFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_9BFF: /* 0x19b */ -/* File: mips/OP_UNUSED_9BFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_9CFF: /* 0x19c */ -/* File: mips/OP_UNUSED_9CFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_9DFF: /* 0x19d */ -/* File: mips/OP_UNUSED_9DFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_9EFF: /* 0x19e */ -/* File: mips/OP_UNUSED_9EFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_9FFF: /* 0x19f */ -/* File: mips/OP_UNUSED_9FFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A0FF: /* 0x1a0 */ -/* File: mips/OP_UNUSED_A0FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A1FF: /* 0x1a1 */ -/* File: mips/OP_UNUSED_A1FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A2FF: /* 0x1a2 */ -/* File: mips/OP_UNUSED_A2FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A3FF: /* 0x1a3 */ -/* File: mips/OP_UNUSED_A3FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A4FF: /* 0x1a4 */ -/* File: mips/OP_UNUSED_A4FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A5FF: /* 0x1a5 */ -/* File: mips/OP_UNUSED_A5FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A6FF: /* 0x1a6 */ -/* File: mips/OP_UNUSED_A6FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A7FF: /* 0x1a7 */ -/* File: mips/OP_UNUSED_A7FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A8FF: /* 0x1a8 */ -/* File: mips/OP_UNUSED_A8FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_A9FF: /* 0x1a9 */ -/* File: mips/OP_UNUSED_A9FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_AAFF: /* 0x1aa */ -/* File: mips/OP_UNUSED_AAFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_ABFF: /* 0x1ab */ -/* File: mips/OP_UNUSED_ABFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_ACFF: /* 0x1ac */ -/* File: mips/OP_UNUSED_ACFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_ADFF: /* 0x1ad */ -/* File: mips/OP_UNUSED_ADFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_AEFF: /* 0x1ae */ -/* File: mips/OP_UNUSED_AEFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_AFFF: /* 0x1af */ -/* File: mips/OP_UNUSED_AFFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B0FF: /* 0x1b0 */ -/* File: mips/OP_UNUSED_B0FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B1FF: /* 0x1b1 */ -/* File: mips/OP_UNUSED_B1FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B2FF: /* 0x1b2 */ -/* File: mips/OP_UNUSED_B2FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B3FF: /* 0x1b3 */ -/* File: mips/OP_UNUSED_B3FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B4FF: /* 0x1b4 */ -/* File: mips/OP_UNUSED_B4FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B5FF: /* 0x1b5 */ -/* File: mips/OP_UNUSED_B5FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B6FF: /* 0x1b6 */ -/* File: mips/OP_UNUSED_B6FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B7FF: /* 0x1b7 */ -/* File: mips/OP_UNUSED_B7FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B8FF: /* 0x1b8 */ -/* File: mips/OP_UNUSED_B8FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_B9FF: /* 0x1b9 */ -/* File: mips/OP_UNUSED_B9FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_BAFF: /* 0x1ba */ -/* File: mips/OP_UNUSED_BAFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_BBFF: /* 0x1bb */ -/* File: mips/OP_UNUSED_BBFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_BCFF: /* 0x1bc */ -/* File: mips/OP_UNUSED_BCFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_BDFF: /* 0x1bd */ -/* File: mips/OP_UNUSED_BDFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_BEFF: /* 0x1be */ -/* File: mips/OP_UNUSED_BEFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_BFFF: /* 0x1bf */ -/* File: mips/OP_UNUSED_BFFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C0FF: /* 0x1c0 */ -/* File: mips/OP_UNUSED_C0FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C1FF: /* 0x1c1 */ -/* File: mips/OP_UNUSED_C1FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C2FF: /* 0x1c2 */ -/* File: mips/OP_UNUSED_C2FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C3FF: /* 0x1c3 */ -/* File: mips/OP_UNUSED_C3FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C4FF: /* 0x1c4 */ -/* File: mips/OP_UNUSED_C4FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C5FF: /* 0x1c5 */ -/* File: mips/OP_UNUSED_C5FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C6FF: /* 0x1c6 */ -/* File: mips/OP_UNUSED_C6FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C7FF: /* 0x1c7 */ -/* File: mips/OP_UNUSED_C7FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C8FF: /* 0x1c8 */ -/* File: mips/OP_UNUSED_C8FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_C9FF: /* 0x1c9 */ -/* File: mips/OP_UNUSED_C9FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_CAFF: /* 0x1ca */ -/* File: mips/OP_UNUSED_CAFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_CBFF: /* 0x1cb */ -/* File: mips/OP_UNUSED_CBFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_CCFF: /* 0x1cc */ -/* File: mips/OP_UNUSED_CCFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_CDFF: /* 0x1cd */ -/* File: mips/OP_UNUSED_CDFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_CEFF: /* 0x1ce */ -/* File: mips/OP_UNUSED_CEFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_CFFF: /* 0x1cf */ -/* File: mips/OP_UNUSED_CFFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D0FF: /* 0x1d0 */ -/* File: mips/OP_UNUSED_D0FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D1FF: /* 0x1d1 */ -/* File: mips/OP_UNUSED_D1FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D2FF: /* 0x1d2 */ -/* File: mips/OP_UNUSED_D2FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D3FF: /* 0x1d3 */ -/* File: mips/OP_UNUSED_D3FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D4FF: /* 0x1d4 */ -/* File: mips/OP_UNUSED_D4FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D5FF: /* 0x1d5 */ -/* File: mips/OP_UNUSED_D5FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D6FF: /* 0x1d6 */ -/* File: mips/OP_UNUSED_D6FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D7FF: /* 0x1d7 */ -/* File: mips/OP_UNUSED_D7FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D8FF: /* 0x1d8 */ -/* File: mips/OP_UNUSED_D8FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_D9FF: /* 0x1d9 */ -/* File: mips/OP_UNUSED_D9FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_DAFF: /* 0x1da */ -/* File: mips/OP_UNUSED_DAFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_DBFF: /* 0x1db */ -/* File: mips/OP_UNUSED_DBFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_DCFF: /* 0x1dc */ -/* File: mips/OP_UNUSED_DCFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_DDFF: /* 0x1dd */ -/* File: mips/OP_UNUSED_DDFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_DEFF: /* 0x1de */ -/* File: mips/OP_UNUSED_DEFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_DFFF: /* 0x1df */ -/* File: mips/OP_UNUSED_DFFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E0FF: /* 0x1e0 */ -/* File: mips/OP_UNUSED_E0FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E1FF: /* 0x1e1 */ -/* File: mips/OP_UNUSED_E1FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E2FF: /* 0x1e2 */ -/* File: mips/OP_UNUSED_E2FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E3FF: /* 0x1e3 */ -/* File: mips/OP_UNUSED_E3FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E4FF: /* 0x1e4 */ -/* File: mips/OP_UNUSED_E4FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E5FF: /* 0x1e5 */ -/* File: mips/OP_UNUSED_E5FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E6FF: /* 0x1e6 */ -/* File: mips/OP_UNUSED_E6FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E7FF: /* 0x1e7 */ -/* File: mips/OP_UNUSED_E7FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E8FF: /* 0x1e8 */ -/* File: mips/OP_UNUSED_E8FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_E9FF: /* 0x1e9 */ -/* File: mips/OP_UNUSED_E9FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_EAFF: /* 0x1ea */ -/* File: mips/OP_UNUSED_EAFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_EBFF: /* 0x1eb */ -/* File: mips/OP_UNUSED_EBFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_ECFF: /* 0x1ec */ -/* File: mips/OP_UNUSED_ECFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_EDFF: /* 0x1ed */ -/* File: mips/OP_UNUSED_EDFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_EEFF: /* 0x1ee */ -/* File: mips/OP_UNUSED_EEFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_EFFF: /* 0x1ef */ -/* File: mips/OP_UNUSED_EFFF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_F0FF: /* 0x1f0 */ -/* File: mips/OP_UNUSED_F0FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_UNUSED_F1FF: /* 0x1f1 */ -/* File: mips/OP_UNUSED_F1FF.S */ -/* File: mips/unused.S */ - BAL(common_abort) - - - -/* ------------------------------ */ - .balign 128 -.L_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */ -/* File: mips/OP_INVOKE_OBJECT_INIT_JUMBO.S */ -/* File: mips/OP_INVOKE_OBJECT_INIT_RANGE.S */ - /* - * Invoke Object.<init> on an object. In practice we know that - * Object's nullary constructor doesn't do anything, so we just - * skip it unless a debugger is active. - */ - FETCH(a1, 4) # a1<- CCCC - GET_VREG(a0, a1) # a0<- "this" ptr - # check for NULL - beqz a0, common_errNullObject # export PC and throw NPE - LOAD_base_offObject_clazz(a1, a0) # a1<- obj->clazz - LOAD_base_offClassObject_accessFlags(a2, a1) # a2<- clazz->accessFlags - and a2, CLASS_ISFINALIZABLE # is this class finalizable? - beqz a2, .LOP_INVOKE_OBJECT_INIT_JUMBO_finish # no, go - -.LOP_INVOKE_OBJECT_INIT_JUMBO_setFinal: - EXPORT_PC() # can throw - JAL(dvmSetFinalizable) # call dvmSetFinalizable(obj) - LOAD_offThread_exception(a0, rSELF) # a0<- self->exception - # exception pending? - bnez a0, common_exceptionThrown # yes, handle it - -.LOP_INVOKE_OBJECT_INIT_JUMBO_finish: - lhu a1, offThread_subMode(rSELF) - and a1, kSubModeDebuggerActive # debugger active? - bnez a1, .LOP_INVOKE_OBJECT_INIT_JUMBO_debugger # Yes - skip optimization - FETCH_ADVANCE_INST(4+1) # advance to next instr, load rINST - GET_INST_OPCODE(t0) # t0<- opcode from rINST - GOTO_OPCODE(t0) # execute it - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */ -/* File: mips/OP_IGET_VOLATILE_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_VOLATILE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_VOLATILE_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */ -/* File: mips/OP_IGET_WIDE_VOLATILE_JUMBO.S */ -/* File: mips/OP_IGET_WIDE_JUMBO.S */ - /* - * Jumbo 64-bit instance field get. - */ - /* iget-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[CCCC], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_WIDE_VOLATILE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_WIDE_VOLATILE_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */ -/* File: mips/OP_IGET_OBJECT_VOLATILE_JUMBO.S */ -/* File: mips/OP_IGET_OBJECT_JUMBO.S */ -/* File: mips/OP_IGET_JUMBO.S */ - /* - * Jumbo 32-bit instance field get. - * - * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, - * iget-char/jumbo, iget-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IGET_OBJECT_VOLATILE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IGET_OBJECT_VOLATILE_JUMBO_resolved # resolved, continue - - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */ -/* File: mips/OP_IPUT_VOLATILE_JUMBO.S */ -/* File: mips/OP_IPUT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - * - * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo, - * iput-short/jumbo - */ - /* exop vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_VOLATILE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_VOLATILE_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */ -/* File: mips/OP_IPUT_WIDE_VOLATILE_JUMBO.S */ -/* File: mips/OP_IPUT_WIDE_JUMBO.S */ - /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_WIDE_VOLATILE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_WIDE_VOLATILE_JUMBO_resolved # resolved, continue - - - -/* ------------------------------ */ - .balign 128 -.L_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */ -/* File: mips/OP_IPUT_OBJECT_VOLATILE_JUMBO.S */ -/* File: mips/OP_IPUT_OBJECT_JUMBO.S */ - /* - * Jumbo 32-bit instance field put. - */ - /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - FETCH(a0, 4) # a0<- CCCC - LOAD_rSELF_methodClassDex(a3) # a3 <- DvmDex - sll a1,a1,16 - or a1, a1, a2 # a1<- AAAAaaaa - LOAD_base_offDvmDex_pResFields(a2, a3) # a2 <- pDvmDex->pResFields - GET_VREG(rOBJ, a0) # rOBJ <- fp[B], the object pointer - LOAD_eas2(a0, a2, a1) # a0 <- resolved InstField ptr - # is resolved entry null? - bnez a0, .LOP_IPUT_OBJECT_VOLATILE_JUMBO_finish # no, already resolved - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveInstField) # v0 <- resolved InstField ptr - b .LOP_IPUT_OBJECT_VOLATILE_JUMBO_resolved - - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */ -/* File: mips/OP_SGET_VOLATILE_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_VOLATILE_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_VOLATILE_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */ -/* File: mips/OP_SGET_WIDE_VOLATILE_JUMBO.S */ -/* File: mips/OP_SGET_WIDE_JUMBO.S */ - /* - * Jumbo 64-bit SGET handler. - */ - /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(a2, a2) # a2 <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, a2, a1) # a0 <- resolved StaticField ptr - # is resolved entry null? - bnez a0, .LOP_SGET_WIDE_VOLATILE_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * - * Returns StaticField pointer in v0. - */ - LOAD_rSELF_method(a2) # a2 <- current method - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # a0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception - b .LOP_SGET_WIDE_VOLATILE_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */ -/* File: mips/OP_SGET_OBJECT_VOLATILE_JUMBO.S */ -/* File: mips/OP_SGET_OBJECT_JUMBO.S */ -/* File: mips/OP_SGET_JUMBO.S */ - /* - * Jumbo 32-bit SGET handler. - * - * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, - * sget-char/jumbo, sget-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - # is resolved entry !null? - bnez a0, .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - # success? - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish # resume - - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */ -/* File: mips/OP_SPUT_VOLATILE_JUMBO.S */ -/* File: mips/OP_SPUT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler. - * - * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, - * sput-short/jumbo - */ - /* exop vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1, a0, a1 # a1<- AAAAaaaa - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_VOLATILE_JUMBO_finish # is resolved entry null? - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_VOLATILE_JUMBO_finish # resume - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */ -/* File: mips/OP_SPUT_WIDE_VOLATILE_JUMBO.S */ -/* File: mips/OP_SPUT_WIDE_JUMBO.S */ - /* - * Jumbo 64-bit SPUT handler. - */ - /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a2,a2,16 - or a1, a1, a2 # a1<- AAAAaaaa - FETCH(rOBJ, 3) # rOBJ<- BBBB solved StaticField ptr - EAS2(rOBJ, rFP, t0) # rOBJ<- &fp[BBBB] - # is resolved entry null? - beqz a2, .LOP_SPUT_WIDE_VOLATILE_JUMBO_resolve # yes, do resolve -.LOP_SPUT_WIDE_VOLATILE_JUMBO_finish: # field ptr in a2, BBBB in rOBJ - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - LOAD64(a0, a1, rOBJ) # a0/a1 <- vBBBB/vBBBB+1 - GET_INST_OPCODE(rBIX) # extract opcode from rINST - .if 1 - addu a2, offStaticField_value # a2<- pointer to data - JAL(dvmQuasiAtomicSwap64Sync) # stores a0/a1 into addr a2 - .else - STORE64_off(a0, a1, a2, offStaticField_value) # field <- vBBBB/vBBBB+1 - .endif - GOTO_OPCODE(rBIX) # jump to next instruction - - -/* ------------------------------ */ - .balign 128 -.L_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */ -/* File: mips/OP_SPUT_OBJECT_VOLATILE_JUMBO.S */ -/* File: mips/OP_SPUT_OBJECT_JUMBO.S */ - /* - * Jumbo 32-bit SPUT handler for objects - */ - /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - LOAD_rSELF_methodClassDex(a2) # a2 <- DvmDex - FETCH(a0, 1) # a0<- aaaa (lo) - FETCH(a1, 2) # a1<- AAAA (hi) - LOAD_base_offDvmDex_pResFields(rBIX, a2) # rBIX <- dvmDex->pResFields - sll a1,a1,16 - or a1,a0,a1 # a1<- AAAAaaaa - - LOAD_eas2(a0, rBIX, a1) # a0 <- resolved StaticField ptr - bnez a0, .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish # is resolved entry null? - - /* Continuation if the field has not yet been resolved. - * a1: BBBB field ref - * rBIX: dvmDex->pResFields - */ - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() may throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - move a0, v0 - beqz v0, common_exceptionThrown # success? no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - b .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish # resume - - - -/* ------------------------------ */ - .balign 128 -.L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ -/* File: mips/OP_THROW_VERIFICATION_ERROR_JUMBO.S */ - /* - * Handle a jumbo throw-verification-error instruction. This throws an - * exception for an error discovered during verification. The - * exception is indicated by BBBB, with some detail provided by AAAAAAAA. - */ - /* exop BBBB, Class@AAAAAAAA */ - FETCH(a1, 1) # a1<- aaaa (lo) - FETCH(a2, 2) # a2<- AAAA (hi) - LOAD_rSELF_method(a0) # a0 <- self->method - sll a2,a2,16 - or a2, a1, a2 # a2<- AAAAaaaa - EXPORT_PC() # export the PC - FETCH(a1, 3) # a1<- BBBB - JAL(dvmThrowVerificationError) # always throws - b common_exceptionThrown # handle exception - - .balign 128 .size dvmAsmInstructionStart, .-dvmAsmInstructionStart .global dvmAsmInstructionEnd @@ -14711,1231 +10999,6 @@ d2l_doconv: 1: GOTO_OPCODE(t0) # jump to next instruction -/* continuation for OP_CHECK_CAST_JUMBO */ - - -.LOP_CHECK_CAST_JUMBO_castfailure: - # A cast has failed. We need to throw a ClassCastException with the - # class of the object that failed to be cast. - EXPORT_PC() # about to throw - LOAD_base_offObject_clazz(a0, rOBJ) # a0<- obj->clazz - move a1,rBIX # r1<- desired class - JAL(dvmThrowClassCastException) - b common_exceptionThrown - - /* - * Advance PC and get next opcode - * - */ -.LOP_CHECK_CAST_JUMBO_okay: - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - /* - * Resolution required. This is the least-likely path. - * - * a2 holds AAAAAAAA - * rOBJ holds object - */ -.LOP_CHECK_CAST_JUMBO_resolve: - EXPORT_PC() # resolve() could throw - LOAD_rSELF_method(a3) # a3<- self->method - move a1, a2 # a1<- AAAAAAAA - li a2, 0 # a2<- false - LOAD_base_offMethod_clazz(a0, a3) # a0<- method->clazz - JAL(dvmResolveClass) # v0<- resolved ClassObject ptr - # got null? - beqz v0, common_exceptionThrown # yes, handle exception - move a1, v0 # a1<- class resolved from AAAAAAAA - LOAD_base_offObject_clazz(a0, rOBJ) # a0<- obj->clazz - b .LOP_CHECK_CAST_JUMBO_resolved # pick up where we left off - - - -/* continuation for OP_INSTANCE_OF_JUMBO */ - - /* - * Class resolved, determine type of check necessary. This is common. - * r0 holds obj->clazz - * r1 holds class resolved from AAAAAAAA - * r9 holds BBBB - */ - -.LOP_INSTANCE_OF_JUMBO_resolved: # a0=obj->clazz, a1=resolved class - # same class (trivial success)? - beq a0, a1, .LOP_INSTANCE_OF_JUMBO_trivial # yes, trivial finish - # fall through to OP_INSTANCE_OF_JUMBO_fullcheck - - /* - * Trivial test failed, need to perform full check. This is common. - * a0 holds obj->clazz - * a1 holds class resolved from AAAAAAAA - * rOBJ holds BBBB - */ -.LOP_INSTANCE_OF_JUMBO_fullcheck: - JAL(dvmInstanceofNonTrivial) # v0 <- boolean result - move a0, v0 - b .LOP_INSTANCE_OF_JUMBO_store # go to OP_INSTANCE_OF_JUMBO_store - -.LOP_INSTANCE_OF_JUMBO_trivial: - li a0, 1 # indicate success - # fall thru - /* - * a0 holds boolean result - * rOBJ holds BBBB - */ -.LOP_INSTANCE_OF_JUMBO_store: - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, rOBJ) # vBBBB <- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - /* - * Resolution required. This is the least-likely path. - * - * a3 holds AAAAAAAA - * rOBJ holds BBBB - */ -.LOP_INSTANCE_OF_JUMBO_resolve: - EXPORT_PC() # resolve() could throw - LOAD_rSELF_method(a0) # a0 <- self->method - move a1, a3 # a1 <- AAAAAAAA - li a2, 1 # a2 <- true - LOAD_base_offMethod_clazz(a0, a0) # a0 <- method->clazz - JAL(dvmResolveClass) # v0 <- resolved ClassObject ptr - # got null? - move a1, v0 # a1 <- class resolved from BBB - beqz v0, common_exceptionThrown # yes, handle exception - FETCH(ra, 4) # a3<- vCCCC - move a1, a0 # a1<- class resolved from AAAAAAAA - - GET_VREG(a0, a3) # a0 <- vCCCC (object) - LOAD_base_offObject_clazz(a0, a0) # a0 <- obj->clazz - b .LOP_INSTANCE_OF_JUMBO_resolved # pick up where we left off - - -/* continuation for OP_NEW_INSTANCE_JUMBO */ - -.LOP_NEW_INSTANCE_JUMBO_continue: - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG(v0, a3) # vBBBB <- v0 - GOTO_OPCODE(t0) # jump to next instruction - -#if defined(WITH_JIT) - /* - * Check to see if we need to stop the trace building early. - * v0: new object - * a3: vAA - */ -.LOP_NEW_INSTANCE_JUMBO_jitCheck: - lw a1, 0(rBIX) # reload resolved class - # okay? - bnez a1, .LOP_NEW_INSTANCE_JUMBO_continue # yes, finish - move rOBJ, v0 # preserve new object - move rBIX, a3 # preserve vAA - move a0, rSELF - move a1, rPC - JAL(dvmJitEndTraceSelect) # (self, pc) - FETCH_ADVANCE_INST(2) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG(rOBJ, rBIX) # vAA <- new object - GOTO_OPCODE(t0) # jump to next instruction -#endif - - /* - * Class initialization required. - * - * a0 holds class object - */ -.LOP_NEW_INSTANCE_JUMBO_needinit: - JAL(dvmInitClass) # initialize class - move a0, rOBJ # restore a0 - # check boolean result - bnez v0, .LOP_NEW_INSTANCE_JUMBO_initialized # success, continue - b common_exceptionThrown # failed, deal with init exception - - - /* - * Resolution required. This is the least-likely path. - * - * a1 holds AAAAAAAA - */ -.LOP_NEW_INSTANCE_JUMBO_resolve: - LOAD_rSELF_method(a3) # a3 <- self->method - li a2, 0 # a2 <- false - LOAD_base_offMethod_clazz(a0, a3) # a0 <- method->clazz - JAL(dvmResolveClass) # v0 <- resolved ClassObject ptr - move a0, v0 - # got null? - bnez v0, .LOP_NEW_INSTANCE_JUMBO_resolved # no, continue - b common_exceptionThrown # yes, handle exception - -/* continuation for OP_NEW_ARRAY_JUMBO */ - - /* - * Finish allocation. - * - * a0 holds class - * a1 holds array length - */ -.LOP_NEW_ARRAY_JUMBO_finish: - li a2, ALLOC_DONT_TRACK # don't track in local refs table - JAL(dvmAllocArrayByClass) # v0 <- call(clazz, length, flags) - FETCH(a2, 3) # r2<- vBBBB - # failed? - beqz v0, common_exceptionThrown # yes, handle the exception - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG(v0, a2) # vBBBB <- v0 - GOTO_OPCODE(t0) # jump to next instruction -#%break - - - - /* - * Resolve class. (This is an uncommon case.) - * - * a1 holds array length - * a2 holds class ref AAAAAAAA - */ -.LOP_NEW_ARRAY_JUMBO_resolve: - LOAD_rSELF_method(a3) # a3 <- self->method - move rOBJ, a1 # rOBJ <- length (save) - move a1, a2 # a1 <- AAAAAAAA - li a2, 0 # a2 <- false - LOAD_base_offMethod_clazz(a0, a3) # a0 <- method->clazz - JAL(dvmResolveClass) # v0 <- call(clazz, ref) - move a1, rOBJ # a1 <- length (restore) - # got null? - beqz v0, common_exceptionThrown # yes, handle exception - move a0, v0 - b .LOP_NEW_ARRAY_JUMBO_finish # continue with to OP_NEW_ARRAY_JUMBO_finish - - - -/* continuation for OP_FILLED_NEW_ARRAY_JUMBO */ - - /* - * On entry: - * a0 holds array class - * rOBJ holds AA or BA - */ -.LOP_FILLED_NEW_ARRAY_JUMBO_continue: - LOAD_base_offClassObject_descriptor(a3, a0) # a3 <- arrayClass->descriptor - li a2, ALLOC_DONT_TRACK # a2 <- alloc flags - lbu rINST, 1(a3) # rINST <- descriptor[1] - FETCH(a1, 3) # a1<- BBBB (length) - seq t0, rINST, 'I' # array of ints? - seq t1, rINST, 'L' # array of objects? - or t0, t1 - seq t1, rINST, '[' # array of arrays? - or t0, t1 - move rBIX, a1 # save length in rBIX - beqz t0, .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl # no, not handled yet - JAL(dvmAllocArrayByClass) # v0 <- call(arClass, length, flags) - # null return? - beqz v0, common_exceptionThrown # alloc failed, handle exception - - FETCH(a1, 4) # a1 CCCC - sw v0, offThread_retval(rSELF) # retval.l <- new array - sw rINST, (offThread_retval+4)(rSELF) # retval.h <- type - addu a0, v0, offArrayObject_contents # a0 <- newArray->contents - subu rBIX, rBIX, 1 # length--, check for neg - FETCH_ADVANCE_INST(5) # advance to next instr, load rINST - bltz rBIX, 2f # was zero, bail - - # copy values from registers into the array - # a0=array, a1=CCCC, t0=BBBB(length) - move t0, rBIX - EAS2(a2, rFP, a1) # a2 <- &fp[CCCC] -1: - lw a3, 0(a2) # a3 <- *a2++ - addu a2, 4 - subu t0, t0, 1 # count-- - sw a3, (a0) # *contents++ = vX - addu a0, 4 - bgez t0, 1b - -2: - lw a0, offThread_retval(rSELF) # a0 <- object - lw a1, (offThread_retval+4)(rSELF) # a1 <- type - seq t1, a1, 'I' # Is int array? - bnez t1, 3f - lw a2, offThread_cardTable(rSELF) # a2 <- card table base - srl t3, a0, GC_CARD_SHIFT - addu t2, a2, t3 - sb a2, (t2) -3: - GET_INST_OPCODE(t0) # ip <- opcode from rINST - GOTO_OPCODE(t0) # execute it - - - /* - * Throw an exception indicating that we have not implemented this - * mode of filled-new-array. - */ -.LOP_FILLED_NEW_ARRAY_JUMBO_notimpl: - la a0, .LstrFilledNewArrayNotImpl - JAL(dvmThrowInternalError) - b common_exceptionThrown - -/* continuation for OP_IGET_JUMBO */ - -.LOP_IGET_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - # noop # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_WIDE_JUMBO */ - -.LOP_IGET_WIDE_JUMBO_resolved: - # test return code - move a0, v0 - bnez v0, .LOP_IGET_WIDE_JUMBO_finish - b common_exceptionThrown - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IGET_WIDE_JUMBO_finish: - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - beqz rOBJ, common_errNullObject # object was null - GET_OPA4(a2) # a2 <- A+ - addu rOBJ, rOBJ, a3 # form address - .if 0 - vLOAD64(a0, a1, rOBJ) # a0/a1 <- obj.field (64-bit align ok) - .else - LOAD64(a0, a1, rOBJ) # a0/a1 <- obj.field (64-bit align ok) - .endif - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - EAS2(a3, rFP, a2) # a3 <- &fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - STORE64(a0, a1, a3) # fp[BBBB] <- a0/a1 - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_OBJECT_JUMBO */ - -.LOP_IGET_OBJECT_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_OBJECT_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - # noop # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_BOOLEAN_JUMBO */ - -.LOP_IGET_BOOLEAN_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_BOOLEAN_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - # noop # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_BYTE_JUMBO */ - -.LOP_IGET_BYTE_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_BYTE_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - # noop # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_CHAR_JUMBO */ - -.LOP_IGET_CHAR_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_CHAR_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - # noop # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_SHORT_JUMBO */ - -.LOP_IGET_SHORT_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_SHORT_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - # noop # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_JUMBO */ - -.LOP_IPUT_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_JUMBO_finish - - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu rOBJ, rOBJ, a3 # form address - # noop # releasing store - sw a0, (rOBJ) # obj.field (8/16/32 bits) <- a0 - # noop - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_WIDE_JUMBO */ - -.LOP_IPUT_WIDE_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_WIDE_JUMBO_finish - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_WIDE_JUMBO_finish: - FETCH(a2, 3) # a1<- BBBB - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - EAS2(a2, rFP, a2) # a2 <- &fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - LOAD64(a0, a1, a2) # a0/a1 <- fp[BBBB] - GET_INST_OPCODE(rBIX) # extract opcode from rINST - addu a2, rOBJ, a3 # form address - .if 0 - JAL(dvmQuasiAtomicSwap64Sync) # stores r0/r1 into addr r2 -# STORE64(a0, a1, a2) # obj.field (64 bits, aligned) <- a0 a1 - .else - STORE64(a0, a1, a2) # obj.field (64 bits, aligned) <- a0 a1 - .endif - GOTO_OPCODE(rBIX) # jump to next instruction - - - -/* continuation for OP_IPUT_OBJECT_JUMBO */ - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_OBJECT_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_OBJECT_JUMBO_finish - -.LOP_IPUT_OBJECT_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - lw a2, offThread_cardTable(rSELF) # a2 <- card table base - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu t2, rOBJ, a3 # form address - # noop # releasing store - sw a0, (t2) # obj.field (32 bits) <- a0 - # noop - beqz a0, 1f # stored a null reference? - srl t1, rOBJ, GC_CARD_SHIFT - addu t2, a2, t1 - sb a2, (t2) # mark card if not -1: - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_BOOLEAN_JUMBO */ - -.LOP_IPUT_BOOLEAN_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_BOOLEAN_JUMBO_finish - - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_BOOLEAN_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu rOBJ, rOBJ, a3 # form address - # noop # releasing store - sw a0, (rOBJ) # obj.field (8/16/32 bits) <- a0 - # noop - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_BYTE_JUMBO */ - -.LOP_IPUT_BYTE_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_BYTE_JUMBO_finish - - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_BYTE_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu rOBJ, rOBJ, a3 # form address - # noop # releasing store - sw a0, (rOBJ) # obj.field (8/16/32 bits) <- a0 - # noop - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_CHAR_JUMBO */ - -.LOP_IPUT_CHAR_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_CHAR_JUMBO_finish - - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_CHAR_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu rOBJ, rOBJ, a3 # form address - # noop # releasing store - sw a0, (rOBJ) # obj.field (8/16/32 bits) <- a0 - # noop - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_SHORT_JUMBO */ - -.LOP_IPUT_SHORT_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_SHORT_JUMBO_finish - - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_SHORT_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu rOBJ, rOBJ, a3 # form address - # noop # releasing store - sw a0, (rOBJ) # obj.field (8/16/32 bits) <- a0 - # noop - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_SGET_JUMBO */ - -.LOP_SGET_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - # no-op # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SGET_WIDE_JUMBO */ - -.LOP_SGET_WIDE_JUMBO_finish: - FETCH(a1, 3) # a1<- BBBB - .if 0 - vLOAD64_off(a2, a3, a0, offStaticField_value) # a2/a3 <- field value (aligned) - .else - LOAD64_off(a2, a3, a0, offStaticField_value) # a2/a3 <- field value (aligned) - .endif - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - EAS2(a1, rFP, a1) # a1 <- &fp[BBBB] - STORE64(a2, a3, a1) # vBBBB/vBBBB+1 <- a2/a3 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SGET_OBJECT_JUMBO */ - -.LOP_SGET_OBJECT_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - # no-op # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SGET_BOOLEAN_JUMBO */ - -.LOP_SGET_BOOLEAN_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - # no-op # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SGET_BYTE_JUMBO */ - -.LOP_SGET_BYTE_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - # no-op # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SGET_CHAR_JUMBO */ - -.LOP_SGET_CHAR_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - # no-op # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SGET_SHORT_JUMBO */ - -.LOP_SGET_SHORT_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - # no-op # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SPUT_JUMBO */ - -.LOP_SPUT_JUMBO_finish: - # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - # no-op # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - # no-op - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SPUT_WIDE_JUMBO */ - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rOBJ: &fp[BBBB] - * rBIX: dvmDex->pResFields - * - * Returns StaticField pointer in a2. - */ -.LOP_SPUT_WIDE_JUMBO_resolve: - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - # success ? - move a0, v0 - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - move a2, v0 - b .LOP_SPUT_WIDE_JUMBO_finish # resume - -/* continuation for OP_SPUT_OBJECT_JUMBO */ -.LOP_SPUT_OBJECT_JUMBO_finish: # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - lw a2, offThread_cardTable(rSELF) # a2 <- card table base - lw t1, offField_clazz(a0) # t1 <- field->clazz - GET_INST_OPCODE(t0) # extract opcode from rINST - # no-op # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - # no-op - beqz a1, 1f - srl t2, t1, GC_CARD_SHIFT - addu t3, a2, t2 - sb a2, (t3) - 1: - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SPUT_BOOLEAN_JUMBO */ - -.LOP_SPUT_BOOLEAN_JUMBO_finish: - # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - # no-op # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - # no-op - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SPUT_BYTE_JUMBO */ - -.LOP_SPUT_BYTE_JUMBO_finish: - # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - # no-op # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - # no-op - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SPUT_CHAR_JUMBO */ - -.LOP_SPUT_CHAR_JUMBO_finish: - # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - # no-op # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - # no-op - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SPUT_SHORT_JUMBO */ - -.LOP_SPUT_SHORT_JUMBO_finish: - # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - # no-op # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - # no-op - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_INVOKE_VIRTUAL_JUMBO */ - - /* - * At this point: - * a0 = resolved base method - * rBIX= C or CCCC (index of first arg, which is the "this" ptr) - */ -.LOP_INVOKE_VIRTUAL_JUMBO_continue: - FETCH(rBIX,4) # rBIX <- CCCC - GET_VREG(rOBJ, rBIX) # rOBJ <- "this" ptr - LOADu2_offMethod_methodIndex(a2, a0) # a2 <- baseMethod->methodIndex - # is "this" null? - beqz rOBJ, common_errNullObject # null "this", throw exception - LOAD_base_offObject_clazz(a3, rOBJ) # a3 <- thisPtr->clazz - LOAD_base_offClassObject_vtable(a3, a3) # a3 <- thisPtr->clazz->vtable - LOAD_eas2(a0, a3, a2) # a0 <- vtable[methodIndex] - b common_invokeMethodJumbo # (a0=method, rOBJ="this") - - -/* continuation for OP_INVOKE_SUPER_JUMBO */ - - /* - * At this point: - * a0 = resolved base method - * rBIX = method->clazz - */ -.LOP_INVOKE_SUPER_JUMBO_continue: - LOAD_base_offClassObject_super(a1, rBIX) # a1 <- method->clazz->super - LOADu2_offMethod_methodIndex(a2, a0) # a2 <- baseMethod->methodIndex - LOAD_base_offClassObject_vtableCount(a3, a1) # a3 <- super->vtableCount - EXPORT_PC() # must export for invoke - # compare (methodIndex, vtableCount) - bgeu a2, a3, .LOP_INVOKE_SUPER_JUMBO_nsm # method not present in superclass - LOAD_base_offClassObject_vtable(a1, a1) # a1 <- ...clazz->super->vtable - LOAD_eas2(a0, a1, a2) # a0 <- vtable[methodIndex] - b common_invokeMethodJumbo # a0=method rOBJ="this" - - /* - * Throw a NoSuchMethodError with the method name as the message. - * a0 = resolved base method - */ -.LOP_INVOKE_SUPER_JUMBO_nsm: - LOAD_base_offMethod_name(a1, a0) # a1 <- method name - b common_errNoSuchMethod - - -/* continuation for OP_INVOKE_STATIC_JUMBO */ - -.LOP_INVOKE_STATIC_JUMBO_resolve: - LOAD_rSELF_method(a3) # a3 <- self->method - LOAD_base_offMethod_clazz(a0, a3) # a0 <- method->clazz - li a2, METHOD_STATIC # resolver method type - JAL(dvmResolveMethod) # v0 <- call(clazz, ref, flags) - move a0, v0 -#if defined(WITH_JIT) - /* - * Check to see if we're actively building a trace. If so, - * we need to keep this instruction out of it. - * rBIX: &resolved_methodToCall - */ - lhu a2, offThread_subMode(rSELF) - beqz v0, common_exceptionThrown # null, handle exception - and a2, kSubModeJitTraceBuild # trace under construction? - beqz a2, common_invokeMethodJumboNoThis # no, (a0=method, rOBJ="this") - lw a1, 0(rBIX) # reload resolved method - # finished resloving? - bnez a1, common_invokeMethodJumboNoThis # yes, (a0=method, rOBJ="this") - move rBIX, a0 # preserve method - move a0, rSELF - move a1, rPC - JAL(dvmJitEndTraceSelect) # (self, pc) - move a0, rBIX - b common_invokeMethodJumboNoThis # whew, finally! -#else - # got null? - bnez v0, common_invokeMethodJumboNoThis # (a0=method, rOBJ="this") - b common_exceptionThrown # yes, handle exception -#endif - -/* continuation for OP_INVOKE_OBJECT_INIT_JUMBO */ - /* - * A debugger is attached, so we need to go ahead and do - * this. For simplicity, we'll just jump directly to the - * corresponding handler. Note that we can't use - * rIBASE here because it may be in single-step mode. - * Load the primary table base directly. - */ -.LOP_INVOKE_OBJECT_INIT_JUMBO_debugger: - lw a1, offThread_mainHandlerTable(rSELF) - .if 1 - li t0, OP_INVOKE_DIRECT_JUMBO - .else - li t0, OP_INVOKE_DIRECT_RANGE - .endif - GOTO_OPCODE_BASE(a1, t0) # execute it - -/* continuation for OP_IGET_VOLATILE_JUMBO */ - -.LOP_IGET_VOLATILE_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_VOLATILE_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - SMP_DMB # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_WIDE_VOLATILE_JUMBO */ - -.LOP_IGET_WIDE_VOLATILE_JUMBO_resolved: - # test return code - move a0, v0 - bnez v0, .LOP_IGET_WIDE_VOLATILE_JUMBO_finish - b common_exceptionThrown - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IGET_WIDE_VOLATILE_JUMBO_finish: - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - beqz rOBJ, common_errNullObject # object was null - GET_OPA4(a2) # a2 <- A+ - addu rOBJ, rOBJ, a3 # form address - .if 1 - vLOAD64(a0, a1, rOBJ) # a0/a1 <- obj.field (64-bit align ok) - .else - LOAD64(a0, a1, rOBJ) # a0/a1 <- obj.field (64-bit align ok) - .endif - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - EAS2(a3, rFP, a2) # a3 <- &fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - STORE64(a0, a1, a3) # fp[BBBB] <- a0/a1 - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IGET_OBJECT_VOLATILE_JUMBO */ - -.LOP_IGET_OBJECT_VOLATILE_JUMBO_resolved: - # test results - move a0, v0 - beqz a0,common_exceptionThrown - /* - * Currently: - * v0 holds resolved field - * rOBJ holds object (caller saved) - */ -.LOP_IGET_OBJECT_VOLATILE_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - # check object for null - beqz rOBJ, common_errNullObject # object was null - addu a3, a3, rOBJ # form address - lw a0, (a3) # a0 <- obj.field (8/16/32 bits) - SMP_DMB # acquiring load - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - SET_VREG(a0, a2) # fp[BBBB]<- a0 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_VOLATILE_JUMBO */ - -.LOP_IPUT_VOLATILE_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_VOLATILE_JUMBO_finish - - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_VOLATILE_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu rOBJ, rOBJ, a3 # form address - SMP_DMB_ST # releasing store - sw a0, (rOBJ) # obj.field (8/16/32 bits) <- a0 - SMP_DMB - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_IPUT_WIDE_VOLATILE_JUMBO */ - -.LOP_IPUT_WIDE_VOLATILE_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_WIDE_VOLATILE_JUMBO_finish - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_WIDE_VOLATILE_JUMBO_finish: - FETCH(a2, 3) # a1<- BBBB - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - EAS2(a2, rFP, a2) # a2 <- &fp[BBBB] - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - LOAD64(a0, a1, a2) # a0/a1 <- fp[BBBB] - GET_INST_OPCODE(rBIX) # extract opcode from rINST - addu a2, rOBJ, a3 # form address - .if 1 - JAL(dvmQuasiAtomicSwap64Sync) # stores r0/r1 into addr r2 -# STORE64(a0, a1, a2) # obj.field (64 bits, aligned) <- a0 a1 - .else - STORE64(a0, a1, a2) # obj.field (64 bits, aligned) <- a0 a1 - .endif - GOTO_OPCODE(rBIX) # jump to next instruction - - - -/* continuation for OP_IPUT_OBJECT_VOLATILE_JUMBO */ - - /* - * Currently: - * a0 holds resolved field - * rOBJ holds object - */ -.LOP_IPUT_OBJECT_VOLATILE_JUMBO_resolved: - move a0, v0 - beqz a0, common_exceptionThrown - # fall through to OP_IPUT_OBJECT_VOLATILE_JUMBO_finish - -.LOP_IPUT_OBJECT_VOLATILE_JUMBO_finish: - #BAL(common_squeak0) - LOAD_base_offInstField_byteOffset(a3, a0) # a3 <- byte offset of field - FETCH(a1, 3) # a1<- BBBB - GET_VREG(a0, a1) # a0 <- fp[BBBB] - lw a2, offThread_cardTable(rSELF) # a2 <- card table base - # check object for null - beqz rOBJ, common_errNullObject # object was null - FETCH_ADVANCE_INST(5) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - addu t2, rOBJ, a3 # form address - SMP_DMB_ST # releasing store - sw a0, (t2) # obj.field (32 bits) <- a0 - SMP_DMB - beqz a0, 1f # stored a null reference? - srl t1, rOBJ, GC_CARD_SHIFT - addu t2, a2, t1 - sb a2, (t2) # mark card if not -1: - GOTO_OPCODE(t0) # jump to next instruction - - -/* continuation for OP_SGET_VOLATILE_JUMBO */ - -.LOP_SGET_VOLATILE_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - SMP_DMB # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SGET_WIDE_VOLATILE_JUMBO */ - -.LOP_SGET_WIDE_VOLATILE_JUMBO_finish: - FETCH(a1, 3) # a1<- BBBB - .if 1 - vLOAD64_off(a2, a3, a0, offStaticField_value) # a2/a3 <- field value (aligned) - .else - LOAD64_off(a2, a3, a0, offStaticField_value) # a2/a3 <- field value (aligned) - .endif - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - EAS2(a1, rFP, a1) # a1 <- &fp[BBBB] - STORE64(a2, a3, a1) # vBBBB/vBBBB+1 <- a2/a3 - GET_INST_OPCODE(t0) # extract opcode from rINST - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SGET_OBJECT_VOLATILE_JUMBO */ - -.LOP_SGET_OBJECT_VOLATILE_JUMBO_finish: - LOAD_base_offStaticField_value(a1, a0) # a1 <- field value - SMP_DMB # acquiring load - FETCH(a2, 3) # r2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_INST_OPCODE(t0) # extract opcode from rINST - SET_VREG_GOTO(a1, a2, t0) # fp[BBBB] <- a1 - -/* continuation for OP_SPUT_VOLATILE_JUMBO */ - -.LOP_SPUT_VOLATILE_JUMBO_finish: - # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - GET_INST_OPCODE(t0) # extract opcode from rINST - SMP_DMB_ST # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - SMP_DMB - GOTO_OPCODE(t0) # jump to next instruction - -/* continuation for OP_SPUT_WIDE_VOLATILE_JUMBO */ - - /* - * Continuation if the field has not yet been resolved. - * a1: AAAAAAAA field ref - * rOBJ: &fp[BBBB] - * rBIX: dvmDex->pResFields - * - * Returns StaticField pointer in a2. - */ -.LOP_SPUT_WIDE_VOLATILE_JUMBO_resolve: - LOAD_rSELF_method(a2) # a2 <- current method -#if defined(WITH_JIT) - EAS2(rBIX, rBIX, a1) # rBIX<- &dvmDex->pResFields[field] -#endif - EXPORT_PC() # resolve() could throw, so export now - LOAD_base_offMethod_clazz(a0, a2) # a0 <- method->clazz - JAL(dvmResolveStaticField) # v0 <- resolved StaticField ptr - # success ? - move a0, v0 - beqz v0, common_exceptionThrown # no, handle exception -#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 this instruction. - */ - JAL(common_verifyField) -#endif - move a2, v0 - b .LOP_SPUT_WIDE_VOLATILE_JUMBO_finish # resume - -/* continuation for OP_SPUT_OBJECT_VOLATILE_JUMBO */ -.LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish: # field ptr in a0 - FETCH(a2, 3) # a2<- BBBB - FETCH_ADVANCE_INST(4) # advance rPC, load rINST - GET_VREG(a1, a2) # a1 <- fp[BBBB] - lw a2, offThread_cardTable(rSELF) # a2 <- card table base - lw t1, offField_clazz(a0) # t1 <- field->clazz - GET_INST_OPCODE(t0) # extract opcode from rINST - SMP_DMB_ST # releasing store - sw a1, offStaticField_value(a0) # field <- vBBBB - SMP_DMB - beqz a1, 1f - srl t2, t1, GC_CARD_SHIFT - addu t3, a2, t2 - sb a2, (t3) - 1: - GOTO_OPCODE(t0) # jump to next instruction - .size dvmAsmSisterStart, .-dvmAsmSisterStart .global dvmAsmSisterEnd dvmAsmSisterEnd: @@ -23530,7 +18593,7 @@ dvmAsmAltInstructionStart = .L_ALT_OP_NOP /* ------------------------------ */ .balign 128 -.L_ALT_OP_DISPATCH_FF: /* 0xff */ +.L_ALT_OP_UNUSED_FF: /* 0xff */ /* File: mips/alt_stub.S */ /* * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle @@ -23553,6406 +18616,6 @@ dvmAsmAltInstructionStart = .L_ALT_OP_NOP JAL(dvmCheckBefore) jr rBIX -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (256 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (257 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (258 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (259 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (260 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (261 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_JUMBO: /* 0x106 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (262 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (263 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (264 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (265 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (266 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (267 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (268 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_JUMBO: /* 0x10d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (269 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (270 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (271 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (272 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (273 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (274 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (275 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_JUMBO: /* 0x114 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (276 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (277 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (278 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (279 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (280 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (281 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (282 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_JUMBO: /* 0x11b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (283 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (284 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (285 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (286 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (287 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (288 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (289 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (290 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (291 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (292 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (293 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (294 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_27FF: /* 0x127 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (295 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_28FF: /* 0x128 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (296 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_29FF: /* 0x129 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (297 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_2AFF: /* 0x12a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (298 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_2BFF: /* 0x12b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (299 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_2CFF: /* 0x12c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (300 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_2DFF: /* 0x12d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (301 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_2EFF: /* 0x12e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (302 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_2FFF: /* 0x12f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (303 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_30FF: /* 0x130 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (304 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_31FF: /* 0x131 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (305 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_32FF: /* 0x132 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (306 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_33FF: /* 0x133 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (307 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_34FF: /* 0x134 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (308 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_35FF: /* 0x135 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (309 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_36FF: /* 0x136 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (310 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_37FF: /* 0x137 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (311 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_38FF: /* 0x138 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (312 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_39FF: /* 0x139 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (313 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_3AFF: /* 0x13a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (314 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_3BFF: /* 0x13b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (315 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_3CFF: /* 0x13c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (316 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_3DFF: /* 0x13d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (317 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_3EFF: /* 0x13e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (318 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_3FFF: /* 0x13f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (319 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_40FF: /* 0x140 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (320 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_41FF: /* 0x141 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (321 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_42FF: /* 0x142 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (322 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_43FF: /* 0x143 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (323 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_44FF: /* 0x144 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (324 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_45FF: /* 0x145 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (325 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_46FF: /* 0x146 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (326 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_47FF: /* 0x147 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (327 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_48FF: /* 0x148 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (328 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_49FF: /* 0x149 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (329 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_4AFF: /* 0x14a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (330 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_4BFF: /* 0x14b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (331 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_4CFF: /* 0x14c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (332 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_4DFF: /* 0x14d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (333 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_4EFF: /* 0x14e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (334 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_4FFF: /* 0x14f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (335 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_50FF: /* 0x150 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (336 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_51FF: /* 0x151 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (337 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_52FF: /* 0x152 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (338 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_53FF: /* 0x153 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (339 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_54FF: /* 0x154 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (340 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_55FF: /* 0x155 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (341 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_56FF: /* 0x156 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (342 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_57FF: /* 0x157 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (343 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_58FF: /* 0x158 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (344 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_59FF: /* 0x159 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (345 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_5AFF: /* 0x15a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (346 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_5BFF: /* 0x15b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (347 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_5CFF: /* 0x15c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (348 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_5DFF: /* 0x15d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (349 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_5EFF: /* 0x15e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (350 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_5FFF: /* 0x15f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (351 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_60FF: /* 0x160 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (352 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_61FF: /* 0x161 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (353 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_62FF: /* 0x162 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (354 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_63FF: /* 0x163 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (355 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_64FF: /* 0x164 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (356 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_65FF: /* 0x165 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (357 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_66FF: /* 0x166 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (358 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_67FF: /* 0x167 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (359 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_68FF: /* 0x168 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (360 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_69FF: /* 0x169 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (361 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_6AFF: /* 0x16a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (362 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_6BFF: /* 0x16b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (363 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_6CFF: /* 0x16c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (364 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_6DFF: /* 0x16d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (365 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_6EFF: /* 0x16e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (366 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_6FFF: /* 0x16f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (367 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_70FF: /* 0x170 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (368 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_71FF: /* 0x171 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (369 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_72FF: /* 0x172 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (370 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_73FF: /* 0x173 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (371 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_74FF: /* 0x174 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (372 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_75FF: /* 0x175 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (373 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_76FF: /* 0x176 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (374 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_77FF: /* 0x177 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (375 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_78FF: /* 0x178 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (376 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_79FF: /* 0x179 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (377 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_7AFF: /* 0x17a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (378 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_7BFF: /* 0x17b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (379 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_7CFF: /* 0x17c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (380 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_7DFF: /* 0x17d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (381 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_7EFF: /* 0x17e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (382 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_7FFF: /* 0x17f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (383 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_80FF: /* 0x180 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (384 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_81FF: /* 0x181 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (385 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_82FF: /* 0x182 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (386 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_83FF: /* 0x183 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (387 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_84FF: /* 0x184 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (388 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_85FF: /* 0x185 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (389 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_86FF: /* 0x186 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (390 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_87FF: /* 0x187 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (391 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_88FF: /* 0x188 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (392 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_89FF: /* 0x189 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (393 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_8AFF: /* 0x18a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (394 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_8BFF: /* 0x18b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (395 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_8CFF: /* 0x18c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (396 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_8DFF: /* 0x18d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (397 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_8EFF: /* 0x18e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (398 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_8FFF: /* 0x18f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (399 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_90FF: /* 0x190 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (400 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_91FF: /* 0x191 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (401 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_92FF: /* 0x192 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (402 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_93FF: /* 0x193 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (403 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_94FF: /* 0x194 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (404 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_95FF: /* 0x195 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (405 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_96FF: /* 0x196 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (406 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_97FF: /* 0x197 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (407 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_98FF: /* 0x198 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (408 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_99FF: /* 0x199 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (409 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_9AFF: /* 0x19a */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (410 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_9BFF: /* 0x19b */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (411 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_9CFF: /* 0x19c */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (412 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_9DFF: /* 0x19d */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (413 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_9EFF: /* 0x19e */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (414 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_9FFF: /* 0x19f */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (415 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (416 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (417 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (418 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (419 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (420 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (421 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (422 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (423 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (424 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (425 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_AAFF: /* 0x1aa */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (426 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_ABFF: /* 0x1ab */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (427 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_ACFF: /* 0x1ac */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (428 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_ADFF: /* 0x1ad */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (429 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_AEFF: /* 0x1ae */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (430 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_AFFF: /* 0x1af */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (431 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (432 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (433 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (434 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (435 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (436 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (437 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (438 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (439 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (440 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (441 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_BAFF: /* 0x1ba */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (442 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_BBFF: /* 0x1bb */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (443 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_BCFF: /* 0x1bc */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (444 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_BDFF: /* 0x1bd */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (445 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_BEFF: /* 0x1be */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (446 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_BFFF: /* 0x1bf */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (447 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (448 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (449 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (450 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (451 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (452 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (453 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (454 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (455 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (456 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (457 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_CAFF: /* 0x1ca */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (458 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_CBFF: /* 0x1cb */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (459 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_CCFF: /* 0x1cc */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (460 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_CDFF: /* 0x1cd */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (461 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_CEFF: /* 0x1ce */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (462 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_CFFF: /* 0x1cf */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (463 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (464 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (465 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (466 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (467 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (468 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (469 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (470 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (471 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (472 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (473 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_DAFF: /* 0x1da */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (474 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_DBFF: /* 0x1db */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (475 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_DCFF: /* 0x1dc */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (476 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_DDFF: /* 0x1dd */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (477 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_DEFF: /* 0x1de */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (478 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_DFFF: /* 0x1df */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (479 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (480 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (481 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (482 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (483 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (484 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (485 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (486 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (487 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (488 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (489 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_EAFF: /* 0x1ea */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (490 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_EBFF: /* 0x1eb */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (491 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_ECFF: /* 0x1ec */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (492 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_EDFF: /* 0x1ed */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (493 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_EEFF: /* 0x1ee */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (494 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_EFFF: /* 0x1ef */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (495 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (496 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (497 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (498 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (499 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (500 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (501 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (502 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (503 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (504 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (505 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (506 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (507 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (508 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (509 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (510 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - -/* ------------------------------ */ - .balign 128 -.L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ -/* File: mips/alt_stub.S */ -/* - * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle - * any interesting requests and then jump to the real instruction - * handler. Note that the call to dvmCheckBefore is done as a tail call. - * rIBASE updates won't be seen until a refresh, and we can tell we have a - * stale rIBASE if breakFlags==0. Always refresh rIBASE here, and then - * bail to the real handler if breakFlags==0. - */ - lbu a3, offThread_breakFlags(rSELF) - la rBIX, dvmAsmInstructionStart + (511 * 128) - lw rIBASE, offThread_curHandlerTable(rSELF) - bnez a3, 1f - jr rBIX # nothing to do - jump to real handler -1: - EXPORT_PC() - move a0, rPC # arg0 - move a1, rFP # arg1 - move a2, rSELF # arg2 - JAL(dvmCheckBefore) - jr rBIX - .balign 128 .size dvmAsmAltInstructionStart, .-dvmAsmAltInstructionStart .global dvmAsmAltInstructionEnd diff --git a/vm/mterp/out/InterpC-mips.cpp b/vm/mterp/out/InterpC-mips.cpp index 02f885663..69260da39 100644 --- a/vm/mterp/out/InterpC-mips.cpp +++ b/vm/mterp/out/InterpC-mips.cpp @@ -110,7 +110,7 @@ { \ char* desc; \ desc = dexProtoCopyMethodDescriptor(&curMethod->prototype); \ - LOGE("Invalid branch %d at 0x%04x in %s.%s %s", \ + ALOGE("Invalid branch %d at 0x%04x in %s.%s %s", \ myoff, (int) (pc - curMethod->insns), \ curMethod->clazz->descriptor, curMethod->name, desc); \ free(desc); \ @@ -136,10 +136,10 @@ char debugStrBuf[128]; \ snprintf(debugStrBuf, sizeof(debugStrBuf), __VA_ARGS__); \ if (curMethod != NULL) \ - LOG(_level, LOG_TAG"i", "%-2d|%04x%s", \ + ALOG(_level, LOG_TAG"i", "%-2d|%04x%s", \ self->threadId, (int)(pc - curMethod->insns), debugStrBuf); \ else \ - LOG(_level, LOG_TAG"i", "%-2d|####%s", \ + ALOG(_level, LOG_TAG"i", "%-2d|####%s", \ self->threadId, debugStrBuf); \ } while(false) void dvmDumpRegs(const Method* method, const u4* framePtr, bool inOnly); @@ -328,15 +328,15 @@ static inline bool checkForNull(Object* obj) return false; } #ifdef WITH_EXTRA_OBJECT_VALIDATION - if (!dvmIsHeapAddressObject(obj)) { - LOGE("Invalid object %p", obj); + if (!dvmIsHeapAddress(obj)) { + ALOGE("Invalid object %p", obj); dvmAbort(); } #endif #ifndef NDEBUG if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) { /* probable heap corruption */ - LOGE("Invalid object class %p (in %p)", obj->clazz, obj); + ALOGE("Invalid object class %p (in %p)", obj->clazz, obj); dvmAbort(); } #endif @@ -361,14 +361,14 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } #ifdef WITH_EXTRA_OBJECT_VALIDATION if (!dvmIsHeapAddress(obj)) { - LOGE("Invalid object %p", obj); + ALOGE("Invalid object %p", obj); dvmAbort(); } #endif #ifndef NDEBUG if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) { /* probable heap corruption */ - LOGE("Invalid object class %p (in %p)", obj->clazz, obj); + ALOGE("Invalid object class %p (in %p)", obj->clazz, obj); dvmAbort(); } #endif @@ -481,9 +481,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) return; \ } while(false) -#define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ +#define GOTO_invoke(_target, _methodCallRange) \ do { \ - dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange); \ return; \ } while(false) @@ -515,14 +515,14 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* File: c/opcommon.cpp */ /* forward declarations of goto targets */ -GOTO_TARGET_DECL(filledNewArray, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeVirtual, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeSuper, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeInterface, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeDirect, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeStatic, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeVirtualQuick, bool methodCallRange, bool jumboFormat); -GOTO_TARGET_DECL(invokeSuperQuick, bool methodCallRange, bool jumboFormat); +GOTO_TARGET_DECL(filledNewArray, bool methodCallRange); +GOTO_TARGET_DECL(invokeVirtual, bool methodCallRange); +GOTO_TARGET_DECL(invokeSuper, bool methodCallRange); +GOTO_TARGET_DECL(invokeInterface, bool methodCallRange); +GOTO_TARGET_DECL(invokeDirect, bool methodCallRange); +GOTO_TARGET_DECL(invokeStatic, bool methodCallRange); +GOTO_TARGET_DECL(invokeVirtualQuick, bool methodCallRange); +GOTO_TARGET_DECL(invokeSuperQuick, bool methodCallRange); GOTO_TARGET_DECL(invokeMethod, bool methodCallRange, const Method* methodToCall, u2 count, u2 regs); GOTO_TARGET_DECL(returnFromMethod); @@ -1046,33 +1046,6 @@ GOTO_TARGET_DECL(exceptionThrown); } \ FINISH(2); -#define HANDLE_IGET_X_JUMBO(_opcode, _opname, _ftype, _regsize) \ - HANDLE_OPCODE(_opcode /*vBBBB, vCCCC, class@AAAAAAAA*/) \ - { \ - InstField* ifield; \ - Object* obj; \ - EXPORT_PC(); \ - ref = FETCH(1) | (u4)FETCH(2) << 16; /* field ref */ \ - vdst = FETCH(3); \ - vsrc1 = FETCH(4); /* object ptr */ \ - ILOGV("|iget%s/jumbo v%d,v%d,field@0x%08x", \ - (_opname), vdst, vsrc1, ref); \ - obj = (Object*) GET_REGISTER(vsrc1); \ - if (!checkForNull(obj)) \ - GOTO_exceptionThrown(); \ - ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \ - if (ifield == NULL) { \ - ifield = dvmResolveInstField(curMethod->clazz, ref); \ - if (ifield == NULL) \ - GOTO_exceptionThrown(); \ - } \ - SET_REGISTER##_regsize(vdst, \ - dvmGetField##_ftype(obj, ifield->byteOffset)); \ - ILOGV("+ IGET '%s'=0x%08llx", ifield->name, \ - (u8) GET_REGISTER##_regsize(vdst)); \ - } \ - FINISH(5); - #define HANDLE_IGET_X_QUICK(_opcode, _opname, _ftype, _regsize) \ HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/) \ { \ @@ -1117,33 +1090,6 @@ GOTO_TARGET_DECL(exceptionThrown); } \ FINISH(2); -#define HANDLE_IPUT_X_JUMBO(_opcode, _opname, _ftype, _regsize) \ - HANDLE_OPCODE(_opcode /*vBBBB, vCCCC, class@AAAAAAAA*/) \ - { \ - InstField* ifield; \ - Object* obj; \ - EXPORT_PC(); \ - ref = FETCH(1) | (u4)FETCH(2) << 16; /* field ref */ \ - vdst = FETCH(3); \ - vsrc1 = FETCH(4); /* object ptr */ \ - ILOGV("|iput%s/jumbo v%d,v%d,field@0x%08x", \ - (_opname), vdst, vsrc1, ref); \ - obj = (Object*) GET_REGISTER(vsrc1); \ - if (!checkForNull(obj)) \ - GOTO_exceptionThrown(); \ - ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \ - if (ifield == NULL) { \ - ifield = dvmResolveInstField(curMethod->clazz, ref); \ - if (ifield == NULL) \ - GOTO_exceptionThrown(); \ - } \ - dvmSetField##_ftype(obj, ifield->byteOffset, \ - GET_REGISTER##_regsize(vdst)); \ - ILOGV("+ IPUT '%s'=0x%08llx", ifield->name, \ - (u8) GET_REGISTER##_regsize(vdst)); \ - } \ - FINISH(5); - #define HANDLE_IPUT_X_QUICK(_opcode, _opname, _ftype, _regsize) \ HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/) \ { \ @@ -1193,29 +1139,6 @@ GOTO_TARGET_DECL(exceptionThrown); } \ FINISH(2); -#define HANDLE_SGET_X_JUMBO(_opcode, _opname, _ftype, _regsize) \ - HANDLE_OPCODE(_opcode /*vBBBB, class@AAAAAAAA*/) \ - { \ - StaticField* sfield; \ - ref = FETCH(1) | (u4)FETCH(2) << 16; /* field ref */ \ - vdst = FETCH(3); \ - ILOGV("|sget%s/jumbo v%d,sfield@0x%08x", (_opname), vdst, ref); \ - sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \ - if (sfield == NULL) { \ - EXPORT_PC(); \ - sfield = dvmResolveStaticField(curMethod->clazz, ref); \ - if (sfield == NULL) \ - GOTO_exceptionThrown(); \ - if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \ - JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \ - } \ - } \ - SET_REGISTER##_regsize(vdst, dvmGetStaticField##_ftype(sfield)); \ - ILOGV("+ SGET '%s'=0x%08llx", \ - sfield->name, (u8)GET_REGISTER##_regsize(vdst)); \ - } \ - FINISH(4); - #define HANDLE_SPUT_X(_opcode, _opname, _ftype, _regsize) \ HANDLE_OPCODE(_opcode /*vAA, field@BBBB*/) \ { \ @@ -1239,29 +1162,6 @@ GOTO_TARGET_DECL(exceptionThrown); } \ FINISH(2); -#define HANDLE_SPUT_X_JUMBO(_opcode, _opname, _ftype, _regsize) \ - HANDLE_OPCODE(_opcode /*vBBBB, class@AAAAAAAA*/) \ - { \ - StaticField* sfield; \ - ref = FETCH(1) | (u4)FETCH(2) << 16; /* field ref */ \ - vdst = FETCH(3); \ - ILOGV("|sput%s/jumbo v%d,sfield@0x%08x", (_opname), vdst, ref); \ - sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \ - if (sfield == NULL) { \ - EXPORT_PC(); \ - sfield = dvmResolveStaticField(curMethod->clazz, ref); \ - if (sfield == NULL) \ - GOTO_exceptionThrown(); \ - if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \ - JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \ - } \ - } \ - dvmSetStaticField##_ftype(sfield, GET_REGISTER##_regsize(vdst)); \ - ILOGV("+ SPUT '%s'=0x%08llx", \ - sfield->name, (u8)GET_REGISTER##_regsize(vdst)); \ - } \ - FINISH(4); - /* File: c/OP_BREAKPOINT.cpp */ HANDLE_OPCODE(OP_BREAKPOINT) { @@ -1281,21 +1181,13 @@ HANDLE_OPCODE(OP_BREAKPOINT) * the thread resumed. */ u1 originalOpcode = dvmGetOriginalOpcode(pc); - LOGV("+++ break 0x%02x (0x%04x -> 0x%04x)", originalOpcode, inst, + ALOGV("+++ break 0x%02x (0x%04x -> 0x%04x)", originalOpcode, inst, INST_REPLACE_OP(inst, originalOpcode)); inst = INST_REPLACE_OP(inst, originalOpcode); FINISH_BKPT(originalOpcode); } OP_END -/* File: c/OP_DISPATCH_FF.cpp */ -HANDLE_OPCODE(OP_DISPATCH_FF) - /* - * Indicates extended opcode. Use next 8 bits to choose where to branch. - */ - DISPATCH_EXTENDED(INST_AA(inst)); -OP_END - /* File: c/gotoTargets.cpp */ /* * C footer. This has some common code shared by the various targets. @@ -1307,7 +1199,7 @@ OP_END * next instruction. Here, these are subroutines that return to the caller. */ -GOTO_TARGET(filledNewArray, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(filledNewArray, bool methodCallRange, bool) { ClassObject* arrayClass; ArrayObject* newArray; @@ -1318,28 +1210,19 @@ GOTO_TARGET(filledNewArray, bool methodCallRange, bool jumboFormat) EXPORT_PC(); - if (jumboFormat) { - ref = FETCH(1) | (u4)FETCH(2) << 16; /* class ref */ - vsrc1 = FETCH(3); /* #of elements */ - vdst = FETCH(4); /* range base */ - arg5 = -1; /* silence compiler warning */ - ILOGV("|filled-new-array/jumbo args=%d @0x%08x {regs=v%d-v%d}", + ref = FETCH(1); /* class ref */ + vdst = FETCH(2); /* first 4 regs -or- range base */ + + if (methodCallRange) { + vsrc1 = INST_AA(inst); /* #of elements */ + arg5 = -1; /* silence compiler warning */ + ILOGV("|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}", vsrc1, ref, vdst, vdst+vsrc1-1); } else { - ref = FETCH(1); /* class ref */ - vdst = FETCH(2); /* first 4 regs -or- range base */ - - if (methodCallRange) { - vsrc1 = INST_AA(inst); /* #of elements */ - arg5 = -1; /* silence compiler warning */ - ILOGV("|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - } else { - arg5 = INST_A(inst); - vsrc1 = INST_B(inst); /* #of elements */ - ILOGV("|filled-new-array args=%d @0x%04x {regs=0x%04x %x}", - vsrc1, ref, vdst, arg5); - } + arg5 = INST_A(inst); + vsrc1 = INST_B(inst); /* #of elements */ + ILOGV("|filled-new-array args=%d @0x%04x {regs=0x%04x %x}", + vsrc1, ref, vdst, arg5); } /* @@ -1373,7 +1256,7 @@ GOTO_TARGET(filledNewArray, bool methodCallRange, bool jumboFormat) GOTO_exceptionThrown(); } else if (typeCh != 'L' && typeCh != '[' && typeCh != 'I') { /* TODO: requires multiple "fill in" loops with different widths */ - LOGE("non-int primitives not implemented"); + ALOGE("non-int primitives not implemented"); dvmThrowInternalError( "filled-new-array not implemented for anything but 'int'"); GOTO_exceptionThrown(); @@ -1407,49 +1290,35 @@ GOTO_TARGET(filledNewArray, bool methodCallRange, bool jumboFormat) retval.l = (Object*)newArray; } - if (jumboFormat) { - FINISH(5); - } else { - FINISH(3); - } + FINISH(3); GOTO_TARGET_END -GOTO_TARGET(invokeVirtual, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeVirtual, bool methodCallRange, bool) { Method* baseMethod; Object* thisPtr; EXPORT_PC(); - if (jumboFormat) { - ref = FETCH(1) | (u4)FETCH(2) << 16; /* method ref */ - vsrc1 = FETCH(3); /* count */ - vdst = FETCH(4); /* first reg */ - ADJUST_PC(2); /* advance pc partially to make returns easier */ - ILOGV("|invoke-virtual/jumbo args=%d @0x%08x {regs=v%d-v%d}", + vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ + ref = FETCH(1); /* method ref */ + vdst = FETCH(2); /* 4 regs -or- first reg */ + + /* + * The object against which we are executing a method is always + * in the first argument. + */ + if (methodCallRange) { + assert(vsrc1 > 0); + ILOGV("|invoke-virtual-range args=%d @0x%04x {regs=v%d-v%d}", vsrc1, ref, vdst, vdst+vsrc1-1); thisPtr = (Object*) GET_REGISTER(vdst); } else { - vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ - ref = FETCH(1); /* method ref */ - vdst = FETCH(2); /* 4 regs -or- first reg */ - - /* - * The object against which we are executing a method is always - * in the first argument. - */ - if (methodCallRange) { - assert(vsrc1 > 0); - ILOGV("|invoke-virtual-range args=%d @0x%04x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - thisPtr = (Object*) GET_REGISTER(vdst); - } else { - assert((vsrc1>>4) > 0); - ILOGV("|invoke-virtual args=%d @0x%04x {regs=0x%04x %x}", - vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); - thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); - } + assert((vsrc1>>4) > 0); + ILOGV("|invoke-virtual args=%d @0x%04x {regs=0x%04x %x}", + vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); + thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); } if (!checkForNull(thisPtr)) @@ -1507,7 +1376,7 @@ GOTO_TARGET(invokeVirtual, bool methodCallRange, bool jumboFormat) #if 0 if (vsrc1 != methodToCall->insSize) { - LOGW("WRONG METHOD: base=%s.%s virtual[%d]=%s.%s", + ALOGW("WRONG METHOD: base=%s.%s virtual[%d]=%s.%s", baseMethod->clazz->descriptor, baseMethod->name, (u4) baseMethod->methodIndex, methodToCall->clazz->descriptor, methodToCall->name); @@ -1521,35 +1390,25 @@ GOTO_TARGET(invokeVirtual, bool methodCallRange, bool jumboFormat) } GOTO_TARGET_END -GOTO_TARGET(invokeSuper, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeSuper, bool methodCallRange) { Method* baseMethod; u2 thisReg; EXPORT_PC(); - if (jumboFormat) { - ref = FETCH(1) | (u4)FETCH(2) << 16; /* method ref */ - vsrc1 = FETCH(3); /* count */ - vdst = FETCH(4); /* first reg */ - ADJUST_PC(2); /* advance pc partially to make returns easier */ - ILOGV("|invoke-super/jumbo args=%d @0x%08x {regs=v%d-v%d}", + vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ + ref = FETCH(1); /* method ref */ + vdst = FETCH(2); /* 4 regs -or- first reg */ + + if (methodCallRange) { + ILOGV("|invoke-super-range args=%d @0x%04x {regs=v%d-v%d}", vsrc1, ref, vdst, vdst+vsrc1-1); thisReg = vdst; } else { - vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ - ref = FETCH(1); /* method ref */ - vdst = FETCH(2); /* 4 regs -or- first reg */ - - if (methodCallRange) { - ILOGV("|invoke-super-range args=%d @0x%04x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - thisReg = vdst; - } else { - ILOGV("|invoke-super args=%d @0x%04x {regs=0x%04x %x}", - vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); - thisReg = vdst & 0x0f; - } + ILOGV("|invoke-super args=%d @0x%04x {regs=0x%04x %x}", + vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); + thisReg = vdst & 0x0f; } /* impossible in well-formed code, but we must check nevertheless */ @@ -1609,41 +1468,31 @@ GOTO_TARGET(invokeSuper, bool methodCallRange, bool jumboFormat) } GOTO_TARGET_END -GOTO_TARGET(invokeInterface, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeInterface, bool methodCallRange) { Object* thisPtr; ClassObject* thisClass; EXPORT_PC(); - if (jumboFormat) { - ref = FETCH(1) | (u4)FETCH(2) << 16; /* method ref */ - vsrc1 = FETCH(3); /* count */ - vdst = FETCH(4); /* first reg */ - ADJUST_PC(2); /* advance pc partially to make returns easier */ - ILOGV("|invoke-interface/jumbo args=%d @0x%08x {regs=v%d-v%d}", + vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ + ref = FETCH(1); /* method ref */ + vdst = FETCH(2); /* 4 regs -or- first reg */ + + /* + * The object against which we are executing a method is always + * in the first argument. + */ + if (methodCallRange) { + assert(vsrc1 > 0); + ILOGV("|invoke-interface-range args=%d @0x%04x {regs=v%d-v%d}", vsrc1, ref, vdst, vdst+vsrc1-1); thisPtr = (Object*) GET_REGISTER(vdst); } else { - vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ - ref = FETCH(1); /* method ref */ - vdst = FETCH(2); /* 4 regs -or- first reg */ - - /* - * The object against which we are executing a method is always - * in the first argument. - */ - if (methodCallRange) { - assert(vsrc1 > 0); - ILOGV("|invoke-interface-range args=%d @0x%04x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - thisPtr = (Object*) GET_REGISTER(vdst); - } else { - assert((vsrc1>>4) > 0); - ILOGV("|invoke-interface args=%d @0x%04x {regs=0x%04x %x}", - vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); - thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); - } + assert((vsrc1>>4) > 0); + ILOGV("|invoke-interface args=%d @0x%04x {regs=0x%04x %x}", + vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); + thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); } if (!checkForNull(thisPtr)) @@ -1651,7 +1500,6 @@ GOTO_TARGET(invokeInterface, bool methodCallRange, bool jumboFormat) thisClass = thisPtr->clazz; - /* * Given a class and a method index, find the Method* with the * actual code we want to execute. @@ -1671,34 +1519,24 @@ GOTO_TARGET(invokeInterface, bool methodCallRange, bool jumboFormat) } GOTO_TARGET_END -GOTO_TARGET(invokeDirect, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeDirect, bool methodCallRange) { u2 thisReg; EXPORT_PC(); - if (jumboFormat) { - ref = FETCH(1) | (u4)FETCH(2) << 16; /* method ref */ - vsrc1 = FETCH(3); /* count */ - vdst = FETCH(4); /* first reg */ - ADJUST_PC(2); /* advance pc partially to make returns easier */ - ILOGV("|invoke-direct/jumbo args=%d @0x%08x {regs=v%d-v%d}", + vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ + ref = FETCH(1); /* method ref */ + vdst = FETCH(2); /* 4 regs -or- first reg */ + + if (methodCallRange) { + ILOGV("|invoke-direct-range args=%d @0x%04x {regs=v%d-v%d}", vsrc1, ref, vdst, vdst+vsrc1-1); thisReg = vdst; } else { - vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ - ref = FETCH(1); /* method ref */ - vdst = FETCH(2); /* 4 regs -or- first reg */ - - if (methodCallRange) { - ILOGV("|invoke-direct-range args=%d @0x%04x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - thisReg = vdst; - } else { - ILOGV("|invoke-direct args=%d @0x%04x {regs=0x%04x %x}", - vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); - thisReg = vdst & 0x0f; - } + ILOGV("|invoke-direct args=%d @0x%04x {regs=0x%04x %x}", + vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); + thisReg = vdst & 0x0f; } if (!checkForNull((Object*) GET_REGISTER(thisReg))) @@ -1717,28 +1555,19 @@ GOTO_TARGET(invokeDirect, bool methodCallRange, bool jumboFormat) } GOTO_TARGET_END -GOTO_TARGET(invokeStatic, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeStatic, bool methodCallRange) EXPORT_PC(); - if (jumboFormat) { - ref = FETCH(1) | (u4)FETCH(2) << 16; /* method ref */ - vsrc1 = FETCH(3); /* count */ - vdst = FETCH(4); /* first reg */ - ADJUST_PC(2); /* advance pc partially to make returns easier */ - ILOGV("|invoke-static/jumbo args=%d @0x%08x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - } else { - vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ - ref = FETCH(1); /* method ref */ - vdst = FETCH(2); /* 4 regs -or- first reg */ + vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ + ref = FETCH(1); /* method ref */ + vdst = FETCH(2); /* 4 regs -or- first reg */ - if (methodCallRange) - ILOGV("|invoke-static-range args=%d @0x%04x {regs=v%d-v%d}", - vsrc1, ref, vdst, vdst+vsrc1-1); - else - ILOGV("|invoke-static args=%d @0x%04x {regs=0x%04x %x}", - vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); - } + if (methodCallRange) + ILOGV("|invoke-static-range args=%d @0x%04x {regs=v%d-v%d}", + vsrc1, ref, vdst, vdst+vsrc1-1); + else + ILOGV("|invoke-static args=%d @0x%04x {regs=0x%04x %x}", + vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); methodToCall = dvmDexGetResolvedMethod(methodClassDex, ref); if (methodToCall == NULL) { @@ -1764,7 +1593,7 @@ GOTO_TARGET(invokeStatic, bool methodCallRange, bool jumboFormat) GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); GOTO_TARGET_END -GOTO_TARGET(invokeVirtualQuick, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeVirtualQuick, bool methodCallRange) { Object* thisPtr; @@ -1823,7 +1652,7 @@ GOTO_TARGET(invokeVirtualQuick, bool methodCallRange, bool jumboFormat) } GOTO_TARGET_END -GOTO_TARGET(invokeSuperQuick, bool methodCallRange, bool jumboFormat) +GOTO_TARGET(invokeSuperQuick, bool methodCallRange) { u2 thisReg; @@ -1944,7 +1773,7 @@ GOTO_TARGET(returnFromMethod) { FINISH(3); } else { - //LOGE("Unknown invoke instr %02x at %d", + //ALOGE("Unknown invoke instr %02x at %d", // invokeInstr, (int) (pc - curMethod->insns)); assert(false); } @@ -1976,7 +1805,7 @@ GOTO_TARGET(exceptionThrown) dvmAddTrackedAlloc(exception, self); dvmClearException(self); - LOGV("Handling exception %s at %s:%d", + ALOGV("Handling exception %s at %s:%d", exception->clazz->descriptor, curMethod->name, dvmLineNumFromPC(curMethod, pc - curMethod->insns)); @@ -2044,7 +1873,7 @@ GOTO_TARGET(exceptionThrown) if (catchRelPc < 0) { /* falling through to JNI code or off the bottom of the stack */ #if DVM_SHOW_EXCEPTION >= 2 - LOGD("Exception %s from %s:%d not caught locally", + ALOGD("Exception %s from %s:%d not caught locally", exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod), dvmLineNumFromPC(curMethod, pc - curMethod->insns)); #endif @@ -2056,7 +1885,7 @@ GOTO_TARGET(exceptionThrown) #if DVM_SHOW_EXCEPTION >= 3 { const Method* catchMethod = SAVEAREA_FROM_FP(fp)->method; - LOGD("Exception %s thrown from %s:%d to %s:%d", + ALOGD("Exception %s thrown from %s:%d to %s:%d", exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod), dvmLineNumFromPC(curMethod, pc - curMethod->insns), dvmGetMethodSourceFile(catchMethod), @@ -2206,7 +2035,7 @@ GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall, bottom = (u1*) newSaveArea - methodToCall->outsSize * sizeof(u4); if (bottom < self->interpStackEnd) { /* stack overflow */ - LOGV("Stack overflow on method call (start=%p end=%p newBot=%p(%d) size=%d '%s')", + ALOGV("Stack overflow on method call (start=%p end=%p newBot=%p(%d) size=%d '%s')", self->interpStackStart, self->interpStackEnd, bottom, (u1*) fp - bottom, self->interpStackSize, methodToCall->name); @@ -2214,7 +2043,7 @@ GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall, assert(dvmCheckException(self)); GOTO_exceptionThrown(); } - //LOGD("+++ fp=%p newFp=%p newSave=%p bottom=%p", + //ALOGD("+++ fp=%p newFp=%p newSave=%p bottom=%p", // fp, newFp, newSaveArea, bottom); } @@ -2260,8 +2089,8 @@ GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall, self->interpSave.method = curMethod; methodClassDex = curMethod->clazz->pDvmDex; pc = methodToCall->insns; - self->interpSave.curFrame = newFp; fp = newFp; + self->interpSave.curFrame = fp; #ifdef EASY_GDB debugSaveArea = SAVEAREA_FROM_FP(newFp); #endif @@ -2307,7 +2136,7 @@ GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall, * it, jump to our local exception handling. */ if (dvmCheckException(self)) { - LOGV("Exception thrown by/below native code"); + ALOGV("Exception thrown by/below native code"); GOTO_exceptionThrown(); } @@ -2323,7 +2152,7 @@ GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall, { FINISH(3); } else { - //LOGE("Unknown invoke instr %02x at %d", + //ALOGE("Unknown invoke instr %02x at %d", // invokeInstr, (int) (pc - curMethod->insns)); assert(false); } |