vm/mterp/out/InterpAsm-mips.S

   1 /*
   2  * This file was generated automatically by gen-mterp.py for 'mips'.
   3  *
   4  * --> DO NOT EDIT <--
   5  */
   6
   7 /* File: mips/header.S */
   8 #include "../common/asm-constants.h"
   9 #include "../common/mips-defines.h"
  10 #include <asm/regdef.h>
  11 #include <asm/fpregdef.h>
  12
  13 #ifdef __mips_hard_float
  14 #define HARD_FLOAT
  15 #else
  16 #define SOFT_FLOAT
  17 #endif
  18
  19 #if (__mips==32) && (__mips_isa_rev>=2)
  20 #define MIPS32R2
  21 #endif
  22
  23 /* MIPS definitions and declarations
  24
  25    reg  nick            purpose
  26    s0   rPC             interpreted program counter, used for fetching instructions
  27    s1   rFP             interpreted frame pointer, used for accessing locals and args
  28    s2   rSELF           self (Thread) pointer
  29    s3   rIBASE          interpreted instruction base pointer, used for computed goto
  30    s4   rINST           first 16-bit code unit of current instruction
  31 */
  32
  33
  34 /* single-purpose registers, given names for clarity */
  35 #define rPC s0
  36 #define rFP s1
  37 #define rSELF s2
  38 #define rIBASE s3
  39 #define rINST s4
  40 #define rOBJ s5
  41 #define rBIX s6
  42 #define rTEMP s7
  43
  44 /* The long arguments sent to function calls in Big-endian mode should be register
  45 swapped when sent to functions in little endian mode. In other words long variable
  46 sent as a0(MSW), a1(LSW) for a function call in LE mode should be sent as a1, a0 in
  47 Big Endian mode */
  48
  49 #ifdef HAVE_LITTLE_ENDIAN
  50 #define rARG0 a0
  51 #define rARG1 a1
  52 #define rARG2 a2
  53 #define rARG3 a3
  54 #define rRESULT0 v0
  55 #define rRESULT1 v1
  56 #else
  57 #define rARG0 a1
  58 #define rARG1 a0
  59 #define rARG2 a3
  60 #define rARG3 a2
  61 #define rRESULT0 v1
  62 #define rRESULT1 v0
  63 #endif
  64
  65
  66 /* save/restore the PC and/or FP from the glue struct */
  67 #define LOAD_PC_FROM_SELF() lw rPC, offThread_pc(rSELF)
  68 #define SAVE_PC_TO_SELF() sw rPC, offThread_pc(rSELF)
  69 #define LOAD_FP_FROM_SELF() lw rFP, offThread_curFrame(rSELF)
  70 #define SAVE_FP_TO_SELF() sw rFP, offThread_curFrame(rSELF)
  71 #define LOAD_PC_FP_FROM_SELF() \
  72         LOAD_PC_FROM_SELF();   \
  73         LOAD_FP_FROM_SELF()
  74 #define SAVE_PC_FP_TO_SELF()   \
  75         SAVE_PC_TO_SELF();     \
  76         SAVE_FP_TO_SELF()
  77
  78 #define EXPORT_PC() \
  79     sw        rPC, (offStackSaveArea_currentPc - sizeofStackSaveArea)(rFP)
  80
  81 #define SAVEAREA_FROM_FP(rd, _fpreg) \
  82     subu      rd, _fpreg, sizeofStackSaveArea
  83
  84 #define FETCH_INST() lhu rINST, (rPC)
  85
  86 #define FETCH_ADVANCE_INST(_count) lhu rINST, ((_count)*2)(rPC); \
  87     addu      rPC, rPC, ((_count) * 2)
  88
  89 #define PREFETCH_ADVANCE_INST(_dreg, _sreg, _count) \
  90     lhu       _dreg, ((_count)*2)(_sreg) ;            \
  91     addu      _sreg, _sreg, (_count)*2
  92
  93 #define FETCH_ADVANCE_INST_RB(rd) addu rPC, rPC, rd; \
  94     lhu       rINST, (rPC)
  95
  96 #define FETCH(rd, _count) lhu rd, ((_count) * 2)(rPC)
  97 #define FETCH_S(rd, _count) lh rd, ((_count) * 2)(rPC)
  98
  99 #ifdef HAVE_LITTLE_ENDIAN
 100
 101 #define FETCH_B(rd, _count) lbu rd, ((_count) * 2)(rPC)
 102 #define FETCH_C(rd, _count) lbu rd, ((_count) * 2 + 1)(rPC)
 103
 104 #else
 105
 106 #define FETCH_B(rd, _count) lbu rd, ((_count) * 2 + 1)(rPC)
 107 #define FETCH_C(rd, _count) lbu rd, ((_count) * 2)(rPC)
 108
 109 #endif
 110
 111 #define GET_INST_OPCODE(rd) and rd, rINST, 0xFF
 112
 113 /*
 114  * Put the prefetched instruction's opcode field into the specified register.
 115  */
 116
 117 #define GET_PREFETCHED_OPCODE(dreg, sreg)   andi     dreg, sreg, 255
 118
 119 #define GOTO_OPCODE(rd) sll rd, rd, 7; \
 120     addu      rd, rIBASE, rd; \
 121     jr        rd
 122
 123 #define GOTO_OPCODE_BASE(_base, rd)  sll rd, rd, 7; \
 124     addu      rd, _base, rd; \
 125     jr        rd
 126
 127 #define GET_VREG(rd, rix) LOAD_eas2(rd, rFP, rix)
 128
 129 #define GET_VREG_F(rd, rix) EAS2(AT, rFP, rix); \
 130     .set noat; l.s rd, (AT); .set at
 131
 132 #define SET_VREG(rd, rix) STORE_eas2(rd, rFP, rix)
 133
 134 #define SET_VREG_GOTO(rd, rix, dst) .set noreorder; \
 135     sll       dst, dst, 7; \
 136     addu      dst, rIBASE, dst; \
 137     sll       t8, rix, 2; \
 138     addu      t8, t8, rFP; \
 139     jr        dst; \
 140     sw        rd, 0(t8); \
 141     .set reorder
 142
 143 #define SET_VREG_F(rd, rix) EAS2(AT, rFP, rix); \
 144     .set noat; s.s rd, (AT); .set at
 145
 146
 147 #define GET_OPA(rd) srl rd, rINST, 8
 148 #ifndef MIPS32R2
 149 #define GET_OPA4(rd) GET_OPA(rd); and rd, 0xf
 150 #else
 151 #define GET_OPA4(rd) ext rd, rINST, 8, 4
 152 #endif
 153 #define GET_OPB(rd) srl rd, rINST, 12
 154
 155 #define LOAD_rSELF_OFF(rd, off) lw rd, offThread_##off## (rSELF)
 156
 157 #define LOAD_rSELF_method(rd) LOAD_rSELF_OFF(rd, method)
 158 #define LOAD_rSELF_methodClassDex(rd) LOAD_rSELF_OFF(rd, methodClassDex)
 159 #define LOAD_rSELF_interpStackEnd(rd) LOAD_rSELF_OFF(rd, interpStackEnd)
 160 #define LOAD_rSELF_retval(rd) LOAD_rSELF_OFF(rd, retval)
 161 #define LOAD_rSELF_pActiveProfilers(rd) LOAD_rSELF_OFF(rd, pActiveProfilers)
 162 #define LOAD_rSELF_bailPtr(rd) LOAD_rSELF_OFF(rd, bailPtr)
 163 #define LOAD_rSELF_SelfSuspendCount(rd) LOAD_rSELF_OFF(rd, SelfSuspendCount)
 164
 165
 166 /*
 167  * Form an Effective Address rd = rbase + roff<<n;
 168  * Uses reg AT
 169  */
 170 #define EASN(rd, rbase, roff, rshift) .set noat; \
 171     sll       AT, roff, rshift; \
 172     addu      rd, rbase, AT; \
 173     .set at
 174
 175 #define EAS1(rd, rbase, roff) EASN(rd, rbase, roff, 1)
 176 #define EAS2(rd, rbase, roff) EASN(rd, rbase, roff, 2)
 177 #define EAS3(rd, rbase, roff) EASN(rd, rbase, roff, 3)
 178 #define EAS4(rd, rbase, roff) EASN(rd, rbase, roff, 4)
 179
 180 /*
 181  * Form an Effective Shift Right rd = rbase + roff>>n;
 182  * Uses reg AT
 183  */
 184 #define ESRN(rd, rbase, roff, rshift) .set noat; \
 185     srl       AT, roff, rshift; \
 186     addu      rd, rbase, AT; \
 187     .set at
 188
 189 #define LOAD_eas2(rd, rbase, roff) EAS2(AT, rbase, roff); \
 190     .set noat; lw rd, 0(AT); .set at
 191
 192 #define STORE_eas2(rd, rbase, roff) EAS2(AT, rbase, roff); \
 193     .set noat; sw rd, 0(AT); .set at
 194
 195 #define LOAD_RB_OFF(rd, rbase, off) lw rd, off(rbase)
 196 #define LOADu2_RB_OFF(rd, rbase, off) lhu rd, off(rbase)
 197 #define STORE_RB_OFF(rd, rbase, off) sw rd, off(rbase)
 198
 199 #ifdef HAVE_LITTLE_ENDIAN
 200
 201 #define STORE64_off(rlo, rhi, rbase, off) sw rlo, off(rbase); \
 202     sw        rhi, (off+4)(rbase)
 203 #define LOAD64_off(rlo, rhi, rbase, off) lw rlo, off(rbase); \
 204     lw        rhi, (off+4)(rbase)
 205
 206 #define vSTORE64_off(rlo, rhi, rbase, off) sw rlo, off(rbase); \
 207     sw        rhi, (off+4)(rbase)
 208 #define vLOAD64_off(rlo, rhi, rbase, off) lw rlo, off(rbase); \
 209     lw        rhi, (off+4)(rbase)
 210
 211 #define STORE64_off_F(rlo, rhi, rbase, off) s.s rlo, off(rbase); \
 212     s.s       rhi, (off+4)(rbase)
 213 #define LOAD64_off_F(rlo, rhi, rbase, off) l.s rlo, off(rbase); \
 214     l.s       rhi, (off+4)(rbase)
 215 #else
 216
 217 #define STORE64_off(rlo, rhi, rbase, off) sw rlo, (off+4)(rbase); \
 218     sw        rhi, (off)(rbase)
 219 #define LOAD64_off(rlo, rhi, rbase, off) lw rlo, (off+4)(rbase); \
 220     lw        rhi, (off)(rbase)
 221 #define vSTORE64_off(rlo, rhi, rbase, off) sw rlo, (off+4)(rbase); \
 222     sw        rhi, (off)(rbase)
 223 #define vLOAD64_off(rlo, rhi, rbase, off) lw rlo, (off+4)(rbase); \
 224     lw        rhi, (off)(rbase)
 225 #define STORE64_off_F(rlo, rhi, rbase, off) s.s rlo, (off+4)(rbase); \
 226     s.s       rhi, (off)(rbase)
 227 #define LOAD64_off_F(rlo, rhi, rbase, off) l.s rlo, (off+4)(rbase); \
 228     l.s       rhi, (off)(rbase)
 229 #endif
 230
 231 #define STORE64(rlo, rhi, rbase) STORE64_off(rlo, rhi, rbase, 0)
 232 #define LOAD64(rlo, rhi, rbase) LOAD64_off(rlo, rhi, rbase, 0)
 233
 234 #define vSTORE64(rlo, rhi, rbase) vSTORE64_off(rlo, rhi, rbase, 0)
 235 #define vLOAD64(rlo, rhi, rbase) vLOAD64_off(rlo, rhi, rbase, 0)
 236
 237 #define STORE64_F(rlo, rhi, rbase) STORE64_off_F(rlo, rhi, rbase, 0)
 238 #define LOAD64_F(rlo, rhi, rbase) LOAD64_off_F(rlo, rhi, rbase, 0)
 239
 240 #define STORE64_lo(rd, rbase) sw rd, 0(rbase)
 241 #define STORE64_hi(rd, rbase) sw rd, 4(rbase)
 242
 243
 244 #define LOAD_offThread_exception(rd, rbase) LOAD_RB_OFF(rd, rbase, offThread_exception)
 245 #define LOAD_base_offArrayObject_length(rd, rbase) LOAD_RB_OFF(rd, rbase, offArrayObject_length)
 246 #define LOAD_base_offClassObject_accessFlags(rd, rbase) LOAD_RB_OFF(rd, rbase, offClassObject_accessFlags)
 247 #define LOAD_base_offClassObject_descriptor(rd, rbase) LOAD_RB_OFF(rd, rbase, offClassObject_descriptor)
 248 #define LOAD_base_offClassObject_super(rd, rbase) LOAD_RB_OFF(rd, rbase, offClassObject_super)
 249
 250 #define LOAD_base_offClassObject_vtable(rd, rbase) LOAD_RB_OFF(rd, rbase, offClassObject_vtable)
 251 #define LOAD_base_offClassObject_vtableCount(rd, rbase) LOAD_RB_OFF(rd, rbase, offClassObject_vtableCount)
 252 #define LOAD_base_offDvmDex_pResClasses(rd, rbase) LOAD_RB_OFF(rd, rbase, offDvmDex_pResClasses)
 253 #define LOAD_base_offDvmDex_pResFields(rd, rbase) LOAD_RB_OFF(rd, rbase, offDvmDex_pResFields)
 254
 255 #define LOAD_base_offDvmDex_pResMethods(rd, rbase) LOAD_RB_OFF(rd, rbase, offDvmDex_pResMethods)
 256 #define LOAD_base_offDvmDex_pResStrings(rd, rbase) LOAD_RB_OFF(rd, rbase, offDvmDex_pResStrings)
 257 #define LOAD_base_offInstField_byteOffset(rd, rbase) LOAD_RB_OFF(rd, rbase, offInstField_byteOffset)
 258 #define LOAD_base_offStaticField_value(rd, rbase) LOAD_RB_OFF(rd, rbase, offStaticField_value)
 259 #define LOAD_base_offMethod_clazz(rd, rbase) LOAD_RB_OFF(rd, rbase, offMethod_clazz)
 260
 261 #define LOAD_base_offMethod_name(rd, rbase) LOAD_RB_OFF(rd, rbase, offMethod_name)
 262 #define LOAD_base_offObject_clazz(rd, rbase) LOAD_RB_OFF(rd, rbase, offObject_clazz)
 263
 264 #define LOADu2_offMethod_methodIndex(rd, rbase) LOADu2_RB_OFF(rd, rbase, offMethod_methodIndex)
 265
 266
 267 #define STORE_offThread_exception(rd, rbase) STORE_RB_OFF(rd, rbase, offThread_exception)
 268
 269
 270 #define STACK_STORE(rd, off) sw rd, off(sp)
 271 #define STACK_LOAD(rd, off) lw rd, off(sp)
 272 #define CREATE_STACK(n) subu sp, sp, n
 273 #define DELETE_STACK(n) addu sp, sp, n
 274
 275 #define SAVE_RA(offset) STACK_STORE(ra, offset)
 276 #define LOAD_RA(offset) STACK_LOAD(ra, offset)
 277
 278 #define LOAD_ADDR(dest, addr) la dest, addr
 279 #define LOAD_IMM(dest, imm) li dest, imm
 280 #define MOVE_REG(dest, src) move dest, src
 281 #define RETURN jr ra
 282 #define STACK_SIZE 128
 283
 284 #define STACK_OFFSET_ARG04 16
 285 #define STACK_OFFSET_ARG05 20
 286 #define STACK_OFFSET_ARG06 24
 287 #define STACK_OFFSET_ARG07 28
 288 #define STACK_OFFSET_SCR   32
 289 #define STACK_OFFSET_SCRMX 80
 290 #define STACK_OFFSET_GP    84
 291 #define STACK_OFFSET_rFP   112
 292
 293 #define JAL(n) jal n
 294 #define BAL(n) bal n
 295
 296 #define STACK_STORE_RA() CREATE_STACK(STACK_SIZE); \
 297     STACK_STORE(gp, STACK_OFFSET_GP); \
 298     STACK_STORE(ra, 124)
 299
 300 #define STACK_STORE_S0() STACK_STORE_RA(); \
 301     STACK_STORE(s0, 116)
 302
 303 #define STACK_STORE_S0S1() STACK_STORE_S0(); \
 304     STACK_STORE(s1, STACK_OFFSET_rFP)
 305
 306 #define STACK_LOAD_RA() STACK_LOAD(ra, 124); \
 307     STACK_LOAD(gp, STACK_OFFSET_GP); \
 308     DELETE_STACK(STACK_SIZE)
 309
 310 #define STACK_LOAD_S0() STACK_LOAD(s0, 116); \
 311     STACK_LOAD_RA()
 312
 313 #define STACK_LOAD_S0S1() STACK_LOAD(s1, STACK_OFFSET_rFP); \
 314     STACK_LOAD_S0()
 315
 316 #define STACK_STORE_FULL() CREATE_STACK(STACK_SIZE); \
 317     STACK_STORE(ra, 124); \
 318     STACK_STORE(fp, 120); \
 319     STACK_STORE(s0, 116); \
 320     STACK_STORE(s1, STACK_OFFSET_rFP); \
 321     STACK_STORE(s2, 108); \
 322     STACK_STORE(s3, 104); \
 323     STACK_STORE(s4, 100); \
 324     STACK_STORE(s5, 96); \
 325     STACK_STORE(s6, 92); \
 326     STACK_STORE(s7, 88);
 327
 328 #define STACK_LOAD_FULL() STACK_LOAD(gp, STACK_OFFSET_GP); \
 329     STACK_LOAD(s7, 88); \
 330     STACK_LOAD(s6, 92); \
 331     STACK_LOAD(s5, 96); \
 332     STACK_LOAD(s4, 100); \
 333     STACK_LOAD(s3, 104); \
 334     STACK_LOAD(s2, 108); \
 335     STACK_LOAD(s1, STACK_OFFSET_rFP); \
 336     STACK_LOAD(s0, 116); \
 337     STACK_LOAD(fp, 120); \
 338     STACK_LOAD(ra, 124); \
 339     DELETE_STACK(STACK_SIZE)
 340
 341 /*
 342  * first 8 words are reserved for function calls
 343  * Maximum offset is STACK_OFFSET_SCRMX-STACK_OFFSET_SCR
 344  */
 345 #define SCRATCH_STORE(r,off) \
 346     STACK_STORE(r, STACK_OFFSET_SCR+off);
 347 #define SCRATCH_LOAD(r,off) \
 348     STACK_LOAD(r, STACK_OFFSET_SCR+off);
 349
 350 #if defined(WITH_JIT)
 351 #include "../common/jit-config.h"
 352 #endif
 353
 354 /* File: mips/platform.S */
 355 /*
 356  * ===========================================================================
 357  *  CPU-version-specific defines
 358  * ===========================================================================
 359  */
 360
 361 #if !defined(ANDROID_SMP)
 362 # error "Must define ANDROID_SMP"
 363 #endif
 364
 365 /*
 366  * Macro for data memory barrier.
 367  */
 368 .macro SMP_DMB
 369 #if ANDROID_SMP != 0
 370     sync
 371 #else
 372     /* not SMP */
 373 #endif
 374 .endm
 375
 376 /*
 377  * Macro for data memory barrier (store/store variant).
 378  */
 379 .macro  SMP_DMB_ST
 380 #if ANDROID_SMP != 0
 381     // FIXME: Is this really needed?
 382     sync
 383 #else
 384     /* not SMP */
 385 #endif
 386 .endm
 387
 388 /* File: mips/entry.S */
 389
 390 /*
 391  * Copyright (C) 2008 The Android Open Source Project
 392  *
 393  * Licensed under the Apache License, Version 2.0 (the "License");
 394  * you may not use this file except in compliance with the License.
 395  * You may obtain a copy of the License at
 396  *
 397  *      http://www.apache.org/licenses/LICENSE-2.0
 398  *
 399  * Unless required by applicable law or agreed to in writing, software
 400  * distributed under the License is distributed on an "AS IS" BASIS,
 401  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 402  * See the License for the specific language governing permissions and
 403  * limitations under the License.
 404  */
 405 /*
 406  * Interpreter entry point.
 407  */
 408
 409 #define ASSIST_DEBUGGER 1
 410
 411     .text
 412     .align 2
 413     .global dvmMterpStdRun
 414     .ent dvmMterpStdRun
 415     .frame sp, STACK_SIZE, ra
 416 /*
 417  * On entry:
 418  *  r0  Thread* self
 419  *
 420  * The return comes via a call to dvmMterpStdBail().
 421  */
 422
 423 dvmMterpStdRun:
 424     .set noreorder
 425     .cpload t9
 426     .set reorder
 427 /* Save to the stack. Frame size = STACK_SIZE */
 428     STACK_STORE_FULL()
 429 /* This directive will make sure all subsequent jal restore gp at a known offset */
 430     .cprestore STACK_OFFSET_GP
 431
 432     addu      fp, sp, STACK_SIZE           #  Move Frame Pointer to the base of frame
 433     /* save stack pointer, add magic word for debuggerd */
 434     sw        sp, offThread_bailPtr(a0)      # Save SP
 435
 436     /* set up "named" registers, figure out entry point */
 437     move      rSELF, a0                    #  set rSELF
 438     LOAD_PC_FROM_SELF()
 439     LOAD_FP_FROM_SELF()
 440     lw        rIBASE, offThread_curHandlerTable(rSELF)
 441
 442 #if defined(WITH_JIT)
 443 .LentryInstr:
 444     /* Entry is always a possible trace start */
 445     lw        a0, offThread_pJitProfTable(rSELF)
 446     FETCH_INST()                           #  load rINST from rPC
 447     sw        zero, offThread_inJitCodeCache(rSELF)
 448 #if !defined(WITH_SELF_VERIFICATION)
 449     bnez      a0, common_updateProfile     # profiling is enabled
 450 #else
 451     lw       a2, offThread_shadowSpace(rSELF) # to find out the jit exit state
 452     beqz     a0, 1f                        # profiling is disabled
 453     lw       a3, offShadowSpace_jitExitState(a2) # jit exit state
 454     li       t0, kSVSTraceSelect
 455     bne      a3, t0, 2f
 456     li       a2, kJitTSelectRequestHot     # ask for trace selection
 457     b        common_selectTrace            # go build the trace
 458 2:
 459     li       a4, kSVSNoProfile
 460     beq      a3, a4, 1f                    # don't profile the next instruction?
 461     b        common_updateProfile          # collect profiles
 462 #endif
 463 1:
 464     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 465     GOTO_OPCODE(t0)                        #  jump to next instruction
 466 #else
 467     /* start executing the instruction at rPC */
 468     FETCH_INST()                           #  load rINST from rPC
 469     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 470     GOTO_OPCODE(t0)                        #  jump to next instruction
 471 #endif
 472
 473 .Lbad_arg:
 474     la        a0, .LstrBadEntryPoint
 475     #a1 holds value of entryPoint
 476     JAL(printf)
 477     JAL(dvmAbort)
 478
 479     .end dvmMterpStdRun
 480
 481     .global dvmMterpStdBail
 482     .ent dvmMterpStdBail
 483
 484 /* Restore the stack pointer and all the registers stored at sp from the save
 485  * point established  on entry. Return to whoever called dvmMterpStdRun.
 486  *
 487  * On entry:
 488  *   a0    Thread* self
 489  */
 490 dvmMterpStdBail:
 491     lw        sp, offThread_bailPtr(a0)      #  Restore sp
 492     STACK_LOAD_FULL()
 493     jr        ra
 494
 495     .end dvmMterpStdBail
 496
 497
 498     .global dvmAsmInstructionStart
 499     .type   dvmAsmInstructionStart, %function
 500 dvmAsmInstructionStart = .L_OP_NOP
 501     .text
 502
 503 /* ------------------------------ */
 504     .balign 128
 505 .L_OP_NOP: /* 0x00 */
 506 /* File: mips/OP_NOP.S */
 507     FETCH_ADVANCE_INST(1)                  #  advance to next instr, load rINST
 508     GET_INST_OPCODE(t0)
 509     GOTO_OPCODE(t0)                        #  execute it
 510
 511 #ifdef ASSIST_DEBUGGER
 512     /* insert fake function header to help gdb find the stack frame */
 513     .type dalvik_inst, @function
 514 dalvik_inst:
 515     .ent dalvik_inst
 516     .end dalvik_inst
 517 #endif
 518
 519
 520 /* ------------------------------ */
 521     .balign 128
 522 .L_OP_MOVE: /* 0x01 */
 523 /* File: mips/OP_MOVE.S */
 524     /* for move, move-object, long-to-int */
 525     /* op vA, vB */
 526     GET_OPB(a1)                            #  a1 <- B from 15:12
 527     GET_OPA4(a0)                           #  a0 <- A from 11:8
 528     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 529     GET_VREG(a2, a1)                       #  a2 <- fp[B]
 530     GET_INST_OPCODE(t0)                    #  t0 <- opcode from rINST
 531     SET_VREG_GOTO(a2, a0, t0)              #  fp[A] <- a2
 532
 533
 534 /* ------------------------------ */
 535     .balign 128
 536 .L_OP_MOVE_FROM16: /* 0x02 */
 537 /* File: mips/OP_MOVE_FROM16.S */
 538     /* for: move/from16, move-object/from16 */
 539     /* op vAA, vBBBB */
 540     FETCH(a1, 1)                           #  a1 <- BBBB
 541     GET_OPA(a0)                            #  a0 <- AA
 542     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 543     GET_VREG(a2, a1)                       #  a2 <- fp[BBBB]
 544     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 545     SET_VREG_GOTO(a2, a0, t0)              #  fp[AA] <- a2
 546
 547
 548 /* ------------------------------ */
 549     .balign 128
 550 .L_OP_MOVE_16: /* 0x03 */
 551 /* File: mips/OP_MOVE_16.S */
 552     /* for: move/16, move-object/16 */
 553     /* op vAAAA, vBBBB */
 554     FETCH(a1, 2)                           #  a1 <- BBBB
 555     FETCH(a0, 1)                           #  a0 <- AAAA
 556     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
 557     GET_VREG(a2, a1)                       #  a2 <- fp[BBBB]
 558     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 559     SET_VREG_GOTO(a2, a0, t0)              #  fp[AAAA] <- a2 and jump
 560
 561
 562 /* ------------------------------ */
 563     .balign 128
 564 .L_OP_MOVE_WIDE: /* 0x04 */
 565 /* File: mips/OP_MOVE_WIDE.S */
 566     /* move-wide vA, vB */
 567     /* NOTE: regs can overlap, e.g. "move v6, v7" or "move v7, v6" */
 568     GET_OPA4(a2)                           #  a2 <- A(+)
 569     GET_OPB(a3)                            #  a3 <- B
 570     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
 571     EAS2(a2, rFP, a2)                      #  a2 <- &fp[A]
 572     LOAD64(a0, a1, a3)                     #  a0/a1 <- fp[B]
 573     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 574     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 575     STORE64(a0, a1, a2)                    #  fp[A] <- a0/a1
 576     GOTO_OPCODE(t0)                        #  jump to next instruction
 577
 578
 579 /* ------------------------------ */
 580     .balign 128
 581 .L_OP_MOVE_WIDE_FROM16: /* 0x05 */
 582 /* File: mips/OP_MOVE_WIDE_FROM16.S */
 583     /* move-wide/from16 vAA, vBBBB */
 584     /* NOTE: regs can overlap, e.g. "move v6, v7" or "move v7, v6" */
 585     FETCH(a3, 1)                           #  a3 <- BBBB
 586     GET_OPA(a2)                            #  a2 <- AA
 587     EAS2(a3, rFP, a3)                      #  a3 <- &fp[BBBB]
 588     EAS2(a2, rFP, a2)                      #  a2 <- &fp[AA]
 589     LOAD64(a0, a1, a3)                     #  a0/a1 <- fp[BBBB]
 590     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 591     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 592     STORE64(a0, a1, a2)                    #  fp[AA] <- a0/a1
 593     GOTO_OPCODE(t0)                        #  jump to next instruction
 594
 595
 596 /* ------------------------------ */
 597     .balign 128
 598 .L_OP_MOVE_WIDE_16: /* 0x06 */
 599 /* File: mips/OP_MOVE_WIDE_16.S */
 600     /* move-wide/16 vAAAA, vBBBB */
 601     /* NOTE: regs can overlap, e.g. "move v6, v7" or "move v7, v6" */
 602     FETCH(a3, 2)                           #  a3 <- BBBB
 603     FETCH(a2, 1)                           #  a2 <- AAAA
 604     EAS2(a3, rFP, a3)                      #  a3 <- &fp[BBBB]
 605     EAS2(a2, rFP, a2)                      #  a2 <- &fp[AAAA]
 606     LOAD64(a0, a1, a3)                     #  a0/a1 <- fp[BBBB]
 607     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
 608     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 609     STORE64(a0, a1, a2)                    #  fp[AAAA] <- a0/a1
 610     GOTO_OPCODE(t0)                        #  jump to next instruction
 611
 612
 613 /* ------------------------------ */
 614     .balign 128
 615 .L_OP_MOVE_OBJECT: /* 0x07 */
 616 /* File: mips/OP_MOVE_OBJECT.S */
 617 /* File: mips/OP_MOVE.S */
 618     /* for move, move-object, long-to-int */
 619     /* op vA, vB */
 620     GET_OPB(a1)                            #  a1 <- B from 15:12
 621     GET_OPA4(a0)                           #  a0 <- A from 11:8
 622     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 623     GET_VREG(a2, a1)                       #  a2 <- fp[B]
 624     GET_INST_OPCODE(t0)                    #  t0 <- opcode from rINST
 625     SET_VREG_GOTO(a2, a0, t0)              #  fp[A] <- a2
 626
 627
 628
 629 /* ------------------------------ */
 630     .balign 128
 631 .L_OP_MOVE_OBJECT_FROM16: /* 0x08 */
 632 /* File: mips/OP_MOVE_OBJECT_FROM16.S */
 633 /* File: mips/OP_MOVE_FROM16.S */
 634     /* for: move/from16, move-object/from16 */
 635     /* op vAA, vBBBB */
 636     FETCH(a1, 1)                           #  a1 <- BBBB
 637     GET_OPA(a0)                            #  a0 <- AA
 638     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 639     GET_VREG(a2, a1)                       #  a2 <- fp[BBBB]
 640     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 641     SET_VREG_GOTO(a2, a0, t0)              #  fp[AA] <- a2
 642
 643
 644
 645 /* ------------------------------ */
 646     .balign 128
 647 .L_OP_MOVE_OBJECT_16: /* 0x09 */
 648 /* File: mips/OP_MOVE_OBJECT_16.S */
 649 /* File: mips/OP_MOVE_16.S */
 650     /* for: move/16, move-object/16 */
 651     /* op vAAAA, vBBBB */
 652     FETCH(a1, 2)                           #  a1 <- BBBB
 653     FETCH(a0, 1)                           #  a0 <- AAAA
 654     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
 655     GET_VREG(a2, a1)                       #  a2 <- fp[BBBB]
 656     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 657     SET_VREG_GOTO(a2, a0, t0)              #  fp[AAAA] <- a2 and jump
 658
 659
 660
 661 /* ------------------------------ */
 662     .balign 128
 663 .L_OP_MOVE_RESULT: /* 0x0a */
 664 /* File: mips/OP_MOVE_RESULT.S */
 665     /* for: move-result, move-result-object */
 666     /* op vAA */
 667     GET_OPA(a2)                            #  a2 <- AA
 668     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 669     LOAD_rSELF_retval(a0)                  #  a0 <- self->retval.i
 670     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 671     SET_VREG_GOTO(a0, a2, t0)              #  fp[AA] <- a0
 672
 673
 674 /* ------------------------------ */
 675     .balign 128
 676 .L_OP_MOVE_RESULT_WIDE: /* 0x0b */
 677 /* File: mips/OP_MOVE_RESULT_WIDE.S */
 678     /* move-result-wide vAA */
 679     GET_OPA(a2)                            #  a2 <- AA
 680     addu      a3, rSELF, offThread_retval  #  a3 <- &self->retval
 681     EAS2(a2, rFP, a2)                      #  a2 <- &fp[AA]
 682     LOAD64(a0, a1, a3)                     #  a0/a1 <- retval.j
 683     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 684     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 685     STORE64(a0, a1, a2)                    #  fp[AA] <- a0/a1
 686     GOTO_OPCODE(t0)                        #  jump to next instruction
 687
 688
 689 /* ------------------------------ */
 690     .balign 128
 691 .L_OP_MOVE_RESULT_OBJECT: /* 0x0c */
 692 /* File: mips/OP_MOVE_RESULT_OBJECT.S */
 693 /* File: mips/OP_MOVE_RESULT.S */
 694     /* for: move-result, move-result-object */
 695     /* op vAA */
 696     GET_OPA(a2)                            #  a2 <- AA
 697     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 698     LOAD_rSELF_retval(a0)                  #  a0 <- self->retval.i
 699     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 700     SET_VREG_GOTO(a0, a2, t0)              #  fp[AA] <- a0
 701
 702
 703
 704 /* ------------------------------ */
 705     .balign 128
 706 .L_OP_MOVE_EXCEPTION: /* 0x0d */
 707 /* File: mips/OP_MOVE_EXCEPTION.S */
 708     /* move-exception vAA */
 709     GET_OPA(a2)                            #  a2 <- AA
 710     LOAD_offThread_exception(a3, rSELF)    #  a3 <- dvmGetException bypass
 711     li        a1, 0                        #  a1 <- 0
 712     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 713     SET_VREG(a3, a2)                       #  fp[AA] <- exception obj
 714     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 715     STORE_offThread_exception(a1, rSELF)   #  dvmClearException bypass
 716     GOTO_OPCODE(t0)                        #  jump to next instruction
 717
 718
 719 /* ------------------------------ */
 720     .balign 128
 721 .L_OP_RETURN_VOID: /* 0x0e */
 722 /* File: mips/OP_RETURN_VOID.S */
 723     b         common_returnFromMethod
 724
 725
 726 /* ------------------------------ */
 727     .balign 128
 728 .L_OP_RETURN: /* 0x0f */
 729 /* File: mips/OP_RETURN.S */
 730     /*
 731      * Return a 32-bit value.  Copies the return value into the "thread"
 732      * structure, then jumps to the return handler.
 733      *
 734      * for: return, return-object
 735      */
 736     /* op vAA */
 737     GET_OPA(a2)                            #  a2 <- AA
 738     GET_VREG(a0, a2)                       #  a0 <- vAA
 739     sw        a0, offThread_retval(rSELF)  #  retval.i <- vAA
 740     b         common_returnFromMethod
 741
 742
 743 /* ------------------------------ */
 744     .balign 128
 745 .L_OP_RETURN_WIDE: /* 0x10 */
 746 /* File: mips/OP_RETURN_WIDE.S */
 747     /*
 748      * Return a 64-bit value.  Copies the return value into the "thread"
 749      * structure, then jumps to the return handler.
 750      */
 751     /* return-wide vAA */
 752     GET_OPA(a2)                            #  a2 <- AA
 753     EAS2(a2, rFP, a2)                      #  a2 <- &fp[AA]
 754     addu      a3, rSELF, offThread_retval  #  a3 <- &self->retval
 755     LOAD64(a0, a1, a2)                     #  a0/a1 <- vAA/vAA+1
 756     STORE64(a0, a1, a3)                    #  retval <- a0/a1
 757     b         common_returnFromMethod
 758
 759
 760 /* ------------------------------ */
 761     .balign 128
 762 .L_OP_RETURN_OBJECT: /* 0x11 */
 763 /* File: mips/OP_RETURN_OBJECT.S */
 764 /* File: mips/OP_RETURN.S */
 765     /*
 766      * Return a 32-bit value.  Copies the return value into the "thread"
 767      * structure, then jumps to the return handler.
 768      *
 769      * for: return, return-object
 770      */
 771     /* op vAA */
 772     GET_OPA(a2)                            #  a2 <- AA
 773     GET_VREG(a0, a2)                       #  a0 <- vAA
 774     sw        a0, offThread_retval(rSELF)  #  retval.i <- vAA
 775     b         common_returnFromMethod
 776
 777
 778
 779 /* ------------------------------ */
 780     .balign 128
 781 .L_OP_CONST_4: /* 0x12 */
 782 /* File: mips/OP_CONST_4.S */
 783     # const/4 vA,                          /* +B */
 784     sll       a1, rINST, 16                #  a1 <- Bxxx0000
 785     GET_OPA(a0)                            #  a0 <- A+
 786     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
 787     sra       a1, a1, 28                   #  a1 <- sssssssB (sign-extended)
 788     and       a0, a0, 15
 789     GET_INST_OPCODE(t0)                    #  ip <- opcode from rINST
 790     SET_VREG_GOTO(a1, a0, t0)              #  fp[A] <- a1
 791
 792
 793 /* ------------------------------ */
 794     .balign 128
 795 .L_OP_CONST_16: /* 0x13 */
 796 /* File: mips/OP_CONST_16.S */
 797     # const/16 vAA,                        /* +BBBB */
 798     FETCH_S(a0, 1)                         #  a0 <- ssssBBBB (sign-extended)
 799     GET_OPA(a3)                            #  a3 <- AA
 800     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 801     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 802     SET_VREG_GOTO(a0, a3, t0)              #  vAA <- a0
 803
 804
 805 /* ------------------------------ */
 806     .balign 128
 807 .L_OP_CONST: /* 0x14 */
 808 /* File: mips/OP_CONST.S */
 809     # const vAA,                           /* +BBBBbbbb */
 810     GET_OPA(a3)                            #  a3 <- AA
 811     FETCH(a0, 1)                           #  a0 <- bbbb (low)
 812     FETCH(a1, 2)                           #  a1 <- BBBB (high)
 813     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
 814     sll       a1, a1, 16
 815     or        a0, a1, a0                   #  a0 <- BBBBbbbb
 816     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 817     SET_VREG_GOTO(a0, a3, t0)              #  vAA <- a0
 818
 819
 820 /* ------------------------------ */
 821     .balign 128
 822 .L_OP_CONST_HIGH16: /* 0x15 */
 823 /* File: mips/OP_CONST_HIGH16.S */
 824     # const/high16 vAA,                    /* +BBBB0000 */
 825     FETCH(a0, 1)                           #  a0 <- 0000BBBB (zero-extended)
 826     GET_OPA(a3)                            #  a3 <- AA
 827     sll       a0, a0, 16                   #  a0 <- BBBB0000
 828     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 829     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 830     SET_VREG_GOTO(a0, a3, t0)              #  vAA <- a0
 831
 832
 833 /* ------------------------------ */
 834     .balign 128
 835 .L_OP_CONST_WIDE_16: /* 0x16 */
 836 /* File: mips/OP_CONST_WIDE_16.S */
 837     # const-wide/16 vAA,                   /* +BBBB */
 838     FETCH_S(a0, 1)                         #  a0 <- ssssBBBB (sign-extended)
 839     GET_OPA(a3)                            #  a3 <- AA
 840     sra       a1, a0, 31                   #  a1 <- ssssssss
 841     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 842     EAS2(a3, rFP, a3)                      #  a3 <- &fp[AA]
 843     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 844     STORE64(a0, a1, a3)                    #  vAA <- a0/a1
 845     GOTO_OPCODE(t0)                        #  jump to next instruction
 846
 847
 848 /* ------------------------------ */
 849     .balign 128
 850 .L_OP_CONST_WIDE_32: /* 0x17 */
 851 /* File: mips/OP_CONST_WIDE_32.S */
 852     # const-wide/32 vAA,                   /* +BBBBbbbb */
 853     FETCH(a0, 1)                           #  a0 <- 0000bbbb (low)
 854     GET_OPA(a3)                            #  a3 <- AA
 855     FETCH_S(a2, 2)                         #  a2 <- ssssBBBB (high)
 856     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
 857     sll       a2, a2, 16
 858     or        a0, a0, a2                   #  a0 <- BBBBbbbb
 859     EAS2(a3, rFP, a3)                      #  a3 <- &fp[AA]
 860     sra       a1, a0, 31                   #  a1 <- ssssssss
 861     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 862     STORE64(a0, a1, a3)                    #  vAA <- a0/a1
 863     GOTO_OPCODE(t0)                        #  jump to next instruction
 864
 865
 866 /* ------------------------------ */
 867     .balign 128
 868 .L_OP_CONST_WIDE: /* 0x18 */
 869 /* File: mips/OP_CONST_WIDE.S */
 870     # const-wide vAA,                      /* +HHHHhhhhBBBBbbbb */
 871     FETCH(a0, 1)                           #  a0 <- bbbb (low)
 872     FETCH(a1, 2)                           #  a1 <- BBBB (low middle)
 873     FETCH(a2, 3)                           #  a2 <- hhhh (high middle)
 874     sll       a1, 16 #
 875     or        a0, a1                       #  a0 <- BBBBbbbb (low word)
 876     FETCH(a3, 4)                           #  a3 <- HHHH (high)
 877     GET_OPA(t1)                            #  t1 <- AA
 878     sll       a3, 16
 879     or        a1, a3, a2                   #  a1 <- HHHHhhhh (high word)
 880     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
 881     EAS2(t1, rFP, t1)                      #  t1 <- &fp[AA]
 882     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 883     STORE64(a0, a1, t1)                    #  vAA <- a0/a1
 884     GOTO_OPCODE(t0)                        #  jump to next instruction
 885
 886
 887 /* ------------------------------ */
 888     .balign 128
 889 .L_OP_CONST_WIDE_HIGH16: /* 0x19 */
 890 /* File: mips/OP_CONST_WIDE_HIGH16.S */
 891     # const-wide/high16 vAA,               /* +BBBB000000000000 */
 892     FETCH(a1, 1)                           #  a1 <- 0000BBBB (zero-extended)
 893     GET_OPA(a3)                            #  a3 <- AA
 894     li        a0, 0                        #  a0 <- 00000000
 895     sll       a1, 16                       #  a1 <- BBBB0000
 896     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 897     EAS2(a3, rFP, a3)                      #  a3 <- &fp[AA]
 898     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 899     STORE64(a0, a1, a3)                    #  vAA <- a0/a1
 900     GOTO_OPCODE(t0)                        #  jump to next instruction
 901
 902
 903 /* ------------------------------ */
 904     .balign 128
 905 .L_OP_CONST_STRING: /* 0x1a */
 906 /* File: mips/OP_CONST_STRING.S */
 907     # const/string vAA, String             /* BBBB */
 908     FETCH(a1, 1)                           #  a1 <- BBBB
 909     LOAD_rSELF_methodClassDex(a2)          #  a2 <- self->methodClassDex
 910     GET_OPA(rOBJ)                          #  rOBJ <- AA
 911     LOAD_base_offDvmDex_pResStrings(a2, a2) #  a2 <- dvmDex->pResStrings
 912     LOAD_eas2(v0, a2, a1)                  #  v0 <- pResStrings[BBBB]
 913     # not yet resolved?
 914     bnez      v0, .LOP_CONST_STRING_resolve
 915     /*
 916      * Continuation if the String has not yet been resolved.
 917      *  a1:   BBBB (String ref)
 918      *  rOBJ: target register
 919      */
 920     EXPORT_PC()
 921     LOAD_rSELF_method(a0)                  #  a0 <- self->method
 922     LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
 923     JAL(dvmResolveString)                  #  v0 <- String reference
 924     # failed?
 925     beqz      v0, common_exceptionThrown   #  yup, handle the exception
 926
 927 .LOP_CONST_STRING_resolve:
 928     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 929     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 930     SET_VREG_GOTO(v0, rOBJ, t0)            #  vAA <- v0
 931
 932
 933
 934
 935
 936
 937 /* ------------------------------ */
 938     .balign 128
 939 .L_OP_CONST_STRING_JUMBO: /* 0x1b */
 940 /* File: mips/OP_CONST_STRING_JUMBO.S */
 941     # const/string vAA, String             /* BBBBBBBB */
 942     FETCH(a0, 1)                           #  a0 <- bbbb (low)
 943     FETCH(a1, 2)                           #  a1 <- BBBB (high)
 944     LOAD_rSELF_methodClassDex(a2)          #  a2 <- self->methodClassDex
 945     GET_OPA(rOBJ)                          #  rOBJ <- AA
 946     LOAD_base_offDvmDex_pResStrings(a2, a2) #  a2 <- dvmDex->pResStrings
 947     sll       a1, a1, 16
 948     or        a1, a1, a0                   #  a1 <- BBBBbbbb
 949     LOAD_eas2(v0, a2, a1)                  #  v0 <- pResStrings[BBBB]
 950     bnez      v0, .LOP_CONST_STRING_JUMBO_resolve
 951
 952     /*
 953      * Continuation if the String has not yet been resolved.
 954      *  a1: BBBBBBBB (String ref)
 955      *  rOBJ: target register
 956      */
 957     EXPORT_PC()
 958     LOAD_rSELF_method(a0)                  #  a0 <- self->method
 959     LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
 960     JAL(dvmResolveString)                  #  v0 <- String reference
 961     # failed?
 962     beqz      v0, common_exceptionThrown   #  yup, handle the exception
 963
 964 .LOP_CONST_STRING_JUMBO_resolve:
 965     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
 966     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
 967     SET_VREG_GOTO(v0, rOBJ, t1)            #  vAA <- v0
 968
 969
 970 /* ------------------------------ */
 971     .balign 128
 972 .L_OP_CONST_CLASS: /* 0x1c */
 973 /* File: mips/OP_CONST_CLASS.S */
 974     # const/class vAA, Class               /* BBBB */
 975     FETCH(a1, 1)                           #  a1 <- BBBB
 976     LOAD_rSELF_methodClassDex(a2)          #  a2 <- self->methodClassDex
 977     GET_OPA(rOBJ)                          #  rOBJ <- AA
 978     LOAD_base_offDvmDex_pResClasses(a2, a2) #  a2 <- dvmDex->pResClasses
 979     LOAD_eas2(v0, a2, a1)                  #  v0 <- pResClasses[BBBB]
 980
 981     bnez      v0, .LOP_CONST_CLASS_resolve      #  v0!=0 => resolved-ok
 982     /*
 983      * Continuation if the Class has not yet been resolved.
 984      *  a1: BBBB (Class ref)
 985      *  rOBJ: target register
 986      */
 987     EXPORT_PC()
 988     LOAD_rSELF_method(a0)                  #  a0 <- self->method
 989     li        a2, 1                        #  a2 <- true
 990     LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
 991     JAL(dvmResolveClass)                   #  v0 <- Class reference
 992     # failed==0?
 993     beqz      v0, common_exceptionThrown   #  yup, handle the exception
 994
 995 .LOP_CONST_CLASS_resolve:
 996     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
 997     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
 998     SET_VREG_GOTO(v0, rOBJ, t0)            #  vAA <- v0
 999
1000
1001
1002 /* ------------------------------ */
1003     .balign 128
1004 .L_OP_MONITOR_ENTER: /* 0x1d */
1005 /* File: mips/OP_MONITOR_ENTER.S */
1006     /*
1007      * Synchronize on an object.
1008      */
1009     /* monitor-enter vAA */
1010     GET_OPA(a2)                            #  a2 <- AA
1011     GET_VREG(a1, a2)                       #  a1 <- vAA (object)
1012     move      a0, rSELF                    #  a0 <- self
1013     EXPORT_PC()                            #  export PC so we can grab stack trace
1014     # null object?
1015     beqz      a1, common_errNullObject     #  null object, throw an exception
1016     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
1017     JAL(dvmLockObject)                     #  call(self, obj)
1018     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1019     GOTO_OPCODE(t0)                        #  jump to next instruction
1020
1021
1022 /* ------------------------------ */
1023     .balign 128
1024 .L_OP_MONITOR_EXIT: /* 0x1e */
1025 /* File: mips/OP_MONITOR_EXIT.S */
1026     /*
1027      * Unlock an object.
1028      *
1029      * Exceptions that occur when unlocking a monitor need to appear as
1030      * if they happened at the following instruction.  See the Dalvik
1031      * instruction spec.
1032      */
1033     /* monitor-exit vAA */
1034     GET_OPA(a2)                            #  a2 <- AA
1035     EXPORT_PC()                            #  before fetch: export the PC
1036     GET_VREG(a1, a2)                       #  a1 <- vAA (object)
1037     # null object?
1038     beqz      a1, 1f
1039     move      a0, rSELF                    #  a0 <- self
1040     JAL(dvmUnlockObject)                   #  v0 <- success for unlock(self, obj)
1041     # failed?
1042     FETCH_ADVANCE_INST(1)                  #  before throw: advance rPC, load rINST
1043     beqz      v0, common_exceptionThrown   #  yes, exception is pending
1044     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1045     GOTO_OPCODE(t0)                        #  jump to next instruction
1046 1:
1047     FETCH_ADVANCE_INST(1)                  #  before throw: advance rPC, load rINST
1048     b         common_errNullObject
1049
1050 /* ------------------------------ */
1051     .balign 128
1052 .L_OP_CHECK_CAST: /* 0x1f */
1053 /* File: mips/OP_CHECK_CAST.S */
1054     /*
1055      * Check to see if a cast from one class to another is allowed.
1056      */
1057     # check-cast vAA, class                /* BBBB */
1058     GET_OPA(a3)                            #  a3 <- AA
1059     FETCH(a2, 1)                           #  a2 <- BBBB
1060     GET_VREG(rOBJ, a3)                     #  rOBJ <- object
1061     LOAD_rSELF_methodClassDex(a0)          #  a0 <- pDvmDex
1062     LOAD_base_offDvmDex_pResClasses(a0, a0) #  a0 <- pDvmDex->pResClasses
1063     # is object null?
1064     beqz      rOBJ, .LOP_CHECK_CAST_okay       #  null obj, cast always succeeds
1065     LOAD_eas2(a1, a0, a2)                  #  a1 <- resolved class
1066     LOAD_base_offObject_clazz(a0, rOBJ)    #  a0 <- obj->clazz
1067     # have we resolved this before?
1068     beqz      a1, .LOP_CHECK_CAST_resolve      #  not resolved, do it now
1069 .LOP_CHECK_CAST_resolved:
1070     # same class (trivial success)?
1071     bne       a0, a1, .LOP_CHECK_CAST_fullcheck #  no, do full check
1072 .LOP_CHECK_CAST_okay:
1073     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
1074     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1075     GOTO_OPCODE(t0)                        #  jump to next instruction
1076
1077     /*
1078      * Trivial test failed, need to perform full check.  This is common.
1079      *  a0 holds obj->clazz
1080      *  a1 holds class resolved from BBBB
1081      *  rOBJ holds object
1082      */
1083 .LOP_CHECK_CAST_fullcheck:
1084     move      rBIX,a1                      #  avoid ClassObject getting clobbered
1085     JAL(dvmInstanceofNonTrivial)           #  v0 <- boolean result
1086     # failed?
1087     bnez      v0, .LOP_CHECK_CAST_okay         #  no, success
1088     b         .LOP_CHECK_CAST_castfailure
1089
1090 /* ------------------------------ */
1091     .balign 128
1092 .L_OP_INSTANCE_OF: /* 0x20 */
1093 /* File: mips/OP_INSTANCE_OF.S */
1094     /*
1095      * Check to see if an object reference is an instance of a class.
1096      *
1097      * Most common situation is a non-null object, being compared against
1098      * an already-resolved class.
1099      */
1100     # instance-of vA, vB, class            /* CCCC */
1101     GET_OPB(a3)                            #  a3 <- B
1102     GET_OPA4(rOBJ)                         #  rOBJ <- A+
1103     GET_VREG(a0, a3)                       #  a0 <- vB (object)
1104     LOAD_rSELF_methodClassDex(a2)          #  a2 <- pDvmDex
1105     # is object null?
1106     beqz      a0, .LOP_INSTANCE_OF_store        #  null obj, not an instance, store a0
1107     FETCH(a3, 1)                           #  a3 <- CCCC
1108     LOAD_base_offDvmDex_pResClasses(a2, a2) #  a2 <- pDvmDex->pResClasses
1109     LOAD_eas2(a1, a2, a3)                  #  a1 <- resolved class
1110     LOAD_base_offObject_clazz(a0, a0)      #  a0 <- obj->clazz
1111     # have we resolved this before?
1112     beqz      a1, .LOP_INSTANCE_OF_resolve      #  not resolved, do it now
1113 .LOP_INSTANCE_OF_resolved:                   #  a0=obj->clazz, a1=resolved class
1114     # same class (trivial success)?
1115     beq       a0, a1, .LOP_INSTANCE_OF_trivial  #  yes, trivial finish
1116     b         .LOP_INSTANCE_OF_fullcheck        #  no, do full check
1117
1118     /*
1119      * Trivial test succeeded, save and bail.
1120      *  rOBJ holds A
1121      */
1122 .LOP_INSTANCE_OF_trivial:
1123     li        a0, 1                        #  indicate success
1124     # fall thru
1125     /*
1126      * a0   holds boolean result
1127      * rOBJ holds A
1128      */
1129 .LOP_INSTANCE_OF_store:
1130     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
1131     SET_VREG(a0, rOBJ)                     #  vA <- a0
1132     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1133     GOTO_OPCODE(t0)                        #  jump to next instruction
1134
1135
1136 /* ------------------------------ */
1137     .balign 128
1138 .L_OP_ARRAY_LENGTH: /* 0x21 */
1139 /* File: mips/OP_ARRAY_LENGTH.S */
1140     /*
1141      * Return the length of an array.
1142      */
1143     GET_OPB(a1)                            #  a1 <- B
1144     GET_OPA4(a2)                           #  a2 <- A+
1145     GET_VREG(a0, a1)                       #  a0 <- vB (object ref)
1146     # is object null?
1147     beqz      a0, common_errNullObject     #  yup, fail
1148     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
1149     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- array length
1150     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1151     SET_VREG_GOTO(a3, a2, t0)              #  vA <- length
1152
1153
1154 /* ------------------------------ */
1155     .balign 128
1156 .L_OP_NEW_INSTANCE: /* 0x22 */
1157 /* File: mips/OP_NEW_INSTANCE.S */
1158     /*
1159      * Create a new instance of a class.
1160      */
1161     # new-instance vAA, class              /* BBBB */
1162     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
1163     FETCH(a1, 1)                           #  a1 <- BBBB
1164     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
1165     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
1166 #if defined(WITH_JIT)
1167     EAS2(rBIX, a3, a1)                     #  rBIX <- &resolved_class
1168 #endif
1169     EXPORT_PC()                            #  req'd for init, resolve, alloc
1170     # already resolved?
1171     beqz      a0, .LOP_NEW_INSTANCE_resolve      #  no, resolve it now
1172 .LOP_NEW_INSTANCE_resolved:                      #  a0=class
1173     lbu       a1, offClassObject_status(a0) #  a1 <- ClassStatus enum
1174     # has class been initialized?
1175     li        t0, CLASS_INITIALIZED
1176     move      rOBJ, a0                     #  save a0
1177     bne       a1, t0, .LOP_NEW_INSTANCE_needinit #  no, init class now
1178
1179 .LOP_NEW_INSTANCE_initialized:                   #  a0=class
1180     LOAD_base_offClassObject_accessFlags(a3, a0) #  a3 <- clazz->accessFlags
1181     li        a1, ALLOC_DONT_TRACK         #  flags for alloc call
1182     # a0=class
1183     JAL(dvmAllocObject)                    #  v0 <- new object
1184     GET_OPA(a3)                            #  a3 <- AA
1185 #if defined(WITH_JIT)
1186     /*
1187      * The JIT needs the class to be fully resolved before it can
1188      * include this instruction in a trace.
1189      */
1190     lhu       a1, offThread_subMode(rSELF)
1191     beqz      v0, common_exceptionThrown   #  yes, handle the exception
1192     and       a1, kSubModeJitTraceBuild    #  under construction?
1193     bnez      a1, .LOP_NEW_INSTANCE_jitCheck
1194 #else
1195     # failed?
1196     beqz      v0, common_exceptionThrown   #  yes, handle the exception
1197 #endif
1198     b         .LOP_NEW_INSTANCE_continue
1199
1200
1201 /* ------------------------------ */
1202     .balign 128
1203 .L_OP_NEW_ARRAY: /* 0x23 */
1204 /* File: mips/OP_NEW_ARRAY.S */
1205     /*
1206      * Allocate an array of objects, specified with the array class
1207      * and a count.
1208      *
1209      * The verifier guarantees that this is an array class, so we don't
1210      * check for it here.
1211      */
1212     /* new-array vA, vB, class@CCCC */
1213     GET_OPB(a0)                            #  a0 <- B
1214     FETCH(a2, 1)                           #  a2 <- CCCC
1215     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
1216     GET_VREG(a1, a0)                       #  a1 <- vB (array length)
1217     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
1218     LOAD_eas2(a0, a3, a2)                  #  a0 <- resolved class
1219     # check length
1220     bltz      a1, common_errNegativeArraySize #  negative length, bail - len in a1
1221     EXPORT_PC()                            #  req'd for resolve, alloc
1222     # already resolved?
1223     beqz      a0, .LOP_NEW_ARRAY_resolve
1224
1225     /*
1226      * Finish allocation.
1227      *
1228      *  a0 holds class
1229      *  a1 holds array length
1230      */
1231 .LOP_NEW_ARRAY_finish:
1232     li        a2, ALLOC_DONT_TRACK         #  don't track in local refs table
1233     JAL(dvmAllocArrayByClass)              #  v0 <- call(clazz, length, flags)
1234     GET_OPA4(a2)                           #  a2 <- A+
1235     # failed?
1236     beqz      v0, common_exceptionThrown   #  yes, handle the exception
1237     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
1238     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1239     SET_VREG(v0, a2)                       #  vA <- v0
1240     GOTO_OPCODE(t0)                        #  jump to next instruction
1241
1242 /* ------------------------------ */
1243     .balign 128
1244 .L_OP_FILLED_NEW_ARRAY: /* 0x24 */
1245 /* File: mips/OP_FILLED_NEW_ARRAY.S */
1246     /*
1247      * Create a new array with elements filled from registers.
1248      *
1249      * for: filled-new-array, filled-new-array/range
1250      */
1251     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
1252     # op {vCCCC..v(CCCC+AA-1)}, type       /* BBBB */
1253     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
1254     FETCH(a1, 1)                           #  a1 <- BBBB
1255     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
1256     EXPORT_PC()                            #  need for resolve and alloc
1257     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
1258     GET_OPA(rOBJ)                          #  rOBJ <- AA or BA
1259     # already resolved?
1260     bnez      a0, .LOP_FILLED_NEW_ARRAY_continue     #  yes, continue on
1261     LOAD_rSELF_method(a3)                  #  a3 <- self->method
1262     li        a2, 0                        #  a2 <- false
1263     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
1264     JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
1265     move      a0, v0
1266     # got null?
1267     beqz      v0, common_exceptionThrown   #  yes, handle exception
1268     b         .LOP_FILLED_NEW_ARRAY_continue
1269
1270 /* ------------------------------ */
1271     .balign 128
1272 .L_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */
1273 /* File: mips/OP_FILLED_NEW_ARRAY_RANGE.S */
1274 /* File: mips/OP_FILLED_NEW_ARRAY.S */
1275     /*
1276      * Create a new array with elements filled from registers.
1277      *
1278      * for: filled-new-array, filled-new-array/range
1279      */
1280     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
1281     # op {vCCCC..v(CCCC+AA-1)}, type       /* BBBB */
1282     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
1283     FETCH(a1, 1)                           #  a1 <- BBBB
1284     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
1285     EXPORT_PC()                            #  need for resolve and alloc
1286     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
1287     GET_OPA(rOBJ)                          #  rOBJ <- AA or BA
1288     # already resolved?
1289     bnez      a0, .LOP_FILLED_NEW_ARRAY_RANGE_continue     #  yes, continue on
1290     LOAD_rSELF_method(a3)                  #  a3 <- self->method
1291     li        a2, 0                        #  a2 <- false
1292     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
1293     JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
1294     move      a0, v0
1295     # got null?
1296     beqz      v0, common_exceptionThrown   #  yes, handle exception
1297     b         .LOP_FILLED_NEW_ARRAY_RANGE_continue
1298
1299
1300 /* ------------------------------ */
1301     .balign 128
1302 .L_OP_FILL_ARRAY_DATA: /* 0x26 */
1303 /* File: mips/OP_FILL_ARRAY_DATA.S */
1304     /* fill-array-data vAA, +BBBBBBBB */
1305     FETCH(a0, 1)                           #  a0 <- bbbb (lo)
1306     FETCH(a1, 2)                           #  a1 <- BBBB (hi)
1307     GET_OPA(a3)                            #  a3 <- AA
1308     sll       a1, a1, 16                   #  a1 <- BBBBbbbb
1309     or        a1, a0, a1                   #  a1 <- BBBBbbbb
1310     GET_VREG(a0, a3)                       #  a0 <- vAA (array object)
1311     EAS1(a1, rPC, a1)                      #  a1 <- PC + BBBBbbbb*2 (array data off.)
1312     EXPORT_PC()
1313     JAL(dvmInterpHandleFillArrayData)      #  fill the array with predefined data
1314     # 0 means an exception is thrown
1315     beqz      v0, common_exceptionThrown   #  has exception
1316     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
1317     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1318     GOTO_OPCODE(t0)                        #  jump to next instruction
1319
1320 /* ------------------------------ */
1321     .balign 128
1322 .L_OP_THROW: /* 0x27 */
1323 /* File: mips/OP_THROW.S */
1324     /*
1325      * Throw an exception object in the current thread.
1326      */
1327     /* throw vAA */
1328     GET_OPA(a2)                            #  a2 <- AA
1329     GET_VREG(a1, a2)                       #  a1 <- vAA (exception object)
1330     EXPORT_PC()                            #  exception handler can throw
1331     # null object?
1332     beqz      a1, common_errNullObject     #  yes, throw an NPE instead
1333     # bypass dvmSetException, just store it
1334     STORE_offThread_exception(a1, rSELF)   #  thread->exception <- obj
1335     b         common_exceptionThrown
1336
1337
1338 /* ------------------------------ */
1339     .balign 128
1340 .L_OP_GOTO: /* 0x28 */
1341 /* File: mips/OP_GOTO.S */
1342     /*
1343      * Unconditional branch, 8-bit offset.
1344      *
1345      * The branch distance is a signed code-unit offset, which we need to
1346      * double to get a byte offset.
1347      */
1348     /* goto +AA */
1349     sll       a0, rINST, 16                #  a0 <- AAxx0000
1350     sra       a1, a0, 24                   #  a1 <- ssssssAA (sign-extended)
1351     addu      a2, a1, a1                   #  a2 <- byte offset
1352     /* If backwards branch refresh rBASE */
1353     bgez      a1, 1f
1354     lw        rIBASE, offThread_curHandlerTable(rSELF) #  refresh handler base
1355 1:
1356     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1357 #if defined(WITH_JIT)
1358     lw        a0, offThread_pJitProfTable(rSELF)
1359     bltz      a1, common_testUpdateProfile #  (a0) check for trace hotness
1360 #endif
1361     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1362     GOTO_OPCODE(t0)                        #  jump to next instruction
1363
1364 /* ------------------------------ */
1365     .balign 128
1366 .L_OP_GOTO_16: /* 0x29 */
1367 /* File: mips/OP_GOTO_16.S */
1368     /*
1369      * Unconditional branch, 16-bit offset.
1370      *
1371      * The branch distance is a signed code-unit offset, which we need to
1372      * double to get a byte offset.
1373      */
1374     /* goto/16 +AAAA */
1375     FETCH_S(a0, 1)                         #  a0 <- ssssAAAA (sign-extended)
1376     addu      a1, a0, a0                   #  a1 <- byte offset, flags set
1377     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
1378     bgez      a1, 1f
1379     lw        rIBASE, offThread_curHandlerTable(rSELF) #  refresh handler base
1380 1:
1381 #if defined(WITH_JIT)
1382     lw        a0, offThread_pJitProfTable(rSELF)
1383     bltz      a1, common_testUpdateProfile #  (a0) hot trace head?
1384 #endif
1385     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1386     GOTO_OPCODE(t0)                        #  jump to next instruction
1387
1388 /* ------------------------------ */
1389     .balign 128
1390 .L_OP_GOTO_32: /* 0x2a */
1391 /* File: mips/OP_GOTO_32.S */
1392     /*
1393      * Unconditional branch, 32-bit offset.
1394      *
1395      * The branch distance is a signed code-unit offset, which we need to
1396      * double to get a byte offset.
1397      *
1398      * Unlike most opcodes, this one is allowed to branch to itself, so
1399      * our "backward branch" test must be "<=0" instead of "<0".
1400      */
1401     /* goto/32 +AAAAAAAA */
1402     FETCH(a0, 1)                           #  a0 <- aaaa (lo)
1403     FETCH(a1, 2)                           #  a1 <- AAAA (hi)
1404     sll       a1, a1, 16
1405     or        a0, a0, a1                   #  a0 <- AAAAaaaa
1406     addu      a1, a0, a0                   #  a1 <- byte offset
1407 #if defined(WITH_JIT)
1408     lw        a0, offThread_pJitProfTable(rSELF)
1409     bgtz      a1, 1f
1410     lw        rIBASE, offThread_curHandlerTable(rSELF) #  refresh handler base
1411 1:
1412     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
1413     blez      a1, common_testUpdateProfile # (a0) hot trace head?
1414 #else
1415     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
1416     bgtz      a0, 2f
1417     lw        rIBASE, offThread_curHandlerTable(rSELF) #  refresh handler base
1418 2:
1419 #endif
1420     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1421     GOTO_OPCODE(t0)                        #  jump to next instruction
1422
1423 /* ------------------------------ */
1424     .balign 128
1425 .L_OP_PACKED_SWITCH: /* 0x2b */
1426 /* File: mips/OP_PACKED_SWITCH.S */
1427     /*
1428      * Handle a packed-switch or sparse-switch instruction.  In both cases
1429      * we decode it and hand it off to a helper function.
1430      *
1431      * We don't really expect backward branches in a switch statement, but
1432      * they're perfectly legal, so we check for them here.
1433      *
1434      * When the JIT is present, all targets are considered treated as
1435      * a potential trace heads regardless of branch direction.
1436      *
1437      * for: packed-switch, sparse-switch
1438      */
1439     /* op vAA, +BBBB */
1440     FETCH(a0, 1)                           #  a0 <- bbbb (lo)
1441     FETCH(a1, 2)                           #  a1 <- BBBB (hi)
1442     GET_OPA(a3)                            #  a3 <- AA
1443     sll       t0, a1, 16
1444     or        a0, a0, t0                   #  a0 <- BBBBbbbb
1445     GET_VREG(a1, a3)                       #  a1 <- vAA
1446     EAS1(a0, rPC, a0)                      #  a0 <- PC + BBBBbbbb*2
1447     JAL(dvmInterpHandlePackedSwitch)                             #  a0 <- code-unit branch offset
1448     addu      a1, v0, v0                   #  a1 <- byte offset
1449     bgtz      a1, 1f
1450     lw        rIBASE, offThread_curHandlerTable(rSELF) #  refresh handler base
1451 1:
1452     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
1453 #if defined(WITH_JIT)
1454     lw        a0, offThread_pJitProfTable(rSELF)
1455     bnez      a0, common_updateProfile
1456 #endif
1457     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1458     GOTO_OPCODE(t0)                        #  jump to next instruction
1459
1460 /* ------------------------------ */
1461     .balign 128
1462 .L_OP_SPARSE_SWITCH: /* 0x2c */
1463 /* File: mips/OP_SPARSE_SWITCH.S */
1464 /* File: mips/OP_PACKED_SWITCH.S */
1465     /*
1466      * Handle a packed-switch or sparse-switch instruction.  In both cases
1467      * we decode it and hand it off to a helper function.
1468      *
1469      * We don't really expect backward branches in a switch statement, but
1470      * they're perfectly legal, so we check for them here.
1471      *
1472      * When the JIT is present, all targets are considered treated as
1473      * a potential trace heads regardless of branch direction.
1474      *
1475      * for: packed-switch, sparse-switch
1476      */
1477     /* op vAA, +BBBB */
1478     FETCH(a0, 1)                           #  a0 <- bbbb (lo)
1479     FETCH(a1, 2)                           #  a1 <- BBBB (hi)
1480     GET_OPA(a3)                            #  a3 <- AA
1481     sll       t0, a1, 16
1482     or        a0, a0, t0                   #  a0 <- BBBBbbbb
1483     GET_VREG(a1, a3)                       #  a1 <- vAA
1484     EAS1(a0, rPC, a0)                      #  a0 <- PC + BBBBbbbb*2
1485     JAL(dvmInterpHandleSparseSwitch)                             #  a0 <- code-unit branch offset
1486     addu      a1, v0, v0                   #  a1 <- byte offset
1487     bgtz      a1, 1f
1488     lw        rIBASE, offThread_curHandlerTable(rSELF) #  refresh handler base
1489 1:
1490     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
1491 #if defined(WITH_JIT)
1492     lw        a0, offThread_pJitProfTable(rSELF)
1493     bnez      a0, common_updateProfile
1494 #endif
1495     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1496     GOTO_OPCODE(t0)                        #  jump to next instruction
1497
1498
1499 /* ------------------------------ */
1500     .balign 128
1501 .L_OP_CMPL_FLOAT: /* 0x2d */
1502 /* File: mips/OP_CMPL_FLOAT.S */
1503     /*
1504      * Compare two floating-point values.  Puts 0, 1, or -1 into the
1505      * destination register based on the results of the comparison.
1506      *
1507      * Provide a "naninst" instruction that puts 1 or -1 into a1 depending
1508      * on what value we'd like to return when one of the operands is NaN.
1509      *
1510      * The operation we're implementing is:
1511      *   if (x == y)
1512      *     return 0;
1513      *   else if (x < y)
1514      *     return -1;
1515      *   else if (x > y)
1516      *     return 1;
1517      *   else
1518      *     return {-1,1};  // one or both operands was NaN
1519      *
1520      * for: cmpl-float, cmpg-float
1521      */
1522     /* op vAA, vBB, vCC */
1523
1524     /* "clasic" form */
1525     FETCH(a0, 1)                           #  a0 <- CCBB
1526     and       a2, a0, 255                  #  a2 <- BB
1527     srl       a3, a0, 8
1528 #ifdef SOFT_FLOAT
1529     GET_VREG(rOBJ, a2)                     #  rOBJ <- vBB
1530     GET_VREG(rBIX, a3)                     #  rBIX <- vCC
1531     move      a0, rOBJ                     #  a0 <- vBB
1532     move      a1, rBIX                     #  a1 <- vCC
1533     JAL(__eqsf2)                           #  a0 <- (vBB == vCC)
1534     li        rTEMP, 0                     # set rTEMP to 0
1535     beqz      v0, OP_CMPL_FLOAT_finish
1536     move      a0, rOBJ                     #  a0 <- vBB
1537     move      a1, rBIX                     #  a1 <- vCC
1538     JAL(__ltsf2)                           #  a0 <- (vBB < vCC)
1539     li        rTEMP, -1
1540     bltz      v0, OP_CMPL_FLOAT_finish
1541     move      a0, rOBJ                     #  a0 <- vBB
1542     move      a1, rBIX                     #  a1 <- vCC
1543     b         OP_CMPL_FLOAT_continue
1544 #else
1545     GET_VREG_F(fs0, a2)
1546     GET_VREG_F(fs1, a3)
1547     c.olt.s   fcc0, fs0, fs1               # Is fs0 < fs1
1548     li        rTEMP, -1
1549     bc1t      fcc0, OP_CMPL_FLOAT_finish
1550     c.olt.s   fcc0, fs1, fs0
1551     li        rTEMP, 1
1552     bc1t      fcc0, OP_CMPL_FLOAT_finish
1553     c.eq.s    fcc0, fs0, fs1
1554     li        rTEMP, 0
1555     bc1t      fcc0, OP_CMPL_FLOAT_finish
1556     b         OP_CMPL_FLOAT_nan
1557
1558 #endif
1559
1560
1561 /* ------------------------------ */
1562     .balign 128
1563 .L_OP_CMPG_FLOAT: /* 0x2e */
1564 /* File: mips/OP_CMPG_FLOAT.S */
1565 /* File: mips/OP_CMPL_FLOAT.S */
1566     /*
1567      * Compare two floating-point values.  Puts 0, 1, or -1 into the
1568      * destination register based on the results of the comparison.
1569      *
1570      * Provide a "naninst" instruction that puts 1 or -1 into a1 depending
1571      * on what value we'd like to return when one of the operands is NaN.
1572      *
1573      * The operation we're implementing is:
1574      *   if (x == y)
1575      *     return 0;
1576      *   else if (x < y)
1577      *     return -1;
1578      *   else if (x > y)
1579      *     return 1;
1580      *   else
1581      *     return {-1,1};  // one or both operands was NaN
1582      *
1583      * for: cmpl-float, cmpg-float
1584      */
1585     /* op vAA, vBB, vCC */
1586
1587     /* "clasic" form */
1588     FETCH(a0, 1)                           #  a0 <- CCBB
1589     and       a2, a0, 255                  #  a2 <- BB
1590     srl       a3, a0, 8
1591 #ifdef SOFT_FLOAT
1592     GET_VREG(rOBJ, a2)                     #  rOBJ <- vBB
1593     GET_VREG(rBIX, a3)                     #  rBIX <- vCC
1594     move      a0, rOBJ                     #  a0 <- vBB
1595     move      a1, rBIX                     #  a1 <- vCC
1596     JAL(__eqsf2)                           #  a0 <- (vBB == vCC)
1597     li        rTEMP, 0                     # set rTEMP to 0
1598     beqz      v0, OP_CMPG_FLOAT_finish
1599     move      a0, rOBJ                     #  a0 <- vBB
1600     move      a1, rBIX                     #  a1 <- vCC
1601     JAL(__ltsf2)                           #  a0 <- (vBB < vCC)
1602     li        rTEMP, -1
1603     bltz      v0, OP_CMPG_FLOAT_finish
1604     move      a0, rOBJ                     #  a0 <- vBB
1605     move      a1, rBIX                     #  a1 <- vCC
1606     b         OP_CMPG_FLOAT_continue
1607 #else
1608     GET_VREG_F(fs0, a2)
1609     GET_VREG_F(fs1, a3)
1610     c.olt.s   fcc0, fs0, fs1               # Is fs0 < fs1
1611     li        rTEMP, -1
1612     bc1t      fcc0, OP_CMPG_FLOAT_finish
1613     c.olt.s   fcc0, fs1, fs0
1614     li        rTEMP, 1
1615     bc1t      fcc0, OP_CMPG_FLOAT_finish
1616     c.eq.s    fcc0, fs0, fs1
1617     li        rTEMP, 0
1618     bc1t      fcc0, OP_CMPG_FLOAT_finish
1619     b         OP_CMPG_FLOAT_nan
1620
1621 #endif
1622
1623
1624
1625 /* ------------------------------ */
1626     .balign 128
1627 .L_OP_CMPL_DOUBLE: /* 0x2f */
1628 /* File: mips/OP_CMPL_DOUBLE.S */
1629     /*
1630      * Compare two floating-point values.  Puts 0, 1, or -1 into the
1631      * destination register based on the results of the comparison.
1632      *
1633      * Provide a "naninst" instruction that puts 1 or -1 into a1 depending
1634      * on what value we'd like to return when one of the operands is NaN.
1635      *
1636      * See OP_CMPL_FLOAT for an explanation.
1637      *
1638      * For: cmpl-double, cmpg-double
1639      */
1640     /* op vAA, vBB, vCC */
1641
1642     FETCH(a0, 1)                           #  a0 <- CCBB
1643     and       rOBJ, a0, 255                #  s0 <- BB
1644     srl       rBIX, a0, 8                  #  t0 <- CC
1645     EAS2(rOBJ, rFP, rOBJ)                  #  s0 <- &fp[BB]
1646     EAS2(rBIX, rFP, rBIX)                  #  t0 <- &fp[CC]
1647 #ifdef SOFT_FLOAT
1648     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vBB/vBB+1
1649     LOAD64(rARG2, rARG3, rBIX)             #  a2/a3 <- vCC/vCC+1
1650     JAL(__eqdf2)                           #  cmp <=: C clear if <, Z set if eq
1651     li        rTEMP, 0
1652     beqz      v0, OP_CMPL_DOUBLE_finish
1653
1654     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vBB/vBB+1
1655     LOAD64(rARG2, rARG3, rBIX)             #  a2/a3 <- vCC/vCC+1
1656     JAL(__ltdf2)
1657     li        rTEMP, -1
1658     bltz      v0, OP_CMPL_DOUBLE_finish
1659     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vBB/vBB+1
1660     b         OP_CMPL_DOUBLE_continue
1661 #else
1662     LOAD64_F(fs0, fs0f, rOBJ)
1663     LOAD64_F(fs1, fs1f, rBIX)
1664     c.olt.d   fcc0, fs0, fs1
1665     li        rTEMP, -1
1666     bc1t      fcc0, OP_CMPL_DOUBLE_finish
1667     c.olt.d   fcc0, fs1, fs0
1668     li        rTEMP, 1
1669     bc1t      fcc0, OP_CMPL_DOUBLE_finish
1670     c.eq.d    fcc0, fs0, fs1
1671     li        rTEMP, 0
1672     bc1t      fcc0, OP_CMPL_DOUBLE_finish
1673     b         OP_CMPL_DOUBLE_nan
1674 #endif
1675
1676 /* ------------------------------ */
1677     .balign 128
1678 .L_OP_CMPG_DOUBLE: /* 0x30 */
1679 /* File: mips/OP_CMPG_DOUBLE.S */
1680 /* File: mips/OP_CMPL_DOUBLE.S */
1681     /*
1682      * Compare two floating-point values.  Puts 0, 1, or -1 into the
1683      * destination register based on the results of the comparison.
1684      *
1685      * Provide a "naninst" instruction that puts 1 or -1 into a1 depending
1686      * on what value we'd like to return when one of the operands is NaN.
1687      *
1688      * See OP_CMPL_FLOAT for an explanation.
1689      *
1690      * For: cmpl-double, cmpg-double
1691      */
1692     /* op vAA, vBB, vCC */
1693
1694     FETCH(a0, 1)                           #  a0 <- CCBB
1695     and       rOBJ, a0, 255                #  s0 <- BB
1696     srl       rBIX, a0, 8                  #  t0 <- CC
1697     EAS2(rOBJ, rFP, rOBJ)                  #  s0 <- &fp[BB]
1698     EAS2(rBIX, rFP, rBIX)                  #  t0 <- &fp[CC]
1699 #ifdef SOFT_FLOAT
1700     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vBB/vBB+1
1701     LOAD64(rARG2, rARG3, rBIX)             #  a2/a3 <- vCC/vCC+1
1702     JAL(__eqdf2)                           #  cmp <=: C clear if <, Z set if eq
1703     li        rTEMP, 0
1704     beqz      v0, OP_CMPG_DOUBLE_finish
1705
1706     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vBB/vBB+1
1707     LOAD64(rARG2, rARG3, rBIX)             #  a2/a3 <- vCC/vCC+1
1708     JAL(__ltdf2)
1709     li        rTEMP, -1
1710     bltz      v0, OP_CMPG_DOUBLE_finish
1711     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vBB/vBB+1
1712     b         OP_CMPG_DOUBLE_continue
1713 #else
1714     LOAD64_F(fs0, fs0f, rOBJ)
1715     LOAD64_F(fs1, fs1f, rBIX)
1716     c.olt.d   fcc0, fs0, fs1
1717     li        rTEMP, -1
1718     bc1t      fcc0, OP_CMPG_DOUBLE_finish
1719     c.olt.d   fcc0, fs1, fs0
1720     li        rTEMP, 1
1721     bc1t      fcc0, OP_CMPG_DOUBLE_finish
1722     c.eq.d    fcc0, fs0, fs1
1723     li        rTEMP, 0
1724     bc1t      fcc0, OP_CMPG_DOUBLE_finish
1725     b         OP_CMPG_DOUBLE_nan
1726 #endif
1727
1728
1729 /* ------------------------------ */
1730     .balign 128
1731 .L_OP_CMP_LONG: /* 0x31 */
1732 /* File: mips/OP_CMP_LONG.S */
1733     /*
1734      * Compare two 64-bit values
1735      *    x = y     return  0
1736      *    x < y     return -1
1737      *    x > y     return  1
1738      *
1739      * I think I can improve on the ARM code by the following observation
1740      *    slt   t0,  x.hi, y.hi;        # (x.hi < y.hi) ? 1:0
1741      *    sgt   t1,  x.hi, y.hi;        # (y.hi > x.hi) ? 1:0
1742      *    subu  v0, t0, t1              # v0= -1:1:0 for [ < > = ]
1743      */
1744     /* cmp-long vAA, vBB, vCC */
1745     FETCH(a0, 1)                           #  a0 <- CCBB
1746     GET_OPA(rOBJ)                          #  rOBJ <- AA
1747     and       a2, a0, 255                  #  a2 <- BB
1748     srl       a3, a0, 8                    #  a3 <- CC
1749     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
1750     EAS2(a3, rFP, a3)                      #  a3 <- &fp[CC]
1751     LOAD64(a0, a1, a2)                     #  a0/a1 <- vBB/vBB+1
1752     LOAD64(a2, a3, a3)                     #  a2/a3 <- vCC/vCC+1
1753
1754     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
1755     slt       t0, a1, a3                   #  compare hi
1756     sgt       t1, a1, a3
1757     subu      v0, t1, t0                   #  v0 <- (-1, 1, 0)
1758     bnez      v0, .LOP_CMP_LONG_finish
1759     # at this point x.hi==y.hi
1760     sltu      t0, a0, a2                   #  compare lo
1761     sgtu      t1, a0, a2
1762     subu      v0, t1, t0                   #  v0 <- (-1, 1, 0) for [< > =]
1763
1764 .LOP_CMP_LONG_finish:
1765     SET_VREG(v0, rOBJ)                     #  vAA <- v0
1766     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1767     GOTO_OPCODE(t0)                        #  jump to next instruction
1768
1769
1770 /* ------------------------------ */
1771     .balign 128
1772 .L_OP_IF_EQ: /* 0x32 */
1773 /* File: mips/OP_IF_EQ.S */
1774 /* File: mips/bincmp.S */
1775     /*
1776      * Generic two-operand compare-and-branch operation.  Provide a "revcmp"
1777      * fragment that specifies the *reverse* comparison to perform, e.g.
1778      * for "if-le" you would use "gt".
1779      *
1780      * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1781      */
1782     /* if-cmp vA, vB, +CCCC */
1783     GET_OPA4(a0)                           #  a0 <- A+
1784     GET_OPB(a1)                            #  a1 <- B
1785     GET_VREG(a3, a1)                       #  a3 <- vB
1786     GET_VREG(a2, a0)                       #  a2 <- vA
1787     bne a2, a3, 1f                  #  branch to 1 if comparison failed
1788     FETCH_S(a1, 1)                         #  a1<- branch offset, in code units
1789     b 2f
1790 1:
1791     li        a1, 2                        #  a1- BYTE branch dist for not-taken
1792 2:
1793     addu      a2, a1, a1                   #  convert to bytes
1794     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1795 #if defined(WITH_JIT)
1796     lw        a0, offThread_pJitProfTable(rSELF)
1797     bgez      a2, 3f
1798     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1799 3:
1800     bnez      a0, common_updateProfile
1801 #else
1802     bgez      a2, 4f
1803     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1804 4:
1805 #endif
1806     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1807     GOTO_OPCODE(t0)                        #  jump to next instruction
1808
1809
1810 /* ------------------------------ */
1811     .balign 128
1812 .L_OP_IF_NE: /* 0x33 */
1813 /* File: mips/OP_IF_NE.S */
1814 /* File: mips/bincmp.S */
1815     /*
1816      * Generic two-operand compare-and-branch operation.  Provide a "revcmp"
1817      * fragment that specifies the *reverse* comparison to perform, e.g.
1818      * for "if-le" you would use "gt".
1819      *
1820      * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1821      */
1822     /* if-cmp vA, vB, +CCCC */
1823     GET_OPA4(a0)                           #  a0 <- A+
1824     GET_OPB(a1)                            #  a1 <- B
1825     GET_VREG(a3, a1)                       #  a3 <- vB
1826     GET_VREG(a2, a0)                       #  a2 <- vA
1827     beq a2, a3, 1f                  #  branch to 1 if comparison failed
1828     FETCH_S(a1, 1)                         #  a1<- branch offset, in code units
1829     b 2f
1830 1:
1831     li        a1, 2                        #  a1- BYTE branch dist for not-taken
1832 2:
1833     addu      a2, a1, a1                   #  convert to bytes
1834     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1835 #if defined(WITH_JIT)
1836     lw        a0, offThread_pJitProfTable(rSELF)
1837     bgez      a2, 3f
1838     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1839 3:
1840     bnez      a0, common_updateProfile
1841 #else
1842     bgez      a2, 4f
1843     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1844 4:
1845 #endif
1846     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1847     GOTO_OPCODE(t0)                        #  jump to next instruction
1848
1849
1850 /* ------------------------------ */
1851     .balign 128
1852 .L_OP_IF_LT: /* 0x34 */
1853 /* File: mips/OP_IF_LT.S */
1854 /* File: mips/bincmp.S */
1855     /*
1856      * Generic two-operand compare-and-branch operation.  Provide a "revcmp"
1857      * fragment that specifies the *reverse* comparison to perform, e.g.
1858      * for "if-le" you would use "gt".
1859      *
1860      * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1861      */
1862     /* if-cmp vA, vB, +CCCC */
1863     GET_OPA4(a0)                           #  a0 <- A+
1864     GET_OPB(a1)                            #  a1 <- B
1865     GET_VREG(a3, a1)                       #  a3 <- vB
1866     GET_VREG(a2, a0)                       #  a2 <- vA
1867     bge a2, a3, 1f                  #  branch to 1 if comparison failed
1868     FETCH_S(a1, 1)                         #  a1<- branch offset, in code units
1869     b 2f
1870 1:
1871     li        a1, 2                        #  a1- BYTE branch dist for not-taken
1872 2:
1873     addu      a2, a1, a1                   #  convert to bytes
1874     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1875 #if defined(WITH_JIT)
1876     lw        a0, offThread_pJitProfTable(rSELF)
1877     bgez      a2, 3f
1878     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1879 3:
1880     bnez      a0, common_updateProfile
1881 #else
1882     bgez      a2, 4f
1883     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1884 4:
1885 #endif
1886     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1887     GOTO_OPCODE(t0)                        #  jump to next instruction
1888
1889
1890 /* ------------------------------ */
1891     .balign 128
1892 .L_OP_IF_GE: /* 0x35 */
1893 /* File: mips/OP_IF_GE.S */
1894 /* File: mips/bincmp.S */
1895     /*
1896      * Generic two-operand compare-and-branch operation.  Provide a "revcmp"
1897      * fragment that specifies the *reverse* comparison to perform, e.g.
1898      * for "if-le" you would use "gt".
1899      *
1900      * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1901      */
1902     /* if-cmp vA, vB, +CCCC */
1903     GET_OPA4(a0)                           #  a0 <- A+
1904     GET_OPB(a1)                            #  a1 <- B
1905     GET_VREG(a3, a1)                       #  a3 <- vB
1906     GET_VREG(a2, a0)                       #  a2 <- vA
1907     blt a2, a3, 1f                  #  branch to 1 if comparison failed
1908     FETCH_S(a1, 1)                         #  a1<- branch offset, in code units
1909     b 2f
1910 1:
1911     li        a1, 2                        #  a1- BYTE branch dist for not-taken
1912 2:
1913     addu      a2, a1, a1                   #  convert to bytes
1914     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1915 #if defined(WITH_JIT)
1916     lw        a0, offThread_pJitProfTable(rSELF)
1917     bgez      a2, 3f
1918     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1919 3:
1920     bnez      a0, common_updateProfile
1921 #else
1922     bgez      a2, 4f
1923     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1924 4:
1925 #endif
1926     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1927     GOTO_OPCODE(t0)                        #  jump to next instruction
1928
1929
1930 /* ------------------------------ */
1931     .balign 128
1932 .L_OP_IF_GT: /* 0x36 */
1933 /* File: mips/OP_IF_GT.S */
1934 /* File: mips/bincmp.S */
1935     /*
1936      * Generic two-operand compare-and-branch operation.  Provide a "revcmp"
1937      * fragment that specifies the *reverse* comparison to perform, e.g.
1938      * for "if-le" you would use "gt".
1939      *
1940      * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1941      */
1942     /* if-cmp vA, vB, +CCCC */
1943     GET_OPA4(a0)                           #  a0 <- A+
1944     GET_OPB(a1)                            #  a1 <- B
1945     GET_VREG(a3, a1)                       #  a3 <- vB
1946     GET_VREG(a2, a0)                       #  a2 <- vA
1947     ble a2, a3, 1f                  #  branch to 1 if comparison failed
1948     FETCH_S(a1, 1)                         #  a1<- branch offset, in code units
1949     b 2f
1950 1:
1951     li        a1, 2                        #  a1- BYTE branch dist for not-taken
1952 2:
1953     addu      a2, a1, a1                   #  convert to bytes
1954     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1955 #if defined(WITH_JIT)
1956     lw        a0, offThread_pJitProfTable(rSELF)
1957     bgez      a2, 3f
1958     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1959 3:
1960     bnez      a0, common_updateProfile
1961 #else
1962     bgez      a2, 4f
1963     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1964 4:
1965 #endif
1966     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
1967     GOTO_OPCODE(t0)                        #  jump to next instruction
1968
1969
1970 /* ------------------------------ */
1971     .balign 128
1972 .L_OP_IF_LE: /* 0x37 */
1973 /* File: mips/OP_IF_LE.S */
1974 /* File: mips/bincmp.S */
1975     /*
1976      * Generic two-operand compare-and-branch operation.  Provide a "revcmp"
1977      * fragment that specifies the *reverse* comparison to perform, e.g.
1978      * for "if-le" you would use "gt".
1979      *
1980      * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1981      */
1982     /* if-cmp vA, vB, +CCCC */
1983     GET_OPA4(a0)                           #  a0 <- A+
1984     GET_OPB(a1)                            #  a1 <- B
1985     GET_VREG(a3, a1)                       #  a3 <- vB
1986     GET_VREG(a2, a0)                       #  a2 <- vA
1987     bgt a2, a3, 1f                  #  branch to 1 if comparison failed
1988     FETCH_S(a1, 1)                         #  a1<- branch offset, in code units
1989     b 2f
1990 1:
1991     li        a1, 2                        #  a1- BYTE branch dist for not-taken
1992 2:
1993     addu      a2, a1, a1                   #  convert to bytes
1994     FETCH_ADVANCE_INST_RB(a2)              #  update rPC, load rINST
1995 #if defined(WITH_JIT)
1996     lw        a0, offThread_pJitProfTable(rSELF)
1997     bgez      a2, 3f
1998     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
1999 3:
2000     bnez      a0, common_updateProfile
2001 #else
2002     bgez      a2, 4f
2003     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rIBASE
2004 4:
2005 #endif
2006     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2007     GOTO_OPCODE(t0)                        #  jump to next instruction
2008
2009
2010 /* ------------------------------ */
2011     .balign 128
2012 .L_OP_IF_EQZ: /* 0x38 */
2013 /* File: mips/OP_IF_EQZ.S */
2014 /* File: mips/zcmp.S */
2015     /*
2016      * Generic one-operand compare-and-branch operation.  Provide a "revcmp"
2017      * fragment that specifies the *reverse* comparison to perform, e.g.
2018      * for "if-le" you would use "gt".
2019      *
2020      * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2021      */
2022     /* if-cmp vAA, +BBBB */
2023     GET_OPA(a0)                            #  a0 <- AA
2024     GET_VREG(a2, a0)                       #  a2 <- vAA
2025     FETCH_S(a1, 1)                         #  a1 <- branch offset, in code units
2026     bne a2, zero, 1f                #  branch to 1 if comparison failed
2027     b 2f
2028 1:
2029     li        a1, 2                        #  a1- BYTE branch dist for not-taken
2030 2:
2031     addu      a1, a1, a1                   #  convert to bytes
2032     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
2033 #if defined(WITH_JIT)
2034     lw        a0, offThread_pJitProfTable(rSELF)
2035     bgez      a1, 3f
2036     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh table base
2037 3:
2038     bnez      a0, common_updateProfile     #  test for JIT off at target
2039 #else
2040     bgez      a1, 4f
2041     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rtable base
2042 4:
2043 #endif
2044     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2045     GOTO_OPCODE(t0)                        #  jump to next instruction
2046
2047
2048 /* ------------------------------ */
2049     .balign 128
2050 .L_OP_IF_NEZ: /* 0x39 */
2051 /* File: mips/OP_IF_NEZ.S */
2052 /* File: mips/zcmp.S */
2053     /*
2054      * Generic one-operand compare-and-branch operation.  Provide a "revcmp"
2055      * fragment that specifies the *reverse* comparison to perform, e.g.
2056      * for "if-le" you would use "gt".
2057      *
2058      * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2059      */
2060     /* if-cmp vAA, +BBBB */
2061     GET_OPA(a0)                            #  a0 <- AA
2062     GET_VREG(a2, a0)                       #  a2 <- vAA
2063     FETCH_S(a1, 1)                         #  a1 <- branch offset, in code units
2064     beq a2, zero, 1f                #  branch to 1 if comparison failed
2065     b 2f
2066 1:
2067     li        a1, 2                        #  a1- BYTE branch dist for not-taken
2068 2:
2069     addu      a1, a1, a1                   #  convert to bytes
2070     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
2071 #if defined(WITH_JIT)
2072     lw        a0, offThread_pJitProfTable(rSELF)
2073     bgez      a1, 3f
2074     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh table base
2075 3:
2076     bnez      a0, common_updateProfile     #  test for JIT off at target
2077 #else
2078     bgez      a1, 4f
2079     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rtable base
2080 4:
2081 #endif
2082     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2083     GOTO_OPCODE(t0)                        #  jump to next instruction
2084
2085
2086 /* ------------------------------ */
2087     .balign 128
2088 .L_OP_IF_LTZ: /* 0x3a */
2089 /* File: mips/OP_IF_LTZ.S */
2090 /* File: mips/zcmp.S */
2091     /*
2092      * Generic one-operand compare-and-branch operation.  Provide a "revcmp"
2093      * fragment that specifies the *reverse* comparison to perform, e.g.
2094      * for "if-le" you would use "gt".
2095      *
2096      * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2097      */
2098     /* if-cmp vAA, +BBBB */
2099     GET_OPA(a0)                            #  a0 <- AA
2100     GET_VREG(a2, a0)                       #  a2 <- vAA
2101     FETCH_S(a1, 1)                         #  a1 <- branch offset, in code units
2102     bge a2, zero, 1f                #  branch to 1 if comparison failed
2103     b 2f
2104 1:
2105     li        a1, 2                        #  a1- BYTE branch dist for not-taken
2106 2:
2107     addu      a1, a1, a1                   #  convert to bytes
2108     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
2109 #if defined(WITH_JIT)
2110     lw        a0, offThread_pJitProfTable(rSELF)
2111     bgez      a1, 3f
2112     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh table base
2113 3:
2114     bnez      a0, common_updateProfile     #  test for JIT off at target
2115 #else
2116     bgez      a1, 4f
2117     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rtable base
2118 4:
2119 #endif
2120     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2121     GOTO_OPCODE(t0)                        #  jump to next instruction
2122
2123
2124 /* ------------------------------ */
2125     .balign 128
2126 .L_OP_IF_GEZ: /* 0x3b */
2127 /* File: mips/OP_IF_GEZ.S */
2128 /* File: mips/zcmp.S */
2129     /*
2130      * Generic one-operand compare-and-branch operation.  Provide a "revcmp"
2131      * fragment that specifies the *reverse* comparison to perform, e.g.
2132      * for "if-le" you would use "gt".
2133      *
2134      * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2135      */
2136     /* if-cmp vAA, +BBBB */
2137     GET_OPA(a0)                            #  a0 <- AA
2138     GET_VREG(a2, a0)                       #  a2 <- vAA
2139     FETCH_S(a1, 1)                         #  a1 <- branch offset, in code units
2140     blt a2, zero, 1f                #  branch to 1 if comparison failed
2141     b 2f
2142 1:
2143     li        a1, 2                        #  a1- BYTE branch dist for not-taken
2144 2:
2145     addu      a1, a1, a1                   #  convert to bytes
2146     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
2147 #if defined(WITH_JIT)
2148     lw        a0, offThread_pJitProfTable(rSELF)
2149     bgez      a1, 3f
2150     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh table base
2151 3:
2152     bnez      a0, common_updateProfile     #  test for JIT off at target
2153 #else
2154     bgez      a1, 4f
2155     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rtable base
2156 4:
2157 #endif
2158     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2159     GOTO_OPCODE(t0)                        #  jump to next instruction
2160
2161
2162 /* ------------------------------ */
2163     .balign 128
2164 .L_OP_IF_GTZ: /* 0x3c */
2165 /* File: mips/OP_IF_GTZ.S */
2166 /* File: mips/zcmp.S */
2167     /*
2168      * Generic one-operand compare-and-branch operation.  Provide a "revcmp"
2169      * fragment that specifies the *reverse* comparison to perform, e.g.
2170      * for "if-le" you would use "gt".
2171      *
2172      * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2173      */
2174     /* if-cmp vAA, +BBBB */
2175     GET_OPA(a0)                            #  a0 <- AA
2176     GET_VREG(a2, a0)                       #  a2 <- vAA
2177     FETCH_S(a1, 1)                         #  a1 <- branch offset, in code units
2178     ble a2, zero, 1f                #  branch to 1 if comparison failed
2179     b 2f
2180 1:
2181     li        a1, 2                        #  a1- BYTE branch dist for not-taken
2182 2:
2183     addu      a1, a1, a1                   #  convert to bytes
2184     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
2185 #if defined(WITH_JIT)
2186     lw        a0, offThread_pJitProfTable(rSELF)
2187     bgez      a1, 3f
2188     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh table base
2189 3:
2190     bnez      a0, common_updateProfile     #  test for JIT off at target
2191 #else
2192     bgez      a1, 4f
2193     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rtable base
2194 4:
2195 #endif
2196     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2197     GOTO_OPCODE(t0)                        #  jump to next instruction
2198
2199
2200 /* ------------------------------ */
2201     .balign 128
2202 .L_OP_IF_LEZ: /* 0x3d */
2203 /* File: mips/OP_IF_LEZ.S */
2204 /* File: mips/zcmp.S */
2205     /*
2206      * Generic one-operand compare-and-branch operation.  Provide a "revcmp"
2207      * fragment that specifies the *reverse* comparison to perform, e.g.
2208      * for "if-le" you would use "gt".
2209      *
2210      * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2211      */
2212     /* if-cmp vAA, +BBBB */
2213     GET_OPA(a0)                            #  a0 <- AA
2214     GET_VREG(a2, a0)                       #  a2 <- vAA
2215     FETCH_S(a1, 1)                         #  a1 <- branch offset, in code units
2216     bgt a2, zero, 1f                #  branch to 1 if comparison failed
2217     b 2f
2218 1:
2219     li        a1, 2                        #  a1- BYTE branch dist for not-taken
2220 2:
2221     addu      a1, a1, a1                   #  convert to bytes
2222     FETCH_ADVANCE_INST_RB(a1)              #  update rPC, load rINST
2223 #if defined(WITH_JIT)
2224     lw        a0, offThread_pJitProfTable(rSELF)
2225     bgez      a1, 3f
2226     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh table base
2227 3:
2228     bnez      a0, common_updateProfile     #  test for JIT off at target
2229 #else
2230     bgez      a1, 4f
2231     lw        rIBASE, offThread_curHandlerTable(rSELF)  # refresh rtable base
2232 4:
2233 #endif
2234     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2235     GOTO_OPCODE(t0)                        #  jump to next instruction
2236
2237
2238 /* ------------------------------ */
2239     .balign 128
2240 .L_OP_UNUSED_3E: /* 0x3e */
2241 /* File: mips/OP_UNUSED_3E.S */
2242 /* File: mips/unused.S */
2243     BAL(common_abort)
2244
2245
2246
2247 /* ------------------------------ */
2248     .balign 128
2249 .L_OP_UNUSED_3F: /* 0x3f */
2250 /* File: mips/OP_UNUSED_3F.S */
2251 /* File: mips/unused.S */
2252     BAL(common_abort)
2253
2254
2255
2256 /* ------------------------------ */
2257     .balign 128
2258 .L_OP_UNUSED_40: /* 0x40 */
2259 /* File: mips/OP_UNUSED_40.S */
2260 /* File: mips/unused.S */
2261     BAL(common_abort)
2262
2263
2264
2265 /* ------------------------------ */
2266     .balign 128
2267 .L_OP_UNUSED_41: /* 0x41 */
2268 /* File: mips/OP_UNUSED_41.S */
2269 /* File: mips/unused.S */
2270     BAL(common_abort)
2271
2272
2273
2274 /* ------------------------------ */
2275     .balign 128
2276 .L_OP_UNUSED_42: /* 0x42 */
2277 /* File: mips/OP_UNUSED_42.S */
2278 /* File: mips/unused.S */
2279     BAL(common_abort)
2280
2281
2282
2283 /* ------------------------------ */
2284     .balign 128
2285 .L_OP_UNUSED_43: /* 0x43 */
2286 /* File: mips/OP_UNUSED_43.S */
2287 /* File: mips/unused.S */
2288     BAL(common_abort)
2289
2290
2291
2292 /* ------------------------------ */
2293     .balign 128
2294 .L_OP_AGET: /* 0x44 */
2295 /* File: mips/OP_AGET.S */
2296     /*
2297      * Array get, 32 bits or less.  vAA <- vBB[vCC].
2298      *
2299      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
2300      * instructions.  We use a pair of FETCH_Bs instead.
2301      *
2302      * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2303      */
2304     /* op vAA, vBB, vCC */
2305     FETCH_B(a2, 1)                         #  a2 <- BB
2306     GET_OPA(rOBJ)                          #  rOBJ <- AA
2307     FETCH_C(a3, 1)                         #  a3 <- CC
2308     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2309     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2310     # null array object?
2311     beqz      a0, common_errNullObject     #  yes, bail
2312     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2313     .if 2
2314     EASN(a0, a0, a1, 2)               #  a0 <- arrayObj + index*width
2315     .else
2316     addu      a0, a0, a1
2317     .endif
2318     # a1 >= a3; compare unsigned index
2319     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2320     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2321     lw a2, offArrayObject_contents(a0)  #  a2 <- vBB[vCC]
2322     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2323     SET_VREG_GOTO(a2, rOBJ, t0)            #  vAA <- a2
2324
2325
2326 /* ------------------------------ */
2327     .balign 128
2328 .L_OP_AGET_WIDE: /* 0x45 */
2329 /* File: mips/OP_AGET_WIDE.S */
2330     /*
2331      * Array get, 64 bits.  vAA <- vBB[vCC].
2332      *
2333      * Arrays of long/double are 64-bit aligned.
2334      */
2335     /* aget-wide vAA, vBB, vCC */
2336     FETCH(a0, 1)                           #  a0 <- CCBB
2337     GET_OPA(rOBJ)                          #  rOBJ <- AA
2338     and       a2, a0, 255                  #  a2 <- BB
2339     srl       a3, a0, 8                    #  a3 <- CC
2340     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2341     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2342     # null array object?
2343     beqz      a0, common_errNullObject     #  yes, bail
2344     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2345     EAS3(a0, a0, a1)                       #  a0 <- arrayObj + index*width
2346     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2347
2348 .LOP_AGET_WIDE_finish:
2349     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2350     LOAD64_off(a2, a3, a0, offArrayObject_contents)
2351     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
2352     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2353     STORE64(a2, a3, rOBJ)                  #  vAA/vAA+1 <- a2/a3
2354     GOTO_OPCODE(t0)                        #  jump to next instruction
2355
2356
2357 /* ------------------------------ */
2358     .balign 128
2359 .L_OP_AGET_OBJECT: /* 0x46 */
2360 /* File: mips/OP_AGET_OBJECT.S */
2361 /* File: mips/OP_AGET.S */
2362     /*
2363      * Array get, 32 bits or less.  vAA <- vBB[vCC].
2364      *
2365      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
2366      * instructions.  We use a pair of FETCH_Bs instead.
2367      *
2368      * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2369      */
2370     /* op vAA, vBB, vCC */
2371     FETCH_B(a2, 1)                         #  a2 <- BB
2372     GET_OPA(rOBJ)                          #  rOBJ <- AA
2373     FETCH_C(a3, 1)                         #  a3 <- CC
2374     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2375     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2376     # null array object?
2377     beqz      a0, common_errNullObject     #  yes, bail
2378     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2379     .if 2
2380     EASN(a0, a0, a1, 2)               #  a0 <- arrayObj + index*width
2381     .else
2382     addu      a0, a0, a1
2383     .endif
2384     # a1 >= a3; compare unsigned index
2385     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2386     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2387     lw a2, offArrayObject_contents(a0)  #  a2 <- vBB[vCC]
2388     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2389     SET_VREG_GOTO(a2, rOBJ, t0)            #  vAA <- a2
2390
2391
2392
2393 /* ------------------------------ */
2394     .balign 128
2395 .L_OP_AGET_BOOLEAN: /* 0x47 */
2396 /* File: mips/OP_AGET_BOOLEAN.S */
2397 /* File: mips/OP_AGET.S */
2398     /*
2399      * Array get, 32 bits or less.  vAA <- vBB[vCC].
2400      *
2401      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
2402      * instructions.  We use a pair of FETCH_Bs instead.
2403      *
2404      * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2405      */
2406     /* op vAA, vBB, vCC */
2407     FETCH_B(a2, 1)                         #  a2 <- BB
2408     GET_OPA(rOBJ)                          #  rOBJ <- AA
2409     FETCH_C(a3, 1)                         #  a3 <- CC
2410     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2411     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2412     # null array object?
2413     beqz      a0, common_errNullObject     #  yes, bail
2414     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2415     .if 0
2416     EASN(a0, a0, a1, 0)               #  a0 <- arrayObj + index*width
2417     .else
2418     addu      a0, a0, a1
2419     .endif
2420     # a1 >= a3; compare unsigned index
2421     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2422     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2423     lbu a2, offArrayObject_contents(a0)  #  a2 <- vBB[vCC]
2424     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2425     SET_VREG_GOTO(a2, rOBJ, t0)            #  vAA <- a2
2426
2427
2428
2429 /* ------------------------------ */
2430     .balign 128
2431 .L_OP_AGET_BYTE: /* 0x48 */
2432 /* File: mips/OP_AGET_BYTE.S */
2433 /* File: mips/OP_AGET.S */
2434     /*
2435      * Array get, 32 bits or less.  vAA <- vBB[vCC].
2436      *
2437      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
2438      * instructions.  We use a pair of FETCH_Bs instead.
2439      *
2440      * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2441      */
2442     /* op vAA, vBB, vCC */
2443     FETCH_B(a2, 1)                         #  a2 <- BB
2444     GET_OPA(rOBJ)                          #  rOBJ <- AA
2445     FETCH_C(a3, 1)                         #  a3 <- CC
2446     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2447     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2448     # null array object?
2449     beqz      a0, common_errNullObject     #  yes, bail
2450     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2451     .if 0
2452     EASN(a0, a0, a1, 0)               #  a0 <- arrayObj + index*width
2453     .else
2454     addu      a0, a0, a1
2455     .endif
2456     # a1 >= a3; compare unsigned index
2457     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2458     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2459     lb a2, offArrayObject_contents(a0)  #  a2 <- vBB[vCC]
2460     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2461     SET_VREG_GOTO(a2, rOBJ, t0)            #  vAA <- a2
2462
2463
2464
2465 /* ------------------------------ */
2466     .balign 128
2467 .L_OP_AGET_CHAR: /* 0x49 */
2468 /* File: mips/OP_AGET_CHAR.S */
2469 /* File: mips/OP_AGET.S */
2470     /*
2471      * Array get, 32 bits or less.  vAA <- vBB[vCC].
2472      *
2473      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
2474      * instructions.  We use a pair of FETCH_Bs instead.
2475      *
2476      * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2477      */
2478     /* op vAA, vBB, vCC */
2479     FETCH_B(a2, 1)                         #  a2 <- BB
2480     GET_OPA(rOBJ)                          #  rOBJ <- AA
2481     FETCH_C(a3, 1)                         #  a3 <- CC
2482     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2483     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2484     # null array object?
2485     beqz      a0, common_errNullObject     #  yes, bail
2486     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2487     .if 1
2488     EASN(a0, a0, a1, 1)               #  a0 <- arrayObj + index*width
2489     .else
2490     addu      a0, a0, a1
2491     .endif
2492     # a1 >= a3; compare unsigned index
2493     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2494     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2495     lhu a2, offArrayObject_contents(a0)  #  a2 <- vBB[vCC]
2496     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2497     SET_VREG_GOTO(a2, rOBJ, t0)            #  vAA <- a2
2498
2499
2500
2501 /* ------------------------------ */
2502     .balign 128
2503 .L_OP_AGET_SHORT: /* 0x4a */
2504 /* File: mips/OP_AGET_SHORT.S */
2505 /* File: mips/OP_AGET.S */
2506     /*
2507      * Array get, 32 bits or less.  vAA <- vBB[vCC].
2508      *
2509      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
2510      * instructions.  We use a pair of FETCH_Bs instead.
2511      *
2512      * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2513      */
2514     /* op vAA, vBB, vCC */
2515     FETCH_B(a2, 1)                         #  a2 <- BB
2516     GET_OPA(rOBJ)                          #  rOBJ <- AA
2517     FETCH_C(a3, 1)                         #  a3 <- CC
2518     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2519     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2520     # null array object?
2521     beqz      a0, common_errNullObject     #  yes, bail
2522     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2523     .if 1
2524     EASN(a0, a0, a1, 1)               #  a0 <- arrayObj + index*width
2525     .else
2526     addu      a0, a0, a1
2527     .endif
2528     # a1 >= a3; compare unsigned index
2529     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2530     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2531     lh a2, offArrayObject_contents(a0)  #  a2 <- vBB[vCC]
2532     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2533     SET_VREG_GOTO(a2, rOBJ, t0)            #  vAA <- a2
2534
2535
2536
2537 /* ------------------------------ */
2538     .balign 128
2539 .L_OP_APUT: /* 0x4b */
2540 /* File: mips/OP_APUT.S */
2541     /*
2542      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
2543      * for: aput, aput-boolean, aput-byte, aput-char, aput-short
2544      */
2545     /* op vAA, vBB, vCC */
2546     FETCH_B(a2, 1)                         #  a2 <- BB
2547     GET_OPA(rOBJ)                          #  rOBJ <- AA
2548     FETCH_C(a3, 1)                         #  a3 <- CC
2549     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2550     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2551     # null array object?
2552     beqz      a0, common_errNullObject     #  yes, bail
2553     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2554     .if 2
2555     EASN(a0, a0, a1, 2)               #  a0 <- arrayObj + index*width
2556     .else
2557     addu      a0, a0, a1
2558     .endif
2559     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2560     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2561     GET_VREG(a2, rOBJ)                     #  a2 <- vAA
2562     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2563     sw a2, offArrayObject_contents(a0) #  vBB[vCC] <- a2
2564     GOTO_OPCODE(t0)                        #  jump to next instruction
2565
2566
2567 /* ------------------------------ */
2568     .balign 128
2569 .L_OP_APUT_WIDE: /* 0x4c */
2570 /* File: mips/OP_APUT_WIDE.S */
2571     /*
2572      * Array put, 64 bits.  vBB[vCC] <- vAA.
2573      *
2574      * Arrays of long/double are 64-bit aligned, so it's okay to use STRD.
2575      */
2576     /* aput-wide vAA, vBB, vCC */
2577     FETCH(a0, 1)                           #  a0 <- CCBB
2578     GET_OPA(t0)                            #  t0 <- AA
2579     and       a2, a0, 255                  #  a2 <- BB
2580     srl       a3, a0, 8                    #  a3 <- CC
2581     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2582     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2583     # null array object?
2584     beqz      a0, common_errNullObject     #  yes, bail
2585     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2586     EAS3(a0, a0, a1)                       #  a0 <- arrayObj + index*width
2587     EAS2(rOBJ, rFP, t0)                    #  rOBJ <- &fp[AA]
2588     # compare unsigned index, length
2589     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2590
2591     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2592     LOAD64(a2, a3, rOBJ)                   #  a2/a3 <- vAA/vAA+1
2593     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2594     STORE64_off(a2, a3, a0, offArrayObject_contents) #  a2/a3 <- vBB[vCC]
2595     GOTO_OPCODE(t0)                        #  jump to next instruction
2596
2597
2598 /* ------------------------------ */
2599     .balign 128
2600 .L_OP_APUT_OBJECT: /* 0x4d */
2601 /* File: mips/OP_APUT_OBJECT.S */
2602     /*
2603      * Store an object into an array.  vBB[vCC] <- vAA.
2604      *
2605      */
2606     /* op vAA, vBB, vCC */
2607     FETCH(a0, 1)                           #  a0 <- CCBB
2608     GET_OPA(t1)                            #  t1 <- AA
2609     and       a2, a0, 255                  #  a2 <- BB
2610     srl       a3, a0, 8                    #  a3 <- CC
2611     GET_VREG(rINST, a2)                    #  rINST <- vBB (array object)
2612     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2613     GET_VREG(rBIX, t1)                     #  rBIX <- vAA
2614     # null array object?
2615     beqz      rINST, common_errNullObject  #  yes, bail
2616
2617     LOAD_base_offArrayObject_length(a3, rINST) #  a3 <- arrayObj->length
2618     EAS2(rOBJ, rINST, a1)                  #  rOBJ <- arrayObj + index*width
2619     # compare unsigned index, length
2620     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2621     /*
2622      * On entry:
2623      *  rINST = vBB (arrayObj)
2624      *  rBIX = vAA (obj)
2625      *  rOBJ = offset into array (vBB + vCC * width)
2626      */
2627     bnez      rBIX, .LOP_APUT_OBJECT_checks     #  yes, skip type checks
2628 .LOP_APUT_OBJECT_finish:
2629     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2630     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2631     sw        rBIX, offArrayObject_contents(rOBJ) #  vBB[vCC] <- vAA
2632     GOTO_OPCODE(t0)                        #  jump to next instruction
2633
2634
2635 /* ------------------------------ */
2636     .balign 128
2637 .L_OP_APUT_BOOLEAN: /* 0x4e */
2638 /* File: mips/OP_APUT_BOOLEAN.S */
2639 /* File: mips/OP_APUT.S */
2640     /*
2641      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
2642      * for: aput, aput-boolean, aput-byte, aput-char, aput-short
2643      */
2644     /* op vAA, vBB, vCC */
2645     FETCH_B(a2, 1)                         #  a2 <- BB
2646     GET_OPA(rOBJ)                          #  rOBJ <- AA
2647     FETCH_C(a3, 1)                         #  a3 <- CC
2648     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2649     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2650     # null array object?
2651     beqz      a0, common_errNullObject     #  yes, bail
2652     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2653     .if 0
2654     EASN(a0, a0, a1, 0)               #  a0 <- arrayObj + index*width
2655     .else
2656     addu      a0, a0, a1
2657     .endif
2658     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2659     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2660     GET_VREG(a2, rOBJ)                     #  a2 <- vAA
2661     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2662     sb a2, offArrayObject_contents(a0) #  vBB[vCC] <- a2
2663     GOTO_OPCODE(t0)                        #  jump to next instruction
2664
2665
2666
2667 /* ------------------------------ */
2668     .balign 128
2669 .L_OP_APUT_BYTE: /* 0x4f */
2670 /* File: mips/OP_APUT_BYTE.S */
2671 /* File: mips/OP_APUT.S */
2672     /*
2673      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
2674      * for: aput, aput-boolean, aput-byte, aput-char, aput-short
2675      */
2676     /* op vAA, vBB, vCC */
2677     FETCH_B(a2, 1)                         #  a2 <- BB
2678     GET_OPA(rOBJ)                          #  rOBJ <- AA
2679     FETCH_C(a3, 1)                         #  a3 <- CC
2680     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2681     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2682     # null array object?
2683     beqz      a0, common_errNullObject     #  yes, bail
2684     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2685     .if 0
2686     EASN(a0, a0, a1, 0)               #  a0 <- arrayObj + index*width
2687     .else
2688     addu      a0, a0, a1
2689     .endif
2690     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2691     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2692     GET_VREG(a2, rOBJ)                     #  a2 <- vAA
2693     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2694     sb a2, offArrayObject_contents(a0) #  vBB[vCC] <- a2
2695     GOTO_OPCODE(t0)                        #  jump to next instruction
2696
2697
2698
2699 /* ------------------------------ */
2700     .balign 128
2701 .L_OP_APUT_CHAR: /* 0x50 */
2702 /* File: mips/OP_APUT_CHAR.S */
2703 /* File: mips/OP_APUT.S */
2704     /*
2705      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
2706      * for: aput, aput-boolean, aput-byte, aput-char, aput-short
2707      */
2708     /* op vAA, vBB, vCC */
2709     FETCH_B(a2, 1)                         #  a2 <- BB
2710     GET_OPA(rOBJ)                          #  rOBJ <- AA
2711     FETCH_C(a3, 1)                         #  a3 <- CC
2712     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2713     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2714     # null array object?
2715     beqz      a0, common_errNullObject     #  yes, bail
2716     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2717     .if 1
2718     EASN(a0, a0, a1, 1)               #  a0 <- arrayObj + index*width
2719     .else
2720     addu      a0, a0, a1
2721     .endif
2722     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2723     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2724     GET_VREG(a2, rOBJ)                     #  a2 <- vAA
2725     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2726     sh a2, offArrayObject_contents(a0) #  vBB[vCC] <- a2
2727     GOTO_OPCODE(t0)                        #  jump to next instruction
2728
2729
2730
2731 /* ------------------------------ */
2732     .balign 128
2733 .L_OP_APUT_SHORT: /* 0x51 */
2734 /* File: mips/OP_APUT_SHORT.S */
2735 /* File: mips/OP_APUT.S */
2736     /*
2737      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
2738      * for: aput, aput-boolean, aput-byte, aput-char, aput-short
2739      */
2740     /* op vAA, vBB, vCC */
2741     FETCH_B(a2, 1)                         #  a2 <- BB
2742     GET_OPA(rOBJ)                          #  rOBJ <- AA
2743     FETCH_C(a3, 1)                         #  a3 <- CC
2744     GET_VREG(a0, a2)                       #  a0 <- vBB (array object)
2745     GET_VREG(a1, a3)                       #  a1 <- vCC (requested index)
2746     # null array object?
2747     beqz      a0, common_errNullObject     #  yes, bail
2748     LOAD_base_offArrayObject_length(a3, a0) #  a3 <- arrayObj->length
2749     .if 1
2750     EASN(a0, a0, a1, 1)               #  a0 <- arrayObj + index*width
2751     .else
2752     addu      a0, a0, a1
2753     .endif
2754     bgeu      a1, a3, common_errArrayIndex #  index >= length, bail
2755     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
2756     GET_VREG(a2, rOBJ)                     #  a2 <- vAA
2757     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
2758     sh a2, offArrayObject_contents(a0) #  vBB[vCC] <- a2
2759     GOTO_OPCODE(t0)                        #  jump to next instruction
2760
2761
2762
2763 /* ------------------------------ */
2764     .balign 128
2765 .L_OP_IGET: /* 0x52 */
2766 /* File: mips/OP_IGET.S */
2767     /*
2768      * General 32-bit instance field get.
2769      *
2770      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2771      */
2772     # op vA, vB, field                     /* CCCC */
2773     GET_OPB(a0)                            #  a0 <- B
2774     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2775     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2776     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2777     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2778     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2779     # is resolved entry null?
2780     bnez      a0, .LOP_IGET_finish       #  no, already resolved
2781     LOAD_rSELF_method(a2)                  #  a2 <- current method
2782     EXPORT_PC()                            #  resolve() could throw
2783     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2784     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2785     # test results
2786     move      a0, v0
2787     bnez      v0, .LOP_IGET_finish
2788     b         common_exceptionThrown
2789
2790 /* ------------------------------ */
2791     .balign 128
2792 .L_OP_IGET_WIDE: /* 0x53 */
2793 /* File: mips/OP_IGET_WIDE.S */
2794     /*
2795      * Wide 32-bit instance field get.
2796      */
2797     # iget-wide vA, vB, field              /* CCCC */
2798     GET_OPB(a0)                            #  a0 <- B
2799     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2800     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2801     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
2802     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2803     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2804     # is resolved entry null?
2805     bnez      a0, .LOP_IGET_WIDE_finish       #  no, already resolved
2806     LOAD_rSELF_method(a2)                  #  a2 <- current method
2807     EXPORT_PC()                            #  resolve() could throw
2808     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2809     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2810     # test return code
2811     move      a0, v0
2812     bnez      v0, .LOP_IGET_WIDE_finish
2813     b         common_exceptionThrown
2814
2815 /* ------------------------------ */
2816     .balign 128
2817 .L_OP_IGET_OBJECT: /* 0x54 */
2818 /* File: mips/OP_IGET_OBJECT.S */
2819 /* File: mips/OP_IGET.S */
2820     /*
2821      * General 32-bit instance field get.
2822      *
2823      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2824      */
2825     # op vA, vB, field                     /* CCCC */
2826     GET_OPB(a0)                            #  a0 <- B
2827     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2828     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2829     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2830     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2831     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2832     # is resolved entry null?
2833     bnez      a0, .LOP_IGET_OBJECT_finish       #  no, already resolved
2834     LOAD_rSELF_method(a2)                  #  a2 <- current method
2835     EXPORT_PC()                            #  resolve() could throw
2836     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2837     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2838     # test results
2839     move      a0, v0
2840     bnez      v0, .LOP_IGET_OBJECT_finish
2841     b         common_exceptionThrown
2842
2843
2844 /* ------------------------------ */
2845     .balign 128
2846 .L_OP_IGET_BOOLEAN: /* 0x55 */
2847 /* File: mips/OP_IGET_BOOLEAN.S */
2848 /* File: mips/OP_IGET.S */
2849     /*
2850      * General 32-bit instance field get.
2851      *
2852      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2853      */
2854     # op vA, vB, field                     /* CCCC */
2855     GET_OPB(a0)                            #  a0 <- B
2856     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2857     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2858     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2859     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2860     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2861     # is resolved entry null?
2862     bnez      a0, .LOP_IGET_BOOLEAN_finish       #  no, already resolved
2863     LOAD_rSELF_method(a2)                  #  a2 <- current method
2864     EXPORT_PC()                            #  resolve() could throw
2865     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2866     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2867     # test results
2868     move      a0, v0
2869     bnez      v0, .LOP_IGET_BOOLEAN_finish
2870     b         common_exceptionThrown
2871
2872
2873 /* ------------------------------ */
2874     .balign 128
2875 .L_OP_IGET_BYTE: /* 0x56 */
2876 /* File: mips/OP_IGET_BYTE.S */
2877 /* File: mips/OP_IGET.S */
2878     /*
2879      * General 32-bit instance field get.
2880      *
2881      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2882      */
2883     # op vA, vB, field                     /* CCCC */
2884     GET_OPB(a0)                            #  a0 <- B
2885     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2886     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2887     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2888     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2889     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2890     # is resolved entry null?
2891     bnez      a0, .LOP_IGET_BYTE_finish       #  no, already resolved
2892     LOAD_rSELF_method(a2)                  #  a2 <- current method
2893     EXPORT_PC()                            #  resolve() could throw
2894     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2895     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2896     # test results
2897     move      a0, v0
2898     bnez      v0, .LOP_IGET_BYTE_finish
2899     b         common_exceptionThrown
2900
2901
2902 /* ------------------------------ */
2903     .balign 128
2904 .L_OP_IGET_CHAR: /* 0x57 */
2905 /* File: mips/OP_IGET_CHAR.S */
2906 /* File: mips/OP_IGET.S */
2907     /*
2908      * General 32-bit instance field get.
2909      *
2910      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2911      */
2912     # op vA, vB, field                     /* CCCC */
2913     GET_OPB(a0)                            #  a0 <- B
2914     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2915     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2916     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2917     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2918     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2919     # is resolved entry null?
2920     bnez      a0, .LOP_IGET_CHAR_finish       #  no, already resolved
2921     LOAD_rSELF_method(a2)                  #  a2 <- current method
2922     EXPORT_PC()                            #  resolve() could throw
2923     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2924     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2925     # test results
2926     move      a0, v0
2927     bnez      v0, .LOP_IGET_CHAR_finish
2928     b         common_exceptionThrown
2929
2930
2931 /* ------------------------------ */
2932     .balign 128
2933 .L_OP_IGET_SHORT: /* 0x58 */
2934 /* File: mips/OP_IGET_SHORT.S */
2935 /* File: mips/OP_IGET.S */
2936     /*
2937      * General 32-bit instance field get.
2938      *
2939      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2940      */
2941     # op vA, vB, field                     /* CCCC */
2942     GET_OPB(a0)                            #  a0 <- B
2943     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2944     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2945     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2946     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2947     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2948     # is resolved entry null?
2949     bnez      a0, .LOP_IGET_SHORT_finish       #  no, already resolved
2950     LOAD_rSELF_method(a2)                  #  a2 <- current method
2951     EXPORT_PC()                            #  resolve() could throw
2952     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2953     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2954     # test results
2955     move      a0, v0
2956     bnez      v0, .LOP_IGET_SHORT_finish
2957     b         common_exceptionThrown
2958
2959
2960 /* ------------------------------ */
2961     .balign 128
2962 .L_OP_IPUT: /* 0x59 */
2963 /* File: mips/OP_IPUT.S */
2964     /*
2965      * General 32-bit instance field put.
2966      *
2967      * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
2968      */
2969     # op vA, vB, field                     /* CCCC */
2970     GET_OPB(a0)                            #  a0 <- B
2971     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2972     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2973     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
2974     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2975     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2976     # is resolved entry null?
2977     bnez      a0, .LOP_IPUT_finish       #  no, already resolved
2978     LOAD_rSELF_method(a2)                  #  a2 <- current method
2979     EXPORT_PC()                            #  resolve() could throw
2980     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
2981     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
2982     # success?
2983     move      a0, v0
2984     bnez      v0, .LOP_IPUT_finish       #  yes, finish up
2985     b         common_exceptionThrown
2986
2987 /* ------------------------------ */
2988     .balign 128
2989 .L_OP_IPUT_WIDE: /* 0x5a */
2990 /* File: mips/OP_IPUT_WIDE.S */
2991     # iput-wide vA, vB, field              /* CCCC */
2992     GET_OPB(a0)                            #  a0 <- B
2993     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
2994     FETCH(a1, 1)                           #  a1 <- field ref CCCC
2995     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
2996     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
2997     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
2998     # is resolved entry null?
2999     bnez      a0, .LOP_IPUT_WIDE_finish       #  no, already resolved
3000     LOAD_rSELF_method(a2)                  #  a2 <- current method
3001     EXPORT_PC()                            #  resolve() could throw
3002     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3003     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
3004     # success?
3005     move      a0, v0
3006     bnez      v0, .LOP_IPUT_WIDE_finish       #  yes, finish up
3007     b         common_exceptionThrown
3008
3009 /* ------------------------------ */
3010     .balign 128
3011 .L_OP_IPUT_OBJECT: /* 0x5b */
3012 /* File: mips/OP_IPUT_OBJECT.S */
3013     /*
3014      * 32-bit instance field put.
3015      *
3016      * for: iput-object, iput-object-volatile
3017      */
3018     # op vA, vB, field                     /* CCCC */
3019     GET_OPB(a0)                            #  a0 <- B
3020     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
3021     FETCH(a1, 1)                           #  a1 <- field ref CCCC
3022     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
3023     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
3024     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
3025     # is resolved entry null?
3026     bnez      a0, .LOP_IPUT_OBJECT_finish       #  no, already resolved
3027     LOAD_rSELF_method(a2)                  #  a2 <- current method
3028     EXPORT_PC()                            #  resolve() could throw
3029     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3030     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
3031     # success?
3032     move      a0, v0
3033     bnez      v0, .LOP_IPUT_OBJECT_finish       #  yes, finish up
3034     b         common_exceptionThrown
3035
3036 /* ------------------------------ */
3037     .balign 128
3038 .L_OP_IPUT_BOOLEAN: /* 0x5c */
3039 /* File: mips/OP_IPUT_BOOLEAN.S */
3040 /* File: mips/OP_IPUT.S */
3041     /*
3042      * General 32-bit instance field put.
3043      *
3044      * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3045      */
3046     # op vA, vB, field                     /* CCCC */
3047     GET_OPB(a0)                            #  a0 <- B
3048     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
3049     FETCH(a1, 1)                           #  a1 <- field ref CCCC
3050     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
3051     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
3052     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
3053     # is resolved entry null?
3054     bnez      a0, .LOP_IPUT_BOOLEAN_finish       #  no, already resolved
3055     LOAD_rSELF_method(a2)                  #  a2 <- current method
3056     EXPORT_PC()                            #  resolve() could throw
3057     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3058     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
3059     # success?
3060     move      a0, v0
3061     bnez      v0, .LOP_IPUT_BOOLEAN_finish       #  yes, finish up
3062     b         common_exceptionThrown
3063
3064
3065 /* ------------------------------ */
3066     .balign 128
3067 .L_OP_IPUT_BYTE: /* 0x5d */
3068 /* File: mips/OP_IPUT_BYTE.S */
3069 /* File: mips/OP_IPUT.S */
3070     /*
3071      * General 32-bit instance field put.
3072      *
3073      * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3074      */
3075     # op vA, vB, field                     /* CCCC */
3076     GET_OPB(a0)                            #  a0 <- B
3077     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
3078     FETCH(a1, 1)                           #  a1 <- field ref CCCC
3079     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
3080     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
3081     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
3082     # is resolved entry null?
3083     bnez      a0, .LOP_IPUT_BYTE_finish       #  no, already resolved
3084     LOAD_rSELF_method(a2)                  #  a2 <- current method
3085     EXPORT_PC()                            #  resolve() could throw
3086     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3087     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
3088     # success?
3089     move      a0, v0
3090     bnez      v0, .LOP_IPUT_BYTE_finish       #  yes, finish up
3091     b         common_exceptionThrown
3092
3093
3094 /* ------------------------------ */
3095     .balign 128
3096 .L_OP_IPUT_CHAR: /* 0x5e */
3097 /* File: mips/OP_IPUT_CHAR.S */
3098 /* File: mips/OP_IPUT.S */
3099     /*
3100      * General 32-bit instance field put.
3101      *
3102      * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3103      */
3104     # op vA, vB, field                     /* CCCC */
3105     GET_OPB(a0)                            #  a0 <- B
3106     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
3107     FETCH(a1, 1)                           #  a1 <- field ref CCCC
3108     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
3109     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
3110     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
3111     # is resolved entry null?
3112     bnez      a0, .LOP_IPUT_CHAR_finish       #  no, already resolved
3113     LOAD_rSELF_method(a2)                  #  a2 <- current method
3114     EXPORT_PC()                            #  resolve() could throw
3115     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3116     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
3117     # success?
3118     move      a0, v0
3119     bnez      v0, .LOP_IPUT_CHAR_finish       #  yes, finish up
3120     b         common_exceptionThrown
3121
3122
3123 /* ------------------------------ */
3124     .balign 128
3125 .L_OP_IPUT_SHORT: /* 0x5f */
3126 /* File: mips/OP_IPUT_SHORT.S */
3127 /* File: mips/OP_IPUT.S */
3128     /*
3129      * General 32-bit instance field put.
3130      *
3131      * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3132      */
3133     # op vA, vB, field                     /* CCCC */
3134     GET_OPB(a0)                            #  a0 <- B
3135     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
3136     FETCH(a1, 1)                           #  a1 <- field ref CCCC
3137     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
3138     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
3139     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
3140     # is resolved entry null?
3141     bnez      a0, .LOP_IPUT_SHORT_finish       #  no, already resolved
3142     LOAD_rSELF_method(a2)                  #  a2 <- current method
3143     EXPORT_PC()                            #  resolve() could throw
3144     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3145     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
3146     # success?
3147     move      a0, v0
3148     bnez      v0, .LOP_IPUT_SHORT_finish       #  yes, finish up
3149     b         common_exceptionThrown
3150
3151
3152 /* ------------------------------ */
3153     .balign 128
3154 .L_OP_SGET: /* 0x60 */
3155 /* File: mips/OP_SGET.S */
3156     /*
3157      * General 32-bit SGET handler.
3158      *
3159      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3160      */
3161     # op vAA, field                        /* BBBB */
3162     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3163     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3164     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3165     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3166     # is resolved entry !null?
3167     bnez      a0, .LOP_SGET_finish
3168
3169     /*
3170      * Continuation if the field has not yet been resolved.
3171      *  a1:  BBBB field ref
3172      *  rBIX: dvmDex->pResFields
3173      */
3174     LOAD_rSELF_method(a2)                  #  a2 <- current method
3175 #if defined(WITH_JIT)
3176     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3177 #endif
3178     EXPORT_PC()                            #  resolve() could throw, so export now
3179     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3180     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3181     move      a0, v0
3182     # success?
3183     beqz      v0, common_exceptionThrown   #  no, handle exception
3184 #if defined(WITH_JIT)
3185     /*
3186      * If the JIT is actively building a trace we need to make sure
3187      * that the field is fully resolved before including this instruction.
3188      */
3189     JAL(common_verifyField)
3190 #endif
3191     b        .LOP_SGET_finish            # resume
3192
3193 /* ------------------------------ */
3194     .balign 128
3195 .L_OP_SGET_WIDE: /* 0x61 */
3196 /* File: mips/OP_SGET_WIDE.S */
3197     /*
3198      * 64-bit SGET handler.
3199      */
3200     # sget-wide vAA, field                 /* BBBB */
3201     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3202     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3203     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3204     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3205     # is resolved entry null?
3206     bnez      a0, .LOP_SGET_WIDE_finish
3207
3208     /*
3209      * Continuation if the field has not yet been resolved.
3210      *  a1:  BBBB field ref
3211      *  rBIX: dvmDex->pResFields
3212      *
3213      * Returns StaticField pointer in v0.
3214      */
3215     LOAD_rSELF_method(a2)                  #  a2 <- current method
3216 #if defined(WITH_JIT)
3217     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3218 #endif
3219     EXPORT_PC()                            #  resolve() could throw, so export now
3220     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3221     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3222     move      a0, v0
3223     # success?
3224     beqz      v0, common_exceptionThrown   #  no, handle exception
3225 #if defined(WITH_JIT)
3226     /*
3227      * If the JIT is actively building a trace we need to make sure
3228      * that the field is fully resolved before including this instruction.
3229      */
3230     JAL(common_verifyField)
3231 #endif
3232
3233     b        .LOP_SGET_WIDE_finish            # resume
3234
3235 /* ------------------------------ */
3236     .balign 128
3237 .L_OP_SGET_OBJECT: /* 0x62 */
3238 /* File: mips/OP_SGET_OBJECT.S */
3239 /* File: mips/OP_SGET.S */
3240     /*
3241      * General 32-bit SGET handler.
3242      *
3243      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3244      */
3245     # op vAA, field                        /* BBBB */
3246     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3247     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3248     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3249     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3250     # is resolved entry !null?
3251     bnez      a0, .LOP_SGET_OBJECT_finish
3252
3253     /*
3254      * Continuation if the field has not yet been resolved.
3255      *  a1:  BBBB field ref
3256      *  rBIX: dvmDex->pResFields
3257      */
3258     LOAD_rSELF_method(a2)                  #  a2 <- current method
3259 #if defined(WITH_JIT)
3260     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3261 #endif
3262     EXPORT_PC()                            #  resolve() could throw, so export now
3263     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3264     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3265     move      a0, v0
3266     # success?
3267     beqz      v0, common_exceptionThrown   #  no, handle exception
3268 #if defined(WITH_JIT)
3269     /*
3270      * If the JIT is actively building a trace we need to make sure
3271      * that the field is fully resolved before including this instruction.
3272      */
3273     JAL(common_verifyField)
3274 #endif
3275     b        .LOP_SGET_OBJECT_finish            # resume
3276
3277
3278 /* ------------------------------ */
3279     .balign 128
3280 .L_OP_SGET_BOOLEAN: /* 0x63 */
3281 /* File: mips/OP_SGET_BOOLEAN.S */
3282 /* File: mips/OP_SGET.S */
3283     /*
3284      * General 32-bit SGET handler.
3285      *
3286      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3287      */
3288     # op vAA, field                        /* BBBB */
3289     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3290     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3291     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3292     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3293     # is resolved entry !null?
3294     bnez      a0, .LOP_SGET_BOOLEAN_finish
3295
3296     /*
3297      * Continuation if the field has not yet been resolved.
3298      *  a1:  BBBB field ref
3299      *  rBIX: dvmDex->pResFields
3300      */
3301     LOAD_rSELF_method(a2)                  #  a2 <- current method
3302 #if defined(WITH_JIT)
3303     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3304 #endif
3305     EXPORT_PC()                            #  resolve() could throw, so export now
3306     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3307     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3308     move      a0, v0
3309     # success?
3310     beqz      v0, common_exceptionThrown   #  no, handle exception
3311 #if defined(WITH_JIT)
3312     /*
3313      * If the JIT is actively building a trace we need to make sure
3314      * that the field is fully resolved before including this instruction.
3315      */
3316     JAL(common_verifyField)
3317 #endif
3318     b        .LOP_SGET_BOOLEAN_finish            # resume
3319
3320
3321 /* ------------------------------ */
3322     .balign 128
3323 .L_OP_SGET_BYTE: /* 0x64 */
3324 /* File: mips/OP_SGET_BYTE.S */
3325 /* File: mips/OP_SGET.S */
3326     /*
3327      * General 32-bit SGET handler.
3328      *
3329      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3330      */
3331     # op vAA, field                        /* BBBB */
3332     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3333     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3334     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3335     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3336     # is resolved entry !null?
3337     bnez      a0, .LOP_SGET_BYTE_finish
3338
3339     /*
3340      * Continuation if the field has not yet been resolved.
3341      *  a1:  BBBB field ref
3342      *  rBIX: dvmDex->pResFields
3343      */
3344     LOAD_rSELF_method(a2)                  #  a2 <- current method
3345 #if defined(WITH_JIT)
3346     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3347 #endif
3348     EXPORT_PC()                            #  resolve() could throw, so export now
3349     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3350     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3351     move      a0, v0
3352     # success?
3353     beqz      v0, common_exceptionThrown   #  no, handle exception
3354 #if defined(WITH_JIT)
3355     /*
3356      * If the JIT is actively building a trace we need to make sure
3357      * that the field is fully resolved before including this instruction.
3358      */
3359     JAL(common_verifyField)
3360 #endif
3361     b        .LOP_SGET_BYTE_finish            # resume
3362
3363
3364 /* ------------------------------ */
3365     .balign 128
3366 .L_OP_SGET_CHAR: /* 0x65 */
3367 /* File: mips/OP_SGET_CHAR.S */
3368 /* File: mips/OP_SGET.S */
3369     /*
3370      * General 32-bit SGET handler.
3371      *
3372      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3373      */
3374     # op vAA, field                        /* BBBB */
3375     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3376     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3377     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3378     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3379     # is resolved entry !null?
3380     bnez      a0, .LOP_SGET_CHAR_finish
3381
3382     /*
3383      * Continuation if the field has not yet been resolved.
3384      *  a1:  BBBB field ref
3385      *  rBIX: dvmDex->pResFields
3386      */
3387     LOAD_rSELF_method(a2)                  #  a2 <- current method
3388 #if defined(WITH_JIT)
3389     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3390 #endif
3391     EXPORT_PC()                            #  resolve() could throw, so export now
3392     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3393     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3394     move      a0, v0
3395     # success?
3396     beqz      v0, common_exceptionThrown   #  no, handle exception
3397 #if defined(WITH_JIT)
3398     /*
3399      * If the JIT is actively building a trace we need to make sure
3400      * that the field is fully resolved before including this instruction.
3401      */
3402     JAL(common_verifyField)
3403 #endif
3404     b        .LOP_SGET_CHAR_finish            # resume
3405
3406
3407 /* ------------------------------ */
3408     .balign 128
3409 .L_OP_SGET_SHORT: /* 0x66 */
3410 /* File: mips/OP_SGET_SHORT.S */
3411 /* File: mips/OP_SGET.S */
3412     /*
3413      * General 32-bit SGET handler.
3414      *
3415      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3416      */
3417     # op vAA, field                        /* BBBB */
3418     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3419     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3420     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3421     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3422     # is resolved entry !null?
3423     bnez      a0, .LOP_SGET_SHORT_finish
3424
3425     /*
3426      * Continuation if the field has not yet been resolved.
3427      *  a1:  BBBB field ref
3428      *  rBIX: dvmDex->pResFields
3429      */
3430     LOAD_rSELF_method(a2)                  #  a2 <- current method
3431 #if defined(WITH_JIT)
3432     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3433 #endif
3434     EXPORT_PC()                            #  resolve() could throw, so export now
3435     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3436     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3437     move      a0, v0
3438     # success?
3439     beqz      v0, common_exceptionThrown   #  no, handle exception
3440 #if defined(WITH_JIT)
3441     /*
3442      * If the JIT is actively building a trace we need to make sure
3443      * that the field is fully resolved before including this instruction.
3444      */
3445     JAL(common_verifyField)
3446 #endif
3447     b        .LOP_SGET_SHORT_finish            # resume
3448
3449
3450 /* ------------------------------ */
3451     .balign 128
3452 .L_OP_SPUT: /* 0x67 */
3453 /* File: mips/OP_SPUT.S */
3454     /*
3455      * General 32-bit SPUT handler.
3456      *
3457      * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
3458      */
3459     # op vAA, field                        /* BBBB */
3460     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3461     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3462     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3463     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3464     bnez      a0, .LOP_SPUT_finish       #  is resolved entry null?
3465     /*
3466      * Continuation if the field has not yet been resolved.
3467      *  a1:  BBBB field ref
3468      *  rBIX: dvmDex->pResFields
3469      */
3470     LOAD_rSELF_method(a2)                  #  a2 <- current method
3471 #if defined(WITH_JIT)
3472     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3473 #endif
3474     EXPORT_PC()                            #  resolve() may throw, so export now
3475     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3476     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3477     move      a0, v0
3478     beqz      v0, common_exceptionThrown   #  success? no, handle exception
3479 #if defined(WITH_JIT)
3480     /*
3481      * If the JIT is actively building a trace we need to make sure
3482      * that the field is fully resolved before including this instruction.
3483      */
3484     JAL(common_verifyField)
3485 #endif
3486     b        .LOP_SPUT_finish            # resume
3487
3488 /* ------------------------------ */
3489     .balign 128
3490 .L_OP_SPUT_WIDE: /* 0x68 */
3491 /* File: mips/OP_SPUT_WIDE.S */
3492     /*
3493      * 64-bit SPUT handler.
3494      */
3495     # sput-wide vAA, field                 /* BBBB */
3496     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3497     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3498     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3499     GET_OPA(t0)                            #  t0 <- AA
3500     LOAD_eas2(a2, rBIX, a1)                #  a2 <- resolved StaticField ptr
3501     EAS2(rOBJ, rFP, t0)                    #  rOBJ<- &fp[AA]
3502     # is resolved entry null?
3503     beqz      a2, .LOP_SPUT_WIDE_resolve      #  yes, do resolve
3504 .LOP_SPUT_WIDE_finish:                        #  field ptr in a2, AA in rOBJ
3505     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
3506     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vAA/vAA+1
3507     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
3508     .if 0
3509     addu    a2, offStaticField_value       #  a2<- pointer to data
3510     JAL(dvmQuasiAtomicSwap64Sync)          #  stores a0/a1 into addr a2
3511     .else
3512     STORE64_off(a0, a1, a2, offStaticField_value) #  field <- vAA/vAA+1
3513     .endif
3514     GOTO_OPCODE(rBIX)                      #  jump to next instruction
3515
3516 /* ------------------------------ */
3517     .balign 128
3518 .L_OP_SPUT_OBJECT: /* 0x69 */
3519 /* File: mips/OP_SPUT_OBJECT.S */
3520     /*
3521      * General 32-bit SPUT handler.
3522      *
3523      * for: sput-object, sput-object-volatile
3524      */
3525     /* op vAA, field@BBBB */
3526     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3527     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3528     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3529     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3530     bnez      a0, .LOP_SPUT_OBJECT_finish       #  is resolved entry null?
3531
3532     /* Continuation if the field has not yet been resolved.
3533      * a1:  BBBB field ref
3534      * rBIX: dvmDex->pResFields
3535      */
3536     LOAD_rSELF_method(a2)                  #  a2 <- current method
3537 #if defined(WITH_JIT)
3538     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3539 #endif
3540     EXPORT_PC()                            #  resolve() may throw, so export now
3541     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3542     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3543     move      a0, v0
3544     beqz      v0, common_exceptionThrown   #  success? no, handle exception
3545 #if defined(WITH_JIT)
3546     /*
3547      * If the JIT is actively building a trace we need to make sure
3548      * that the field is fully resolved before including this instruction.
3549      */
3550     JAL(common_verifyField)
3551 #endif
3552     b       .LOP_SPUT_OBJECT_finish             # resume
3553
3554
3555 /* ------------------------------ */
3556     .balign 128
3557 .L_OP_SPUT_BOOLEAN: /* 0x6a */
3558 /* File: mips/OP_SPUT_BOOLEAN.S */
3559 /* File: mips/OP_SPUT.S */
3560     /*
3561      * General 32-bit SPUT handler.
3562      *
3563      * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
3564      */
3565     # op vAA, field                        /* BBBB */
3566     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3567     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3568     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3569     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3570     bnez      a0, .LOP_SPUT_BOOLEAN_finish       #  is resolved entry null?
3571     /*
3572      * Continuation if the field has not yet been resolved.
3573      *  a1:  BBBB field ref
3574      *  rBIX: dvmDex->pResFields
3575      */
3576     LOAD_rSELF_method(a2)                  #  a2 <- current method
3577 #if defined(WITH_JIT)
3578     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3579 #endif
3580     EXPORT_PC()                            #  resolve() may throw, so export now
3581     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3582     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3583     move      a0, v0
3584     beqz      v0, common_exceptionThrown   #  success? no, handle exception
3585 #if defined(WITH_JIT)
3586     /*
3587      * If the JIT is actively building a trace we need to make sure
3588      * that the field is fully resolved before including this instruction.
3589      */
3590     JAL(common_verifyField)
3591 #endif
3592     b        .LOP_SPUT_BOOLEAN_finish            # resume
3593
3594
3595 /* ------------------------------ */
3596     .balign 128
3597 .L_OP_SPUT_BYTE: /* 0x6b */
3598 /* File: mips/OP_SPUT_BYTE.S */
3599 /* File: mips/OP_SPUT.S */
3600     /*
3601      * General 32-bit SPUT handler.
3602      *
3603      * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
3604      */
3605     # op vAA, field                        /* BBBB */
3606     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3607     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3608     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3609     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3610     bnez      a0, .LOP_SPUT_BYTE_finish       #  is resolved entry null?
3611     /*
3612      * Continuation if the field has not yet been resolved.
3613      *  a1:  BBBB field ref
3614      *  rBIX: dvmDex->pResFields
3615      */
3616     LOAD_rSELF_method(a2)                  #  a2 <- current method
3617 #if defined(WITH_JIT)
3618     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3619 #endif
3620     EXPORT_PC()                            #  resolve() may throw, so export now
3621     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3622     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3623     move      a0, v0
3624     beqz      v0, common_exceptionThrown   #  success? no, handle exception
3625 #if defined(WITH_JIT)
3626     /*
3627      * If the JIT is actively building a trace we need to make sure
3628      * that the field is fully resolved before including this instruction.
3629      */
3630     JAL(common_verifyField)
3631 #endif
3632     b        .LOP_SPUT_BYTE_finish            # resume
3633
3634
3635 /* ------------------------------ */
3636     .balign 128
3637 .L_OP_SPUT_CHAR: /* 0x6c */
3638 /* File: mips/OP_SPUT_CHAR.S */
3639 /* File: mips/OP_SPUT.S */
3640     /*
3641      * General 32-bit SPUT handler.
3642      *
3643      * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
3644      */
3645     # op vAA, field                        /* BBBB */
3646     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3647     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3648     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3649     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3650     bnez      a0, .LOP_SPUT_CHAR_finish       #  is resolved entry null?
3651     /*
3652      * Continuation if the field has not yet been resolved.
3653      *  a1:  BBBB field ref
3654      *  rBIX: dvmDex->pResFields
3655      */
3656     LOAD_rSELF_method(a2)                  #  a2 <- current method
3657 #if defined(WITH_JIT)
3658     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3659 #endif
3660     EXPORT_PC()                            #  resolve() may throw, so export now
3661     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3662     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3663     move      a0, v0
3664     beqz      v0, common_exceptionThrown   #  success? no, handle exception
3665 #if defined(WITH_JIT)
3666     /*
3667      * If the JIT is actively building a trace we need to make sure
3668      * that the field is fully resolved before including this instruction.
3669      */
3670     JAL(common_verifyField)
3671 #endif
3672     b        .LOP_SPUT_CHAR_finish            # resume
3673
3674
3675 /* ------------------------------ */
3676     .balign 128
3677 .L_OP_SPUT_SHORT: /* 0x6d */
3678 /* File: mips/OP_SPUT_SHORT.S */
3679 /* File: mips/OP_SPUT.S */
3680     /*
3681      * General 32-bit SPUT handler.
3682      *
3683      * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
3684      */
3685     # op vAA, field                        /* BBBB */
3686     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
3687     FETCH(a1, 1)                           #  a1 <- field ref BBBB
3688     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
3689     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
3690     bnez      a0, .LOP_SPUT_SHORT_finish       #  is resolved entry null?
3691     /*
3692      * Continuation if the field has not yet been resolved.
3693      *  a1:  BBBB field ref
3694      *  rBIX: dvmDex->pResFields
3695      */
3696     LOAD_rSELF_method(a2)                  #  a2 <- current method
3697 #if defined(WITH_JIT)
3698     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
3699 #endif
3700     EXPORT_PC()                            #  resolve() may throw, so export now
3701     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
3702     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
3703     move      a0, v0
3704     beqz      v0, common_exceptionThrown   #  success? no, handle exception
3705 #if defined(WITH_JIT)
3706     /*
3707      * If the JIT is actively building a trace we need to make sure
3708      * that the field is fully resolved before including this instruction.
3709      */
3710     JAL(common_verifyField)
3711 #endif
3712     b        .LOP_SPUT_SHORT_finish            # resume
3713
3714
3715 /* ------------------------------ */
3716     .balign 128
3717 .L_OP_INVOKE_VIRTUAL: /* 0x6e */
3718 /* File: mips/OP_INVOKE_VIRTUAL.S */
3719     /*
3720      * Handle a virtual method call.
3721      *
3722      * for: invoke-virtual, invoke-virtual/range
3723      */
3724     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3725     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
3726     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3727     FETCH(a1, 1)                           #  a1 <- BBBB
3728     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3729     FETCH(rBIX, 2)                         #  rBIX <- GFED or CCCC
3730     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
3731     .if (!0)
3732     and       rBIX, rBIX, 15               #  rBIX <- D (or stays CCCC)
3733     .endif
3734     EXPORT_PC()                            #  must export for invoke
3735     # already resolved?
3736     bnez      a0, .LOP_INVOKE_VIRTUAL_continue     #  yes, continue on
3737
3738     LOAD_rSELF_method(a3)                  #  a3 <- self->method
3739     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
3740     li        a2, METHOD_VIRTUAL           #  resolver method type
3741     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
3742     move      a0, v0
3743     # got null?
3744     bnez      v0, .LOP_INVOKE_VIRTUAL_continue     #  no, continue
3745     b         common_exceptionThrown       #  yes, handle exception
3746
3747 /* ------------------------------ */
3748     .balign 128
3749 .L_OP_INVOKE_SUPER: /* 0x6f */
3750 /* File: mips/OP_INVOKE_SUPER.S */
3751     /*
3752      * Handle a "super" method call.
3753      *
3754      * for: invoke-super, invoke-super/range
3755      */
3756     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3757     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
3758     FETCH(t0, 2)                           #  t0 <- GFED or CCCC
3759     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3760     .if (!0)
3761     and       t0, t0, 15                   #  t0 <- D (or stays CCCC)
3762     .endif
3763     FETCH(a1, 1)                           #  a1 <- BBBB
3764     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3765     GET_VREG(rOBJ, t0)                     #  rOBJ <- "this" ptr
3766     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
3767     # null "this"?
3768     LOAD_rSELF_method(t1)                  #  t1 <- current method
3769     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
3770     # cmp a0, 0; already resolved?
3771     LOAD_base_offMethod_clazz(rBIX, t1)    #  rBIX <- method->clazz
3772     EXPORT_PC()                            #  must export for invoke
3773     bnez      a0, .LOP_INVOKE_SUPER_continue     #  resolved, continue on
3774
3775     move      a0, rBIX                     #  a0 <- method->clazz
3776     li        a2, METHOD_VIRTUAL           #  resolver method type
3777     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
3778     move      a0, v0
3779     # got null?
3780     beqz      v0, common_exceptionThrown   #  yes, handle exception
3781     b         .LOP_INVOKE_SUPER_continue
3782
3783 /* ------------------------------ */
3784     .balign 128
3785 .L_OP_INVOKE_DIRECT: /* 0x70 */
3786 /* File: mips/OP_INVOKE_DIRECT.S */
3787     /*
3788      * Handle a direct method call.
3789      *
3790      * (We could defer the "is 'this' pointer null" test to the common
3791      * method invocation code, and use a flag to indicate that static
3792      * calls don't count.  If we do this as part of copying the arguments
3793      * out we could avoiding loading the first arg twice.)
3794      *
3795      * for: invoke-direct, invoke-direct/range
3796      */
3797     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3798     # op {vCCCC..v(CCCC+AA-1)}, meth       /* BBBB */
3799     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3800     FETCH(a1, 1)                           #  a1 <- BBBB
3801     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3802     FETCH(rBIX, 2)                         #  rBIX <- GFED or CCCC
3803     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
3804     .if (!0)
3805     and       rBIX, rBIX, 15               #  rBIX <- D (or stays CCCC)
3806     .endif
3807     EXPORT_PC()                            #  must export for invoke
3808     GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
3809     # already resolved?
3810     bnez      a0, 1f                       #  resolved, call the function
3811
3812     lw        a3, offThread_method(rSELF)  #  a3 <- self->method
3813     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
3814     li        a2, METHOD_DIRECT            #  resolver method type
3815     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
3816     move      a0, v0
3817     # got null?
3818     beqz      v0, common_exceptionThrown   #  yes, handle exception
3819
3820 1:
3821     bnez      rOBJ, common_invokeMethodNoRange #  a0=method, rOBJ="this"
3822     b         common_errNullObject         #  yes, throw exception
3823
3824
3825
3826
3827 /* ------------------------------ */
3828     .balign 128
3829 .L_OP_INVOKE_STATIC: /* 0x71 */
3830 /* File: mips/OP_INVOKE_STATIC.S */
3831     /*
3832      * Handle a static method call.
3833      *
3834      * for: invoke-static, invoke-static/range
3835      */
3836     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3837     # op {vCCCC..v(CCCC+AA-1)}, meth       /* BBBB */
3838     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3839     FETCH(a1, 1)                           #  a1 <- BBBB
3840     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3841     li      rOBJ, 0                        #  null "this" in delay slot
3842     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
3843 #if defined(WITH_JIT)
3844     EAS2(rBIX, a3, a1)                     #  rBIX<- &resolved_metherToCall
3845 #endif
3846     EXPORT_PC()                            #  must export for invoke
3847     # already resolved?
3848     bnez      a0, common_invokeMethodNoRange #  yes, continue on
3849     b         .LOP_INVOKE_STATIC_resolve
3850
3851 /* ------------------------------ */
3852     .balign 128
3853 .L_OP_INVOKE_INTERFACE: /* 0x72 */
3854 /* File: mips/OP_INVOKE_INTERFACE.S */
3855     /*
3856      * Handle an interface method call.
3857      *
3858      * for: invoke-interface, invoke-interface/range
3859      */
3860     /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
3861     /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
3862     FETCH(a2, 2)                           #  a2 <- FEDC or CCCC
3863     FETCH(a1, 1)                           #  a1 <- BBBB
3864     .if (!0)
3865     and       a2, 15                       #  a2 <- C (or stays CCCC)
3866     .endif
3867     EXPORT_PC()                            #  must export for invoke
3868     GET_VREG(rOBJ, a2)                     #  rOBJ <- first arg ("this")
3869     LOAD_rSELF_methodClassDex(a3)          #  a3 <- methodClassDex
3870     LOAD_rSELF_method(a2)                  #  a2 <- method
3871     # null obj?
3872     beqz      rOBJ, common_errNullObject   #  yes, fail
3873     LOAD_base_offObject_clazz(a0, rOBJ)      #  a0 <- thisPtr->clazz
3874     JAL(dvmFindInterfaceMethodInCache)     #  v0 <- call(class, ref, method, dex)
3875     move      a0, v0
3876     # failed?
3877     beqz      v0, common_exceptionThrown   #  yes, handle exception
3878     b         common_invokeMethodNoRange #  (a0=method, rOBJ="this")
3879
3880 /* ------------------------------ */
3881     .balign 128
3882 .L_OP_UNUSED_73: /* 0x73 */
3883 /* File: mips/OP_UNUSED_73.S */
3884 /* File: mips/unused.S */
3885     BAL(common_abort)
3886
3887
3888
3889 /* ------------------------------ */
3890     .balign 128
3891 .L_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */
3892 /* File: mips/OP_INVOKE_VIRTUAL_RANGE.S */
3893 /* File: mips/OP_INVOKE_VIRTUAL.S */
3894     /*
3895      * Handle a virtual method call.
3896      *
3897      * for: invoke-virtual, invoke-virtual/range
3898      */
3899     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3900     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
3901     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3902     FETCH(a1, 1)                           #  a1 <- BBBB
3903     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3904     FETCH(rBIX, 2)                         #  rBIX <- GFED or CCCC
3905     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
3906     .if (!1)
3907     and       rBIX, rBIX, 15               #  rBIX <- D (or stays CCCC)
3908     .endif
3909     EXPORT_PC()                            #  must export for invoke
3910     # already resolved?
3911     bnez      a0, .LOP_INVOKE_VIRTUAL_RANGE_continue     #  yes, continue on
3912
3913     LOAD_rSELF_method(a3)                  #  a3 <- self->method
3914     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
3915     li        a2, METHOD_VIRTUAL           #  resolver method type
3916     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
3917     move      a0, v0
3918     # got null?
3919     bnez      v0, .LOP_INVOKE_VIRTUAL_RANGE_continue     #  no, continue
3920     b         common_exceptionThrown       #  yes, handle exception
3921
3922
3923 /* ------------------------------ */
3924     .balign 128
3925 .L_OP_INVOKE_SUPER_RANGE: /* 0x75 */
3926 /* File: mips/OP_INVOKE_SUPER_RANGE.S */
3927 /* File: mips/OP_INVOKE_SUPER.S */
3928     /*
3929      * Handle a "super" method call.
3930      *
3931      * for: invoke-super, invoke-super/range
3932      */
3933     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3934     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
3935     FETCH(t0, 2)                           #  t0 <- GFED or CCCC
3936     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3937     .if (!1)
3938     and       t0, t0, 15                   #  t0 <- D (or stays CCCC)
3939     .endif
3940     FETCH(a1, 1)                           #  a1 <- BBBB
3941     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3942     GET_VREG(rOBJ, t0)                     #  rOBJ <- "this" ptr
3943     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
3944     # null "this"?
3945     LOAD_rSELF_method(t1)                  #  t1 <- current method
3946     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
3947     # cmp a0, 0; already resolved?
3948     LOAD_base_offMethod_clazz(rBIX, t1)    #  rBIX <- method->clazz
3949     EXPORT_PC()                            #  must export for invoke
3950     bnez      a0, .LOP_INVOKE_SUPER_RANGE_continue     #  resolved, continue on
3951
3952     move      a0, rBIX                     #  a0 <- method->clazz
3953     li        a2, METHOD_VIRTUAL           #  resolver method type
3954     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
3955     move      a0, v0
3956     # got null?
3957     beqz      v0, common_exceptionThrown   #  yes, handle exception
3958     b         .LOP_INVOKE_SUPER_RANGE_continue
3959
3960
3961 /* ------------------------------ */
3962     .balign 128
3963 .L_OP_INVOKE_DIRECT_RANGE: /* 0x76 */
3964 /* File: mips/OP_INVOKE_DIRECT_RANGE.S */
3965 /* File: mips/OP_INVOKE_DIRECT.S */
3966     /*
3967      * Handle a direct method call.
3968      *
3969      * (We could defer the "is 'this' pointer null" test to the common
3970      * method invocation code, and use a flag to indicate that static
3971      * calls don't count.  If we do this as part of copying the arguments
3972      * out we could avoiding loading the first arg twice.)
3973      *
3974      * for: invoke-direct, invoke-direct/range
3975      */
3976     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
3977     # op {vCCCC..v(CCCC+AA-1)}, meth       /* BBBB */
3978     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
3979     FETCH(a1, 1)                           #  a1 <- BBBB
3980     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
3981     FETCH(rBIX, 2)                         #  rBIX <- GFED or CCCC
3982     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
3983     .if (!1)
3984     and       rBIX, rBIX, 15               #  rBIX <- D (or stays CCCC)
3985     .endif
3986     EXPORT_PC()                            #  must export for invoke
3987     GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
3988     # already resolved?
3989     bnez      a0, 1f                       #  resolved, call the function
3990
3991     lw        a3, offThread_method(rSELF)  #  a3 <- self->method
3992     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
3993     li        a2, METHOD_DIRECT            #  resolver method type
3994     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
3995     move      a0, v0
3996     # got null?
3997     beqz      v0, common_exceptionThrown   #  yes, handle exception
3998
3999 1:
4000     bnez      rOBJ, common_invokeMethodRange #  a0=method, rOBJ="this"
4001     b         common_errNullObject         #  yes, throw exception
4002
4003
4004
4005
4006
4007 /* ------------------------------ */
4008     .balign 128
4009 .L_OP_INVOKE_STATIC_RANGE: /* 0x77 */
4010 /* File: mips/OP_INVOKE_STATIC_RANGE.S */
4011 /* File: mips/OP_INVOKE_STATIC.S */
4012     /*
4013      * Handle a static method call.
4014      *
4015      * for: invoke-static, invoke-static/range
4016      */
4017     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
4018     # op {vCCCC..v(CCCC+AA-1)}, meth       /* BBBB */
4019     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
4020     FETCH(a1, 1)                           #  a1 <- BBBB
4021     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
4022     li      rOBJ, 0                        #  null "this" in delay slot
4023     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
4024 #if defined(WITH_JIT)
4025     EAS2(rBIX, a3, a1)                     #  rBIX<- &resolved_metherToCall
4026 #endif
4027     EXPORT_PC()                            #  must export for invoke
4028     # already resolved?
4029     bnez      a0, common_invokeMethodRange #  yes, continue on
4030     b         .LOP_INVOKE_STATIC_RANGE_resolve
4031
4032
4033 /* ------------------------------ */
4034     .balign 128
4035 .L_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */
4036 /* File: mips/OP_INVOKE_INTERFACE_RANGE.S */
4037 /* File: mips/OP_INVOKE_INTERFACE.S */
4038     /*
4039      * Handle an interface method call.
4040      *
4041      * for: invoke-interface, invoke-interface/range
4042      */
4043     /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4044     /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4045     FETCH(a2, 2)                           #  a2 <- FEDC or CCCC
4046     FETCH(a1, 1)                           #  a1 <- BBBB
4047     .if (!1)
4048     and       a2, 15                       #  a2 <- C (or stays CCCC)
4049     .endif
4050     EXPORT_PC()                            #  must export for invoke
4051     GET_VREG(rOBJ, a2)                     #  rOBJ <- first arg ("this")
4052     LOAD_rSELF_methodClassDex(a3)          #  a3 <- methodClassDex
4053     LOAD_rSELF_method(a2)                  #  a2 <- method
4054     # null obj?
4055     beqz      rOBJ, common_errNullObject   #  yes, fail
4056     LOAD_base_offObject_clazz(a0, rOBJ)      #  a0 <- thisPtr->clazz
4057     JAL(dvmFindInterfaceMethodInCache)     #  v0 <- call(class, ref, method, dex)
4058     move      a0, v0
4059     # failed?
4060     beqz      v0, common_exceptionThrown   #  yes, handle exception
4061     b         common_invokeMethodRange #  (a0=method, rOBJ="this")
4062
4063
4064 /* ------------------------------ */
4065     .balign 128
4066 .L_OP_UNUSED_79: /* 0x79 */
4067 /* File: mips/OP_UNUSED_79.S */
4068 /* File: mips/unused.S */
4069     BAL(common_abort)
4070
4071
4072
4073 /* ------------------------------ */
4074     .balign 128
4075 .L_OP_UNUSED_7A: /* 0x7a */
4076 /* File: mips/OP_UNUSED_7A.S */
4077 /* File: mips/unused.S */
4078     BAL(common_abort)
4079
4080
4081
4082 /* ------------------------------ */
4083     .balign 128
4084 .L_OP_NEG_INT: /* 0x7b */
4085 /* File: mips/OP_NEG_INT.S */
4086 /* File: mips/unop.S */
4087     /*
4088      * Generic 32-bit unary operation.  Provide an "instr" line that
4089      * specifies an instruction that performs "result = op a0".
4090      * This could be a MIPS instruction or a function call.
4091      *
4092      * for: neg-int, not-int, neg-float, int-to-float, float-to-int,
4093      *      int-to-byte, int-to-char, int-to-short
4094      */
4095     /* unop vA, vB */
4096     GET_OPB(a3)                            #  a3 <- B
4097     GET_OPA4(t0)                           #  t0 <- A+
4098     GET_VREG(a0, a3)                       #  a0 <- vB
4099     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4100                                   #  optional op
4101     negu a0, a0                                 #  a0 <- op, a0-a3 changed
4102     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4103     SET_VREG_GOTO(a0, t0, t1)        #  vAA <- result0
4104     /* 9-10 instructions */
4105
4106
4107 /* ------------------------------ */
4108     .balign 128
4109 .L_OP_NOT_INT: /* 0x7c */
4110 /* File: mips/OP_NOT_INT.S */
4111 /* File: mips/unop.S */
4112     /*
4113      * Generic 32-bit unary operation.  Provide an "instr" line that
4114      * specifies an instruction that performs "result = op a0".
4115      * This could be a MIPS instruction or a function call.
4116      *
4117      * for: neg-int, not-int, neg-float, int-to-float, float-to-int,
4118      *      int-to-byte, int-to-char, int-to-short
4119      */
4120     /* unop vA, vB */
4121     GET_OPB(a3)                            #  a3 <- B
4122     GET_OPA4(t0)                           #  t0 <- A+
4123     GET_VREG(a0, a3)                       #  a0 <- vB
4124     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4125                                   #  optional op
4126     not a0, a0                                 #  a0 <- op, a0-a3 changed
4127     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4128     SET_VREG_GOTO(a0, t0, t1)        #  vAA <- result0
4129     /* 9-10 instructions */
4130
4131
4132 /* ------------------------------ */
4133     .balign 128
4134 .L_OP_NEG_LONG: /* 0x7d */
4135 /* File: mips/OP_NEG_LONG.S */
4136 /* File: mips/unopWide.S */
4137     /*
4138      * Generic 64-bit unary operation.  Provide an "instr" line that
4139      * specifies an instruction that performs "result = op a0/a1".
4140      * This could be MIPS instruction or a function call.
4141      *
4142      * For: neg-long, not-long, neg-double, long-to-double, double-to-long
4143      */
4144     /* unop vA, vB */
4145     GET_OPA4(t1)                           #  t1 <- A+
4146     GET_OPB(a3)                            #  a3 <- B
4147     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4148     EAS2(rOBJ, rFP, t1)                    #  rOBJ <- &fp[A]
4149     LOAD64(a0, a1, a3)                     #  a0/a1 <- vAA
4150     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4151     negu v0, a0                              #  optional op
4152     negu v1, a1; sltu a0, zero, v0; subu v1, v1, a0                                 #  a0/a1 <- op, a2-a3 changed
4153     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4154     STORE64(v0, v1, rOBJ)      #  vAA <- a0/a1
4155     GOTO_OPCODE(t0)                        #  jump to next instruction
4156     /* 12-13 instructions */
4157
4158
4159
4160
4161 /* ------------------------------ */
4162     .balign 128
4163 .L_OP_NOT_LONG: /* 0x7e */
4164 /* File: mips/OP_NOT_LONG.S */
4165 /* File: mips/unopWide.S */
4166     /*
4167      * Generic 64-bit unary operation.  Provide an "instr" line that
4168      * specifies an instruction that performs "result = op a0/a1".
4169      * This could be MIPS instruction or a function call.
4170      *
4171      * For: neg-long, not-long, neg-double, long-to-double, double-to-long
4172      */
4173     /* unop vA, vB */
4174     GET_OPA4(t1)                           #  t1 <- A+
4175     GET_OPB(a3)                            #  a3 <- B
4176     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4177     EAS2(rOBJ, rFP, t1)                    #  rOBJ <- &fp[A]
4178     LOAD64(a0, a1, a3)                     #  a0/a1 <- vAA
4179     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4180     not a0, a0                              #  optional op
4181     not a1, a1                                 #  a0/a1 <- op, a2-a3 changed
4182     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4183     STORE64(a0, a1, rOBJ)      #  vAA <- a0/a1
4184     GOTO_OPCODE(t0)                        #  jump to next instruction
4185     /* 12-13 instructions */
4186
4187
4188
4189 /* ------------------------------ */
4190     .balign 128
4191 .L_OP_NEG_FLOAT: /* 0x7f */
4192 /* File: mips/OP_NEG_FLOAT.S */
4193 /* File: mips/unop.S */
4194     /*
4195      * Generic 32-bit unary operation.  Provide an "instr" line that
4196      * specifies an instruction that performs "result = op a0".
4197      * This could be a MIPS instruction or a function call.
4198      *
4199      * for: neg-int, not-int, neg-float, int-to-float, float-to-int,
4200      *      int-to-byte, int-to-char, int-to-short
4201      */
4202     /* unop vA, vB */
4203     GET_OPB(a3)                            #  a3 <- B
4204     GET_OPA4(t0)                           #  t0 <- A+
4205     GET_VREG(a0, a3)                       #  a0 <- vB
4206     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4207                                   #  optional op
4208     addu a0, a0, 0x80000000                                 #  a0 <- op, a0-a3 changed
4209     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4210     SET_VREG_GOTO(a0, t0, t1)        #  vAA <- result0
4211     /* 9-10 instructions */
4212
4213
4214 /* ------------------------------ */
4215     .balign 128
4216 .L_OP_NEG_DOUBLE: /* 0x80 */
4217 /* File: mips/OP_NEG_DOUBLE.S */
4218 /* File: mips/unopWide.S */
4219     /*
4220      * Generic 64-bit unary operation.  Provide an "instr" line that
4221      * specifies an instruction that performs "result = op a0/a1".
4222      * This could be MIPS instruction or a function call.
4223      *
4224      * For: neg-long, not-long, neg-double, long-to-double, double-to-long
4225      */
4226     /* unop vA, vB */
4227     GET_OPA4(t1)                           #  t1 <- A+
4228     GET_OPB(a3)                            #  a3 <- B
4229     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4230     EAS2(rOBJ, rFP, t1)                    #  rOBJ <- &fp[A]
4231     LOAD64(a0, a1, a3)                     #  a0/a1 <- vAA
4232     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4233                                   #  optional op
4234     addu a1, a1, 0x80000000                                 #  a0/a1 <- op, a2-a3 changed
4235     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4236     STORE64(a0, a1, rOBJ)      #  vAA <- a0/a1
4237     GOTO_OPCODE(t0)                        #  jump to next instruction
4238     /* 12-13 instructions */
4239
4240
4241
4242 /* ------------------------------ */
4243     .balign 128
4244 .L_OP_INT_TO_LONG: /* 0x81 */
4245 /* File: mips/OP_INT_TO_LONG.S */
4246 /* File: mips/unopWider.S */
4247     /*
4248      * Generic 32bit-to-64bit unary operation.  Provide an "instr" line
4249      * that specifies an instruction that performs "result = op a0", where
4250      * "result" is a 64-bit quantity in a0/a1.
4251      *
4252      * For: int-to-long, int-to-double, float-to-long, float-to-double
4253      */
4254     /* unop vA, vB */
4255     GET_OPA4(t1)                           #  t1 <- A+
4256     GET_OPB(a3)                            #  a3 <- B
4257     GET_VREG(a0, a3)                       #  a0 <- vB
4258     EAS2(rOBJ, rFP, t1)                    #  rOBJ <- &fp[A]
4259     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4260                                   #  optional op
4261     sra a1, a0, 31                                 #  result <- op, a0-a3 changed
4262     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4263     STORE64(a0, a1, rOBJ)      #  vA/vA+1 <- a0/a1
4264     GOTO_OPCODE(t0)                        #  jump to next instruction
4265     /* 10-11 instructions */
4266
4267
4268 /* ------------------------------ */
4269     .balign 128
4270 .L_OP_INT_TO_FLOAT: /* 0x82 */
4271 /* File: mips/OP_INT_TO_FLOAT.S */
4272 /* File: mips/unflop.S */
4273     /*
4274      * Generic 32-bit unary operation.  Provide an "instr" line that
4275      * specifies an instruction that performs "result = op a0".
4276      * This could be a MIPS instruction or a function call.
4277      *
4278      * for: int-to-float, float-to-int
4279      */
4280     /* unop vA, vB */
4281     GET_OPB(a3)                            #  a3 <- B
4282     GET_OPA4(rOBJ)                         #  t0 <- A+
4283 #ifdef SOFT_FLOAT
4284     GET_VREG(a0, a3)                       #  a0 <- vB
4285 #else
4286     GET_VREG_F(fa0, a3)
4287 #endif
4288                                   #  optional op
4289     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4290 #ifdef SOFT_FLOAT
4291     JAL(__floatsisf)                                 #  a0 <- op, a0-a3 changed
4292
4293 .LOP_INT_TO_FLOAT_set_vreg:
4294     SET_VREG(v0, rOBJ)                     #  vAA <- result0
4295 #else
4296     cvt.s.w fv0, fa0
4297
4298 .LOP_INT_TO_FLOAT_set_vreg_f:
4299     SET_VREG_F(fv0, rOBJ)
4300 #endif
4301     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4302     GOTO_OPCODE(t1)                        #  jump to next instruction
4303     /* 9-10 instructions */
4304
4305
4306 /* ------------------------------ */
4307     .balign 128
4308 .L_OP_INT_TO_DOUBLE: /* 0x83 */
4309 /* File: mips/OP_INT_TO_DOUBLE.S */
4310 /* File: mips/unflopWider.S */
4311     /*
4312      * Generic 32bit-to-64bit unary operation.  Provide an "instr" line
4313      * that specifies an instruction that performs "result = op a0", where
4314      * "result" is a 64-bit quantity in a0/a1.
4315      *
4316      * For: int-to-double, float-to-long, float-to-double
4317      */
4318     /* unop vA, vB */
4319     GET_OPA4(rOBJ)                         #  rOBJ <- A+
4320     GET_OPB(a3)                            #  a3 <- B
4321 #ifdef SOFT_FLOAT
4322     GET_VREG(a0, a3)                       #  a0 <- vB
4323 #else
4324     GET_VREG_F(fa0, a3)
4325 #endif
4326     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
4327     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4328                                   #  optional op
4329 #ifdef SOFT_FLOAT
4330     JAL(__floatsidf)                                 #  result <- op, a0-a3 changed
4331
4332 .LOP_INT_TO_DOUBLE_set_vreg:
4333     STORE64(rRESULT0, rRESULT1, rOBJ)      #  vA/vA+1 <- a0/a1
4334 #else
4335     cvt.d.w fv0, fa0
4336
4337 .LOP_INT_TO_DOUBLE_set_vreg:
4338     STORE64_F(fv0, fv0f, rOBJ)                             #  vA/vA+1 <- a0/a1
4339 #endif
4340     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4341     GOTO_OPCODE(t0)                        #  jump to next instruction
4342     /* 10-11 instructions */
4343
4344
4345 /* ------------------------------ */
4346     .balign 128
4347 .L_OP_LONG_TO_INT: /* 0x84 */
4348 /* File: mips/OP_LONG_TO_INT.S */
4349     GET_OPB(a1)                            #  a1 <- B from 15:12
4350     GET_OPA4(a0)                           #  a0 <- A from 11:8
4351     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4352 #ifdef HAVE_BIG_ENDIAN
4353     addu      a1, a1, 1
4354 #endif
4355     GET_VREG(a2, a1)                       #  a2 <- fp[B]
4356     GET_INST_OPCODE(t0)                    #  t0 <- opcode from rINST
4357     SET_VREG_GOTO(a2, a0, t0)              #  fp[A] <- a2
4358
4359 /* ------------------------------ */
4360     .balign 128
4361 .L_OP_LONG_TO_FLOAT: /* 0x85 */
4362 /* File: mips/OP_LONG_TO_FLOAT.S */
4363 /* File: mips/unopNarrower.S */
4364     /*
4365      * Generic 64bit-to-32bit unary operation.  Provide an "instr" line
4366      * that specifies an instruction that performs "result = op a0/a1", where
4367      * "result" is a 32-bit quantity in a0.
4368      *
4369      * For: long-to-float, double-to-int, double-to-float
4370      * If hard floating point support is available, use fa0 as the parameter, except for
4371      * long-to-float opcode.
4372      * (This would work for long-to-int, but that instruction is actually
4373      * an exact match for OP_MOVE.)
4374      */
4375     /* unop vA, vB */
4376     GET_OPB(a3)                            #  a3 <- B
4377     GET_OPA4(rOBJ)                         #  t1 <- A+
4378     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4379 #ifdef SOFT_FLOAT
4380     LOAD64(rARG0, rARG1, a3)               #  a0/a1 <- vB/vB+1
4381 #else
4382     LOAD64(rARG0, rARG1, a3)
4383 #endif
4384     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4385                                   #  optional op
4386 #ifdef SOFT_FLOAT
4387     JAL(__floatdisf)                                 #  a0 <- op, a0-a3 changed
4388
4389 .LOP_LONG_TO_FLOAT_set_vreg:
4390     SET_VREG(v0, rOBJ)                     #  vA <- result0
4391 #else
4392     JAL(__floatdisf)
4393
4394 .LOP_LONG_TO_FLOAT_set_vreg_f:
4395     SET_VREG_F(fv0, rOBJ)                  #  vA <- result0
4396 #endif
4397     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4398     GOTO_OPCODE(t0)                        #  jump to next instruction
4399     /* 10-11 instructions */
4400
4401
4402 /* ------------------------------ */
4403     .balign 128
4404 .L_OP_LONG_TO_DOUBLE: /* 0x86 */
4405 /* File: mips/OP_LONG_TO_DOUBLE.S */
4406 /* File: mips/unflopWide.S */
4407     /*
4408      * Generic 64-bit unary operation.  Provide an "instr" line that
4409      * specifies an instruction that performs "result = op a0/a1".
4410      * This could be a MIPS instruction or a function call.
4411      *
4412      * long-to-double, double-to-long
4413      */
4414     /* unop vA, vB */
4415     GET_OPA4(rOBJ)                         #  t1 <- A+
4416     GET_OPB(a3)                            #  a3 <- B
4417     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4418     EAS2(rOBJ, rFP, rOBJ)                  #  t1 <- &fp[A]
4419 #ifdef SOFT_FLOAT
4420     LOAD64(rARG0, rARG1, a3)               #  a0/a1 <- vAA
4421 #else
4422     LOAD64(rARG0, rARG1, a3)
4423 #endif
4424     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4425                                   #  optional op
4426     JAL(__floatdidf)                                 #  a0/a1 <- op, a2-a3 changed
4427
4428 .LOP_LONG_TO_DOUBLE_set_vreg:
4429 #ifdef SOFT_FLOAT
4430     STORE64(rRESULT0, rRESULT1, rOBJ)      #  vAA <- a0/a1
4431 #else
4432     STORE64_F(fv0, fv0f, rOBJ)                             #  vAA <- a0/a1
4433 #endif
4434     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4435     GOTO_OPCODE(t0)                        #  jump to next instruction
4436     /* 12-13 instructions */
4437
4438
4439
4440 /* ------------------------------ */
4441     .balign 128
4442 .L_OP_FLOAT_TO_INT: /* 0x87 */
4443 /* File: mips/OP_FLOAT_TO_INT.S */
4444 /* File: mips/unflop.S */
4445     /*
4446      * Generic 32-bit unary operation.  Provide an "instr" line that
4447      * specifies an instruction that performs "result = op a0".
4448      * This could be a MIPS instruction or a function call.
4449      *
4450      * for: int-to-float, float-to-int
4451      */
4452     /* unop vA, vB */
4453     GET_OPB(a3)                            #  a3 <- B
4454     GET_OPA4(rOBJ)                         #  t0 <- A+
4455 #ifdef SOFT_FLOAT
4456     GET_VREG(a0, a3)                       #  a0 <- vB
4457 #else
4458     GET_VREG_F(fa0, a3)
4459 #endif
4460                                   #  optional op
4461     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4462 #ifdef SOFT_FLOAT
4463     b f2i_doconv                                 #  a0 <- op, a0-a3 changed
4464
4465 .LOP_FLOAT_TO_INT_set_vreg:
4466     SET_VREG(v0, rOBJ)                     #  vAA <- result0
4467 #else
4468     b f2i_doconv
4469
4470 .LOP_FLOAT_TO_INT_set_vreg_f:
4471     SET_VREG_F(fv0, rOBJ)
4472 #endif
4473     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4474     GOTO_OPCODE(t1)                        #  jump to next instruction
4475     /* 9-10 instructions */
4476
4477
4478 /* ------------------------------ */
4479     .balign 128
4480 .L_OP_FLOAT_TO_LONG: /* 0x88 */
4481 /* File: mips/OP_FLOAT_TO_LONG.S */
4482 /* File: mips/unflopWider.S */
4483     /*
4484      * Generic 32bit-to-64bit unary operation.  Provide an "instr" line
4485      * that specifies an instruction that performs "result = op a0", where
4486      * "result" is a 64-bit quantity in a0/a1.
4487      *
4488      * For: int-to-double, float-to-long, float-to-double
4489      */
4490     /* unop vA, vB */
4491     GET_OPA4(rOBJ)                         #  rOBJ <- A+
4492     GET_OPB(a3)                            #  a3 <- B
4493 #ifdef SOFT_FLOAT
4494     GET_VREG(a0, a3)                       #  a0 <- vB
4495 #else
4496     GET_VREG_F(fa0, a3)
4497 #endif
4498     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
4499     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4500                                   #  optional op
4501 #ifdef SOFT_FLOAT
4502     b f2l_doconv                                 #  result <- op, a0-a3 changed
4503
4504 .LOP_FLOAT_TO_LONG_set_vreg:
4505     STORE64(rRESULT0, rRESULT1, rOBJ)      #  vA/vA+1 <- a0/a1
4506 #else
4507     b f2l_doconv
4508
4509 .LOP_FLOAT_TO_LONG_set_vreg:
4510     STORE64(rRESULT0, rRESULT1, rOBJ)                             #  vA/vA+1 <- a0/a1
4511 #endif
4512     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4513     GOTO_OPCODE(t0)                        #  jump to next instruction
4514     /* 10-11 instructions */
4515
4516
4517 /* ------------------------------ */
4518     .balign 128
4519 .L_OP_FLOAT_TO_DOUBLE: /* 0x89 */
4520 /* File: mips/OP_FLOAT_TO_DOUBLE.S */
4521 /* File: mips/unflopWider.S */
4522     /*
4523      * Generic 32bit-to-64bit unary operation.  Provide an "instr" line
4524      * that specifies an instruction that performs "result = op a0", where
4525      * "result" is a 64-bit quantity in a0/a1.
4526      *
4527      * For: int-to-double, float-to-long, float-to-double
4528      */
4529     /* unop vA, vB */
4530     GET_OPA4(rOBJ)                         #  rOBJ <- A+
4531     GET_OPB(a3)                            #  a3 <- B
4532 #ifdef SOFT_FLOAT
4533     GET_VREG(a0, a3)                       #  a0 <- vB
4534 #else
4535     GET_VREG_F(fa0, a3)
4536 #endif
4537     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
4538     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4539                                   #  optional op
4540 #ifdef SOFT_FLOAT
4541     JAL(__extendsfdf2)                                 #  result <- op, a0-a3 changed
4542
4543 .LOP_FLOAT_TO_DOUBLE_set_vreg:
4544     STORE64(rRESULT0, rRESULT1, rOBJ)      #  vA/vA+1 <- a0/a1
4545 #else
4546     cvt.d.s fv0, fa0
4547
4548 .LOP_FLOAT_TO_DOUBLE_set_vreg:
4549     STORE64_F(fv0, fv0f, rOBJ)                             #  vA/vA+1 <- a0/a1
4550 #endif
4551     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4552     GOTO_OPCODE(t0)                        #  jump to next instruction
4553     /* 10-11 instructions */
4554
4555
4556 /* ------------------------------ */
4557     .balign 128
4558 .L_OP_DOUBLE_TO_INT: /* 0x8a */
4559 /* File: mips/OP_DOUBLE_TO_INT.S */
4560 /* File: mips/unopNarrower.S */
4561     /*
4562      * Generic 64bit-to-32bit unary operation.  Provide an "instr" line
4563      * that specifies an instruction that performs "result = op a0/a1", where
4564      * "result" is a 32-bit quantity in a0.
4565      *
4566      * For: long-to-float, double-to-int, double-to-float
4567      * If hard floating point support is available, use fa0 as the parameter, except for
4568      * long-to-float opcode.
4569      * (This would work for long-to-int, but that instruction is actually
4570      * an exact match for OP_MOVE.)
4571      */
4572     /* unop vA, vB */
4573     GET_OPB(a3)                            #  a3 <- B
4574     GET_OPA4(rOBJ)                         #  t1 <- A+
4575     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4576 #ifdef SOFT_FLOAT
4577     LOAD64(rARG0, rARG1, a3)               #  a0/a1 <- vB/vB+1
4578 #else
4579     LOAD64_F(fa0, fa0f, a3)
4580 #endif
4581     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4582                                   #  optional op
4583 #ifdef SOFT_FLOAT
4584     b d2i_doconv                                 #  a0 <- op, a0-a3 changed
4585
4586 .LOP_DOUBLE_TO_INT_set_vreg:
4587     SET_VREG(v0, rOBJ)                     #  vA <- result0
4588 #else
4589     b d2i_doconv
4590
4591 .LOP_DOUBLE_TO_INT_set_vreg_f:
4592     SET_VREG_F(fv0, rOBJ)                  #  vA <- result0
4593 #endif
4594     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4595     GOTO_OPCODE(t0)                        #  jump to next instruction
4596     /* 10-11 instructions */
4597
4598 /*
4599  * Convert the double in a0/a1 to an int in a0.
4600  *
4601  * We have to clip values to int min/max per the specification.  The
4602  * expected common case is a "reasonable" value that converts directly
4603  * to modest integer.  The EABI convert function isn't doing this for us.
4604  * Use rBIX / rTEMP as global to hold arguments (they are not bound to a global var)
4605  */
4606
4607 /* ------------------------------ */
4608     .balign 128
4609 .L_OP_DOUBLE_TO_LONG: /* 0x8b */
4610 /* File: mips/OP_DOUBLE_TO_LONG.S */
4611 /* File: mips/unflopWide.S */
4612     /*
4613      * Generic 64-bit unary operation.  Provide an "instr" line that
4614      * specifies an instruction that performs "result = op a0/a1".
4615      * This could be a MIPS instruction or a function call.
4616      *
4617      * long-to-double, double-to-long
4618      */
4619     /* unop vA, vB */
4620     GET_OPA4(rOBJ)                         #  t1 <- A+
4621     GET_OPB(a3)                            #  a3 <- B
4622     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4623     EAS2(rOBJ, rFP, rOBJ)                  #  t1 <- &fp[A]
4624 #ifdef SOFT_FLOAT
4625     LOAD64(rARG0, rARG1, a3)               #  a0/a1 <- vAA
4626 #else
4627     LOAD64_F(fa0, fa0f, a3)
4628 #endif
4629     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4630                                   #  optional op
4631     b d2l_doconv                                 #  a0/a1 <- op, a2-a3 changed
4632
4633 .LOP_DOUBLE_TO_LONG_set_vreg:
4634 #ifdef SOFT_FLOAT
4635     STORE64(rRESULT0, rRESULT1, rOBJ)      #  vAA <- a0/a1
4636 #else
4637     STORE64(rRESULT0, rRESULT1, rOBJ)                             #  vAA <- a0/a1
4638 #endif
4639     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4640     GOTO_OPCODE(t0)                        #  jump to next instruction
4641     /* 12-13 instructions */
4642
4643
4644
4645 /* ------------------------------ */
4646     .balign 128
4647 .L_OP_DOUBLE_TO_FLOAT: /* 0x8c */
4648 /* File: mips/OP_DOUBLE_TO_FLOAT.S */
4649 /* File: mips/unopNarrower.S */
4650     /*
4651      * Generic 64bit-to-32bit unary operation.  Provide an "instr" line
4652      * that specifies an instruction that performs "result = op a0/a1", where
4653      * "result" is a 32-bit quantity in a0.
4654      *
4655      * For: long-to-float, double-to-int, double-to-float
4656      * If hard floating point support is available, use fa0 as the parameter, except for
4657      * long-to-float opcode.
4658      * (This would work for long-to-int, but that instruction is actually
4659      * an exact match for OP_MOVE.)
4660      */
4661     /* unop vA, vB */
4662     GET_OPB(a3)                            #  a3 <- B
4663     GET_OPA4(rOBJ)                         #  t1 <- A+
4664     EAS2(a3, rFP, a3)                      #  a3 <- &fp[B]
4665 #ifdef SOFT_FLOAT
4666     LOAD64(rARG0, rARG1, a3)               #  a0/a1 <- vB/vB+1
4667 #else
4668     LOAD64_F(fa0, fa0f, a3)
4669 #endif
4670     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4671                                   #  optional op
4672 #ifdef SOFT_FLOAT
4673     JAL(__truncdfsf2)                                 #  a0 <- op, a0-a3 changed
4674
4675 .LOP_DOUBLE_TO_FLOAT_set_vreg:
4676     SET_VREG(v0, rOBJ)                     #  vA <- result0
4677 #else
4678     cvt.s.d fv0, fa0
4679
4680 .LOP_DOUBLE_TO_FLOAT_set_vreg_f:
4681     SET_VREG_F(fv0, rOBJ)                  #  vA <- result0
4682 #endif
4683     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4684     GOTO_OPCODE(t0)                        #  jump to next instruction
4685     /* 10-11 instructions */
4686
4687
4688 /* ------------------------------ */
4689     .balign 128
4690 .L_OP_INT_TO_BYTE: /* 0x8d */
4691 /* File: mips/OP_INT_TO_BYTE.S */
4692 /* File: mips/unop.S */
4693     /*
4694      * Generic 32-bit unary operation.  Provide an "instr" line that
4695      * specifies an instruction that performs "result = op a0".
4696      * This could be a MIPS instruction or a function call.
4697      *
4698      * for: neg-int, not-int, neg-float, int-to-float, float-to-int,
4699      *      int-to-byte, int-to-char, int-to-short
4700      */
4701     /* unop vA, vB */
4702     GET_OPB(a3)                            #  a3 <- B
4703     GET_OPA4(t0)                           #  t0 <- A+
4704     GET_VREG(a0, a3)                       #  a0 <- vB
4705     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4706     sll a0, a0, 24                              #  optional op
4707     sra a0, a0, 24                                 #  a0 <- op, a0-a3 changed
4708     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4709     SET_VREG_GOTO(a0, t0, t1)        #  vAA <- result0
4710     /* 9-10 instructions */
4711
4712
4713 /* ------------------------------ */
4714     .balign 128
4715 .L_OP_INT_TO_CHAR: /* 0x8e */
4716 /* File: mips/OP_INT_TO_CHAR.S */
4717 /* File: mips/unop.S */
4718     /*
4719      * Generic 32-bit unary operation.  Provide an "instr" line that
4720      * specifies an instruction that performs "result = op a0".
4721      * This could be a MIPS instruction or a function call.
4722      *
4723      * for: neg-int, not-int, neg-float, int-to-float, float-to-int,
4724      *      int-to-byte, int-to-char, int-to-short
4725      */
4726     /* unop vA, vB */
4727     GET_OPB(a3)                            #  a3 <- B
4728     GET_OPA4(t0)                           #  t0 <- A+
4729     GET_VREG(a0, a3)                       #  a0 <- vB
4730     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4731                                   #  optional op
4732     and a0, 0xffff                                 #  a0 <- op, a0-a3 changed
4733     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4734     SET_VREG_GOTO(a0, t0, t1)        #  vAA <- result0
4735     /* 9-10 instructions */
4736
4737
4738 /* ------------------------------ */
4739     .balign 128
4740 .L_OP_INT_TO_SHORT: /* 0x8f */
4741 /* File: mips/OP_INT_TO_SHORT.S */
4742 /* File: mips/unop.S */
4743     /*
4744      * Generic 32-bit unary operation.  Provide an "instr" line that
4745      * specifies an instruction that performs "result = op a0".
4746      * This could be a MIPS instruction or a function call.
4747      *
4748      * for: neg-int, not-int, neg-float, int-to-float, float-to-int,
4749      *      int-to-byte, int-to-char, int-to-short
4750      */
4751     /* unop vA, vB */
4752     GET_OPB(a3)                            #  a3 <- B
4753     GET_OPA4(t0)                           #  t0 <- A+
4754     GET_VREG(a0, a3)                       #  a0 <- vB
4755     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
4756     sll a0, 16                              #  optional op
4757     sra a0, 16                                 #  a0 <- op, a0-a3 changed
4758     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
4759     SET_VREG_GOTO(a0, t0, t1)        #  vAA <- result0
4760     /* 9-10 instructions */
4761
4762
4763 /* ------------------------------ */
4764     .balign 128
4765 .L_OP_ADD_INT: /* 0x90 */
4766 /* File: mips/OP_ADD_INT.S */
4767 /* File: mips/binop.S */
4768     /*
4769      * Generic 32-bit binary operation.  Provide an "instr" line that
4770      * specifies an instruction that performs "result = a0 op a1".
4771      * This could be a MIPS instruction or a function call.  (If the result
4772      * comes back in a register other than a0, you can override "result".)
4773      *
4774      * If "chkzero" is set to 1, we perform a divide-by-zero check on
4775      * vCC (a1).  Useful for integer division and modulus.  Note that we
4776      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
4777      * handles it correctly.
4778      *
4779      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
4780      *      xor-int, shl-int, shr-int, ushr-int
4781      */
4782     /* binop vAA, vBB, vCC */
4783     FETCH(a0, 1)                           #  a0 <- CCBB
4784     GET_OPA(rOBJ)                          #  rOBJ <- AA
4785     srl       a3, a0, 8                    #  a3 <- CC
4786     and       a2, a0, 255                  #  a2 <- BB
4787     GET_VREG(a1, a3)                       #  a1 <- vCC
4788     GET_VREG(a0, a2)                       #  a0 <- vBB
4789     .if 0
4790     # is second operand zero?
4791     beqz      a1, common_errDivideByZero
4792     .endif
4793
4794     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
4795                                   #  optional op
4796     addu a0, a0, a1                                 #  a0 <- op, a0-a3 changed
4797     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4798     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
4799     /* 11-14 instructions */
4800
4801
4802
4803 /* ------------------------------ */
4804     .balign 128
4805 .L_OP_SUB_INT: /* 0x91 */
4806 /* File: mips/OP_SUB_INT.S */
4807 /* File: mips/binop.S */
4808     /*
4809      * Generic 32-bit binary operation.  Provide an "instr" line that
4810      * specifies an instruction that performs "result = a0 op a1".
4811      * This could be a MIPS instruction or a function call.  (If the result
4812      * comes back in a register other than a0, you can override "result".)
4813      *
4814      * If "chkzero" is set to 1, we perform a divide-by-zero check on
4815      * vCC (a1).  Useful for integer division and modulus.  Note that we
4816      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
4817      * handles it correctly.
4818      *
4819      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
4820      *      xor-int, shl-int, shr-int, ushr-int
4821      */
4822     /* binop vAA, vBB, vCC */
4823     FETCH(a0, 1)                           #  a0 <- CCBB
4824     GET_OPA(rOBJ)                          #  rOBJ <- AA
4825     srl       a3, a0, 8                    #  a3 <- CC
4826     and       a2, a0, 255                  #  a2 <- BB
4827     GET_VREG(a1, a3)                       #  a1 <- vCC
4828     GET_VREG(a0, a2)                       #  a0 <- vBB
4829     .if 0
4830     # is second operand zero?
4831     beqz      a1, common_errDivideByZero
4832     .endif
4833
4834     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
4835                                   #  optional op
4836     subu a0, a0, a1                                 #  a0 <- op, a0-a3 changed
4837     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4838     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
4839     /* 11-14 instructions */
4840
4841
4842
4843 /* ------------------------------ */
4844     .balign 128
4845 .L_OP_MUL_INT: /* 0x92 */
4846 /* File: mips/OP_MUL_INT.S */
4847 /* File: mips/binop.S */
4848     /*
4849      * Generic 32-bit binary operation.  Provide an "instr" line that
4850      * specifies an instruction that performs "result = a0 op a1".
4851      * This could be a MIPS instruction or a function call.  (If the result
4852      * comes back in a register other than a0, you can override "result".)
4853      *
4854      * If "chkzero" is set to 1, we perform a divide-by-zero check on
4855      * vCC (a1).  Useful for integer division and modulus.  Note that we
4856      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
4857      * handles it correctly.
4858      *
4859      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
4860      *      xor-int, shl-int, shr-int, ushr-int
4861      */
4862     /* binop vAA, vBB, vCC */
4863     FETCH(a0, 1)                           #  a0 <- CCBB
4864     GET_OPA(rOBJ)                          #  rOBJ <- AA
4865     srl       a3, a0, 8                    #  a3 <- CC
4866     and       a2, a0, 255                  #  a2 <- BB
4867     GET_VREG(a1, a3)                       #  a1 <- vCC
4868     GET_VREG(a0, a2)                       #  a0 <- vBB
4869     .if 0
4870     # is second operand zero?
4871     beqz      a1, common_errDivideByZero
4872     .endif
4873
4874     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
4875                                   #  optional op
4876     mul a0, a0, a1                                 #  a0 <- op, a0-a3 changed
4877     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4878     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
4879     /* 11-14 instructions */
4880
4881
4882
4883 /* ------------------------------ */
4884     .balign 128
4885 .L_OP_DIV_INT: /* 0x93 */
4886 /* File: mips/OP_DIV_INT.S */
4887 /* File: mips/binop.S */
4888     /*
4889      * Generic 32-bit binary operation.  Provide an "instr" line that
4890      * specifies an instruction that performs "result = a0 op a1".
4891      * This could be a MIPS instruction or a function call.  (If the result
4892      * comes back in a register other than a0, you can override "result".)
4893      *
4894      * If "chkzero" is set to 1, we perform a divide-by-zero check on
4895      * vCC (a1).  Useful for integer division and modulus.  Note that we
4896      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
4897      * handles it correctly.
4898      *
4899      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
4900      *      xor-int, shl-int, shr-int, ushr-int
4901      */
4902     /* binop vAA, vBB, vCC */
4903     FETCH(a0, 1)                           #  a0 <- CCBB
4904     GET_OPA(rOBJ)                          #  rOBJ <- AA
4905     srl       a3, a0, 8                    #  a3 <- CC
4906     and       a2, a0, 255                  #  a2 <- BB
4907     GET_VREG(a1, a3)                       #  a1 <- vCC
4908     GET_VREG(a0, a2)                       #  a0 <- vBB
4909     .if 1
4910     # is second operand zero?
4911     beqz      a1, common_errDivideByZero
4912     .endif
4913
4914     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
4915                                   #  optional op
4916     div zero, a0, a1; mflo a0                                 #  a0 <- op, a0-a3 changed
4917     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4918     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
4919     /* 11-14 instructions */
4920
4921
4922
4923 /* ------------------------------ */
4924     .balign 128
4925 .L_OP_REM_INT: /* 0x94 */
4926 /* File: mips/OP_REM_INT.S */
4927 /* File: mips/binop.S */
4928     /*
4929      * Generic 32-bit binary operation.  Provide an "instr" line that
4930      * specifies an instruction that performs "result = a0 op a1".
4931      * This could be a MIPS instruction or a function call.  (If the result
4932      * comes back in a register other than a0, you can override "result".)
4933      *
4934      * If "chkzero" is set to 1, we perform a divide-by-zero check on
4935      * vCC (a1).  Useful for integer division and modulus.  Note that we
4936      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
4937      * handles it correctly.
4938      *
4939      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
4940      *      xor-int, shl-int, shr-int, ushr-int
4941      */
4942     /* binop vAA, vBB, vCC */
4943     FETCH(a0, 1)                           #  a0 <- CCBB
4944     GET_OPA(rOBJ)                          #  rOBJ <- AA
4945     srl       a3, a0, 8                    #  a3 <- CC
4946     and       a2, a0, 255                  #  a2 <- BB
4947     GET_VREG(a1, a3)                       #  a1 <- vCC
4948     GET_VREG(a0, a2)                       #  a0 <- vBB
4949     .if 1
4950     # is second operand zero?
4951     beqz      a1, common_errDivideByZero
4952     .endif
4953
4954     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
4955                                   #  optional op
4956     div zero, a0, a1; mfhi a0                                 #  a0 <- op, a0-a3 changed
4957     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4958     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
4959     /* 11-14 instructions */
4960
4961
4962
4963 /* ------------------------------ */
4964     .balign 128
4965 .L_OP_AND_INT: /* 0x95 */
4966 /* File: mips/OP_AND_INT.S */
4967 /* File: mips/binop.S */
4968     /*
4969      * Generic 32-bit binary operation.  Provide an "instr" line that
4970      * specifies an instruction that performs "result = a0 op a1".
4971      * This could be a MIPS instruction or a function call.  (If the result
4972      * comes back in a register other than a0, you can override "result".)
4973      *
4974      * If "chkzero" is set to 1, we perform a divide-by-zero check on
4975      * vCC (a1).  Useful for integer division and modulus.  Note that we
4976      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
4977      * handles it correctly.
4978      *
4979      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
4980      *      xor-int, shl-int, shr-int, ushr-int
4981      */
4982     /* binop vAA, vBB, vCC */
4983     FETCH(a0, 1)                           #  a0 <- CCBB
4984     GET_OPA(rOBJ)                          #  rOBJ <- AA
4985     srl       a3, a0, 8                    #  a3 <- CC
4986     and       a2, a0, 255                  #  a2 <- BB
4987     GET_VREG(a1, a3)                       #  a1 <- vCC
4988     GET_VREG(a0, a2)                       #  a0 <- vBB
4989     .if 0
4990     # is second operand zero?
4991     beqz      a1, common_errDivideByZero
4992     .endif
4993
4994     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
4995                                   #  optional op
4996     and a0, a0, a1                                 #  a0 <- op, a0-a3 changed
4997     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
4998     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
4999     /* 11-14 instructions */
5000
5001
5002
5003 /* ------------------------------ */
5004     .balign 128
5005 .L_OP_OR_INT: /* 0x96 */
5006 /* File: mips/OP_OR_INT.S */
5007 /* File: mips/binop.S */
5008     /*
5009      * Generic 32-bit binary operation.  Provide an "instr" line that
5010      * specifies an instruction that performs "result = a0 op a1".
5011      * This could be a MIPS instruction or a function call.  (If the result
5012      * comes back in a register other than a0, you can override "result".)
5013      *
5014      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5015      * vCC (a1).  Useful for integer division and modulus.  Note that we
5016      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
5017      * handles it correctly.
5018      *
5019      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
5020      *      xor-int, shl-int, shr-int, ushr-int
5021      */
5022     /* binop vAA, vBB, vCC */
5023     FETCH(a0, 1)                           #  a0 <- CCBB
5024     GET_OPA(rOBJ)                          #  rOBJ <- AA
5025     srl       a3, a0, 8                    #  a3 <- CC
5026     and       a2, a0, 255                  #  a2 <- BB
5027     GET_VREG(a1, a3)                       #  a1 <- vCC
5028     GET_VREG(a0, a2)                       #  a0 <- vBB
5029     .if 0
5030     # is second operand zero?
5031     beqz      a1, common_errDivideByZero
5032     .endif
5033
5034     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5035                                   #  optional op
5036     or a0, a0, a1                                 #  a0 <- op, a0-a3 changed
5037     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5038     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
5039     /* 11-14 instructions */
5040
5041
5042
5043 /* ------------------------------ */
5044     .balign 128
5045 .L_OP_XOR_INT: /* 0x97 */
5046 /* File: mips/OP_XOR_INT.S */
5047 /* File: mips/binop.S */
5048     /*
5049      * Generic 32-bit binary operation.  Provide an "instr" line that
5050      * specifies an instruction that performs "result = a0 op a1".
5051      * This could be a MIPS instruction or a function call.  (If the result
5052      * comes back in a register other than a0, you can override "result".)
5053      *
5054      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5055      * vCC (a1).  Useful for integer division and modulus.  Note that we
5056      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
5057      * handles it correctly.
5058      *
5059      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
5060      *      xor-int, shl-int, shr-int, ushr-int
5061      */
5062     /* binop vAA, vBB, vCC */
5063     FETCH(a0, 1)                           #  a0 <- CCBB
5064     GET_OPA(rOBJ)                          #  rOBJ <- AA
5065     srl       a3, a0, 8                    #  a3 <- CC
5066     and       a2, a0, 255                  #  a2 <- BB
5067     GET_VREG(a1, a3)                       #  a1 <- vCC
5068     GET_VREG(a0, a2)                       #  a0 <- vBB
5069     .if 0
5070     # is second operand zero?
5071     beqz      a1, common_errDivideByZero
5072     .endif
5073
5074     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5075                                   #  optional op
5076     xor a0, a0, a1                                 #  a0 <- op, a0-a3 changed
5077     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5078     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
5079     /* 11-14 instructions */
5080
5081
5082
5083 /* ------------------------------ */
5084     .balign 128
5085 .L_OP_SHL_INT: /* 0x98 */
5086 /* File: mips/OP_SHL_INT.S */
5087 /* File: mips/binop.S */
5088     /*
5089      * Generic 32-bit binary operation.  Provide an "instr" line that
5090      * specifies an instruction that performs "result = a0 op a1".
5091      * This could be a MIPS instruction or a function call.  (If the result
5092      * comes back in a register other than a0, you can override "result".)
5093      *
5094      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5095      * vCC (a1).  Useful for integer division and modulus.  Note that we
5096      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
5097      * handles it correctly.
5098      *
5099      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
5100      *      xor-int, shl-int, shr-int, ushr-int
5101      */
5102     /* binop vAA, vBB, vCC */
5103     FETCH(a0, 1)                           #  a0 <- CCBB
5104     GET_OPA(rOBJ)                          #  rOBJ <- AA
5105     srl       a3, a0, 8                    #  a3 <- CC
5106     and       a2, a0, 255                  #  a2 <- BB
5107     GET_VREG(a1, a3)                       #  a1 <- vCC
5108     GET_VREG(a0, a2)                       #  a0 <- vBB
5109     .if 0
5110     # is second operand zero?
5111     beqz      a1, common_errDivideByZero
5112     .endif
5113
5114     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5115     and a1, a1, 31                              #  optional op
5116     sll a0, a0, a1                                 #  a0 <- op, a0-a3 changed
5117     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5118     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
5119     /* 11-14 instructions */
5120
5121
5122
5123 /* ------------------------------ */
5124     .balign 128
5125 .L_OP_SHR_INT: /* 0x99 */
5126 /* File: mips/OP_SHR_INT.S */
5127 /* File: mips/binop.S */
5128     /*
5129      * Generic 32-bit binary operation.  Provide an "instr" line that
5130      * specifies an instruction that performs "result = a0 op a1".
5131      * This could be a MIPS instruction or a function call.  (If the result
5132      * comes back in a register other than a0, you can override "result".)
5133      *
5134      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5135      * vCC (a1).  Useful for integer division and modulus.  Note that we
5136      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
5137      * handles it correctly.
5138      *
5139      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
5140      *      xor-int, shl-int, shr-int, ushr-int
5141      */
5142     /* binop vAA, vBB, vCC */
5143     FETCH(a0, 1)                           #  a0 <- CCBB
5144     GET_OPA(rOBJ)                          #  rOBJ <- AA
5145     srl       a3, a0, 8                    #  a3 <- CC
5146     and       a2, a0, 255                  #  a2 <- BB
5147     GET_VREG(a1, a3)                       #  a1 <- vCC
5148     GET_VREG(a0, a2)                       #  a0 <- vBB
5149     .if 0
5150     # is second operand zero?
5151     beqz      a1, common_errDivideByZero
5152     .endif
5153
5154     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5155     and a1, a1, 31                              #  optional op
5156     sra a0, a0, a1                                 #  a0 <- op, a0-a3 changed
5157     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5158     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
5159     /* 11-14 instructions */
5160
5161
5162
5163 /* ------------------------------ */
5164     .balign 128
5165 .L_OP_USHR_INT: /* 0x9a */
5166 /* File: mips/OP_USHR_INT.S */
5167 /* File: mips/binop.S */
5168     /*
5169      * Generic 32-bit binary operation.  Provide an "instr" line that
5170      * specifies an instruction that performs "result = a0 op a1".
5171      * This could be a MIPS instruction or a function call.  (If the result
5172      * comes back in a register other than a0, you can override "result".)
5173      *
5174      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5175      * vCC (a1).  Useful for integer division and modulus.  Note that we
5176      * *don't* check for (INT_MIN / -1) here, because the ARM math lib
5177      * handles it correctly.
5178      *
5179      * For: add-int, sub-int, mul-int, div-int, rem-int, and-int, or-int,
5180      *      xor-int, shl-int, shr-int, ushr-int
5181      */
5182     /* binop vAA, vBB, vCC */
5183     FETCH(a0, 1)                           #  a0 <- CCBB
5184     GET_OPA(rOBJ)                          #  rOBJ <- AA
5185     srl       a3, a0, 8                    #  a3 <- CC
5186     and       a2, a0, 255                  #  a2 <- BB
5187     GET_VREG(a1, a3)                       #  a1 <- vCC
5188     GET_VREG(a0, a2)                       #  a0 <- vBB
5189     .if 0
5190     # is second operand zero?
5191     beqz      a1, common_errDivideByZero
5192     .endif
5193
5194     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5195     and a1, a1, 31                              #  optional op
5196     srl a0, a0, a1                                 #  a0 <- op, a0-a3 changed
5197     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5198     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
5199     /* 11-14 instructions */
5200
5201
5202
5203 /* ------------------------------ */
5204     .balign 128
5205 .L_OP_ADD_LONG: /* 0x9b */
5206 /* File: mips/OP_ADD_LONG.S */
5207 /*
5208  *  The compiler generates the following sequence for
5209  *  [v1 v0] =  [a1 a0] + [a3 a2];
5210  *    addu v0,a2,a0
5211  *    addu a1,a3,a1
5212  *    sltu v1,v0,a2
5213  *    addu v1,v1,a1
5214  */
5215 /* File: mips/binopWide.S */
5216     /*
5217      * Generic 64-bit binary operation.  Provide an "instr" line that
5218      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5219      * This could be a MIPS instruction or a function call.  (If the result
5220      * comes back in a register other than a0, you can override "result".)
5221      *
5222      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5223      * vCC (a1).  Useful for integer division and modulus.
5224      *
5225      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5226      *      xor-long
5227      *
5228      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5229      */
5230     /* binop vAA, vBB, vCC */
5231     FETCH(a0, 1)                           #  a0 <- CCBB
5232     GET_OPA(rOBJ)                          #  rOBJ <- AA
5233     and       a2, a0, 255                  #  a2 <- BB
5234     srl       a3, a0, 8                    #  a3 <- CC
5235     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5236     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5237     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5238     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5239     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5240     .if 0
5241     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5242     beqz      t0, common_errDivideByZero
5243     .endif
5244     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5245
5246     addu v0, a2, a0                              #  optional op
5247     addu a1, a3, a1; sltu v1, v0, a2; addu v1, v1, a1                                 #  result <- op, a0-a3 changed
5248     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5249     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
5250     GOTO_OPCODE(t0)                        #  jump to next instruction
5251     /* 14-17 instructions */
5252
5253
5254
5255 /* ------------------------------ */
5256     .balign 128
5257 .L_OP_SUB_LONG: /* 0x9c */
5258 /* File: mips/OP_SUB_LONG.S */
5259 /*
5260  * For little endian the code sequence looks as follows:
5261  *    subu    v0,a0,a2
5262  *    subu    v1,a1,a3
5263  *    sltu    a0,a0,v0
5264  *    subu    v1,v1,a0
5265  */
5266 /* File: mips/binopWide.S */
5267     /*
5268      * Generic 64-bit binary operation.  Provide an "instr" line that
5269      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5270      * This could be a MIPS instruction or a function call.  (If the result
5271      * comes back in a register other than a0, you can override "result".)
5272      *
5273      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5274      * vCC (a1).  Useful for integer division and modulus.
5275      *
5276      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5277      *      xor-long
5278      *
5279      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5280      */
5281     /* binop vAA, vBB, vCC */
5282     FETCH(a0, 1)                           #  a0 <- CCBB
5283     GET_OPA(rOBJ)                          #  rOBJ <- AA
5284     and       a2, a0, 255                  #  a2 <- BB
5285     srl       a3, a0, 8                    #  a3 <- CC
5286     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5287     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5288     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5289     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5290     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5291     .if 0
5292     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5293     beqz      t0, common_errDivideByZero
5294     .endif
5295     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5296
5297     subu v0, a0, a2                              #  optional op
5298     subu v1, a1, a3; sltu a0, a0, v0; subu v1, v1, a0                                 #  result <- op, a0-a3 changed
5299     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5300     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
5301     GOTO_OPCODE(t0)                        #  jump to next instruction
5302     /* 14-17 instructions */
5303
5304
5305
5306
5307 /* ------------------------------ */
5308     .balign 128
5309 .L_OP_MUL_LONG: /* 0x9d */
5310 /* File: mips/OP_MUL_LONG.S */
5311     /*
5312      * Signed 64-bit integer multiply.
5313      *         a1   a0
5314      *   x     a3   a2
5315      *   -------------
5316      *       a2a1 a2a0
5317      *       a3a0
5318      *  a3a1 (<= unused)
5319      *  ---------------
5320      *         v1   v0
5321      */
5322     /* mul-long vAA, vBB, vCC */
5323     FETCH(a0, 1)                           #  a0 <- CCBB
5324     and       t0, a0, 255                  #  a2 <- BB
5325     srl       t1, a0, 8                    #  a3 <- CC
5326     EAS2(t0, rFP, t0)                      #  t0 <- &fp[BB]
5327     LOAD64(a0, a1, t0)                     #  a0/a1 <- vBB/vBB+1
5328
5329     EAS2(t1, rFP, t1)                      #  t0 <- &fp[CC]
5330     LOAD64(a2, a3, t1)                     #  a2/a3 <- vCC/vCC+1
5331
5332     mul       v1, a3, a0                   #  v1= a3a0
5333     multu     a2, a0
5334     mfhi      t1
5335     mflo      v0                           #  v0= a2a0
5336     mul       t0, a2, a1                   #  t0= a2a1
5337     addu      v1, v1, t1                   #  v1+= hi(a2a0)
5338     addu      v1, v1, t0                   #  v1= a3a0 + a2a1;
5339
5340     GET_OPA(a0)                            #  a0 <- AA
5341     EAS2(a0, rFP, a0)                      #  a0 <- &fp[A]
5342     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5343     b         .LOP_MUL_LONG_finish
5344
5345 /* ------------------------------ */
5346     .balign 128
5347 .L_OP_DIV_LONG: /* 0x9e */
5348 /* File: mips/OP_DIV_LONG.S */
5349 #ifdef HAVE_LITTLE_ENDIAN
5350 /* File: mips/binopWide.S */
5351     /*
5352      * Generic 64-bit binary operation.  Provide an "instr" line that
5353      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5354      * This could be a MIPS instruction or a function call.  (If the result
5355      * comes back in a register other than a0, you can override "result".)
5356      *
5357      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5358      * vCC (a1).  Useful for integer division and modulus.
5359      *
5360      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5361      *      xor-long
5362      *
5363      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5364      */
5365     /* binop vAA, vBB, vCC */
5366     FETCH(a0, 1)                           #  a0 <- CCBB
5367     GET_OPA(rOBJ)                          #  rOBJ <- AA
5368     and       a2, a0, 255                  #  a2 <- BB
5369     srl       a3, a0, 8                    #  a3 <- CC
5370     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5371     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5372     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5373     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5374     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5375     .if 1
5376     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5377     beqz      t0, common_errDivideByZero
5378     .endif
5379     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5380
5381                                   #  optional op
5382     JAL(__divdi3)                                 #  result <- op, a0-a3 changed
5383     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5384     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
5385     GOTO_OPCODE(t0)                        #  jump to next instruction
5386     /* 14-17 instructions */
5387
5388
5389 #else
5390 /* File: mips/binopWide.S */
5391     /*
5392      * Generic 64-bit binary operation.  Provide an "instr" line that
5393      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5394      * This could be a MIPS instruction or a function call.  (If the result
5395      * comes back in a register other than a0, you can override "result".)
5396      *
5397      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5398      * vCC (a1).  Useful for integer division and modulus.
5399      *
5400      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5401      *      xor-long
5402      *
5403      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5404      */
5405     /* binop vAA, vBB, vCC */
5406     FETCH(a0, 1)                           #  a0 <- CCBB
5407     GET_OPA(rOBJ)                          #  rOBJ <- AA
5408     and       a2, a0, 255                  #  a2 <- BB
5409     srl       a3, a0, 8                    #  a3 <- CC
5410     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5411     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5412     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5413     LOAD64(a1, a0, a2)               #  a0/a1 <- vBB/vBB+1
5414     LOAD64(a3, a2, t1)               #  a2/a3 <- vCC/vCC+1
5415     .if 1
5416     or        t0, a3, a2             #  second arg (a2-a3) is zero?
5417     beqz      t0, common_errDivideByZero
5418     .endif
5419     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5420
5421                                   #  optional op
5422     JAL(__divdi3)                                 #  result <- op, a0-a3 changed
5423     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5424     STORE64(v1, v0, rOBJ)      #  vAA/vAA+1 <- v1/v0
5425     GOTO_OPCODE(t0)                        #  jump to next instruction
5426     /* 14-17 instructions */
5427
5428
5429 #endif
5430
5431 /* ------------------------------ */
5432     .balign 128
5433 .L_OP_REM_LONG: /* 0x9f */
5434 /* File: mips/OP_REM_LONG.S */
5435 /* ldivmod returns quotient in a0/a1 and remainder in a2/a3 */
5436 #ifdef HAVE_LITTLE_ENDIAN
5437 /* File: mips/binopWide.S */
5438     /*
5439      * Generic 64-bit binary operation.  Provide an "instr" line that
5440      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5441      * This could be a MIPS instruction or a function call.  (If the result
5442      * comes back in a register other than a0, you can override "result".)
5443      *
5444      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5445      * vCC (a1).  Useful for integer division and modulus.
5446      *
5447      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5448      *      xor-long
5449      *
5450      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5451      */
5452     /* binop vAA, vBB, vCC */
5453     FETCH(a0, 1)                           #  a0 <- CCBB
5454     GET_OPA(rOBJ)                          #  rOBJ <- AA
5455     and       a2, a0, 255                  #  a2 <- BB
5456     srl       a3, a0, 8                    #  a3 <- CC
5457     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5458     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5459     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5460     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5461     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5462     .if 1
5463     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5464     beqz      t0, common_errDivideByZero
5465     .endif
5466     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5467
5468                                   #  optional op
5469     JAL(__moddi3)                                 #  result <- op, a0-a3 changed
5470     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5471     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
5472     GOTO_OPCODE(t0)                        #  jump to next instruction
5473     /* 14-17 instructions */
5474
5475
5476 #else
5477 /* File: mips/binopWide.S */
5478     /*
5479      * Generic 64-bit binary operation.  Provide an "instr" line that
5480      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5481      * This could be a MIPS instruction or a function call.  (If the result
5482      * comes back in a register other than a0, you can override "result".)
5483      *
5484      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5485      * vCC (a1).  Useful for integer division and modulus.
5486      *
5487      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5488      *      xor-long
5489      *
5490      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5491      */
5492     /* binop vAA, vBB, vCC */
5493     FETCH(a0, 1)                           #  a0 <- CCBB
5494     GET_OPA(rOBJ)                          #  rOBJ <- AA
5495     and       a2, a0, 255                  #  a2 <- BB
5496     srl       a3, a0, 8                    #  a3 <- CC
5497     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5498     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5499     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5500     LOAD64(a1, a0, a2)               #  a0/a1 <- vBB/vBB+1
5501     LOAD64(a3, a2, t1)               #  a2/a3 <- vCC/vCC+1
5502     .if 1
5503     or        t0, a3, a2             #  second arg (a2-a3) is zero?
5504     beqz      t0, common_errDivideByZero
5505     .endif
5506     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5507
5508                                   #  optional op
5509     JAL(__moddi3)                                 #  result <- op, a0-a3 changed
5510     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5511     STORE64(v1, v0, rOBJ)      #  vAA/vAA+1 <- v1/v0
5512     GOTO_OPCODE(t0)                        #  jump to next instruction
5513     /* 14-17 instructions */
5514
5515
5516 #endif
5517
5518 /* ------------------------------ */
5519     .balign 128
5520 .L_OP_AND_LONG: /* 0xa0 */
5521 /* File: mips/OP_AND_LONG.S */
5522 /* File: mips/binopWide.S */
5523     /*
5524      * Generic 64-bit binary operation.  Provide an "instr" line that
5525      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5526      * This could be a MIPS instruction or a function call.  (If the result
5527      * comes back in a register other than a0, you can override "result".)
5528      *
5529      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5530      * vCC (a1).  Useful for integer division and modulus.
5531      *
5532      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5533      *      xor-long
5534      *
5535      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5536      */
5537     /* binop vAA, vBB, vCC */
5538     FETCH(a0, 1)                           #  a0 <- CCBB
5539     GET_OPA(rOBJ)                          #  rOBJ <- AA
5540     and       a2, a0, 255                  #  a2 <- BB
5541     srl       a3, a0, 8                    #  a3 <- CC
5542     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5543     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5544     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5545     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5546     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5547     .if 0
5548     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5549     beqz      t0, common_errDivideByZero
5550     .endif
5551     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5552
5553     and a0, a0, a2                              #  optional op
5554     and a1, a1, a3                                 #  result <- op, a0-a3 changed
5555     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5556     STORE64(a0, a1, rOBJ)      #  vAA/vAA+1 <- a0/a1
5557     GOTO_OPCODE(t0)                        #  jump to next instruction
5558     /* 14-17 instructions */
5559
5560
5561
5562 /* ------------------------------ */
5563     .balign 128
5564 .L_OP_OR_LONG: /* 0xa1 */
5565 /* File: mips/OP_OR_LONG.S */
5566 /* File: mips/binopWide.S */
5567     /*
5568      * Generic 64-bit binary operation.  Provide an "instr" line that
5569      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5570      * This could be a MIPS instruction or a function call.  (If the result
5571      * comes back in a register other than a0, you can override "result".)
5572      *
5573      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5574      * vCC (a1).  Useful for integer division and modulus.
5575      *
5576      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5577      *      xor-long
5578      *
5579      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5580      */
5581     /* binop vAA, vBB, vCC */
5582     FETCH(a0, 1)                           #  a0 <- CCBB
5583     GET_OPA(rOBJ)                          #  rOBJ <- AA
5584     and       a2, a0, 255                  #  a2 <- BB
5585     srl       a3, a0, 8                    #  a3 <- CC
5586     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5587     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5588     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5589     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5590     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5591     .if 0
5592     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5593     beqz      t0, common_errDivideByZero
5594     .endif
5595     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5596
5597     or a0, a0, a2                              #  optional op
5598     or a1, a1, a3                                 #  result <- op, a0-a3 changed
5599     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5600     STORE64(a0, a1, rOBJ)      #  vAA/vAA+1 <- a0/a1
5601     GOTO_OPCODE(t0)                        #  jump to next instruction
5602     /* 14-17 instructions */
5603
5604
5605
5606 /* ------------------------------ */
5607     .balign 128
5608 .L_OP_XOR_LONG: /* 0xa2 */
5609 /* File: mips/OP_XOR_LONG.S */
5610 /* File: mips/binopWide.S */
5611     /*
5612      * Generic 64-bit binary operation.  Provide an "instr" line that
5613      * specifies an instruction that performs "result = a0-a1 op a2-a3".
5614      * This could be a MIPS instruction or a function call.  (If the result
5615      * comes back in a register other than a0, you can override "result".)
5616      *
5617      * If "chkzero" is set to 1, we perform a divide-by-zero check on
5618      * vCC (a1).  Useful for integer division and modulus.
5619      *
5620      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
5621      *      xor-long
5622      *
5623      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
5624      */
5625     /* binop vAA, vBB, vCC */
5626     FETCH(a0, 1)                           #  a0 <- CCBB
5627     GET_OPA(rOBJ)                          #  rOBJ <- AA
5628     and       a2, a0, 255                  #  a2 <- BB
5629     srl       a3, a0, 8                    #  a3 <- CC
5630     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[AA]
5631     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
5632     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
5633     LOAD64(a0, a1, a2)               #  a0/a1 <- vBB/vBB+1
5634     LOAD64(a2, a3, t1)               #  a2/a3 <- vCC/vCC+1
5635     .if 0
5636     or        t0, a2, a3             #  second arg (a2-a3) is zero?
5637     beqz      t0, common_errDivideByZero
5638     .endif
5639     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5640
5641     xor a0, a0, a2                              #  optional op
5642     xor a1, a1, a3                                 #  result <- op, a0-a3 changed
5643     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5644     STORE64(a0, a1, rOBJ)      #  vAA/vAA+1 <- a0/a1
5645     GOTO_OPCODE(t0)                        #  jump to next instruction
5646     /* 14-17 instructions */
5647
5648
5649
5650 /* ------------------------------ */
5651     .balign 128
5652 .L_OP_SHL_LONG: /* 0xa3 */
5653 /* File: mips/OP_SHL_LONG.S */
5654     /*
5655      * Long integer shift.  This is different from the generic 32/64-bit
5656      * binary operations because vAA/vBB are 64-bit but vCC (the shift
5657      * distance) is 32-bit.  Also, Dalvik requires us to mask off the low
5658      * 6 bits of the shift distance.
5659      */
5660     /* shl-long vAA, vBB, vCC */
5661     FETCH(a0, 1)                           #  a0 <- CCBB
5662     GET_OPA(t2)                            #  t2 <- AA
5663     and       a3, a0, 255                  #  a3 <- BB
5664     srl       a0, a0, 8                    #  a0 <- CC
5665     EAS2(a3, rFP, a3)                      #  a3 <- &fp[BB]
5666     GET_VREG(a2, a0)                       #  a2 <- vCC
5667     LOAD64(a0, a1, a3)                     #  a0/a1 <- vBB/vBB+1
5668
5669     EAS2(t2, rFP, t2)                      #  t2 <- &fp[AA]
5670     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5671
5672     sll     v0, a0, a2                     #  rlo<- alo << (shift&31)
5673     not     v1, a2                         #  rhi<- 31-shift  (shift is 5b)
5674     srl     a0, 1
5675     srl     a0, v1                         #  alo<- alo >> (32-(shift&31))
5676     sll     v1, a1, a2                     #  rhi<- ahi << (shift&31)
5677     or      v1, a0                         #  rhi<- rhi | alo
5678     andi    a2, 0x20                       #  shift< shift & 0x20
5679     movn    v1, v0, a2                     #  rhi<- rlo (if shift&0x20)
5680     movn    v0, zero, a2                   #  rlo<- 0  (if shift&0x20)
5681
5682     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5683     STORE64(v0, v1, t2)                    #  vAA/vAA+1 <- a0/a1
5684     GOTO_OPCODE(t0)                        #  jump to next instruction
5685
5686
5687 /* ------------------------------ */
5688     .balign 128
5689 .L_OP_SHR_LONG: /* 0xa4 */
5690 /* File: mips/OP_SHR_LONG.S */
5691     /*
5692      * Long integer shift.  This is different from the generic 32/64-bit
5693      * binary operations because vAA/vBB are 64-bit but vCC (the shift
5694      * distance) is 32-bit.  Also, Dalvik requires us to mask off the low
5695      * 6 bits of the shift distance.
5696      */
5697     /* shr-long vAA, vBB, vCC */
5698     FETCH(a0, 1)                           #  a0 <- CCBB
5699     GET_OPA(t3)                            #  t3 <- AA
5700     and       a3, a0, 255                  #  a3 <- BB
5701     srl       a0, a0, 8                    #  a0 <- CC
5702     EAS2(a3, rFP, a3)                      #  a3 <- &fp[BB]
5703     GET_VREG(a2, a0)                       #  a2 <- vCC
5704     LOAD64(a0, a1, a3)                     #  a0/a1 <- vBB/vBB+1
5705     EAS2(t3, rFP, t3)                      #  t3 <- &fp[AA]
5706     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5707
5708     sra     v1, a1, a2                     #  rhi<- ahi >> (shift&31)
5709     srl     v0, a0, a2                     #  rlo<- alo >> (shift&31)
5710     sra     a3, a1, 31                     #  a3<- sign(ah)
5711     not     a0, a2                         #  alo<- 31-shift (shift is 5b)
5712     sll     a1, 1
5713     sll     a1, a0                         #  ahi<- ahi << (32-(shift&31))
5714     or      v0, a1                         #  rlo<- rlo | ahi
5715     andi    a2, 0x20                       #  shift & 0x20
5716     movn    v0, v1, a2                     #  rlo<- rhi (if shift&0x20)
5717     movn    v1, a3, a2                     #  rhi<- sign(ahi) (if shift&0x20)
5718
5719     STORE64(v0, v1, t3)                    #  vAA/VAA+1 <- v0/v0
5720     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5721     GOTO_OPCODE(t0)                        #  jump to next instruction
5722
5723
5724 /* ------------------------------ */
5725     .balign 128
5726 .L_OP_USHR_LONG: /* 0xa5 */
5727 /* File: mips/OP_USHR_LONG.S */
5728     /*
5729      * Long integer shift.  This is different from the generic 32/64-bit
5730      * binary operations because vAA/vBB are 64-bit but vCC (the shift
5731      * distance) is 32-bit.  Also, Dalvik requires us to mask off the low
5732      * 6 bits of the shift distance.
5733      */
5734     /* ushr-long vAA, vBB, vCC */
5735     FETCH(a0, 1)                           #  a0 <- CCBB
5736     GET_OPA(t0)                            #  t3 <- AA
5737     and       a3, a0, 255                  #  a3 <- BB
5738     srl       a0, a0, 8                    #  a0 <- CC
5739     EAS2(a3, rFP, a3)                      #  a3 <- &fp[BB]
5740     GET_VREG(a2, a0)                       #  a2 <- vCC
5741     LOAD64(a0, a1, a3)                     #  a0/a1 <- vBB/vBB+1
5742     EAS2(rOBJ, rFP, t0)                    #  rOBJ <- &fp[AA]
5743
5744     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5745     srl       v1, a1, a2                   #  rhi<- ahi >> (shift&31)
5746     srl       v0, a0, a2                   #  rlo<- alo >> (shift&31)
5747     not       a0, a2                       #  alo<- 31-n  (shift is 5b)
5748     sll       a1, 1
5749     sll       a1, a0                       #  ahi<- ahi << (32-(shift&31))
5750     or        v0, a1                       #  rlo<- rlo | ahi
5751     andi      a2, 0x20                     #  shift & 0x20
5752     movn      v0, v1, a2                   #  rlo<- rhi (if shift&0x20)
5753     movn      v1, zero, a2                 #  rhi<- 0 (if shift&0x20)
5754
5755     STORE64(v0, v1, rOBJ)                  #  vAA/vAA+1 <- v0/v1
5756     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5757     GOTO_OPCODE(t0)                        #  jump to next instruction
5758
5759
5760 /* ------------------------------ */
5761     .balign 128
5762 .L_OP_ADD_FLOAT: /* 0xa6 */
5763 /* File: mips/OP_ADD_FLOAT.S */
5764 /* File: mips/binflop.S */
5765     /*
5766      * Generic 32-bit binary float operation.
5767      *
5768      * For: add-fp, sub-fp, mul-fp, div-fp
5769      */
5770
5771     /* binop vAA, vBB, vCC */
5772     FETCH(a0, 1)                           #  a0 <- CCBB
5773     GET_OPA(rOBJ)                          #  s5 <- AA
5774     srl       a3, a0, 8                    #  a3 <- CC
5775     and       a2, a0, 255                  #  a2 <- BB
5776 #ifdef SOFT_FLOAT
5777     GET_VREG(a1, a3)                       #  a1 <- vCC
5778     GET_VREG(a0, a2)                       #  a0 <- vBB
5779     .if 0
5780     # is second operand zero?
5781     beqz      a1, common_errDivideByZero
5782     .endif
5783 #else
5784     GET_VREG_F(fa1, a3)                    #  a1 <- vCC
5785     GET_VREG_F(fa0, a2)                    #  a0 <- vBB
5786
5787     .if 0
5788     # is second operand zero?
5789     li.s      ft0, 0
5790     c.eq.s    fcc0, ft0, fa1               #  condition bit and comparision with 0
5791     bc1t      fcc0, common_errDivideByZero
5792     .endif
5793 #endif
5794
5795     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5796                                   #  optional op
5797 #ifdef SOFT_FLOAT
5798     JAL(__addsf3)                                 #  v0 = result
5799     SET_VREG(v0, rOBJ)                     #  vAA <- v0
5800 #else
5801     add.s fv0, fa0, fa1                               #  f0 = result
5802     SET_VREG_F(fv0, rOBJ)                  #  vAA <- fv0
5803 #endif
5804     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5805     GOTO_OPCODE(t0)                        #  jump to next instruction
5806     /* 11-14 instructions */
5807
5808
5809
5810 /* ------------------------------ */
5811     .balign 128
5812 .L_OP_SUB_FLOAT: /* 0xa7 */
5813 /* File: mips/OP_SUB_FLOAT.S */
5814 /* File: mips/binflop.S */
5815     /*
5816      * Generic 32-bit binary float operation.
5817      *
5818      * For: add-fp, sub-fp, mul-fp, div-fp
5819      */
5820
5821     /* binop vAA, vBB, vCC */
5822     FETCH(a0, 1)                           #  a0 <- CCBB
5823     GET_OPA(rOBJ)                          #  s5 <- AA
5824     srl       a3, a0, 8                    #  a3 <- CC
5825     and       a2, a0, 255                  #  a2 <- BB
5826 #ifdef SOFT_FLOAT
5827     GET_VREG(a1, a3)                       #  a1 <- vCC
5828     GET_VREG(a0, a2)                       #  a0 <- vBB
5829     .if 0
5830     # is second operand zero?
5831     beqz      a1, common_errDivideByZero
5832     .endif
5833 #else
5834     GET_VREG_F(fa1, a3)                    #  a1 <- vCC
5835     GET_VREG_F(fa0, a2)                    #  a0 <- vBB
5836
5837     .if 0
5838     # is second operand zero?
5839     li.s      ft0, 0
5840     c.eq.s    fcc0, ft0, fa1               #  condition bit and comparision with 0
5841     bc1t      fcc0, common_errDivideByZero
5842     .endif
5843 #endif
5844
5845     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5846                                   #  optional op
5847 #ifdef SOFT_FLOAT
5848     JAL(__subsf3)                                 #  v0 = result
5849     SET_VREG(v0, rOBJ)                     #  vAA <- v0
5850 #else
5851     sub.s fv0, fa0, fa1                               #  f0 = result
5852     SET_VREG_F(fv0, rOBJ)                  #  vAA <- fv0
5853 #endif
5854     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5855     GOTO_OPCODE(t0)                        #  jump to next instruction
5856     /* 11-14 instructions */
5857
5858
5859
5860 /* ------------------------------ */
5861     .balign 128
5862 .L_OP_MUL_FLOAT: /* 0xa8 */
5863 /* File: mips/OP_MUL_FLOAT.S */
5864 /* File: mips/binflop.S */
5865     /*
5866      * Generic 32-bit binary float operation.
5867      *
5868      * For: add-fp, sub-fp, mul-fp, div-fp
5869      */
5870
5871     /* binop vAA, vBB, vCC */
5872     FETCH(a0, 1)                           #  a0 <- CCBB
5873     GET_OPA(rOBJ)                          #  s5 <- AA
5874     srl       a3, a0, 8                    #  a3 <- CC
5875     and       a2, a0, 255                  #  a2 <- BB
5876 #ifdef SOFT_FLOAT
5877     GET_VREG(a1, a3)                       #  a1 <- vCC
5878     GET_VREG(a0, a2)                       #  a0 <- vBB
5879     .if 0
5880     # is second operand zero?
5881     beqz      a1, common_errDivideByZero
5882     .endif
5883 #else
5884     GET_VREG_F(fa1, a3)                    #  a1 <- vCC
5885     GET_VREG_F(fa0, a2)                    #  a0 <- vBB
5886
5887     .if 0
5888     # is second operand zero?
5889     li.s      ft0, 0
5890     c.eq.s    fcc0, ft0, fa1               #  condition bit and comparision with 0
5891     bc1t      fcc0, common_errDivideByZero
5892     .endif
5893 #endif
5894
5895     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5896                                   #  optional op
5897 #ifdef SOFT_FLOAT
5898     JAL(__mulsf3)                                 #  v0 = result
5899     SET_VREG(v0, rOBJ)                     #  vAA <- v0
5900 #else
5901     mul.s fv0, fa0, fa1                               #  f0 = result
5902     SET_VREG_F(fv0, rOBJ)                  #  vAA <- fv0
5903 #endif
5904     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5905     GOTO_OPCODE(t0)                        #  jump to next instruction
5906     /* 11-14 instructions */
5907
5908
5909
5910 /* ------------------------------ */
5911     .balign 128
5912 .L_OP_DIV_FLOAT: /* 0xa9 */
5913 /* File: mips/OP_DIV_FLOAT.S */
5914 /* File: mips/binflop.S */
5915     /*
5916      * Generic 32-bit binary float operation.
5917      *
5918      * For: add-fp, sub-fp, mul-fp, div-fp
5919      */
5920
5921     /* binop vAA, vBB, vCC */
5922     FETCH(a0, 1)                           #  a0 <- CCBB
5923     GET_OPA(rOBJ)                          #  s5 <- AA
5924     srl       a3, a0, 8                    #  a3 <- CC
5925     and       a2, a0, 255                  #  a2 <- BB
5926 #ifdef SOFT_FLOAT
5927     GET_VREG(a1, a3)                       #  a1 <- vCC
5928     GET_VREG(a0, a2)                       #  a0 <- vBB
5929     .if 0
5930     # is second operand zero?
5931     beqz      a1, common_errDivideByZero
5932     .endif
5933 #else
5934     GET_VREG_F(fa1, a3)                    #  a1 <- vCC
5935     GET_VREG_F(fa0, a2)                    #  a0 <- vBB
5936
5937     .if 0
5938     # is second operand zero?
5939     li.s      ft0, 0
5940     c.eq.s    fcc0, ft0, fa1               #  condition bit and comparision with 0
5941     bc1t      fcc0, common_errDivideByZero
5942     .endif
5943 #endif
5944
5945     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5946                                   #  optional op
5947 #ifdef SOFT_FLOAT
5948     JAL(__divsf3)                                 #  v0 = result
5949     SET_VREG(v0, rOBJ)                     #  vAA <- v0
5950 #else
5951     div.s fv0, fa0, fa1                               #  f0 = result
5952     SET_VREG_F(fv0, rOBJ)                  #  vAA <- fv0
5953 #endif
5954     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
5955     GOTO_OPCODE(t0)                        #  jump to next instruction
5956     /* 11-14 instructions */
5957
5958
5959
5960 /* ------------------------------ */
5961     .balign 128
5962 .L_OP_REM_FLOAT: /* 0xaa */
5963 /* File: mips/OP_REM_FLOAT.S */
5964 /* File: mips/binflop.S */
5965     /*
5966      * Generic 32-bit binary float operation.
5967      *
5968      * For: add-fp, sub-fp, mul-fp, div-fp
5969      */
5970
5971     /* binop vAA, vBB, vCC */
5972     FETCH(a0, 1)                           #  a0 <- CCBB
5973     GET_OPA(rOBJ)                          #  s5 <- AA
5974     srl       a3, a0, 8                    #  a3 <- CC
5975     and       a2, a0, 255                  #  a2 <- BB
5976 #ifdef SOFT_FLOAT
5977     GET_VREG(a1, a3)                       #  a1 <- vCC
5978     GET_VREG(a0, a2)                       #  a0 <- vBB
5979     .if 0
5980     # is second operand zero?
5981     beqz      a1, common_errDivideByZero
5982     .endif
5983 #else
5984     GET_VREG_F(fa1, a3)                    #  a1 <- vCC
5985     GET_VREG_F(fa0, a2)                    #  a0 <- vBB
5986
5987     .if 0
5988     # is second operand zero?
5989     li.s      ft0, 0
5990     c.eq.s    fcc0, ft0, fa1               #  condition bit and comparision with 0
5991     bc1t      fcc0, common_errDivideByZero
5992     .endif
5993 #endif
5994
5995     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
5996                                   #  optional op
5997 #ifdef SOFT_FLOAT
5998     JAL(fmodf)                                 #  v0 = result
5999     SET_VREG(v0, rOBJ)                     #  vAA <- v0
6000 #else
6001     JAL(fmodf)                               #  f0 = result
6002     SET_VREG_F(fv0, rOBJ)                  #  vAA <- fv0
6003 #endif
6004     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6005     GOTO_OPCODE(t0)                        #  jump to next instruction
6006     /* 11-14 instructions */
6007
6008
6009
6010 /* ------------------------------ */
6011     .balign 128
6012 .L_OP_ADD_DOUBLE: /* 0xab */
6013 /* File: mips/OP_ADD_DOUBLE.S */
6014 /* File: mips/binflopWide.S */
6015     /*
6016      * Generic 64-bit binary operation.  Provide an "instr" line that
6017      * specifies an instruction that performs "result = a0-a1 op a2-a3".
6018      * This could be an MIPS instruction or a function call.
6019      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6020      * vCC (a1).  Useful for integer division and modulus.
6021      *
6022      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
6023      *      xor-long, add-double, sub-double, mul-double, div-double,
6024      *      rem-double
6025      *
6026      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
6027      */
6028     /* binop vAA, vBB, vCC */
6029     FETCH(a0, 1)                           #  a0 <- CCBB
6030     GET_OPA(rOBJ)                          #  s5 <- AA
6031     and       a2, a0, 255                  #  a2 <- BB
6032     srl       a3, a0, 8                    #  a3 <- CC
6033     EAS2(rOBJ, rFP, rOBJ)                  #  s5 <- &fp[AA]
6034     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
6035     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
6036 #ifdef SOFT_FLOAT
6037     LOAD64(rARG0, rARG1, a2)               #  a0/a1 <- vBB/vBB+1
6038     LOAD64(rARG2, rARG3, t1)               #  a2/a3 <- vCC/vCC+1
6039     .if 0
6040     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
6041     beqz      t0, common_errDivideByZero
6042     .endif
6043 #else
6044     LOAD64_F(fa0, fa0f, a2)
6045     LOAD64_F(fa1, fa1f, t1)
6046     .if 0
6047     li.d      ft0, 0
6048     c.eq.d    fcc0, fa1, ft0
6049     bc1t      fcc0, common_errDivideByZero
6050     .endif
6051 #endif
6052 1:
6053     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
6054                                   #  optional op
6055 #ifdef SOFT_FLOAT
6056     JAL(__adddf3)                                 #  result <- op, a0-a3 changed
6057     STORE64(rRESULT0, rRESULT1, rOBJ)
6058 #else
6059     add.d fv0, fa0, fa1
6060     STORE64_F(fv0, fv0f, rOBJ)
6061 #endif
6062     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6063     GOTO_OPCODE(t0)                        #  jump to next instruction
6064     /* 14-17 instructions */
6065
6066
6067
6068 /* ------------------------------ */
6069     .balign 128
6070 .L_OP_SUB_DOUBLE: /* 0xac */
6071 /* File: mips/OP_SUB_DOUBLE.S */
6072 /* File: mips/binflopWide.S */
6073     /*
6074      * Generic 64-bit binary operation.  Provide an "instr" line that
6075      * specifies an instruction that performs "result = a0-a1 op a2-a3".
6076      * This could be an MIPS instruction or a function call.
6077      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6078      * vCC (a1).  Useful for integer division and modulus.
6079      *
6080      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
6081      *      xor-long, add-double, sub-double, mul-double, div-double,
6082      *      rem-double
6083      *
6084      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
6085      */
6086     /* binop vAA, vBB, vCC */
6087     FETCH(a0, 1)                           #  a0 <- CCBB
6088     GET_OPA(rOBJ)                          #  s5 <- AA
6089     and       a2, a0, 255                  #  a2 <- BB
6090     srl       a3, a0, 8                    #  a3 <- CC
6091     EAS2(rOBJ, rFP, rOBJ)                  #  s5 <- &fp[AA]
6092     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
6093     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
6094 #ifdef SOFT_FLOAT
6095     LOAD64(rARG0, rARG1, a2)               #  a0/a1 <- vBB/vBB+1
6096     LOAD64(rARG2, rARG3, t1)               #  a2/a3 <- vCC/vCC+1
6097     .if 0
6098     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
6099     beqz      t0, common_errDivideByZero
6100     .endif
6101 #else
6102     LOAD64_F(fa0, fa0f, a2)
6103     LOAD64_F(fa1, fa1f, t1)
6104     .if 0
6105     li.d      ft0, 0
6106     c.eq.d    fcc0, fa1, ft0
6107     bc1t      fcc0, common_errDivideByZero
6108     .endif
6109 #endif
6110 1:
6111     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
6112                                   #  optional op
6113 #ifdef SOFT_FLOAT
6114     JAL(__subdf3)                                 #  result <- op, a0-a3 changed
6115     STORE64(rRESULT0, rRESULT1, rOBJ)
6116 #else
6117     sub.d fv0, fa0, fa1
6118     STORE64_F(fv0, fv0f, rOBJ)
6119 #endif
6120     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6121     GOTO_OPCODE(t0)                        #  jump to next instruction
6122     /* 14-17 instructions */
6123
6124
6125
6126 /* ------------------------------ */
6127     .balign 128
6128 .L_OP_MUL_DOUBLE: /* 0xad */
6129 /* File: mips/OP_MUL_DOUBLE.S */
6130 /* File: mips/binflopWide.S */
6131     /*
6132      * Generic 64-bit binary operation.  Provide an "instr" line that
6133      * specifies an instruction that performs "result = a0-a1 op a2-a3".
6134      * This could be an MIPS instruction or a function call.
6135      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6136      * vCC (a1).  Useful for integer division and modulus.
6137      *
6138      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
6139      *      xor-long, add-double, sub-double, mul-double, div-double,
6140      *      rem-double
6141      *
6142      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
6143      */
6144     /* binop vAA, vBB, vCC */
6145     FETCH(a0, 1)                           #  a0 <- CCBB
6146     GET_OPA(rOBJ)                          #  s5 <- AA
6147     and       a2, a0, 255                  #  a2 <- BB
6148     srl       a3, a0, 8                    #  a3 <- CC
6149     EAS2(rOBJ, rFP, rOBJ)                  #  s5 <- &fp[AA]
6150     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
6151     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
6152 #ifdef SOFT_FLOAT
6153     LOAD64(rARG0, rARG1, a2)               #  a0/a1 <- vBB/vBB+1
6154     LOAD64(rARG2, rARG3, t1)               #  a2/a3 <- vCC/vCC+1
6155     .if 0
6156     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
6157     beqz      t0, common_errDivideByZero
6158     .endif
6159 #else
6160     LOAD64_F(fa0, fa0f, a2)
6161     LOAD64_F(fa1, fa1f, t1)
6162     .if 0
6163     li.d      ft0, 0
6164     c.eq.d    fcc0, fa1, ft0
6165     bc1t      fcc0, common_errDivideByZero
6166     .endif
6167 #endif
6168 1:
6169     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
6170                                   #  optional op
6171 #ifdef SOFT_FLOAT
6172     JAL(__muldf3)                                 #  result <- op, a0-a3 changed
6173     STORE64(rRESULT0, rRESULT1, rOBJ)
6174 #else
6175     mul.d fv0, fa0, fa1
6176     STORE64_F(fv0, fv0f, rOBJ)
6177 #endif
6178     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6179     GOTO_OPCODE(t0)                        #  jump to next instruction
6180     /* 14-17 instructions */
6181
6182
6183
6184 /* ------------------------------ */
6185     .balign 128
6186 .L_OP_DIV_DOUBLE: /* 0xae */
6187 /* File: mips/OP_DIV_DOUBLE.S */
6188 /* File: mips/binflopWide.S */
6189     /*
6190      * Generic 64-bit binary operation.  Provide an "instr" line that
6191      * specifies an instruction that performs "result = a0-a1 op a2-a3".
6192      * This could be an MIPS instruction or a function call.
6193      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6194      * vCC (a1).  Useful for integer division and modulus.
6195      *
6196      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
6197      *      xor-long, add-double, sub-double, mul-double, div-double,
6198      *      rem-double
6199      *
6200      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
6201      */
6202     /* binop vAA, vBB, vCC */
6203     FETCH(a0, 1)                           #  a0 <- CCBB
6204     GET_OPA(rOBJ)                          #  s5 <- AA
6205     and       a2, a0, 255                  #  a2 <- BB
6206     srl       a3, a0, 8                    #  a3 <- CC
6207     EAS2(rOBJ, rFP, rOBJ)                  #  s5 <- &fp[AA]
6208     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
6209     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
6210 #ifdef SOFT_FLOAT
6211     LOAD64(rARG0, rARG1, a2)               #  a0/a1 <- vBB/vBB+1
6212     LOAD64(rARG2, rARG3, t1)               #  a2/a3 <- vCC/vCC+1
6213     .if 0
6214     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
6215     beqz      t0, common_errDivideByZero
6216     .endif
6217 #else
6218     LOAD64_F(fa0, fa0f, a2)
6219     LOAD64_F(fa1, fa1f, t1)
6220     .if 0
6221     li.d      ft0, 0
6222     c.eq.d    fcc0, fa1, ft0
6223     bc1t      fcc0, common_errDivideByZero
6224     .endif
6225 #endif
6226 1:
6227     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
6228                                   #  optional op
6229 #ifdef SOFT_FLOAT
6230     JAL(__divdf3)                                 #  result <- op, a0-a3 changed
6231     STORE64(rRESULT0, rRESULT1, rOBJ)
6232 #else
6233     div.d fv0, fa0, fa1
6234     STORE64_F(fv0, fv0f, rOBJ)
6235 #endif
6236     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6237     GOTO_OPCODE(t0)                        #  jump to next instruction
6238     /* 14-17 instructions */
6239
6240
6241
6242 /* ------------------------------ */
6243     .balign 128
6244 .L_OP_REM_DOUBLE: /* 0xaf */
6245 /* File: mips/OP_REM_DOUBLE.S */
6246 /* File: mips/binflopWide.S */
6247     /*
6248      * Generic 64-bit binary operation.  Provide an "instr" line that
6249      * specifies an instruction that performs "result = a0-a1 op a2-a3".
6250      * This could be an MIPS instruction or a function call.
6251      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6252      * vCC (a1).  Useful for integer division and modulus.
6253      *
6254      * for: add-long, sub-long, div-long, rem-long, and-long, or-long,
6255      *      xor-long, add-double, sub-double, mul-double, div-double,
6256      *      rem-double
6257      *
6258      * IMPORTANT: you may specify "chkzero" or "preinstr" but not both.
6259      */
6260     /* binop vAA, vBB, vCC */
6261     FETCH(a0, 1)                           #  a0 <- CCBB
6262     GET_OPA(rOBJ)                          #  s5 <- AA
6263     and       a2, a0, 255                  #  a2 <- BB
6264     srl       a3, a0, 8                    #  a3 <- CC
6265     EAS2(rOBJ, rFP, rOBJ)                  #  s5 <- &fp[AA]
6266     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BB]
6267     EAS2(t1, rFP, a3)                      #  a3 <- &fp[CC]
6268 #ifdef SOFT_FLOAT
6269     LOAD64(rARG0, rARG1, a2)               #  a0/a1 <- vBB/vBB+1
6270     LOAD64(rARG2, rARG3, t1)               #  a2/a3 <- vCC/vCC+1
6271     .if 0
6272     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
6273     beqz      t0, common_errDivideByZero
6274     .endif
6275 #else
6276     LOAD64_F(fa0, fa0f, a2)
6277     LOAD64_F(fa1, fa1f, t1)
6278     .if 0
6279     li.d      ft0, 0
6280     c.eq.d    fcc0, fa1, ft0
6281     bc1t      fcc0, common_errDivideByZero
6282     .endif
6283 #endif
6284 1:
6285     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
6286                                   #  optional op
6287 #ifdef SOFT_FLOAT
6288     JAL(fmod)                                 #  result <- op, a0-a3 changed
6289     STORE64(rRESULT0, rRESULT1, rOBJ)
6290 #else
6291     JAL(fmod)
6292     STORE64_F(fv0, fv0f, rOBJ)
6293 #endif
6294     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6295     GOTO_OPCODE(t0)                        #  jump to next instruction
6296     /* 14-17 instructions */
6297
6298
6299
6300 /* ------------------------------ */
6301     .balign 128
6302 .L_OP_ADD_INT_2ADDR: /* 0xb0 */
6303 /* File: mips/OP_ADD_INT_2ADDR.S */
6304 /* File: mips/binop2addr.S */
6305     /*
6306      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6307      * that specifies an instruction that performs "result = a0 op a1".
6308      * This could be an MIPS instruction or a function call.
6309      *
6310      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6311      * vCC (a1).  Useful for integer division and modulus.
6312      *
6313      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6314      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6315      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6316      */
6317     /* binop/2addr vA, vB */
6318     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6319     GET_OPB(a3)                            #  a3 <- B
6320     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6321     GET_VREG(a1, a3)                       #  a1 <- vB
6322     .if 0
6323     # is second operand zero?
6324     beqz      a1, common_errDivideByZero
6325     .endif
6326     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6327
6328                                   #  optional op
6329     addu a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6330     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6331     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6332     /* 10-13 instructions */
6333
6334
6335
6336 /* ------------------------------ */
6337     .balign 128
6338 .L_OP_SUB_INT_2ADDR: /* 0xb1 */
6339 /* File: mips/OP_SUB_INT_2ADDR.S */
6340 /* File: mips/binop2addr.S */
6341     /*
6342      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6343      * that specifies an instruction that performs "result = a0 op a1".
6344      * This could be an MIPS instruction or a function call.
6345      *
6346      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6347      * vCC (a1).  Useful for integer division and modulus.
6348      *
6349      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6350      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6351      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6352      */
6353     /* binop/2addr vA, vB */
6354     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6355     GET_OPB(a3)                            #  a3 <- B
6356     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6357     GET_VREG(a1, a3)                       #  a1 <- vB
6358     .if 0
6359     # is second operand zero?
6360     beqz      a1, common_errDivideByZero
6361     .endif
6362     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6363
6364                                   #  optional op
6365     subu a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6366     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6367     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6368     /* 10-13 instructions */
6369
6370
6371
6372 /* ------------------------------ */
6373     .balign 128
6374 .L_OP_MUL_INT_2ADDR: /* 0xb2 */
6375 /* File: mips/OP_MUL_INT_2ADDR.S */
6376 /* File: mips/binop2addr.S */
6377     /*
6378      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6379      * that specifies an instruction that performs "result = a0 op a1".
6380      * This could be an MIPS instruction or a function call.
6381      *
6382      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6383      * vCC (a1).  Useful for integer division and modulus.
6384      *
6385      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6386      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6387      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6388      */
6389     /* binop/2addr vA, vB */
6390     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6391     GET_OPB(a3)                            #  a3 <- B
6392     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6393     GET_VREG(a1, a3)                       #  a1 <- vB
6394     .if 0
6395     # is second operand zero?
6396     beqz      a1, common_errDivideByZero
6397     .endif
6398     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6399
6400                                   #  optional op
6401     mul a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6402     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6403     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6404     /* 10-13 instructions */
6405
6406
6407
6408 /* ------------------------------ */
6409     .balign 128
6410 .L_OP_DIV_INT_2ADDR: /* 0xb3 */
6411 /* File: mips/OP_DIV_INT_2ADDR.S */
6412 /* File: mips/binop2addr.S */
6413     /*
6414      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6415      * that specifies an instruction that performs "result = a0 op a1".
6416      * This could be an MIPS instruction or a function call.
6417      *
6418      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6419      * vCC (a1).  Useful for integer division and modulus.
6420      *
6421      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6422      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6423      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6424      */
6425     /* binop/2addr vA, vB */
6426     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6427     GET_OPB(a3)                            #  a3 <- B
6428     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6429     GET_VREG(a1, a3)                       #  a1 <- vB
6430     .if 1
6431     # is second operand zero?
6432     beqz      a1, common_errDivideByZero
6433     .endif
6434     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6435
6436                                   #  optional op
6437     div zero, a0, a1; mflo a0                                 #  a0 <- op, a0-a3 changed
6438     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6439     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6440     /* 10-13 instructions */
6441
6442
6443
6444 /* ------------------------------ */
6445     .balign 128
6446 .L_OP_REM_INT_2ADDR: /* 0xb4 */
6447 /* File: mips/OP_REM_INT_2ADDR.S */
6448 /* File: mips/binop2addr.S */
6449     /*
6450      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6451      * that specifies an instruction that performs "result = a0 op a1".
6452      * This could be an MIPS instruction or a function call.
6453      *
6454      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6455      * vCC (a1).  Useful for integer division and modulus.
6456      *
6457      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6458      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6459      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6460      */
6461     /* binop/2addr vA, vB */
6462     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6463     GET_OPB(a3)                            #  a3 <- B
6464     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6465     GET_VREG(a1, a3)                       #  a1 <- vB
6466     .if 1
6467     # is second operand zero?
6468     beqz      a1, common_errDivideByZero
6469     .endif
6470     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6471
6472                                   #  optional op
6473     div zero, a0, a1; mfhi a0                                 #  a0 <- op, a0-a3 changed
6474     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6475     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6476     /* 10-13 instructions */
6477
6478
6479
6480 /* ------------------------------ */
6481     .balign 128
6482 .L_OP_AND_INT_2ADDR: /* 0xb5 */
6483 /* File: mips/OP_AND_INT_2ADDR.S */
6484 /* File: mips/binop2addr.S */
6485     /*
6486      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6487      * that specifies an instruction that performs "result = a0 op a1".
6488      * This could be an MIPS instruction or a function call.
6489      *
6490      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6491      * vCC (a1).  Useful for integer division and modulus.
6492      *
6493      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6494      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6495      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6496      */
6497     /* binop/2addr vA, vB */
6498     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6499     GET_OPB(a3)                            #  a3 <- B
6500     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6501     GET_VREG(a1, a3)                       #  a1 <- vB
6502     .if 0
6503     # is second operand zero?
6504     beqz      a1, common_errDivideByZero
6505     .endif
6506     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6507
6508                                   #  optional op
6509     and a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6510     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6511     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6512     /* 10-13 instructions */
6513
6514
6515
6516 /* ------------------------------ */
6517     .balign 128
6518 .L_OP_OR_INT_2ADDR: /* 0xb6 */
6519 /* File: mips/OP_OR_INT_2ADDR.S */
6520 /* File: mips/binop2addr.S */
6521     /*
6522      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6523      * that specifies an instruction that performs "result = a0 op a1".
6524      * This could be an MIPS instruction or a function call.
6525      *
6526      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6527      * vCC (a1).  Useful for integer division and modulus.
6528      *
6529      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6530      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6531      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6532      */
6533     /* binop/2addr vA, vB */
6534     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6535     GET_OPB(a3)                            #  a3 <- B
6536     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6537     GET_VREG(a1, a3)                       #  a1 <- vB
6538     .if 0
6539     # is second operand zero?
6540     beqz      a1, common_errDivideByZero
6541     .endif
6542     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6543
6544                                   #  optional op
6545     or a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6546     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6547     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6548     /* 10-13 instructions */
6549
6550
6551
6552 /* ------------------------------ */
6553     .balign 128
6554 .L_OP_XOR_INT_2ADDR: /* 0xb7 */
6555 /* File: mips/OP_XOR_INT_2ADDR.S */
6556 /* File: mips/binop2addr.S */
6557     /*
6558      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6559      * that specifies an instruction that performs "result = a0 op a1".
6560      * This could be an MIPS instruction or a function call.
6561      *
6562      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6563      * vCC (a1).  Useful for integer division and modulus.
6564      *
6565      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6566      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6567      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6568      */
6569     /* binop/2addr vA, vB */
6570     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6571     GET_OPB(a3)                            #  a3 <- B
6572     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6573     GET_VREG(a1, a3)                       #  a1 <- vB
6574     .if 0
6575     # is second operand zero?
6576     beqz      a1, common_errDivideByZero
6577     .endif
6578     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6579
6580                                   #  optional op
6581     xor a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6582     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6583     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6584     /* 10-13 instructions */
6585
6586
6587
6588 /* ------------------------------ */
6589     .balign 128
6590 .L_OP_SHL_INT_2ADDR: /* 0xb8 */
6591 /* File: mips/OP_SHL_INT_2ADDR.S */
6592 /* File: mips/binop2addr.S */
6593     /*
6594      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6595      * that specifies an instruction that performs "result = a0 op a1".
6596      * This could be an MIPS instruction or a function call.
6597      *
6598      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6599      * vCC (a1).  Useful for integer division and modulus.
6600      *
6601      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6602      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6603      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6604      */
6605     /* binop/2addr vA, vB */
6606     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6607     GET_OPB(a3)                            #  a3 <- B
6608     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6609     GET_VREG(a1, a3)                       #  a1 <- vB
6610     .if 0
6611     # is second operand zero?
6612     beqz      a1, common_errDivideByZero
6613     .endif
6614     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6615
6616     and a1, a1, 31                              #  optional op
6617     sll a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6618     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6619     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6620     /* 10-13 instructions */
6621
6622
6623
6624 /* ------------------------------ */
6625     .balign 128
6626 .L_OP_SHR_INT_2ADDR: /* 0xb9 */
6627 /* File: mips/OP_SHR_INT_2ADDR.S */
6628 /* File: mips/binop2addr.S */
6629     /*
6630      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6631      * that specifies an instruction that performs "result = a0 op a1".
6632      * This could be an MIPS instruction or a function call.
6633      *
6634      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6635      * vCC (a1).  Useful for integer division and modulus.
6636      *
6637      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6638      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6639      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6640      */
6641     /* binop/2addr vA, vB */
6642     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6643     GET_OPB(a3)                            #  a3 <- B
6644     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6645     GET_VREG(a1, a3)                       #  a1 <- vB
6646     .if 0
6647     # is second operand zero?
6648     beqz      a1, common_errDivideByZero
6649     .endif
6650     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6651
6652     and a1, a1, 31                              #  optional op
6653     sra a0, a0, a1                                 #  a0 <- op, a0-a3 changed
6654     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6655     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6656     /* 10-13 instructions */
6657
6658
6659
6660 /* ------------------------------ */
6661     .balign 128
6662 .L_OP_USHR_INT_2ADDR: /* 0xba */
6663 /* File: mips/OP_USHR_INT_2ADDR.S */
6664 /* File: mips/binop2addr.S */
6665     /*
6666      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" line
6667      * that specifies an instruction that performs "result = a0 op a1".
6668      * This could be an MIPS instruction or a function call.
6669      *
6670      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6671      * vCC (a1).  Useful for integer division and modulus.
6672      *
6673      * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6674      *      rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6675      *      shl-int/2addr, shr-int/2addr, ushr-int/2addr
6676      */
6677     /* binop/2addr vA, vB */
6678     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6679     GET_OPB(a3)                            #  a3 <- B
6680     GET_VREG(a0, rOBJ)                     #  a0 <- vA
6681     GET_VREG(a1, a3)                       #  a1 <- vB
6682     .if 0
6683     # is second operand zero?
6684     beqz      a1, common_errDivideByZero
6685     .endif
6686     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6687
6688     and a1, a1, 31                              #  optional op
6689     srl a0, a0, a1                                  #  a0 <- op, a0-a3 changed
6690     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6691     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
6692     /* 10-13 instructions */
6693
6694
6695
6696 /* ------------------------------ */
6697     .balign 128
6698 .L_OP_ADD_LONG_2ADDR: /* 0xbb */
6699 /* File: mips/OP_ADD_LONG_2ADDR.S */
6700 /*
6701  *See OP_ADD_LONG.S for details
6702  */
6703 /* File: mips/binopWide2addr.S */
6704     /*
6705      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6706      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6707      * This could be a MIPS instruction or a function call.  (If the result
6708      * comes back in a register other than a0, you can override "result".)
6709      *
6710      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6711      * vCC (a1).  Useful for integer division and modulus.
6712      *
6713      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6714      *      and-long/2addr, or-long/2addr, xor-long/2addr
6715      *      rem-double/2addr
6716      */
6717     /* binop/2addr vA, vB */
6718     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6719     GET_OPB(a1)                            #  a1 <- B
6720     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6721     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6722     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
6723     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
6724     .if 0
6725     or        t0, a2, a3             #  second arg (a2-a3) is zero?
6726     beqz      t0, common_errDivideByZero
6727     .endif
6728     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6729
6730     addu v0, a2, a0                              #  optional op
6731     addu a1, a3, a1; sltu v1, v0, a2; addu v1, v1, a1                                 #  result <- op, a0-a3 changed
6732     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6733     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
6734     GOTO_OPCODE(t0)                        #  jump to next instruction
6735     /* 12-15 instructions */
6736
6737
6738
6739 /* ------------------------------ */
6740     .balign 128
6741 .L_OP_SUB_LONG_2ADDR: /* 0xbc */
6742 /* File: mips/OP_SUB_LONG_2ADDR.S */
6743 /*
6744  * See comments in OP_SUB_LONG.S
6745  */
6746 /* File: mips/binopWide2addr.S */
6747     /*
6748      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6749      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6750      * This could be a MIPS instruction or a function call.  (If the result
6751      * comes back in a register other than a0, you can override "result".)
6752      *
6753      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6754      * vCC (a1).  Useful for integer division and modulus.
6755      *
6756      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6757      *      and-long/2addr, or-long/2addr, xor-long/2addr
6758      *      rem-double/2addr
6759      */
6760     /* binop/2addr vA, vB */
6761     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6762     GET_OPB(a1)                            #  a1 <- B
6763     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6764     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6765     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
6766     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
6767     .if 0
6768     or        t0, a2, a3             #  second arg (a2-a3) is zero?
6769     beqz      t0, common_errDivideByZero
6770     .endif
6771     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6772
6773     subu v0, a0, a2                              #  optional op
6774     subu v1, a1, a3; sltu a0, a0, v0; subu v1, v1, a0                                 #  result <- op, a0-a3 changed
6775     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6776     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
6777     GOTO_OPCODE(t0)                        #  jump to next instruction
6778     /* 12-15 instructions */
6779
6780
6781
6782 /* ------------------------------ */
6783     .balign 128
6784 .L_OP_MUL_LONG_2ADDR: /* 0xbd */
6785 /* File: mips/OP_MUL_LONG_2ADDR.S */
6786     /*
6787      * See comments in OP_MUL_LONG.S
6788      */
6789     /* mul-long/2addr vA, vB */
6790     GET_OPA4(t0)                           #  t0 <- A+
6791
6792     EAS2(t0, rFP, t0)                      #  t0 <- &fp[A]
6793     LOAD64(a0, a1, t0)                     #  vAA.low / high
6794
6795     GET_OPB(t1)                            #  t1 <- B
6796     EAS2(t1, rFP, t1)                      #  t1 <- &fp[B]
6797     LOAD64(a2, a3, t1)                     #  vBB.low / high
6798
6799     mul       v1, a3, a0                   #  v1= a3a0
6800     multu     a2, a0
6801     mfhi      t1
6802     mflo      v0                           #  v0= a2a0
6803     mul       t2, a2, a1                   #  t2= a2a1
6804     addu      v1, v1, t1                   #  v1= a3a0 + hi(a2a0)
6805     addu      v1, v1, t2                   #  v1= v1 + a2a1;
6806
6807     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6808     GET_INST_OPCODE(t1)                    #  extract opcode from rINST
6809     # vAA <- v0 (low)
6810     STORE64(v0, v1, t0)                    #  vAA+1 <- v1 (high)
6811     GOTO_OPCODE(t1)                        #  jump to next instruction
6812
6813
6814 /* ------------------------------ */
6815     .balign 128
6816 .L_OP_DIV_LONG_2ADDR: /* 0xbe */
6817 /* File: mips/OP_DIV_LONG_2ADDR.S */
6818 #ifdef HAVE_LITTLE_ENDIAN
6819 /* File: mips/binopWide2addr.S */
6820     /*
6821      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6822      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6823      * This could be a MIPS instruction or a function call.  (If the result
6824      * comes back in a register other than a0, you can override "result".)
6825      *
6826      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6827      * vCC (a1).  Useful for integer division and modulus.
6828      *
6829      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6830      *      and-long/2addr, or-long/2addr, xor-long/2addr
6831      *      rem-double/2addr
6832      */
6833     /* binop/2addr vA, vB */
6834     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6835     GET_OPB(a1)                            #  a1 <- B
6836     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6837     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6838     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
6839     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
6840     .if 1
6841     or        t0, a2, a3             #  second arg (a2-a3) is zero?
6842     beqz      t0, common_errDivideByZero
6843     .endif
6844     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6845
6846                                   #  optional op
6847     JAL(__divdi3)                                 #  result <- op, a0-a3 changed
6848     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6849     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
6850     GOTO_OPCODE(t0)                        #  jump to next instruction
6851     /* 12-15 instructions */
6852
6853
6854 #else
6855 /* File: mips/binopWide2addr.S */
6856     /*
6857      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6858      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6859      * This could be a MIPS instruction or a function call.  (If the result
6860      * comes back in a register other than a0, you can override "result".)
6861      *
6862      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6863      * vCC (a1).  Useful for integer division and modulus.
6864      *
6865      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6866      *      and-long/2addr, or-long/2addr, xor-long/2addr
6867      *      rem-double/2addr
6868      */
6869     /* binop/2addr vA, vB */
6870     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6871     GET_OPB(a1)                            #  a1 <- B
6872     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6873     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6874     LOAD64(a3, a2, a1)               #  a2/a3 <- vBB/vBB+1
6875     LOAD64(a1, a0, rOBJ)             #  a0/a1 <- vAA/vAA+1
6876     .if 1
6877     or        t0, a3, a2             #  second arg (a2-a3) is zero?
6878     beqz      t0, common_errDivideByZero
6879     .endif
6880     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6881
6882                                   #  optional op
6883     JAL(__divdi3)                                 #  result <- op, a0-a3 changed
6884     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6885     STORE64(v1, v0, rOBJ)      #  vAA/vAA+1 <- v1/v0
6886     GOTO_OPCODE(t0)                        #  jump to next instruction
6887     /* 12-15 instructions */
6888
6889
6890 #endif
6891
6892 /* ------------------------------ */
6893     .balign 128
6894 .L_OP_REM_LONG_2ADDR: /* 0xbf */
6895 /* File: mips/OP_REM_LONG_2ADDR.S */
6896 #ifdef HAVE_LITTLE_ENDIAN
6897 /* File: mips/binopWide2addr.S */
6898     /*
6899      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6900      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6901      * This could be a MIPS instruction or a function call.  (If the result
6902      * comes back in a register other than a0, you can override "result".)
6903      *
6904      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6905      * vCC (a1).  Useful for integer division and modulus.
6906      *
6907      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6908      *      and-long/2addr, or-long/2addr, xor-long/2addr
6909      *      rem-double/2addr
6910      */
6911     /* binop/2addr vA, vB */
6912     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6913     GET_OPB(a1)                            #  a1 <- B
6914     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6915     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6916     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
6917     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
6918     .if 1
6919     or        t0, a2, a3             #  second arg (a2-a3) is zero?
6920     beqz      t0, common_errDivideByZero
6921     .endif
6922     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6923
6924                                   #  optional op
6925     JAL(__moddi3)                                 #  result <- op, a0-a3 changed
6926     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6927     STORE64(v0, v1, rOBJ)      #  vAA/vAA+1 <- v0/v1
6928     GOTO_OPCODE(t0)                        #  jump to next instruction
6929     /* 12-15 instructions */
6930
6931
6932 #else
6933 /* File: mips/binopWide2addr.S */
6934     /*
6935      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6936      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6937      * This could be a MIPS instruction or a function call.  (If the result
6938      * comes back in a register other than a0, you can override "result".)
6939      *
6940      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6941      * vCC (a1).  Useful for integer division and modulus.
6942      *
6943      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6944      *      and-long/2addr, or-long/2addr, xor-long/2addr
6945      *      rem-double/2addr
6946      */
6947     /* binop/2addr vA, vB */
6948     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6949     GET_OPB(a1)                            #  a1 <- B
6950     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6951     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6952     LOAD64(a3, a2, a1)               #  a2/a3 <- vBB/vBB+1
6953     LOAD64(a1, a0, rOBJ)             #  a0/a1 <- vAA/vAA+1
6954     .if 1
6955     or        t0, a3, a2             #  second arg (a2-a3) is zero?
6956     beqz      t0, common_errDivideByZero
6957     .endif
6958     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
6959
6960                                   #  optional op
6961     JAL(__moddi3)                                 #  result <- op, a0-a3 changed
6962     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
6963     STORE64(v1, v0, rOBJ)      #  vAA/vAA+1 <- v1/v0
6964     GOTO_OPCODE(t0)                        #  jump to next instruction
6965     /* 12-15 instructions */
6966
6967
6968 #endif
6969
6970 /* ------------------------------ */
6971     .balign 128
6972 .L_OP_AND_LONG_2ADDR: /* 0xc0 */
6973 /* File: mips/OP_AND_LONG_2ADDR.S */
6974 /* File: mips/binopWide2addr.S */
6975     /*
6976      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
6977      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
6978      * This could be a MIPS instruction or a function call.  (If the result
6979      * comes back in a register other than a0, you can override "result".)
6980      *
6981      * If "chkzero" is set to 1, we perform a divide-by-zero check on
6982      * vCC (a1).  Useful for integer division and modulus.
6983      *
6984      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
6985      *      and-long/2addr, or-long/2addr, xor-long/2addr
6986      *      rem-double/2addr
6987      */
6988     /* binop/2addr vA, vB */
6989     GET_OPA4(rOBJ)                         #  rOBJ <- A+
6990     GET_OPB(a1)                            #  a1 <- B
6991     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
6992     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
6993     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
6994     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
6995     .if 0
6996     or        t0, a2, a3             #  second arg (a2-a3) is zero?
6997     beqz      t0, common_errDivideByZero
6998     .endif
6999     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7000
7001     and a0, a0, a2                              #  optional op
7002     and a1, a1, a3                                 #  result <- op, a0-a3 changed
7003     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7004     STORE64(a0, a1, rOBJ)      #  vAA/vAA+1 <- a0/a1
7005     GOTO_OPCODE(t0)                        #  jump to next instruction
7006     /* 12-15 instructions */
7007
7008
7009
7010 /* ------------------------------ */
7011     .balign 128
7012 .L_OP_OR_LONG_2ADDR: /* 0xc1 */
7013 /* File: mips/OP_OR_LONG_2ADDR.S */
7014 /* File: mips/binopWide2addr.S */
7015     /*
7016      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7017      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7018      * This could be a MIPS instruction or a function call.  (If the result
7019      * comes back in a register other than a0, you can override "result".)
7020      *
7021      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7022      * vCC (a1).  Useful for integer division and modulus.
7023      *
7024      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
7025      *      and-long/2addr, or-long/2addr, xor-long/2addr
7026      *      rem-double/2addr
7027      */
7028     /* binop/2addr vA, vB */
7029     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7030     GET_OPB(a1)                            #  a1 <- B
7031     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7032     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7033     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
7034     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7035     .if 0
7036     or        t0, a2, a3             #  second arg (a2-a3) is zero?
7037     beqz      t0, common_errDivideByZero
7038     .endif
7039     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7040
7041     or a0, a0, a2                              #  optional op
7042     or a1, a1, a3                                 #  result <- op, a0-a3 changed
7043     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7044     STORE64(a0, a1, rOBJ)      #  vAA/vAA+1 <- a0/a1
7045     GOTO_OPCODE(t0)                        #  jump to next instruction
7046     /* 12-15 instructions */
7047
7048
7049
7050 /* ------------------------------ */
7051     .balign 128
7052 .L_OP_XOR_LONG_2ADDR: /* 0xc2 */
7053 /* File: mips/OP_XOR_LONG_2ADDR.S */
7054 /* File: mips/binopWide2addr.S */
7055     /*
7056      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7057      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7058      * This could be a MIPS instruction or a function call.  (If the result
7059      * comes back in a register other than a0, you can override "result".)
7060      *
7061      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7062      * vCC (a1).  Useful for integer division and modulus.
7063      *
7064      * For: add-long/2addr, sub-long/2addr, div-long/2addr, rem-long/2addr,
7065      *      and-long/2addr, or-long/2addr, xor-long/2addr
7066      *      rem-double/2addr
7067      */
7068     /* binop/2addr vA, vB */
7069     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7070     GET_OPB(a1)                            #  a1 <- B
7071     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7072     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7073     LOAD64(a2, a3, a1)               #  a2/a3 <- vBB/vBB+1
7074     LOAD64(a0, a1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7075     .if 0
7076     or        t0, a2, a3             #  second arg (a2-a3) is zero?
7077     beqz      t0, common_errDivideByZero
7078     .endif
7079     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7080
7081     xor a0, a0, a2                              #  optional op
7082     xor a1, a1, a3                                 #  result <- op, a0-a3 changed
7083     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7084     STORE64(a0, a1, rOBJ)      #  vAA/vAA+1 <- a0/a1
7085     GOTO_OPCODE(t0)                        #  jump to next instruction
7086     /* 12-15 instructions */
7087
7088
7089
7090 /* ------------------------------ */
7091     .balign 128
7092 .L_OP_SHL_LONG_2ADDR: /* 0xc3 */
7093 /* File: mips/OP_SHL_LONG_2ADDR.S */
7094     /*
7095      * Long integer shift, 2addr version.  vA is 64-bit value/result, vB is
7096      * 32-bit shift distance.
7097      */
7098     /* shl-long/2addr vA, vB */
7099     GET_OPA4(t2)                           #  t2 <- A+
7100     GET_OPB(a3)                            #  a3 <- B
7101     GET_VREG(a2, a3)                       #  a2 <- vB
7102     EAS2(rOBJ, rFP, t2)                    #  rOBJ <- &fp[A]
7103     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vAA/vAA+1
7104
7105     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7106
7107     sll     v0, a0, a2                     #  rlo<- alo << (shift&31)
7108     not     v1, a2                         #  rhi<- 31-shift  (shift is 5b)
7109     srl     a0, 1
7110     srl     a0, v1                         #  alo<- alo >> (32-(shift&31))
7111     sll     v1, a1, a2                     #  rhi<- ahi << (shift&31)
7112     or      v1, a0                         #  rhi<- rhi | alo
7113     andi    a2, 0x20                       #  shift< shift & 0x20
7114     movn    v1, v0, a2                     #  rhi<- rlo (if shift&0x20)
7115     movn    v0, zero, a2                   #  rlo<- 0  (if shift&0x20)
7116
7117     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7118     STORE64(v0, v1, rOBJ)                  #  vAA/vAA+1 <- a0/a1
7119     GOTO_OPCODE(t0)                        #  jump to next instruction
7120
7121
7122 /* ------------------------------ */
7123     .balign 128
7124 .L_OP_SHR_LONG_2ADDR: /* 0xc4 */
7125 /* File: mips/OP_SHR_LONG_2ADDR.S */
7126     /*
7127      * Long integer shift, 2addr version.  vA is 64-bit value/result, vB is
7128      * 32-bit shift distance.
7129      */
7130     /* shr-long/2addr vA, vB */
7131     GET_OPA4(t2)                           #  t2 <- A+
7132     GET_OPB(a3)                            #  a3 <- B
7133     GET_VREG(a2, a3)                       #  a2 <- vB
7134     EAS2(t2, rFP, t2)                      #  t2 <- &fp[A]
7135     LOAD64(a0, a1, t2)                     #  a0/a1 <- vAA/vAA+1
7136     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7137
7138     sra     v1, a1, a2                     #  rhi<- ahi >> (shift&31)
7139     srl     v0, a0, a2                     #  rlo<- alo >> (shift&31)
7140     sra     a3, a1, 31                     #  a3<- sign(ah)
7141     not     a0, a2                         #  alo<- 31-shift (shift is 5b)
7142     sll     a1, 1
7143     sll     a1, a0                         #  ahi<- ahi << (32-(shift&31))
7144     or      v0, a1                         #  rlo<- rlo | ahi
7145     andi    a2, 0x20                       #  shift & 0x20
7146     movn    v0, v1, a2                     #  rlo<- rhi (if shift&0x20)
7147     movn    v1, a3, a2                     #  rhi<- sign(ahi) (if shift&0x20)
7148
7149     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7150     STORE64(v0, v1, t2)                    #  vAA/vAA+1 <- a0/a1
7151     GOTO_OPCODE(t0)                        #  jump to next instruction
7152
7153
7154 /* ------------------------------ */
7155     .balign 128
7156 .L_OP_USHR_LONG_2ADDR: /* 0xc5 */
7157 /* File: mips/OP_USHR_LONG_2ADDR.S */
7158     /*
7159      * Long integer shift, 2addr version.  vA is 64-bit value/result, vB is
7160      * 32-bit shift distance.
7161      */
7162     /* ushr-long/2addr vA, vB */
7163     GET_OPA4(t3)                           #  t3 <- A+
7164     GET_OPB(a3)                            #  a3 <- B
7165     GET_VREG(a2, a3)                       #  a2 <- vB
7166     EAS2(t3, rFP, t3)                      #  t3 <- &fp[A]
7167     LOAD64(a0, a1, t3)                     #  a0/a1 <- vAA/vAA+1
7168
7169     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7170     srl       v1, a1, a2                   #  rhi<- ahi >> (shift&31)
7171     srl       v0, a0, a2                   #  rlo<- alo >> (shift&31)
7172     not       a0, a2                       #  alo<- 31-n  (shift is 5b)
7173     sll       a1, 1
7174     sll       a1, a0                       #  ahi<- ahi << (32-(shift&31))
7175     or        v0, a1                       #  rlo<- rlo | ahi
7176     andi      a2, 0x20                     #  shift & 0x20
7177     movn      v0, v1, a2                   #  rlo<- rhi (if shift&0x20)
7178     movn      v1, zero, a2                 #  rhi<- 0 (if shift&0x20)
7179
7180     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7181     STORE64(v0, v1, t3)                    #  vAA/vAA+1 <- a0/a1
7182     GOTO_OPCODE(t0)                        #  jump to next instruction
7183
7184
7185 /* ------------------------------ */
7186     .balign 128
7187 .L_OP_ADD_FLOAT_2ADDR: /* 0xc6 */
7188 /* File: mips/OP_ADD_FLOAT_2ADDR.S */
7189 /* File: mips/binflop2addr.S */
7190     /*
7191      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" and
7192      * "instr_f" line
7193      * that specifies an instruction that performs "result = a0 op a1".
7194      * This could be an MIPS instruction or a function call.
7195      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7196      * vCC (a1).  Useful for integer division and modulus.
7197      *
7198      * For: add-float/2addr, sub-float/2addr, mul-float/2addr,
7199      * div-float/2addr, rem-float/2addr
7200      */
7201     /* binop/2addr vA, vB */
7202     GET_OPA4(rOBJ)                         #  t1 <- A+
7203     GET_OPB(a3)                            #  a3 <- B
7204 #ifdef SOFT_FLOAT
7205     GET_VREG(a0, rOBJ)                     #  a0 <- vA
7206     GET_VREG(a1, a3)                       #  a1 <- vB
7207     .if 0
7208     # is second operand zero?
7209     beqz      a1, common_errDivideByZero
7210     .endif
7211 #else
7212     GET_VREG_F(fa0, rOBJ)
7213     GET_VREG_F(fa1, a3)
7214     .if 0
7215     # is second operand zero?
7216     li.s      ft0, 0
7217     c.eq.s    fcc0, ft0, fa1
7218     bc1t      fcc0, common_errDivideByZero
7219     .endif
7220 #endif
7221     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7222                                   #  optional op
7223 #ifdef SOFT_FLOAT
7224     JAL(__addsf3)                                 #  result <- op, a0-a3 changed
7225     SET_VREG(v0, rOBJ)                     #  vAA <- result
7226 #else
7227     add.s fv0, fa0, fa1
7228     SET_VREG_F(fv0, rOBJ)                  #  vAA <- result
7229 #endif
7230     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7231     GOTO_OPCODE(t0)                        #  jump to next instruction
7232     /* 10-13 instructions */
7233
7234
7235
7236 /* ------------------------------ */
7237     .balign 128
7238 .L_OP_SUB_FLOAT_2ADDR: /* 0xc7 */
7239 /* File: mips/OP_SUB_FLOAT_2ADDR.S */
7240 /* File: mips/binflop2addr.S */
7241     /*
7242      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" and
7243      * "instr_f" line
7244      * that specifies an instruction that performs "result = a0 op a1".
7245      * This could be an MIPS instruction or a function call.
7246      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7247      * vCC (a1).  Useful for integer division and modulus.
7248      *
7249      * For: add-float/2addr, sub-float/2addr, mul-float/2addr,
7250      * div-float/2addr, rem-float/2addr
7251      */
7252     /* binop/2addr vA, vB */
7253     GET_OPA4(rOBJ)                         #  t1 <- A+
7254     GET_OPB(a3)                            #  a3 <- B
7255 #ifdef SOFT_FLOAT
7256     GET_VREG(a0, rOBJ)                     #  a0 <- vA
7257     GET_VREG(a1, a3)                       #  a1 <- vB
7258     .if 0
7259     # is second operand zero?
7260     beqz      a1, common_errDivideByZero
7261     .endif
7262 #else
7263     GET_VREG_F(fa0, rOBJ)
7264     GET_VREG_F(fa1, a3)
7265     .if 0
7266     # is second operand zero?
7267     li.s      ft0, 0
7268     c.eq.s    fcc0, ft0, fa1
7269     bc1t      fcc0, common_errDivideByZero
7270     .endif
7271 #endif
7272     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7273                                   #  optional op
7274 #ifdef SOFT_FLOAT
7275     JAL(__subsf3)                                 #  result <- op, a0-a3 changed
7276     SET_VREG(v0, rOBJ)                     #  vAA <- result
7277 #else
7278     sub.s fv0, fa0, fa1
7279     SET_VREG_F(fv0, rOBJ)                  #  vAA <- result
7280 #endif
7281     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7282     GOTO_OPCODE(t0)                        #  jump to next instruction
7283     /* 10-13 instructions */
7284
7285
7286
7287 /* ------------------------------ */
7288     .balign 128
7289 .L_OP_MUL_FLOAT_2ADDR: /* 0xc8 */
7290 /* File: mips/OP_MUL_FLOAT_2ADDR.S */
7291 /* File: mips/binflop2addr.S */
7292     /*
7293      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" and
7294      * "instr_f" line
7295      * that specifies an instruction that performs "result = a0 op a1".
7296      * This could be an MIPS instruction or a function call.
7297      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7298      * vCC (a1).  Useful for integer division and modulus.
7299      *
7300      * For: add-float/2addr, sub-float/2addr, mul-float/2addr,
7301      * div-float/2addr, rem-float/2addr
7302      */
7303     /* binop/2addr vA, vB */
7304     GET_OPA4(rOBJ)                         #  t1 <- A+
7305     GET_OPB(a3)                            #  a3 <- B
7306 #ifdef SOFT_FLOAT
7307     GET_VREG(a0, rOBJ)                     #  a0 <- vA
7308     GET_VREG(a1, a3)                       #  a1 <- vB
7309     .if 0
7310     # is second operand zero?
7311     beqz      a1, common_errDivideByZero
7312     .endif
7313 #else
7314     GET_VREG_F(fa0, rOBJ)
7315     GET_VREG_F(fa1, a3)
7316     .if 0
7317     # is second operand zero?
7318     li.s      ft0, 0
7319     c.eq.s    fcc0, ft0, fa1
7320     bc1t      fcc0, common_errDivideByZero
7321     .endif
7322 #endif
7323     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7324                                   #  optional op
7325 #ifdef SOFT_FLOAT
7326     JAL(__mulsf3)                                 #  result <- op, a0-a3 changed
7327     SET_VREG(v0, rOBJ)                     #  vAA <- result
7328 #else
7329     mul.s fv0, fa0, fa1
7330     SET_VREG_F(fv0, rOBJ)                  #  vAA <- result
7331 #endif
7332     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7333     GOTO_OPCODE(t0)                        #  jump to next instruction
7334     /* 10-13 instructions */
7335
7336
7337
7338 /* ------------------------------ */
7339     .balign 128
7340 .L_OP_DIV_FLOAT_2ADDR: /* 0xc9 */
7341 /* File: mips/OP_DIV_FLOAT_2ADDR.S */
7342 /* File: mips/binflop2addr.S */
7343     /*
7344      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" and
7345      * "instr_f" line
7346      * that specifies an instruction that performs "result = a0 op a1".
7347      * This could be an MIPS instruction or a function call.
7348      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7349      * vCC (a1).  Useful for integer division and modulus.
7350      *
7351      * For: add-float/2addr, sub-float/2addr, mul-float/2addr,
7352      * div-float/2addr, rem-float/2addr
7353      */
7354     /* binop/2addr vA, vB */
7355     GET_OPA4(rOBJ)                         #  t1 <- A+
7356     GET_OPB(a3)                            #  a3 <- B
7357 #ifdef SOFT_FLOAT
7358     GET_VREG(a0, rOBJ)                     #  a0 <- vA
7359     GET_VREG(a1, a3)                       #  a1 <- vB
7360     .if 0
7361     # is second operand zero?
7362     beqz      a1, common_errDivideByZero
7363     .endif
7364 #else
7365     GET_VREG_F(fa0, rOBJ)
7366     GET_VREG_F(fa1, a3)
7367     .if 0
7368     # is second operand zero?
7369     li.s      ft0, 0
7370     c.eq.s    fcc0, ft0, fa1
7371     bc1t      fcc0, common_errDivideByZero
7372     .endif
7373 #endif
7374     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7375                                   #  optional op
7376 #ifdef SOFT_FLOAT
7377     JAL(__divsf3)                                 #  result <- op, a0-a3 changed
7378     SET_VREG(v0, rOBJ)                     #  vAA <- result
7379 #else
7380     div.s fv0, fa0, fa1
7381     SET_VREG_F(fv0, rOBJ)                  #  vAA <- result
7382 #endif
7383     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7384     GOTO_OPCODE(t0)                        #  jump to next instruction
7385     /* 10-13 instructions */
7386
7387
7388
7389 /* ------------------------------ */
7390     .balign 128
7391 .L_OP_REM_FLOAT_2ADDR: /* 0xca */
7392 /* File: mips/OP_REM_FLOAT_2ADDR.S */
7393 /* File: mips/binflop2addr.S */
7394     /*
7395      * Generic 32-bit "/2addr" binary operation.  Provide an "instr" and
7396      * "instr_f" line
7397      * that specifies an instruction that performs "result = a0 op a1".
7398      * This could be an MIPS instruction or a function call.
7399      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7400      * vCC (a1).  Useful for integer division and modulus.
7401      *
7402      * For: add-float/2addr, sub-float/2addr, mul-float/2addr,
7403      * div-float/2addr, rem-float/2addr
7404      */
7405     /* binop/2addr vA, vB */
7406     GET_OPA4(rOBJ)                         #  t1 <- A+
7407     GET_OPB(a3)                            #  a3 <- B
7408 #ifdef SOFT_FLOAT
7409     GET_VREG(a0, rOBJ)                     #  a0 <- vA
7410     GET_VREG(a1, a3)                       #  a1 <- vB
7411     .if 0
7412     # is second operand zero?
7413     beqz      a1, common_errDivideByZero
7414     .endif
7415 #else
7416     GET_VREG_F(fa0, rOBJ)
7417     GET_VREG_F(fa1, a3)
7418     .if 0
7419     # is second operand zero?
7420     li.s      ft0, 0
7421     c.eq.s    fcc0, ft0, fa1
7422     bc1t      fcc0, common_errDivideByZero
7423     .endif
7424 #endif
7425     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7426                                   #  optional op
7427 #ifdef SOFT_FLOAT
7428     JAL(fmodf)                                 #  result <- op, a0-a3 changed
7429     SET_VREG(v0, rOBJ)                     #  vAA <- result
7430 #else
7431     JAL(fmodf)
7432     SET_VREG_F(fv0, rOBJ)                  #  vAA <- result
7433 #endif
7434     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7435     GOTO_OPCODE(t0)                        #  jump to next instruction
7436     /* 10-13 instructions */
7437
7438
7439
7440 /* ------------------------------ */
7441     .balign 128
7442 .L_OP_ADD_DOUBLE_2ADDR: /* 0xcb */
7443 /* File: mips/OP_ADD_DOUBLE_2ADDR.S */
7444 /* File: mips/binflopWide2addr.S */
7445     /*
7446      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7447      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7448      * This could be an MIPS instruction or a function call.
7449      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7450      * vCC (a1).  Useful for integer division and modulus.
7451      *
7452      * For: add-double/2addr, sub-double/2addr, mul-double/2addr,
7453      *  div-double/2addr, rem-double/2addr
7454      */
7455     /* binop/2addr vA, vB */
7456     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7457     GET_OPB(a1)                            #  a1 <- B
7458     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7459     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7460 #ifdef SOFT_FLOAT
7461     LOAD64(rARG2, rARG3, a1)               #  a2/a3 <- vBB/vBB+1
7462     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7463     .if 0
7464     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
7465     beqz      t0, common_errDivideByZero
7466     .endif
7467 #else
7468     LOAD64_F(fa0, fa0f, rOBJ)
7469     LOAD64_F(fa1, fa1f, a1)
7470     .if 0
7471     li.d      ft0, 0
7472     c.eq.d    fcc0, fa1, ft0
7473     bc1t      fcc0, common_errDivideByZero
7474     .endif
7475 #endif
7476 1:
7477     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7478                                   #  optional op
7479 #ifdef SOFT_FLOAT
7480     JAL(__adddf3)                                 #  result <- op, a0-a3 changed
7481     STORE64(rRESULT0, rRESULT1, rOBJ)
7482 #else
7483     add.d fv0, fa0, fa1
7484     STORE64_F(fv0, fv0f, rOBJ)
7485 #endif
7486     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7487     GOTO_OPCODE(t0)                        #  jump to next instruction
7488     /* 12-15 instructions */
7489
7490
7491
7492 /* ------------------------------ */
7493     .balign 128
7494 .L_OP_SUB_DOUBLE_2ADDR: /* 0xcc */
7495 /* File: mips/OP_SUB_DOUBLE_2ADDR.S */
7496 /* File: mips/binflopWide2addr.S */
7497     /*
7498      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7499      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7500      * This could be an MIPS instruction or a function call.
7501      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7502      * vCC (a1).  Useful for integer division and modulus.
7503      *
7504      * For: add-double/2addr, sub-double/2addr, mul-double/2addr,
7505      *  div-double/2addr, rem-double/2addr
7506      */
7507     /* binop/2addr vA, vB */
7508     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7509     GET_OPB(a1)                            #  a1 <- B
7510     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7511     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7512 #ifdef SOFT_FLOAT
7513     LOAD64(rARG2, rARG3, a1)               #  a2/a3 <- vBB/vBB+1
7514     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7515     .if 0
7516     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
7517     beqz      t0, common_errDivideByZero
7518     .endif
7519 #else
7520     LOAD64_F(fa0, fa0f, rOBJ)
7521     LOAD64_F(fa1, fa1f, a1)
7522     .if 0
7523     li.d      ft0, 0
7524     c.eq.d    fcc0, fa1, ft0
7525     bc1t      fcc0, common_errDivideByZero
7526     .endif
7527 #endif
7528 1:
7529     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7530                                   #  optional op
7531 #ifdef SOFT_FLOAT
7532     JAL(__subdf3)                                 #  result <- op, a0-a3 changed
7533     STORE64(rRESULT0, rRESULT1, rOBJ)
7534 #else
7535     sub.d fv0, fa0, fa1
7536     STORE64_F(fv0, fv0f, rOBJ)
7537 #endif
7538     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7539     GOTO_OPCODE(t0)                        #  jump to next instruction
7540     /* 12-15 instructions */
7541
7542
7543
7544 /* ------------------------------ */
7545     .balign 128
7546 .L_OP_MUL_DOUBLE_2ADDR: /* 0xcd */
7547 /* File: mips/OP_MUL_DOUBLE_2ADDR.S */
7548 /* File: mips/binflopWide2addr.S */
7549     /*
7550      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7551      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7552      * This could be an MIPS instruction or a function call.
7553      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7554      * vCC (a1).  Useful for integer division and modulus.
7555      *
7556      * For: add-double/2addr, sub-double/2addr, mul-double/2addr,
7557      *  div-double/2addr, rem-double/2addr
7558      */
7559     /* binop/2addr vA, vB */
7560     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7561     GET_OPB(a1)                            #  a1 <- B
7562     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7563     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7564 #ifdef SOFT_FLOAT
7565     LOAD64(rARG2, rARG3, a1)               #  a2/a3 <- vBB/vBB+1
7566     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7567     .if 0
7568     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
7569     beqz      t0, common_errDivideByZero
7570     .endif
7571 #else
7572     LOAD64_F(fa0, fa0f, rOBJ)
7573     LOAD64_F(fa1, fa1f, a1)
7574     .if 0
7575     li.d      ft0, 0
7576     c.eq.d    fcc0, fa1, ft0
7577     bc1t      fcc0, common_errDivideByZero
7578     .endif
7579 #endif
7580 1:
7581     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7582                                   #  optional op
7583 #ifdef SOFT_FLOAT
7584     JAL(__muldf3)                                 #  result <- op, a0-a3 changed
7585     STORE64(rRESULT0, rRESULT1, rOBJ)
7586 #else
7587     mul.d fv0, fa0, fa1
7588     STORE64_F(fv0, fv0f, rOBJ)
7589 #endif
7590     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7591     GOTO_OPCODE(t0)                        #  jump to next instruction
7592     /* 12-15 instructions */
7593
7594
7595
7596 /* ------------------------------ */
7597     .balign 128
7598 .L_OP_DIV_DOUBLE_2ADDR: /* 0xce */
7599 /* File: mips/OP_DIV_DOUBLE_2ADDR.S */
7600 /* File: mips/binflopWide2addr.S */
7601     /*
7602      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7603      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7604      * This could be an MIPS instruction or a function call.
7605      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7606      * vCC (a1).  Useful for integer division and modulus.
7607      *
7608      * For: add-double/2addr, sub-double/2addr, mul-double/2addr,
7609      *  div-double/2addr, rem-double/2addr
7610      */
7611     /* binop/2addr vA, vB */
7612     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7613     GET_OPB(a1)                            #  a1 <- B
7614     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7615     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7616 #ifdef SOFT_FLOAT
7617     LOAD64(rARG2, rARG3, a1)               #  a2/a3 <- vBB/vBB+1
7618     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7619     .if 0
7620     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
7621     beqz      t0, common_errDivideByZero
7622     .endif
7623 #else
7624     LOAD64_F(fa0, fa0f, rOBJ)
7625     LOAD64_F(fa1, fa1f, a1)
7626     .if 0
7627     li.d      ft0, 0
7628     c.eq.d    fcc0, fa1, ft0
7629     bc1t      fcc0, common_errDivideByZero
7630     .endif
7631 #endif
7632 1:
7633     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7634                                   #  optional op
7635 #ifdef SOFT_FLOAT
7636     JAL(__divdf3)                                 #  result <- op, a0-a3 changed
7637     STORE64(rRESULT0, rRESULT1, rOBJ)
7638 #else
7639     div.d fv0, fa0, fa1
7640     STORE64_F(fv0, fv0f, rOBJ)
7641 #endif
7642     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7643     GOTO_OPCODE(t0)                        #  jump to next instruction
7644     /* 12-15 instructions */
7645
7646
7647
7648 /* ------------------------------ */
7649     .balign 128
7650 .L_OP_REM_DOUBLE_2ADDR: /* 0xcf */
7651 /* File: mips/OP_REM_DOUBLE_2ADDR.S */
7652 /* File: mips/binflopWide2addr.S */
7653     /*
7654      * Generic 64-bit "/2addr" binary operation.  Provide an "instr" line
7655      * that specifies an instruction that performs "result = a0-a1 op a2-a3".
7656      * This could be an MIPS instruction or a function call.
7657      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7658      * vCC (a1).  Useful for integer division and modulus.
7659      *
7660      * For: add-double/2addr, sub-double/2addr, mul-double/2addr,
7661      *  div-double/2addr, rem-double/2addr
7662      */
7663     /* binop/2addr vA, vB */
7664     GET_OPA4(rOBJ)                         #  rOBJ <- A+
7665     GET_OPB(a1)                            #  a1 <- B
7666     EAS2(a1, rFP, a1)                      #  a1 <- &fp[B]
7667     EAS2(rOBJ, rFP, rOBJ)                  #  rOBJ <- &fp[A]
7668 #ifdef SOFT_FLOAT
7669     LOAD64(rARG2, rARG3, a1)               #  a2/a3 <- vBB/vBB+1
7670     LOAD64(rARG0, rARG1, rOBJ)             #  a0/a1 <- vAA/vAA+1
7671     .if 0
7672     or        t0, rARG2, rARG3             #  second arg (a2-a3) is zero?
7673     beqz      t0, common_errDivideByZero
7674     .endif
7675 #else
7676     LOAD64_F(fa0, fa0f, rOBJ)
7677     LOAD64_F(fa1, fa1f, a1)
7678     .if 0
7679     li.d      ft0, 0
7680     c.eq.d    fcc0, fa1, ft0
7681     bc1t      fcc0, common_errDivideByZero
7682     .endif
7683 #endif
7684 1:
7685     FETCH_ADVANCE_INST(1)                  #  advance rPC, load rINST
7686                                   #  optional op
7687 #ifdef SOFT_FLOAT
7688     JAL(fmod)                                 #  result <- op, a0-a3 changed
7689     STORE64(rRESULT0, rRESULT1, rOBJ)
7690 #else
7691     JAL(fmod)
7692     STORE64_F(fv0, fv0f, rOBJ)
7693 #endif
7694     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7695     GOTO_OPCODE(t0)                        #  jump to next instruction
7696     /* 12-15 instructions */
7697
7698
7699
7700 /* ------------------------------ */
7701     .balign 128
7702 .L_OP_ADD_INT_LIT16: /* 0xd0 */
7703 /* File: mips/OP_ADD_INT_LIT16.S */
7704 /* File: mips/binopLit16.S */
7705     /*
7706      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7707      * that specifies an instruction that performs "result = a0 op a1".
7708      * This could be an MIPS instruction or a function call.  (If the result
7709      * comes back in a register other than a0, you can override "result".)
7710      *
7711      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7712      * vCC (a1).  Useful for integer division and modulus.
7713      *
7714      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7715      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7716      */
7717     # binop/lit16 vA, vB,                  /* +CCCC */
7718     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7719     GET_OPB(a2)                            #  a2 <- B
7720     GET_OPA(rOBJ)                          #  rOBJ <- A+
7721     GET_VREG(a0, a2)                       #  a0 <- vB
7722     and       rOBJ, rOBJ, 15
7723     .if 0
7724     # cmp a1, 0; is second operand zero?
7725     beqz      a1, common_errDivideByZero
7726     .endif
7727     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7728
7729     addu a0, a0, a1                                 #  a0 <- op, a0-a3 changed
7730     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7731     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7732     /* 10-13 instructions */
7733
7734
7735
7736 /* ------------------------------ */
7737     .balign 128
7738 .L_OP_RSUB_INT: /* 0xd1 */
7739 /* File: mips/OP_RSUB_INT.S */
7740 /* this op is "rsub-int", but can be thought of as "rsub-int/lit16" */
7741 /* File: mips/binopLit16.S */
7742     /*
7743      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7744      * that specifies an instruction that performs "result = a0 op a1".
7745      * This could be an MIPS instruction or a function call.  (If the result
7746      * comes back in a register other than a0, you can override "result".)
7747      *
7748      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7749      * vCC (a1).  Useful for integer division and modulus.
7750      *
7751      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7752      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7753      */
7754     # binop/lit16 vA, vB,                  /* +CCCC */
7755     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7756     GET_OPB(a2)                            #  a2 <- B
7757     GET_OPA(rOBJ)                          #  rOBJ <- A+
7758     GET_VREG(a0, a2)                       #  a0 <- vB
7759     and       rOBJ, rOBJ, 15
7760     .if 0
7761     # cmp a1, 0; is second operand zero?
7762     beqz      a1, common_errDivideByZero
7763     .endif
7764     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7765
7766     subu a0, a1, a0                                 #  a0 <- op, a0-a3 changed
7767     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7768     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7769     /* 10-13 instructions */
7770
7771
7772
7773 /* ------------------------------ */
7774     .balign 128
7775 .L_OP_MUL_INT_LIT16: /* 0xd2 */
7776 /* File: mips/OP_MUL_INT_LIT16.S */
7777 /* File: mips/binopLit16.S */
7778     /*
7779      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7780      * that specifies an instruction that performs "result = a0 op a1".
7781      * This could be an MIPS instruction or a function call.  (If the result
7782      * comes back in a register other than a0, you can override "result".)
7783      *
7784      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7785      * vCC (a1).  Useful for integer division and modulus.
7786      *
7787      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7788      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7789      */
7790     # binop/lit16 vA, vB,                  /* +CCCC */
7791     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7792     GET_OPB(a2)                            #  a2 <- B
7793     GET_OPA(rOBJ)                          #  rOBJ <- A+
7794     GET_VREG(a0, a2)                       #  a0 <- vB
7795     and       rOBJ, rOBJ, 15
7796     .if 0
7797     # cmp a1, 0; is second operand zero?
7798     beqz      a1, common_errDivideByZero
7799     .endif
7800     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7801
7802     mul a0, a0, a1                                 #  a0 <- op, a0-a3 changed
7803     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7804     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7805     /* 10-13 instructions */
7806
7807
7808
7809 /* ------------------------------ */
7810     .balign 128
7811 .L_OP_DIV_INT_LIT16: /* 0xd3 */
7812 /* File: mips/OP_DIV_INT_LIT16.S */
7813 /* File: mips/binopLit16.S */
7814     /*
7815      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7816      * that specifies an instruction that performs "result = a0 op a1".
7817      * This could be an MIPS instruction or a function call.  (If the result
7818      * comes back in a register other than a0, you can override "result".)
7819      *
7820      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7821      * vCC (a1).  Useful for integer division and modulus.
7822      *
7823      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7824      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7825      */
7826     # binop/lit16 vA, vB,                  /* +CCCC */
7827     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7828     GET_OPB(a2)                            #  a2 <- B
7829     GET_OPA(rOBJ)                          #  rOBJ <- A+
7830     GET_VREG(a0, a2)                       #  a0 <- vB
7831     and       rOBJ, rOBJ, 15
7832     .if 1
7833     # cmp a1, 0; is second operand zero?
7834     beqz      a1, common_errDivideByZero
7835     .endif
7836     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7837
7838     div zero, a0, a1; mflo a0                                 #  a0 <- op, a0-a3 changed
7839     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7840     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7841     /* 10-13 instructions */
7842
7843
7844
7845 /* ------------------------------ */
7846     .balign 128
7847 .L_OP_REM_INT_LIT16: /* 0xd4 */
7848 /* File: mips/OP_REM_INT_LIT16.S */
7849 /* File: mips/binopLit16.S */
7850     /*
7851      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7852      * that specifies an instruction that performs "result = a0 op a1".
7853      * This could be an MIPS instruction or a function call.  (If the result
7854      * comes back in a register other than a0, you can override "result".)
7855      *
7856      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7857      * vCC (a1).  Useful for integer division and modulus.
7858      *
7859      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7860      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7861      */
7862     # binop/lit16 vA, vB,                  /* +CCCC */
7863     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7864     GET_OPB(a2)                            #  a2 <- B
7865     GET_OPA(rOBJ)                          #  rOBJ <- A+
7866     GET_VREG(a0, a2)                       #  a0 <- vB
7867     and       rOBJ, rOBJ, 15
7868     .if 1
7869     # cmp a1, 0; is second operand zero?
7870     beqz      a1, common_errDivideByZero
7871     .endif
7872     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7873
7874     div zero, a0, a1; mfhi a0                                 #  a0 <- op, a0-a3 changed
7875     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7876     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7877     /* 10-13 instructions */
7878
7879
7880
7881 /* ------------------------------ */
7882     .balign 128
7883 .L_OP_AND_INT_LIT16: /* 0xd5 */
7884 /* File: mips/OP_AND_INT_LIT16.S */
7885 /* File: mips/binopLit16.S */
7886     /*
7887      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7888      * that specifies an instruction that performs "result = a0 op a1".
7889      * This could be an MIPS instruction or a function call.  (If the result
7890      * comes back in a register other than a0, you can override "result".)
7891      *
7892      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7893      * vCC (a1).  Useful for integer division and modulus.
7894      *
7895      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7896      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7897      */
7898     # binop/lit16 vA, vB,                  /* +CCCC */
7899     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7900     GET_OPB(a2)                            #  a2 <- B
7901     GET_OPA(rOBJ)                          #  rOBJ <- A+
7902     GET_VREG(a0, a2)                       #  a0 <- vB
7903     and       rOBJ, rOBJ, 15
7904     .if 0
7905     # cmp a1, 0; is second operand zero?
7906     beqz      a1, common_errDivideByZero
7907     .endif
7908     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7909
7910     and a0, a0, a1                                 #  a0 <- op, a0-a3 changed
7911     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7912     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7913     /* 10-13 instructions */
7914
7915
7916
7917 /* ------------------------------ */
7918     .balign 128
7919 .L_OP_OR_INT_LIT16: /* 0xd6 */
7920 /* File: mips/OP_OR_INT_LIT16.S */
7921 /* File: mips/binopLit16.S */
7922     /*
7923      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7924      * that specifies an instruction that performs "result = a0 op a1".
7925      * This could be an MIPS instruction or a function call.  (If the result
7926      * comes back in a register other than a0, you can override "result".)
7927      *
7928      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7929      * vCC (a1).  Useful for integer division and modulus.
7930      *
7931      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7932      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7933      */
7934     # binop/lit16 vA, vB,                  /* +CCCC */
7935     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7936     GET_OPB(a2)                            #  a2 <- B
7937     GET_OPA(rOBJ)                          #  rOBJ <- A+
7938     GET_VREG(a0, a2)                       #  a0 <- vB
7939     and       rOBJ, rOBJ, 15
7940     .if 0
7941     # cmp a1, 0; is second operand zero?
7942     beqz      a1, common_errDivideByZero
7943     .endif
7944     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7945
7946     or a0, a0, a1                                 #  a0 <- op, a0-a3 changed
7947     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7948     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7949     /* 10-13 instructions */
7950
7951
7952
7953 /* ------------------------------ */
7954     .balign 128
7955 .L_OP_XOR_INT_LIT16: /* 0xd7 */
7956 /* File: mips/OP_XOR_INT_LIT16.S */
7957 /* File: mips/binopLit16.S */
7958     /*
7959      * Generic 32-bit "lit16" binary operation.  Provide an "instr" line
7960      * that specifies an instruction that performs "result = a0 op a1".
7961      * This could be an MIPS instruction or a function call.  (If the result
7962      * comes back in a register other than a0, you can override "result".)
7963      *
7964      * If "chkzero" is set to 1, we perform a divide-by-zero check on
7965      * vCC (a1).  Useful for integer division and modulus.
7966      *
7967      * For: add-int/lit16, rsub-int, mul-int/lit16, div-int/lit16,
7968      *      rem-int/lit16, and-int/lit16, or-int/lit16, xor-int/lit16
7969      */
7970     # binop/lit16 vA, vB,                  /* +CCCC */
7971     FETCH_S(a1, 1)                         #  a1 <- ssssCCCC (sign-extended)
7972     GET_OPB(a2)                            #  a2 <- B
7973     GET_OPA(rOBJ)                          #  rOBJ <- A+
7974     GET_VREG(a0, a2)                       #  a0 <- vB
7975     and       rOBJ, rOBJ, 15
7976     .if 0
7977     # cmp a1, 0; is second operand zero?
7978     beqz      a1, common_errDivideByZero
7979     .endif
7980     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
7981
7982     xor a0, a0, a1                                 #  a0 <- op, a0-a3 changed
7983     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
7984     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
7985     /* 10-13 instructions */
7986
7987
7988
7989 /* ------------------------------ */
7990     .balign 128
7991 .L_OP_ADD_INT_LIT8: /* 0xd8 */
7992 /* File: mips/OP_ADD_INT_LIT8.S */
7993 /* File: mips/binopLit8.S */
7994     /*
7995      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
7996      * that specifies an instruction that performs "result = a0 op a1".
7997      * This could be an MIPS instruction or a function call.  (If the result
7998      * comes back in a register other than a0, you can override "result".)
7999      *
8000      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8001      * vCC (a1).  Useful for integer division and modulus.
8002      *
8003      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8004      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8005      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8006      */
8007     # binop/lit8 vAA, vBB,                 /* +CC */
8008     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8009     GET_OPA(rOBJ)                          #  rOBJ <- AA
8010     and       a2, a3, 255                  #  a2 <- BB
8011     GET_VREG(a0, a2)                       #  a0 <- vBB
8012     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8013     .if 0
8014     # is second operand zero?
8015     beqz      a1, common_errDivideByZero
8016     .endif
8017     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8018
8019                                   #  optional op
8020     addu a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8021     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8022     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8023     /* 10-12 instructions */
8024
8025
8026
8027 /* ------------------------------ */
8028     .balign 128
8029 .L_OP_RSUB_INT_LIT8: /* 0xd9 */
8030 /* File: mips/OP_RSUB_INT_LIT8.S */
8031 /* File: mips/binopLit8.S */
8032     /*
8033      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8034      * that specifies an instruction that performs "result = a0 op a1".
8035      * This could be an MIPS instruction or a function call.  (If the result
8036      * comes back in a register other than a0, you can override "result".)
8037      *
8038      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8039      * vCC (a1).  Useful for integer division and modulus.
8040      *
8041      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8042      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8043      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8044      */
8045     # binop/lit8 vAA, vBB,                 /* +CC */
8046     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8047     GET_OPA(rOBJ)                          #  rOBJ <- AA
8048     and       a2, a3, 255                  #  a2 <- BB
8049     GET_VREG(a0, a2)                       #  a0 <- vBB
8050     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8051     .if 0
8052     # is second operand zero?
8053     beqz      a1, common_errDivideByZero
8054     .endif
8055     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8056
8057                                   #  optional op
8058     subu a0, a1, a0                                 #  a0 <- op, a0-a3 changed
8059     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8060     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8061     /* 10-12 instructions */
8062
8063
8064
8065 /* ------------------------------ */
8066     .balign 128
8067 .L_OP_MUL_INT_LIT8: /* 0xda */
8068 /* File: mips/OP_MUL_INT_LIT8.S */
8069 /* File: mips/binopLit8.S */
8070     /*
8071      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8072      * that specifies an instruction that performs "result = a0 op a1".
8073      * This could be an MIPS instruction or a function call.  (If the result
8074      * comes back in a register other than a0, you can override "result".)
8075      *
8076      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8077      * vCC (a1).  Useful for integer division and modulus.
8078      *
8079      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8080      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8081      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8082      */
8083     # binop/lit8 vAA, vBB,                 /* +CC */
8084     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8085     GET_OPA(rOBJ)                          #  rOBJ <- AA
8086     and       a2, a3, 255                  #  a2 <- BB
8087     GET_VREG(a0, a2)                       #  a0 <- vBB
8088     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8089     .if 0
8090     # is second operand zero?
8091     beqz      a1, common_errDivideByZero
8092     .endif
8093     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8094
8095                                   #  optional op
8096     mul a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8097     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8098     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8099     /* 10-12 instructions */
8100
8101
8102
8103 /* ------------------------------ */
8104     .balign 128
8105 .L_OP_DIV_INT_LIT8: /* 0xdb */
8106 /* File: mips/OP_DIV_INT_LIT8.S */
8107 /* File: mips/binopLit8.S */
8108     /*
8109      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8110      * that specifies an instruction that performs "result = a0 op a1".
8111      * This could be an MIPS instruction or a function call.  (If the result
8112      * comes back in a register other than a0, you can override "result".)
8113      *
8114      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8115      * vCC (a1).  Useful for integer division and modulus.
8116      *
8117      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8118      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8119      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8120      */
8121     # binop/lit8 vAA, vBB,                 /* +CC */
8122     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8123     GET_OPA(rOBJ)                          #  rOBJ <- AA
8124     and       a2, a3, 255                  #  a2 <- BB
8125     GET_VREG(a0, a2)                       #  a0 <- vBB
8126     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8127     .if 1
8128     # is second operand zero?
8129     beqz      a1, common_errDivideByZero
8130     .endif
8131     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8132
8133                                   #  optional op
8134     div zero, a0, a1; mflo a0                                 #  a0 <- op, a0-a3 changed
8135     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8136     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8137     /* 10-12 instructions */
8138
8139
8140
8141 /* ------------------------------ */
8142     .balign 128
8143 .L_OP_REM_INT_LIT8: /* 0xdc */
8144 /* File: mips/OP_REM_INT_LIT8.S */
8145 /* File: mips/binopLit8.S */
8146     /*
8147      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8148      * that specifies an instruction that performs "result = a0 op a1".
8149      * This could be an MIPS instruction or a function call.  (If the result
8150      * comes back in a register other than a0, you can override "result".)
8151      *
8152      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8153      * vCC (a1).  Useful for integer division and modulus.
8154      *
8155      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8156      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8157      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8158      */
8159     # binop/lit8 vAA, vBB,                 /* +CC */
8160     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8161     GET_OPA(rOBJ)                          #  rOBJ <- AA
8162     and       a2, a3, 255                  #  a2 <- BB
8163     GET_VREG(a0, a2)                       #  a0 <- vBB
8164     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8165     .if 1
8166     # is second operand zero?
8167     beqz      a1, common_errDivideByZero
8168     .endif
8169     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8170
8171                                   #  optional op
8172     div zero, a0, a1; mfhi a0                                 #  a0 <- op, a0-a3 changed
8173     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8174     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8175     /* 10-12 instructions */
8176
8177
8178
8179 /* ------------------------------ */
8180     .balign 128
8181 .L_OP_AND_INT_LIT8: /* 0xdd */
8182 /* File: mips/OP_AND_INT_LIT8.S */
8183 /* File: mips/binopLit8.S */
8184     /*
8185      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8186      * that specifies an instruction that performs "result = a0 op a1".
8187      * This could be an MIPS instruction or a function call.  (If the result
8188      * comes back in a register other than a0, you can override "result".)
8189      *
8190      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8191      * vCC (a1).  Useful for integer division and modulus.
8192      *
8193      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8194      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8195      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8196      */
8197     # binop/lit8 vAA, vBB,                 /* +CC */
8198     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8199     GET_OPA(rOBJ)                          #  rOBJ <- AA
8200     and       a2, a3, 255                  #  a2 <- BB
8201     GET_VREG(a0, a2)                       #  a0 <- vBB
8202     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8203     .if 0
8204     # is second operand zero?
8205     beqz      a1, common_errDivideByZero
8206     .endif
8207     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8208
8209                                   #  optional op
8210     and a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8211     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8212     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8213     /* 10-12 instructions */
8214
8215
8216
8217 /* ------------------------------ */
8218     .balign 128
8219 .L_OP_OR_INT_LIT8: /* 0xde */
8220 /* File: mips/OP_OR_INT_LIT8.S */
8221 /* File: mips/binopLit8.S */
8222     /*
8223      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8224      * that specifies an instruction that performs "result = a0 op a1".
8225      * This could be an MIPS instruction or a function call.  (If the result
8226      * comes back in a register other than a0, you can override "result".)
8227      *
8228      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8229      * vCC (a1).  Useful for integer division and modulus.
8230      *
8231      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8232      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8233      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8234      */
8235     # binop/lit8 vAA, vBB,                 /* +CC */
8236     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8237     GET_OPA(rOBJ)                          #  rOBJ <- AA
8238     and       a2, a3, 255                  #  a2 <- BB
8239     GET_VREG(a0, a2)                       #  a0 <- vBB
8240     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8241     .if 0
8242     # is second operand zero?
8243     beqz      a1, common_errDivideByZero
8244     .endif
8245     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8246
8247                                   #  optional op
8248     or a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8249     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8250     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8251     /* 10-12 instructions */
8252
8253
8254
8255 /* ------------------------------ */
8256     .balign 128
8257 .L_OP_XOR_INT_LIT8: /* 0xdf */
8258 /* File: mips/OP_XOR_INT_LIT8.S */
8259 /* File: mips/binopLit8.S */
8260     /*
8261      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8262      * that specifies an instruction that performs "result = a0 op a1".
8263      * This could be an MIPS instruction or a function call.  (If the result
8264      * comes back in a register other than a0, you can override "result".)
8265      *
8266      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8267      * vCC (a1).  Useful for integer division and modulus.
8268      *
8269      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8270      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8271      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8272      */
8273     # binop/lit8 vAA, vBB,                 /* +CC */
8274     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8275     GET_OPA(rOBJ)                          #  rOBJ <- AA
8276     and       a2, a3, 255                  #  a2 <- BB
8277     GET_VREG(a0, a2)                       #  a0 <- vBB
8278     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8279     .if 0
8280     # is second operand zero?
8281     beqz      a1, common_errDivideByZero
8282     .endif
8283     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8284
8285                                   #  optional op
8286     xor a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8287     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8288     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8289     /* 10-12 instructions */
8290
8291
8292
8293 /* ------------------------------ */
8294     .balign 128
8295 .L_OP_SHL_INT_LIT8: /* 0xe0 */
8296 /* File: mips/OP_SHL_INT_LIT8.S */
8297 /* File: mips/binopLit8.S */
8298     /*
8299      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8300      * that specifies an instruction that performs "result = a0 op a1".
8301      * This could be an MIPS instruction or a function call.  (If the result
8302      * comes back in a register other than a0, you can override "result".)
8303      *
8304      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8305      * vCC (a1).  Useful for integer division and modulus.
8306      *
8307      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8308      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8309      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8310      */
8311     # binop/lit8 vAA, vBB,                 /* +CC */
8312     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8313     GET_OPA(rOBJ)                          #  rOBJ <- AA
8314     and       a2, a3, 255                  #  a2 <- BB
8315     GET_VREG(a0, a2)                       #  a0 <- vBB
8316     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8317     .if 0
8318     # is second operand zero?
8319     beqz      a1, common_errDivideByZero
8320     .endif
8321     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8322
8323     and a1, a1, 31                              #  optional op
8324     sll a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8325     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8326     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8327     /* 10-12 instructions */
8328
8329
8330
8331 /* ------------------------------ */
8332     .balign 128
8333 .L_OP_SHR_INT_LIT8: /* 0xe1 */
8334 /* File: mips/OP_SHR_INT_LIT8.S */
8335 /* File: mips/binopLit8.S */
8336     /*
8337      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8338      * that specifies an instruction that performs "result = a0 op a1".
8339      * This could be an MIPS instruction or a function call.  (If the result
8340      * comes back in a register other than a0, you can override "result".)
8341      *
8342      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8343      * vCC (a1).  Useful for integer division and modulus.
8344      *
8345      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8346      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8347      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8348      */
8349     # binop/lit8 vAA, vBB,                 /* +CC */
8350     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8351     GET_OPA(rOBJ)                          #  rOBJ <- AA
8352     and       a2, a3, 255                  #  a2 <- BB
8353     GET_VREG(a0, a2)                       #  a0 <- vBB
8354     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8355     .if 0
8356     # is second operand zero?
8357     beqz      a1, common_errDivideByZero
8358     .endif
8359     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8360
8361     and a1, a1, 31                              #  optional op
8362     sra a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8363     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8364     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8365     /* 10-12 instructions */
8366
8367
8368
8369 /* ------------------------------ */
8370     .balign 128
8371 .L_OP_USHR_INT_LIT8: /* 0xe2 */
8372 /* File: mips/OP_USHR_INT_LIT8.S */
8373 /* File: mips/binopLit8.S */
8374     /*
8375      * Generic 32-bit "lit8" binary operation.  Provide an "instr" line
8376      * that specifies an instruction that performs "result = a0 op a1".
8377      * This could be an MIPS instruction or a function call.  (If the result
8378      * comes back in a register other than a0, you can override "result".)
8379      *
8380      * If "chkzero" is set to 1, we perform a divide-by-zero check on
8381      * vCC (a1).  Useful for integer division and modulus.
8382      *
8383      * For: add-int/lit8, rsub-int/lit8, mul-int/lit8, div-int/lit8,
8384      *      rem-int/lit8, and-int/lit8, or-int/lit8, xor-int/lit8,
8385      *      shl-int/lit8, shr-int/lit8, ushr-int/lit8
8386      */
8387     # binop/lit8 vAA, vBB,                 /* +CC */
8388     FETCH_S(a3, 1)                         #  a3 <- ssssCCBB (sign-extended for CC)
8389     GET_OPA(rOBJ)                          #  rOBJ <- AA
8390     and       a2, a3, 255                  #  a2 <- BB
8391     GET_VREG(a0, a2)                       #  a0 <- vBB
8392     sra       a1, a3, 8                    #  a1 <- ssssssCC (sign extended)
8393     .if 0
8394     # is second operand zero?
8395     beqz      a1, common_errDivideByZero
8396     .endif
8397     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8398
8399     and a1, a1, 31                              #  optional op
8400     srl a0, a0, a1                                 #  a0 <- op, a0-a3 changed
8401     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8402     SET_VREG_GOTO(a0, rOBJ, t0)       #  vAA <- a0
8403     /* 10-12 instructions */
8404
8405
8406
8407 /* ------------------------------ */
8408     .balign 128
8409 .L_OP_IGET_VOLATILE: /* 0xe3 */
8410 /* File: mips/OP_IGET_VOLATILE.S */
8411 /* File: mips/OP_IGET.S */
8412     /*
8413      * General 32-bit instance field get.
8414      *
8415      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
8416      */
8417     # op vA, vB, field                     /* CCCC */
8418     GET_OPB(a0)                            #  a0 <- B
8419     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
8420     FETCH(a1, 1)                           #  a1 <- field ref CCCC
8421     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
8422     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
8423     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
8424     # is resolved entry null?
8425     bnez      a0, .LOP_IGET_VOLATILE_finish       #  no, already resolved
8426     LOAD_rSELF_method(a2)                  #  a2 <- current method
8427     EXPORT_PC()                            #  resolve() could throw
8428     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8429     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
8430     # test results
8431     move      a0, v0
8432     bnez      v0, .LOP_IGET_VOLATILE_finish
8433     b         common_exceptionThrown
8434
8435
8436 /* ------------------------------ */
8437     .balign 128
8438 .L_OP_IPUT_VOLATILE: /* 0xe4 */
8439 /* File: mips/OP_IPUT_VOLATILE.S */
8440 /* File: mips/OP_IPUT.S */
8441     /*
8442      * General 32-bit instance field put.
8443      *
8444      * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
8445      */
8446     # op vA, vB, field                     /* CCCC */
8447     GET_OPB(a0)                            #  a0 <- B
8448     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
8449     FETCH(a1, 1)                           #  a1 <- field ref CCCC
8450     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
8451     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
8452     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
8453     # is resolved entry null?
8454     bnez      a0, .LOP_IPUT_VOLATILE_finish       #  no, already resolved
8455     LOAD_rSELF_method(a2)                  #  a2 <- current method
8456     EXPORT_PC()                            #  resolve() could throw
8457     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8458     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
8459     # success?
8460     move      a0, v0
8461     bnez      v0, .LOP_IPUT_VOLATILE_finish       #  yes, finish up
8462     b         common_exceptionThrown
8463
8464
8465 /* ------------------------------ */
8466     .balign 128
8467 .L_OP_SGET_VOLATILE: /* 0xe5 */
8468 /* File: mips/OP_SGET_VOLATILE.S */
8469 /* File: mips/OP_SGET.S */
8470     /*
8471      * General 32-bit SGET handler.
8472      *
8473      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
8474      */
8475     # op vAA, field                        /* BBBB */
8476     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
8477     FETCH(a1, 1)                           #  a1 <- field ref BBBB
8478     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
8479     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
8480     # is resolved entry !null?
8481     bnez      a0, .LOP_SGET_VOLATILE_finish
8482
8483     /*
8484      * Continuation if the field has not yet been resolved.
8485      *  a1:  BBBB field ref
8486      *  rBIX: dvmDex->pResFields
8487      */
8488     LOAD_rSELF_method(a2)                  #  a2 <- current method
8489 #if defined(WITH_JIT)
8490     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
8491 #endif
8492     EXPORT_PC()                            #  resolve() could throw, so export now
8493     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8494     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
8495     move      a0, v0
8496     # success?
8497     beqz      v0, common_exceptionThrown   #  no, handle exception
8498 #if defined(WITH_JIT)
8499     /*
8500      * If the JIT is actively building a trace we need to make sure
8501      * that the field is fully resolved before including this instruction.
8502      */
8503     JAL(common_verifyField)
8504 #endif
8505     b        .LOP_SGET_VOLATILE_finish            # resume
8506
8507
8508 /* ------------------------------ */
8509     .balign 128
8510 .L_OP_SPUT_VOLATILE: /* 0xe6 */
8511 /* File: mips/OP_SPUT_VOLATILE.S */
8512 /* File: mips/OP_SPUT.S */
8513     /*
8514      * General 32-bit SPUT handler.
8515      *
8516      * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
8517      */
8518     # op vAA, field                        /* BBBB */
8519     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
8520     FETCH(a1, 1)                           #  a1 <- field ref BBBB
8521     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
8522     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
8523     bnez      a0, .LOP_SPUT_VOLATILE_finish       #  is resolved entry null?
8524     /*
8525      * Continuation if the field has not yet been resolved.
8526      *  a1:  BBBB field ref
8527      *  rBIX: dvmDex->pResFields
8528      */
8529     LOAD_rSELF_method(a2)                  #  a2 <- current method
8530 #if defined(WITH_JIT)
8531     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
8532 #endif
8533     EXPORT_PC()                            #  resolve() may throw, so export now
8534     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8535     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
8536     move      a0, v0
8537     beqz      v0, common_exceptionThrown   #  success? no, handle exception
8538 #if defined(WITH_JIT)
8539     /*
8540      * If the JIT is actively building a trace we need to make sure
8541      * that the field is fully resolved before including this instruction.
8542      */
8543     JAL(common_verifyField)
8544 #endif
8545     b        .LOP_SPUT_VOLATILE_finish            # resume
8546
8547
8548 /* ------------------------------ */
8549     .balign 128
8550 .L_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */
8551 /* File: mips/OP_IGET_OBJECT_VOLATILE.S */
8552 /* File: mips/OP_IGET.S */
8553     /*
8554      * General 32-bit instance field get.
8555      *
8556      * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
8557      */
8558     # op vA, vB, field                     /* CCCC */
8559     GET_OPB(a0)                            #  a0 <- B
8560     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
8561     FETCH(a1, 1)                           #  a1 <- field ref CCCC
8562     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
8563     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
8564     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
8565     # is resolved entry null?
8566     bnez      a0, .LOP_IGET_OBJECT_VOLATILE_finish       #  no, already resolved
8567     LOAD_rSELF_method(a2)                  #  a2 <- current method
8568     EXPORT_PC()                            #  resolve() could throw
8569     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8570     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
8571     # test results
8572     move      a0, v0
8573     bnez      v0, .LOP_IGET_OBJECT_VOLATILE_finish
8574     b         common_exceptionThrown
8575
8576
8577 /* ------------------------------ */
8578     .balign 128
8579 .L_OP_IGET_WIDE_VOLATILE: /* 0xe8 */
8580 /* File: mips/OP_IGET_WIDE_VOLATILE.S */
8581 /* File: mips/OP_IGET_WIDE.S */
8582     /*
8583      * Wide 32-bit instance field get.
8584      */
8585     # iget-wide vA, vB, field              /* CCCC */
8586     GET_OPB(a0)                            #  a0 <- B
8587     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
8588     FETCH(a1, 1)                           #  a1 <- field ref CCCC
8589     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
8590     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
8591     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
8592     # is resolved entry null?
8593     bnez      a0, .LOP_IGET_WIDE_VOLATILE_finish       #  no, already resolved
8594     LOAD_rSELF_method(a2)                  #  a2 <- current method
8595     EXPORT_PC()                            #  resolve() could throw
8596     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8597     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
8598     # test return code
8599     move      a0, v0
8600     bnez      v0, .LOP_IGET_WIDE_VOLATILE_finish
8601     b         common_exceptionThrown
8602
8603
8604 /* ------------------------------ */
8605     .balign 128
8606 .L_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */
8607 /* File: mips/OP_IPUT_WIDE_VOLATILE.S */
8608 /* File: mips/OP_IPUT_WIDE.S */
8609     # iput-wide vA, vB, field              /* CCCC */
8610     GET_OPB(a0)                            #  a0 <- B
8611     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
8612     FETCH(a1, 1)                           #  a1 <- field ref CCCC
8613     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
8614     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
8615     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
8616     # is resolved entry null?
8617     bnez      a0, .LOP_IPUT_WIDE_VOLATILE_finish       #  no, already resolved
8618     LOAD_rSELF_method(a2)                  #  a2 <- current method
8619     EXPORT_PC()                            #  resolve() could throw
8620     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8621     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
8622     # success?
8623     move      a0, v0
8624     bnez      v0, .LOP_IPUT_WIDE_VOLATILE_finish       #  yes, finish up
8625     b         common_exceptionThrown
8626
8627
8628 /* ------------------------------ */
8629     .balign 128
8630 .L_OP_SGET_WIDE_VOLATILE: /* 0xea */
8631 /* File: mips/OP_SGET_WIDE_VOLATILE.S */
8632 /* File: mips/OP_SGET_WIDE.S */
8633     /*
8634      * 64-bit SGET handler.
8635      */
8636     # sget-wide vAA, field                 /* BBBB */
8637     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
8638     FETCH(a1, 1)                           #  a1 <- field ref BBBB
8639     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
8640     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
8641     # is resolved entry null?
8642     bnez      a0, .LOP_SGET_WIDE_VOLATILE_finish
8643
8644     /*
8645      * Continuation if the field has not yet been resolved.
8646      *  a1:  BBBB field ref
8647      *  rBIX: dvmDex->pResFields
8648      *
8649      * Returns StaticField pointer in v0.
8650      */
8651     LOAD_rSELF_method(a2)                  #  a2 <- current method
8652 #if defined(WITH_JIT)
8653     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
8654 #endif
8655     EXPORT_PC()                            #  resolve() could throw, so export now
8656     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
8657     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
8658     move      a0, v0
8659     # success?
8660     beqz      v0, common_exceptionThrown   #  no, handle exception
8661 #if defined(WITH_JIT)
8662     /*
8663      * If the JIT is actively building a trace we need to make sure
8664      * that the field is fully resolved before including this instruction.
8665      */
8666     JAL(common_verifyField)
8667 #endif
8668
8669     b        .LOP_SGET_WIDE_VOLATILE_finish            # resume
8670
8671
8672 /* ------------------------------ */
8673     .balign 128
8674 .L_OP_SPUT_WIDE_VOLATILE: /* 0xeb */
8675 /* File: mips/OP_SPUT_WIDE_VOLATILE.S */
8676 /* File: mips/OP_SPUT_WIDE.S */
8677     /*
8678      * 64-bit SPUT handler.
8679      */
8680     # sput-wide vAA, field                 /* BBBB */
8681     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
8682     FETCH(a1, 1)                           #  a1 <- field ref BBBB
8683     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
8684     GET_OPA(t0)                            #  t0 <- AA
8685     LOAD_eas2(a2, rBIX, a1)                #  a2 <- resolved StaticField ptr
8686     EAS2(rOBJ, rFP, t0)                    #  rOBJ<- &fp[AA]
8687     # is resolved entry null?
8688     beqz      a2, .LOP_SPUT_WIDE_VOLATILE_resolve      #  yes, do resolve
8689 .LOP_SPUT_WIDE_VOLATILE_finish:                        #  field ptr in a2, AA in rOBJ
8690     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8691     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vAA/vAA+1
8692     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
8693     .if 1
8694     addu    a2, offStaticField_value       #  a2<- pointer to data
8695     JAL(dvmQuasiAtomicSwap64Sync)          #  stores a0/a1 into addr a2
8696     .else
8697     STORE64_off(a0, a1, a2, offStaticField_value) #  field <- vAA/vAA+1
8698     .endif
8699     GOTO_OPCODE(rBIX)                      #  jump to next instruction
8700
8701
8702 /* ------------------------------ */
8703     .balign 128
8704 .L_OP_BREAKPOINT: /* 0xec */
8705     /* (stub) */
8706     SAVE_PC_TO_SELF()            # only need to export PC and FP
8707     SAVE_FP_TO_SELF()
8708     move        a0, rSELF        # self is first arg to function
8709     JAL(dvmMterp_OP_BREAKPOINT)      # call
8710     LOAD_PC_FROM_SELF()          # retrieve updated values
8711     LOAD_FP_FROM_SELF()
8712     FETCH_INST()                 # load next instruction from rPC
8713     GET_INST_OPCODE(t0)          # ...trim down to just the opcode
8714     GOTO_OPCODE(t0)              # ...and jump to the handler
8715 /* ------------------------------ */
8716     .balign 128
8717 .L_OP_THROW_VERIFICATION_ERROR: /* 0xed */
8718 /* File: mips/OP_THROW_VERIFICATION_ERROR.S */
8719     /*
8720      * Handle a throw-verification-error instruction.  This throws an
8721      * exception for an error discovered during verification.  The
8722      * exception is indicated by AA, with some detail provided by BBBB.
8723      */
8724     /* op AA, ref@BBBB */
8725
8726     LOAD_rSELF_method(a0)                  #  a0 <- self->method
8727     FETCH(a2, 1)                           #  a2 <- BBBB
8728     EXPORT_PC()                            #  export the PC
8729     GET_OPA(a1)                            #  a1 <- AA
8730     JAL(dvmThrowVerificationError)         #  always throws
8731     b         common_exceptionThrown       #  handle exception
8732
8733
8734 /* ------------------------------ */
8735     .balign 128
8736 .L_OP_EXECUTE_INLINE: /* 0xee */
8737 /* File: mips/OP_EXECUTE_INLINE.S */
8738     /*
8739      * Execute a "native inline" instruction.
8740      *
8741      * We need to call an InlineOp4Func:
8742      *  bool (func)(u4 arg0, u4 arg1, u4 arg2, u4 arg3, JValue* pResult)
8743      *
8744      * The first four args are in a0-a3, pointer to return value storage
8745      * is on the stack.  The function's return value is a flag that tells
8746      * us if an exception was thrown.
8747      *
8748      * TUNING: could maintain two tables, pointer in Thread and
8749      * swap if profiler/debuggger active.
8750      */
8751     /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */
8752     lhu       a2, offThread_subMode(rSELF)
8753     FETCH(rBIX, 1)                         #  rBIX <- BBBB
8754     EXPORT_PC()                            #  can throw
8755     and       a2, kSubModeDebugProfile     #  Any going on?
8756     bnez      a2, .LOP_EXECUTE_INLINE_debugmode    #  yes - take slow path
8757 .LOP_EXECUTE_INLINE_resume:
8758     addu      a1, rSELF, offThread_retval  #  a1 <- &self->retval
8759     GET_OPB(a0)                            #  a0 <- B
8760     # Stack should have 16/20 available
8761     sw        a1, STACK_OFFSET_ARG04(sp)   #  push &self->retval
8762     BAL(.LOP_EXECUTE_INLINE_continue)              #  make call; will return after
8763     lw        gp, STACK_OFFSET_GP(sp)      #  restore gp
8764     # test boolean result of inline
8765     beqz      v0, common_exceptionThrown   #  returned false, handle exception
8766     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
8767     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8768     GOTO_OPCODE(t0)                        #  jump to next instruction
8769
8770 /* ------------------------------ */
8771     .balign 128
8772 .L_OP_EXECUTE_INLINE_RANGE: /* 0xef */
8773 /* File: mips/OP_EXECUTE_INLINE_RANGE.S */
8774     /*
8775      * Execute a "native inline" instruction, using "/range" semantics.
8776      * Same idea as execute-inline, but we get the args differently.
8777      *
8778      * We need to call an InlineOp4Func:
8779      *  bool (func)(u4 arg0, u4 arg1, u4 arg2, u4 arg3, JValue* pResult)
8780      *
8781      * The first four args are in a0-a3, pointer to return value storage
8782      * is on the stack.  The function's return value is a flag that tells
8783      * us if an exception was thrown.
8784      */
8785     /* [opt] execute-inline/range {vCCCC..v(CCCC+AA-1)}, inline@BBBB */
8786     lhu       a2, offThread_subMode(rSELF)
8787     FETCH(rBIX, 1)                       # rBIX<- BBBB
8788     EXPORT_PC()                          # can throw
8789     and       a2, kSubModeDebugProfile   # Any going on?
8790     bnez      a2, .LOP_EXECUTE_INLINE_RANGE_debugmode  # yes - take slow path
8791 .LOP_EXECUTE_INLINE_RANGE_resume:
8792     addu      a1, rSELF, offThread_retval # a1<- &self->retval
8793     GET_OPA(a0)
8794     sw        a1, STACK_OFFSET_ARG04(sp)  # push &self->retval
8795     BAL(.LOP_EXECUTE_INLINE_RANGE_continue)             # make call; will return after
8796     lw        gp, STACK_OFFSET_GP(sp)     #  restore gp
8797     beqz      v0, common_exceptionThrown  # returned false, handle exception
8798     FETCH_ADVANCE_INST(3)                 # advance rPC, load rINST
8799     GET_INST_OPCODE(t0)                   # extract opcode from rINST
8800     GOTO_OPCODE(t0)                       # jump to next instruction
8801
8802
8803 /* ------------------------------ */
8804     .balign 128
8805 .L_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */
8806 /* File: mips/OP_INVOKE_OBJECT_INIT_RANGE.S */
8807     /*
8808      * Invoke Object.<init> on an object.  In practice we know that
8809      * Object's nullary constructor doesn't do anything, so we just
8810      * skip it unless a debugger is active.
8811      */
8812     FETCH(a1, 2)                  # a1<- CCCC
8813     GET_VREG(a0, a1)                    # a0<- "this" ptr
8814     # check for NULL
8815     beqz    a0, common_errNullObject    # export PC and throw NPE
8816     LOAD_base_offObject_clazz(a1, a0)   # a1<- obj->clazz
8817     LOAD_base_offClassObject_accessFlags(a2, a1) # a2<- clazz->accessFlags
8818     and     a2, CLASS_ISFINALIZABLE     # is this class finalizable?
8819     beqz    a2, .LOP_INVOKE_OBJECT_INIT_RANGE_finish      # no, go
8820
8821 .LOP_INVOKE_OBJECT_INIT_RANGE_setFinal:
8822     EXPORT_PC()                         # can throw
8823     JAL(dvmSetFinalizable)              # call dvmSetFinalizable(obj)
8824     LOAD_offThread_exception(a0, rSELF) # a0<- self->exception
8825     # exception pending?
8826     bnez    a0, common_exceptionThrown  # yes, handle it
8827
8828 .LOP_INVOKE_OBJECT_INIT_RANGE_finish:
8829     lhu     a1, offThread_subMode(rSELF)
8830     and     a1, kSubModeDebuggerActive  # debugger active?
8831     bnez    a1, .LOP_INVOKE_OBJECT_INIT_RANGE_debugger    # Yes - skip optimization
8832     FETCH_ADVANCE_INST(2+1)       # advance to next instr, load rINST
8833     GET_INST_OPCODE(t0)                 # t0<- opcode from rINST
8834     GOTO_OPCODE(t0)                     # execute it
8835
8836
8837 /* ------------------------------ */
8838     .balign 128
8839 .L_OP_RETURN_VOID_BARRIER: /* 0xf1 */
8840 /* File: mips/OP_RETURN_VOID_BARRIER.S */
8841     SMP_DMB
8842     b         common_returnFromMethod
8843
8844 /* ------------------------------ */
8845     .balign 128
8846 .L_OP_IGET_QUICK: /* 0xf2 */
8847 /* File: mips/OP_IGET_QUICK.S */
8848     /* For: iget-quick, iget-object-quick */
8849     # op vA, vB, offset                    /* CCCC */
8850     GET_OPB(a2)                            #  a2 <- B
8851     GET_VREG(a3, a2)                       #  a3 <- object we're operating on
8852     FETCH(a1, 1)                           #  a1 <- field byte offset
8853     GET_OPA4(a2)                           #  a2 <- A(+)
8854     # check object for null
8855     beqz      a3, common_errNullObject     #  object was null
8856     addu      t0, a3, a1 #
8857     lw        a0, 0(t0)                    #  a0 <- obj.field (always 32 bits)
8858     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8859     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8860     SET_VREG(a0, a2)                       #  fp[A] <- a0
8861     GOTO_OPCODE(t0)                        #  jump to next instruction
8862
8863
8864 /* ------------------------------ */
8865     .balign 128
8866 .L_OP_IGET_WIDE_QUICK: /* 0xf3 */
8867 /* File: mips/OP_IGET_WIDE_QUICK.S */
8868     # iget-wide-quick vA, vB, offset       /* CCCC */
8869     GET_OPB(a2)                            #  a2 <- B
8870     GET_VREG(a3, a2)                       #  a3 <- object we're operating on
8871     FETCH(a1, 1)                           #  a1 <- field byte offset
8872     GET_OPA4(a2)                           #  a2 <- A(+)
8873     # check object for null
8874     beqz      a3, common_errNullObject     #  object was null
8875     addu      t0, a3, a1                   #  t0 <- a3 + a1
8876     LOAD64(a0, a1, t0)                     #  a0 <- obj.field (64 bits, aligned)
8877     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8878     EAS2(a3, rFP, a2)
8879     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8880     STORE64(a0, a1, a3)                    #  fp[A] <- a0/a1
8881     GOTO_OPCODE(t0)                        #  jump to next instruction
8882
8883
8884 /* ------------------------------ */
8885     .balign 128
8886 .L_OP_IGET_OBJECT_QUICK: /* 0xf4 */
8887 /* File: mips/OP_IGET_OBJECT_QUICK.S */
8888 /* File: mips/OP_IGET_QUICK.S */
8889     /* For: iget-quick, iget-object-quick */
8890     # op vA, vB, offset                    /* CCCC */
8891     GET_OPB(a2)                            #  a2 <- B
8892     GET_VREG(a3, a2)                       #  a3 <- object we're operating on
8893     FETCH(a1, 1)                           #  a1 <- field byte offset
8894     GET_OPA4(a2)                           #  a2 <- A(+)
8895     # check object for null
8896     beqz      a3, common_errNullObject     #  object was null
8897     addu      t0, a3, a1 #
8898     lw        a0, 0(t0)                    #  a0 <- obj.field (always 32 bits)
8899     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8900     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8901     SET_VREG(a0, a2)                       #  fp[A] <- a0
8902     GOTO_OPCODE(t0)                        #  jump to next instruction
8903
8904
8905
8906 /* ------------------------------ */
8907     .balign 128
8908 .L_OP_IPUT_QUICK: /* 0xf5 */
8909 /* File: mips/OP_IPUT_QUICK.S */
8910     /* For: iput-quick, iput-object-quick */
8911     # op vA, vB, offset                    /* CCCC */
8912     GET_OPB(a2)                            #  a2 <- B
8913     GET_VREG(a3, a2)                       #  a3 <- fp[B], the object pointer
8914     FETCH(a1, 1)                           #  a1 <- field byte offset
8915     GET_OPA4(a2)                           #  a2 <- A(+)
8916     beqz      a3, common_errNullObject     #  object was null
8917     GET_VREG(a0, a2)                       #  a0 <- fp[A]
8918     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8919     addu      t0, a3, a1
8920     sw        a0, 0(t0)                    #  obj.field (always 32 bits) <- a0
8921     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8922     GOTO_OPCODE(t0)                        #  jump to next instruction
8923
8924
8925 /* ------------------------------ */
8926     .balign 128
8927 .L_OP_IPUT_WIDE_QUICK: /* 0xf6 */
8928 /* File: mips/OP_IPUT_WIDE_QUICK.S */
8929     # iput-wide-quick vA, vB, offset       /* CCCC */
8930     GET_OPA4(a0)                           #  a0 <- A(+)
8931     GET_OPB(a1)                            #  a1 <- B
8932     GET_VREG(a2, a1)                       #  a2 <- fp[B], the object pointer
8933     EAS2(a3, rFP, a0)                      #  a3 <- &fp[A]
8934     LOAD64(a0, a1, a3)                     #  a0/a1 <- fp[A]
8935     # check object for null
8936     beqz      a2, common_errNullObject     #  object was null
8937     FETCH(a3, 1)                           #  a3 <- field byte offset
8938     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8939     addu      a2, a2, a3                   #  obj.field (64 bits, aligned) <- a0/a1
8940     STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0/a1
8941     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8942     GOTO_OPCODE(t0)                        #  jump to next instruction
8943
8944
8945 /* ------------------------------ */
8946     .balign 128
8947 .L_OP_IPUT_OBJECT_QUICK: /* 0xf7 */
8948 /* File: mips/OP_IPUT_OBJECT_QUICK.S */
8949     /* For: iput-object-quick */
8950     # op vA, vB, offset                    /* CCCC */
8951     GET_OPB(a2)                            #  a2 <- B
8952     GET_VREG(a3, a2)                       #  a3 <- fp[B], the object pointer
8953     FETCH(a1, 1)                           #  a1 <- field byte offset
8954     GET_OPA4(a2)                           #  a2 <- A(+)
8955     beqz      a3, common_errNullObject     #  object was null
8956     GET_VREG(a0, a2)                       #  a0 <- fp[A]
8957     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
8958     addu      t0, a3, a1
8959     sw        a0, 0(t0)                    #  obj.field (always 32 bits) <- a0
8960     beqz      a0, 1f
8961     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
8962     srl       t1, a3, GC_CARD_SHIFT
8963     addu      t2, a2, t1
8964     sb        a2, 0(t2)
8965 1:
8966     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
8967     GOTO_OPCODE(t0)                        #  jump to next instruction
8968
8969 /* ------------------------------ */
8970     .balign 128
8971 .L_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */
8972 /* File: mips/OP_INVOKE_VIRTUAL_QUICK.S */
8973     /*
8974      * Handle an optimized virtual method call.
8975      *
8976      * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range
8977      */
8978     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
8979     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
8980     FETCH(a3, 2)                           #  a3 <- FEDC or CCCC
8981     FETCH(a1, 1)                           #  a1 <- BBBB
8982     .if (!0)
8983     and       a3, a3, 15                   #  a3 <- C (or stays CCCC)
8984     .endif
8985     GET_VREG(rOBJ, a3)                     #  rOBJ <- vC ("this" ptr)
8986     # is "this" null?
8987     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
8988     LOAD_base_offObject_clazz(a2, rOBJ)    #  a2 <- thisPtr->clazz
8989     LOAD_base_offClassObject_vtable(a2, a2) #  a2 <- thisPtr->clazz->vtable
8990     EXPORT_PC()                            #  invoke must export
8991     LOAD_eas2(a0, a2, a1)                  #  a0 <- vtable[BBBB]
8992     b         common_invokeMethodNoRange #  (a0=method, r9="this")
8993
8994 /* ------------------------------ */
8995     .balign 128
8996 .L_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */
8997 /* File: mips/OP_INVOKE_VIRTUAL_QUICK_RANGE.S */
8998 /* File: mips/OP_INVOKE_VIRTUAL_QUICK.S */
8999     /*
9000      * Handle an optimized virtual method call.
9001      *
9002      * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range
9003      */
9004     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
9005     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
9006     FETCH(a3, 2)                           #  a3 <- FEDC or CCCC
9007     FETCH(a1, 1)                           #  a1 <- BBBB
9008     .if (!1)
9009     and       a3, a3, 15                   #  a3 <- C (or stays CCCC)
9010     .endif
9011     GET_VREG(rOBJ, a3)                     #  rOBJ <- vC ("this" ptr)
9012     # is "this" null?
9013     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
9014     LOAD_base_offObject_clazz(a2, rOBJ)    #  a2 <- thisPtr->clazz
9015     LOAD_base_offClassObject_vtable(a2, a2) #  a2 <- thisPtr->clazz->vtable
9016     EXPORT_PC()                            #  invoke must export
9017     LOAD_eas2(a0, a2, a1)                  #  a0 <- vtable[BBBB]
9018     b         common_invokeMethodRange #  (a0=method, r9="this")
9019
9020
9021 /* ------------------------------ */
9022     .balign 128
9023 .L_OP_INVOKE_SUPER_QUICK: /* 0xfa */
9024 /* File: mips/OP_INVOKE_SUPER_QUICK.S */
9025     /*
9026      * Handle an optimized "super" method call.
9027      *
9028      * for: [opt] invoke-super-quick, invoke-super-quick/range
9029      */
9030     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
9031     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
9032     FETCH(t0, 2)                           #  t0 <- GFED or CCCC
9033     LOAD_rSELF_method(a2)                  #  a2 <- current method
9034     .if (!0)
9035     and       t0, t0, 15                   #  t0 <- D (or stays CCCC)
9036     .endif
9037     FETCH(a1, 1)                           #  a1 <- BBBB
9038     LOAD_base_offMethod_clazz(a2, a2)      #  a2 <- method->clazz
9039     EXPORT_PC()                            #  must export for invoke
9040     LOAD_base_offClassObject_super(a2, a2) #  a2 <- method->clazz->super
9041     GET_VREG(rOBJ, t0)                     #  rOBJ <- "this"
9042     LOAD_base_offClassObject_vtable(a2, a2) #  a2 <- ...clazz->super->vtable
9043     # is "this" null ?
9044     LOAD_eas2(a0, a2, a1)                  #  a0 <- super->vtable[BBBB]
9045     beqz      rOBJ, common_errNullObject   #  "this" is null, throw exception
9046     b         common_invokeMethodNoRange #  (a0=method, rOBJ="this")
9047
9048
9049 /* ------------------------------ */
9050     .balign 128
9051 .L_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */
9052 /* File: mips/OP_INVOKE_SUPER_QUICK_RANGE.S */
9053 /* File: mips/OP_INVOKE_SUPER_QUICK.S */
9054     /*
9055      * Handle an optimized "super" method call.
9056      *
9057      * for: [opt] invoke-super-quick, invoke-super-quick/range
9058      */
9059     # op vB, {vD, vE, vF, vG, vA}, class   /* CCCC */
9060     # op vAA, {vCCCC..v(CCCC+AA-1)}, meth  /* BBBB */
9061     FETCH(t0, 2)                           #  t0 <- GFED or CCCC
9062     LOAD_rSELF_method(a2)                  #  a2 <- current method
9063     .if (!1)
9064     and       t0, t0, 15                   #  t0 <- D (or stays CCCC)
9065     .endif
9066     FETCH(a1, 1)                           #  a1 <- BBBB
9067     LOAD_base_offMethod_clazz(a2, a2)      #  a2 <- method->clazz
9068     EXPORT_PC()                            #  must export for invoke
9069     LOAD_base_offClassObject_super(a2, a2) #  a2 <- method->clazz->super
9070     GET_VREG(rOBJ, t0)                     #  rOBJ <- "this"
9071     LOAD_base_offClassObject_vtable(a2, a2) #  a2 <- ...clazz->super->vtable
9072     # is "this" null ?
9073     LOAD_eas2(a0, a2, a1)                  #  a0 <- super->vtable[BBBB]
9074     beqz      rOBJ, common_errNullObject   #  "this" is null, throw exception
9075     b         common_invokeMethodRange #  (a0=method, rOBJ="this")
9076
9077
9078
9079 /* ------------------------------ */
9080     .balign 128
9081 .L_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */
9082 /* File: mips/OP_IPUT_OBJECT_VOLATILE.S */
9083 /* File: mips/OP_IPUT_OBJECT.S */
9084     /*
9085      * 32-bit instance field put.
9086      *
9087      * for: iput-object, iput-object-volatile
9088      */
9089     # op vA, vB, field                     /* CCCC */
9090     GET_OPB(a0)                            #  a0 <- B
9091     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9092     FETCH(a1, 1)                           #  a1 <- field ref CCCC
9093     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9094     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9095     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9096     # is resolved entry null?
9097     bnez      a0, .LOP_IPUT_OBJECT_VOLATILE_finish       #  no, already resolved
9098     LOAD_rSELF_method(a2)                  #  a2 <- current method
9099     EXPORT_PC()                            #  resolve() could throw
9100     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9101     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9102     # success?
9103     move      a0, v0
9104     bnez      v0, .LOP_IPUT_OBJECT_VOLATILE_finish       #  yes, finish up
9105     b         common_exceptionThrown
9106
9107
9108 /* ------------------------------ */
9109     .balign 128
9110 .L_OP_SGET_OBJECT_VOLATILE: /* 0xfd */
9111 /* File: mips/OP_SGET_OBJECT_VOLATILE.S */
9112 /* File: mips/OP_SGET.S */
9113     /*
9114      * General 32-bit SGET handler.
9115      *
9116      * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
9117      */
9118     # op vAA, field                        /* BBBB */
9119     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
9120     FETCH(a1, 1)                           #  a1 <- field ref BBBB
9121     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
9122     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
9123     # is resolved entry !null?
9124     bnez      a0, .LOP_SGET_OBJECT_VOLATILE_finish
9125
9126     /*
9127      * Continuation if the field has not yet been resolved.
9128      *  a1:  BBBB field ref
9129      *  rBIX: dvmDex->pResFields
9130      */
9131     LOAD_rSELF_method(a2)                  #  a2 <- current method
9132 #if defined(WITH_JIT)
9133     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
9134 #endif
9135     EXPORT_PC()                            #  resolve() could throw, so export now
9136     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9137     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
9138     move      a0, v0
9139     # success?
9140     beqz      v0, common_exceptionThrown   #  no, handle exception
9141 #if defined(WITH_JIT)
9142     /*
9143      * If the JIT is actively building a trace we need to make sure
9144      * that the field is fully resolved before including this instruction.
9145      */
9146     JAL(common_verifyField)
9147 #endif
9148     b        .LOP_SGET_OBJECT_VOLATILE_finish            # resume
9149
9150
9151 /* ------------------------------ */
9152     .balign 128
9153 .L_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */
9154 /* File: mips/OP_SPUT_OBJECT_VOLATILE.S */
9155 /* File: mips/OP_SPUT_OBJECT.S */
9156     /*
9157      * General 32-bit SPUT handler.
9158      *
9159      * for: sput-object, sput-object-volatile
9160      */
9161     /* op vAA, field@BBBB */
9162     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
9163     FETCH(a1, 1)                           #  a1 <- field ref BBBB
9164     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
9165     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
9166     bnez      a0, .LOP_SPUT_OBJECT_VOLATILE_finish       #  is resolved entry null?
9167
9168     /* Continuation if the field has not yet been resolved.
9169      * a1:  BBBB field ref
9170      * rBIX: dvmDex->pResFields
9171      */
9172     LOAD_rSELF_method(a2)                  #  a2 <- current method
9173 #if defined(WITH_JIT)
9174     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
9175 #endif
9176     EXPORT_PC()                            #  resolve() may throw, so export now
9177     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9178     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
9179     move      a0, v0
9180     beqz      v0, common_exceptionThrown   #  success? no, handle exception
9181 #if defined(WITH_JIT)
9182     /*
9183      * If the JIT is actively building a trace we need to make sure
9184      * that the field is fully resolved before including this instruction.
9185      */
9186     JAL(common_verifyField)
9187 #endif
9188     b       .LOP_SPUT_OBJECT_VOLATILE_finish             # resume
9189
9190
9191
9192 /* ------------------------------ */
9193     .balign 128
9194 .L_OP_DISPATCH_FF: /* 0xff */
9195     /* (stub) */
9196     SAVE_PC_TO_SELF()            # only need to export PC and FP
9197     SAVE_FP_TO_SELF()
9198     move        a0, rSELF        # self is first arg to function
9199     JAL(dvmMterp_OP_DISPATCH_FF)      # call
9200     LOAD_PC_FROM_SELF()          # retrieve updated values
9201     LOAD_FP_FROM_SELF()
9202     FETCH_INST()                 # load next instruction from rPC
9203     GET_INST_OPCODE(t0)          # ...trim down to just the opcode
9204     GOTO_OPCODE(t0)              # ...and jump to the handler
9205 /* ------------------------------ */
9206     .balign 128
9207 .L_OP_CONST_CLASS_JUMBO: /* 0x100 */
9208 /* File: mips/OP_CONST_CLASS_JUMBO.S */
9209     /* const-class/jumbo vBBBB, Class@AAAAAAAA */
9210     FETCH(a0, 1)                           # a0<- aaaa (lo)
9211     LOAD_rSELF_methodClassDex(a2)          #  a2 <- self->methodClassDex
9212     FETCH(a1, 2)                           # a1<- AAAA (hi)
9213     LOAD_base_offDvmDex_pResClasses(a2, a2) #  a2 <- dvmDex->pResClasses
9214     sll       a1,a1,16
9215     or        a1, a0, a1                  # a1<- AAAAaaaa
9216     FETCH(rOBJ, 3)                        # rOBJ<- BBBB
9217     LOAD_eas2(v0, a2, a1)                  #  v0 <- pResClasses[BBBB]
9218
9219     bnez      v0, .LOP_CONST_CLASS_JUMBO_resolve      #  v0!=0 => resolved-ok
9220     /*
9221      * Continuation if the Class has not yet been resolved.
9222      *  a1: AAAAAAAA (Class ref)
9223      *  rOBJ: target register
9224      */
9225     EXPORT_PC()
9226     LOAD_rSELF_method(a0)                  #  a0 <- self->method
9227     li        a2, 1                        #  a2 <- true
9228     LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
9229     JAL(dvmResolveClass)                   #  v0 <- Class reference
9230     # failed==0?
9231     beqz      v0, common_exceptionThrown   #  yup, handle the exception
9232
9233 .LOP_CONST_CLASS_JUMBO_resolve:
9234     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
9235     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
9236     SET_VREG_GOTO(v0, rOBJ, t0)            #  vBBBB <- v0
9237
9238
9239
9240 /* ------------------------------ */
9241     .balign 128
9242 .L_OP_CHECK_CAST_JUMBO: /* 0x101 */
9243 /* File: mips/OP_CHECK_CAST_JUMBO.S */
9244     /*
9245      * Check to see if a cast from one class to another is allowed.
9246      */
9247     /* check-cast/ jumbo vBBBB, class #AAAAAAAA */
9248     FETCH(a0, 1)                        # a0<- aaaa (lo)
9249     FETCH(a2, 2)                        # a2<- AAAA (hi)
9250     FETCH(a3, 3)                        # a3<- BBBB
9251     sll    a2,a2,16
9252     or     a2, a0, a2                   # a2<- AAAAaaaa
9253
9254     GET_VREG(rOBJ, a3)                          # rOBJ<- object
9255     LOAD_rSELF_methodClassDex(a0)   # a0<- pDvmDex
9256     LOAD_base_offDvmDex_pResClasses(a0, a0) # a0<- pDvmDex->pResClasses
9257                                                 # is object null?
9258     beqz     rOBJ, .LOP_CHECK_CAST_JUMBO_okay             # null obj, cast always succeeds
9259     LOAD_eas2(a1, a0, a2)           # a1<- resolved class
9260     LOAD_base_offObject_clazz(a0, rOBJ)   # a0<- obj->clazz
9261                                                 # have we resolved this before?
9262     beqz    a1, .LOP_CHECK_CAST_JUMBO_resolve             # not resolved, do it now
9263 .LOP_CHECK_CAST_JUMBO_resolved:
9264                                                 # same class (trivial success)?
9265     bne     a0, a1, .LOP_CHECK_CAST_JUMBO_fullcheck       # no, do full check
9266     b       .LOP_CHECK_CAST_JUMBO_okay                    # yes, finish up
9267
9268     /*
9269      * Trivial test failed, need to perform full check.  This is common.
9270      *  a0 holds obj->clazz
9271      *  a1 holds class resolved from BBBB
9272      *  rOBJ holds object
9273      */
9274 .LOP_CHECK_CAST_JUMBO_fullcheck:
9275     move      rBIX,a1                      #  avoid ClassObject getting clobbered
9276     JAL(dvmInstanceofNonTrivial)    # v0<- boolean result
9277                                                 # failed?
9278     bnez    v0, .LOP_CHECK_CAST_JUMBO_okay                # no, success
9279     b       .LOP_CHECK_CAST_JUMBO_castfailure
9280
9281
9282 /* ------------------------------ */
9283     .balign 128
9284 .L_OP_INSTANCE_OF_JUMBO: /* 0x102 */
9285 /* File: mips/OP_INSTANCE_OF_JUMBO.S */
9286     /*
9287      * Check to see if an object reference is an instance of a class.
9288      *
9289      * Most common situation is a non-null object, being compared against
9290      * an already-resolved class.
9291      *
9292      * TODO: convert most of this into a common subroutine, shared with
9293      *       OP_INSTANCE_OF.S.
9294      */
9295     /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */
9296     FETCH(a3, 4)                           # a3<- vCCCC
9297     FETCH(rOBJ, 3)                         # rOBJ<- vBBBB
9298     GET_VREG(a0, a3)                       #  a0 <- vCCCC (object)
9299     LOAD_rSELF_methodClassDex(a2)          #  a2 <- pDvmDex
9300     # is object null?
9301     beqz      a0, .LOP_INSTANCE_OF_JUMBO_store        #  null obj, not an instance, store a0
9302     FETCH(a1, 1)                           # r1<- aaaa (lo)
9303     FETCH(a3, 2)                           # r3<- AAAA (hi)
9304     LOAD_base_offDvmDex_pResClasses(a2, a2) #  a2 <- pDvmDex->pResClasses
9305     sll     a3,a3,16
9306     or      a3, a1, a3                     # a3<- AAAAaaaa
9307
9308     LOAD_eas2(a1, a2, a3)                  #  a1 <- resolved class
9309     LOAD_base_offObject_clazz(a0, a0)      #  a0 <- obj->clazz
9310     # have we resolved this before?
9311     beqz      a1, .LOP_INSTANCE_OF_JUMBO_resolve      #  not resolved, do it now
9312     b       .LOP_INSTANCE_OF_JUMBO_resolved           # resolved, continue
9313
9314
9315 /* ------------------------------ */
9316     .balign 128
9317 .L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */
9318 /* File: mips/OP_NEW_INSTANCE_JUMBO.S */
9319     /*
9320      * Create a new instance of a class.
9321      */
9322     /* new-instance/jumbo vBBBB, class@AAAAAAAA */
9323     FETCH(a0, 1)                            # a0<- aaaa (lo)DvmDex
9324     FETCH(a1, 2)                            # a1<- AAAA (hi)BBB
9325     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
9326     sll      a1,a1,16
9327     or       a1, a0, a1                    # a1<- AAAAaaaa
9328     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
9329 #if defined(WITH_JIT)
9330     EAS2(rBIX, a3, a1)                     #  rBIX <- &resolved_class
9331 #endif
9332     EXPORT_PC()                            #  req'd for init, resolve, alloc
9333     # already resolved?
9334     beqz      a0, .LOP_NEW_INSTANCE_JUMBO_resolve      #  no, resolve it now
9335 .LOP_NEW_INSTANCE_JUMBO_resolved:                   #  a0=class
9336     lbu       a1, offClassObject_status(a0) #  a1 <- ClassStatus enum
9337     # has class been initialized?
9338     li        t0, CLASS_INITIALIZED
9339     move      rOBJ, a0                     #  save a0
9340     bne       a1, t0, .LOP_NEW_INSTANCE_JUMBO_needinit #  no, init class now
9341
9342 .LOP_NEW_INSTANCE_JUMBO_initialized:                #  a0=class
9343     LOAD_base_offClassObject_accessFlags(a3, a0) #  a3 <- clazz->accessFlags
9344     li        a1, ALLOC_DONT_TRACK         #  flags for alloc call
9345     # a0=class
9346     JAL(dvmAllocObject)                    #  v0 <- new object
9347     FETCH(a3, 3)                           # a3<- BBBB
9348 #if defined(WITH_JIT)
9349     /*
9350      * The JIT needs the class to be fully resolved before it can
9351      * include this instruction in a trace.
9352      */
9353     lhu       a1, offThread_subMode(rSELF)
9354     beqz      v0, common_exceptionThrown   #  yes, handle the exception
9355     and       a1, kSubModeJitTraceBuild    #  under construction?
9356     bnez      a1, .LOP_NEW_INSTANCE_JUMBO_jitCheck
9357 #else
9358     # failed?
9359     beqz      v0, common_exceptionThrown   #  yes, handle the exception
9360 #endif
9361     b         .LOP_NEW_INSTANCE_JUMBO_continue
9362
9363
9364 /* ------------------------------ */
9365     .balign 128
9366 .L_OP_NEW_ARRAY_JUMBO: /* 0x104 */
9367 /* File: mips/OP_NEW_ARRAY_JUMBO.S */
9368     /*
9369      * Allocate an array of objects, specified with the array class
9370      * and a count.
9371      *
9372      * The verifier guarantees that this is an array class, so we don't
9373      * check for it here.
9374      */
9375     /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */
9376     FETCH(a2, 1)                           # a2<- aaaa (lo)
9377     FETCH(a3, 2)                           # a3<- AAAA (hi)
9378     FETCH(a0, 4)                           # a0<- vCCCC
9379     sll     a3,a3,16                       #
9380     or      a2, a2, a3                     # a2<- AAAAaaaa
9381
9382     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
9383     GET_VREG(a1, a0)                       #  a1 <- vCCCC (array length)
9384     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
9385     LOAD_eas2(a0, a3, a2)                  #  a0 <- resolved class
9386     # check length
9387     bltz      a1, common_errNegativeArraySize #  negative length, bail - len in a1
9388     EXPORT_PC()                            #  req'd for resolve, alloc
9389     # already resolved?
9390     beqz      a0, .LOP_NEW_ARRAY_JUMBO_resolve      #  not resolved,
9391     b         .LOP_NEW_ARRAY_JUMBO_finish
9392
9393 /* ------------------------------ */
9394     .balign 128
9395 .L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */
9396 /* File: mips/OP_FILLED_NEW_ARRAY_JUMBO.S */
9397     /*
9398      * Create a new array with elements filled from registers.
9399      *
9400      * TODO: convert most of this into a common subroutine, shared with
9401      *       OP_FILLED_NEW_ARRAY.S.
9402      */
9403      /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */
9404
9405     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
9406     FETCH(a0, 1)                           # r0<- aaaa (lo)
9407     FETCH(a1, 2)                           # r1<- AAAA (hi)
9408     LOAD_base_offDvmDex_pResClasses(a3, a3) #  a3 <- pDvmDex->pResClasses
9409     sll       a1,a1,16
9410     or        a1, a0, a1                   # a1<- AAAAaaaa
9411     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved class
9412     GET_OPA(rOBJ)                          #  rOBJ <- AA or BA
9413     EXPORT_PC()                            #  need for resolve and alloc
9414     # already resolved?
9415     bnez      a0, .LOP_FILLED_NEW_ARRAY_JUMBO_continue     #  yes, continue on
9416     LOAD_rSELF_method(a3)                  #  a3 <- self->method
9417     li        a2, 0                        #  a2 <- false
9418     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
9419     JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
9420     move      a0, v0
9421     # got null?
9422     beqz      v0, common_exceptionThrown   #  yes, handle exception
9423     b         .LOP_FILLED_NEW_ARRAY_JUMBO_continue
9424
9425 /* ------------------------------ */
9426     .balign 128
9427 .L_OP_IGET_JUMBO: /* 0x106 */
9428 /* File: mips/OP_IGET_JUMBO.S */
9429     /*
9430      * Jumbo 32-bit instance field get.
9431      *
9432      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
9433      *      iget-char/jumbo, iget-short/jumbo
9434      */
9435     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9436     FETCH(a1, 1)                           # a1<- aaaa (lo)
9437     FETCH(a2, 2)                           # a2<- AAAA (hi)
9438     FETCH(a0, 4)                           # a0<- CCCC
9439     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9440     sll     a2,a2,16
9441     or      a1, a1, a2                     # a1<- AAAAaaaa
9442     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9443     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9444     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9445     # is resolved entry null?
9446     bnez      a0, .LOP_IGET_JUMBO_finish       #  no, already resolved
9447     LOAD_rSELF_method(a2)                  #  a2 <- current method
9448     EXPORT_PC()                            #  resolve() could throw
9449     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9450     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9451     b       .LOP_IGET_JUMBO_resolved        # resolved, continue
9452
9453
9454 /* ------------------------------ */
9455     .balign 128
9456 .L_OP_IGET_WIDE_JUMBO: /* 0x107 */
9457 /* File: mips/OP_IGET_WIDE_JUMBO.S */
9458     /*
9459      * Jumbo 64-bit instance field get.
9460      */
9461     /* iget-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
9462     FETCH(a1, 1)                           # a1<- aaaa (lo)
9463     FETCH(a2, 2)                           # a2<- AAAA (hi)
9464     FETCH(a0, 4)                           # a0<- CCCC
9465     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9466     sll    a2,a2,16
9467     or     a1, a1, a2                      # a1<- AAAAaaaa
9468     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
9469     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[CCCC], the object pointer
9470     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9471     # is resolved entry null?
9472     bnez      a0, .LOP_IGET_WIDE_JUMBO_finish       #  no, already resolved
9473     LOAD_rSELF_method(a2)                  #  a2 <- current method
9474     EXPORT_PC()                            #  resolve() could throw
9475     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9476     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9477     b       .LOP_IGET_WIDE_JUMBO_resolved           # resolved, continue
9478
9479
9480 /* ------------------------------ */
9481     .balign 128
9482 .L_OP_IGET_OBJECT_JUMBO: /* 0x108 */
9483 /* File: mips/OP_IGET_OBJECT_JUMBO.S */
9484 /* File: mips/OP_IGET_JUMBO.S */
9485     /*
9486      * Jumbo 32-bit instance field get.
9487      *
9488      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
9489      *      iget-char/jumbo, iget-short/jumbo
9490      */
9491     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9492     FETCH(a1, 1)                           # a1<- aaaa (lo)
9493     FETCH(a2, 2)                           # a2<- AAAA (hi)
9494     FETCH(a0, 4)                           # a0<- CCCC
9495     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9496     sll     a2,a2,16
9497     or      a1, a1, a2                     # a1<- AAAAaaaa
9498     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9499     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9500     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9501     # is resolved entry null?
9502     bnez      a0, .LOP_IGET_OBJECT_JUMBO_finish       #  no, already resolved
9503     LOAD_rSELF_method(a2)                  #  a2 <- current method
9504     EXPORT_PC()                            #  resolve() could throw
9505     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9506     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9507     b       .LOP_IGET_OBJECT_JUMBO_resolved        # resolved, continue
9508
9509
9510
9511 /* ------------------------------ */
9512     .balign 128
9513 .L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */
9514 /* File: mips/OP_IGET_BOOLEAN_JUMBO.S */
9515 /* File: mips/OP_IGET_JUMBO.S */
9516     /*
9517      * Jumbo 32-bit instance field get.
9518      *
9519      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
9520      *      iget-char/jumbo, iget-short/jumbo
9521      */
9522     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9523     FETCH(a1, 1)                           # a1<- aaaa (lo)
9524     FETCH(a2, 2)                           # a2<- AAAA (hi)
9525     FETCH(a0, 4)                           # a0<- CCCC
9526     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9527     sll     a2,a2,16
9528     or      a1, a1, a2                     # a1<- AAAAaaaa
9529     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9530     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9531     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9532     # is resolved entry null?
9533     bnez      a0, .LOP_IGET_BOOLEAN_JUMBO_finish       #  no, already resolved
9534     LOAD_rSELF_method(a2)                  #  a2 <- current method
9535     EXPORT_PC()                            #  resolve() could throw
9536     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9537     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9538     b       .LOP_IGET_BOOLEAN_JUMBO_resolved        # resolved, continue
9539
9540
9541
9542 /* ------------------------------ */
9543     .balign 128
9544 .L_OP_IGET_BYTE_JUMBO: /* 0x10a */
9545 /* File: mips/OP_IGET_BYTE_JUMBO.S */
9546 /* File: mips/OP_IGET_JUMBO.S */
9547     /*
9548      * Jumbo 32-bit instance field get.
9549      *
9550      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
9551      *      iget-char/jumbo, iget-short/jumbo
9552      */
9553     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9554     FETCH(a1, 1)                           # a1<- aaaa (lo)
9555     FETCH(a2, 2)                           # a2<- AAAA (hi)
9556     FETCH(a0, 4)                           # a0<- CCCC
9557     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9558     sll     a2,a2,16
9559     or      a1, a1, a2                     # a1<- AAAAaaaa
9560     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9561     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9562     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9563     # is resolved entry null?
9564     bnez      a0, .LOP_IGET_BYTE_JUMBO_finish       #  no, already resolved
9565     LOAD_rSELF_method(a2)                  #  a2 <- current method
9566     EXPORT_PC()                            #  resolve() could throw
9567     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9568     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9569     b       .LOP_IGET_BYTE_JUMBO_resolved        # resolved, continue
9570
9571
9572
9573 /* ------------------------------ */
9574     .balign 128
9575 .L_OP_IGET_CHAR_JUMBO: /* 0x10b */
9576 /* File: mips/OP_IGET_CHAR_JUMBO.S */
9577 /* File: mips/OP_IGET_JUMBO.S */
9578     /*
9579      * Jumbo 32-bit instance field get.
9580      *
9581      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
9582      *      iget-char/jumbo, iget-short/jumbo
9583      */
9584     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9585     FETCH(a1, 1)                           # a1<- aaaa (lo)
9586     FETCH(a2, 2)                           # a2<- AAAA (hi)
9587     FETCH(a0, 4)                           # a0<- CCCC
9588     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9589     sll     a2,a2,16
9590     or      a1, a1, a2                     # a1<- AAAAaaaa
9591     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9592     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9593     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9594     # is resolved entry null?
9595     bnez      a0, .LOP_IGET_CHAR_JUMBO_finish       #  no, already resolved
9596     LOAD_rSELF_method(a2)                  #  a2 <- current method
9597     EXPORT_PC()                            #  resolve() could throw
9598     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9599     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9600     b       .LOP_IGET_CHAR_JUMBO_resolved        # resolved, continue
9601
9602
9603
9604 /* ------------------------------ */
9605     .balign 128
9606 .L_OP_IGET_SHORT_JUMBO: /* 0x10c */
9607 /* File: mips/OP_IGET_SHORT_JUMBO.S */
9608 /* File: mips/OP_IGET_JUMBO.S */
9609     /*
9610      * Jumbo 32-bit instance field get.
9611      *
9612      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
9613      *      iget-char/jumbo, iget-short/jumbo
9614      */
9615     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9616     FETCH(a1, 1)                           # a1<- aaaa (lo)
9617     FETCH(a2, 2)                           # a2<- AAAA (hi)
9618     FETCH(a0, 4)                           # a0<- CCCC
9619     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9620     sll     a2,a2,16
9621     or      a1, a1, a2                     # a1<- AAAAaaaa
9622     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9623     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9624     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9625     # is resolved entry null?
9626     bnez      a0, .LOP_IGET_SHORT_JUMBO_finish       #  no, already resolved
9627     LOAD_rSELF_method(a2)                  #  a2 <- current method
9628     EXPORT_PC()                            #  resolve() could throw
9629     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9630     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9631     b       .LOP_IGET_SHORT_JUMBO_resolved        # resolved, continue
9632
9633
9634
9635 /* ------------------------------ */
9636     .balign 128
9637 .L_OP_IPUT_JUMBO: /* 0x10d */
9638 /* File: mips/OP_IPUT_JUMBO.S */
9639     /*
9640      * Jumbo 32-bit instance field put.
9641      *
9642      * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
9643      *      iput-short/jumbo
9644      */
9645     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9646     FETCH(a1, 1)                           # a1<- aaaa (lo)
9647     FETCH(a2, 2)                           # a2<- AAAA (hi)
9648     FETCH(a0, 4)                           # a0<- CCCC
9649     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9650     sll       a2,a2,16
9651     or        a1, a1, a2                   #  a1<- AAAAaaaa
9652     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9653     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9654     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9655     # is resolved entry null?
9656     bnez      a0, .LOP_IPUT_JUMBO_finish       #  no, already resolved
9657     LOAD_rSELF_method(a2)                  #  a2 <- current method
9658     EXPORT_PC()                            #  resolve() could throw
9659     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9660     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9661     b       .LOP_IPUT_JUMBO_resolved           # resolved, continue
9662
9663
9664 /* ------------------------------ */
9665     .balign 128
9666 .L_OP_IPUT_WIDE_JUMBO: /* 0x10e */
9667 /* File: mips/OP_IPUT_WIDE_JUMBO.S */
9668     /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
9669     FETCH(a1, 1)                           # a1<- aaaa (lo)
9670     FETCH(a2, 2)                           # a2<- AAAA (hi)
9671     FETCH(a0, 4)                           # a0<- CCCC
9672     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9673     sll       a2,a2,16
9674     or        a1, a1, a2                   # a1<- AAAAaaaa
9675
9676     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
9677     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9678     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9679     # is resolved entry null?
9680     bnez      a0, .LOP_IPUT_WIDE_JUMBO_finish       #  no, already resolved
9681     LOAD_rSELF_method(a2)                  #  a2 <- current method
9682     EXPORT_PC()                            #  resolve() could throw
9683     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9684     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9685     b       .LOP_IPUT_WIDE_JUMBO_resolved           # resolved, continue
9686
9687
9688 /* ------------------------------ */
9689     .balign 128
9690 .L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */
9691 /* File: mips/OP_IPUT_OBJECT_JUMBO.S */
9692     /*
9693      * Jumbo 32-bit instance field put.
9694      */
9695     /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */
9696     FETCH(a1, 1)                           # a1<- aaaa (lo)
9697     FETCH(a2, 2)                           # a2<- AAAA (hi)
9698     FETCH(a0, 4)                           # a0<- CCCC
9699     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9700     sll      a1,a1,16
9701     or       a1, a1, a2                    # a1<- AAAAaaaa
9702     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9703     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9704     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9705     # is resolved entry null?
9706     bnez      a0, .LOP_IPUT_OBJECT_JUMBO_finish       #  no, already resolved
9707     LOAD_rSELF_method(a2)                  #  a2 <- current method
9708     EXPORT_PC()                            #  resolve() could throw
9709     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9710     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9711     b         .LOP_IPUT_OBJECT_JUMBO_resolved
9712
9713
9714 /* ------------------------------ */
9715     .balign 128
9716 .L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */
9717 /* File: mips/OP_IPUT_BOOLEAN_JUMBO.S */
9718 /* File: mips/OP_IPUT_JUMBO.S */
9719     /*
9720      * Jumbo 32-bit instance field put.
9721      *
9722      * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
9723      *      iput-short/jumbo
9724      */
9725     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9726     FETCH(a1, 1)                           # a1<- aaaa (lo)
9727     FETCH(a2, 2)                           # a2<- AAAA (hi)
9728     FETCH(a0, 4)                           # a0<- CCCC
9729     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9730     sll       a2,a2,16
9731     or        a1, a1, a2                   #  a1<- AAAAaaaa
9732     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9733     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9734     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9735     # is resolved entry null?
9736     bnez      a0, .LOP_IPUT_BOOLEAN_JUMBO_finish       #  no, already resolved
9737     LOAD_rSELF_method(a2)                  #  a2 <- current method
9738     EXPORT_PC()                            #  resolve() could throw
9739     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9740     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9741     b       .LOP_IPUT_BOOLEAN_JUMBO_resolved           # resolved, continue
9742
9743
9744
9745 /* ------------------------------ */
9746     .balign 128
9747 .L_OP_IPUT_BYTE_JUMBO: /* 0x111 */
9748 /* File: mips/OP_IPUT_BYTE_JUMBO.S */
9749 /* File: mips/OP_IPUT_JUMBO.S */
9750     /*
9751      * Jumbo 32-bit instance field put.
9752      *
9753      * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
9754      *      iput-short/jumbo
9755      */
9756     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9757     FETCH(a1, 1)                           # a1<- aaaa (lo)
9758     FETCH(a2, 2)                           # a2<- AAAA (hi)
9759     FETCH(a0, 4)                           # a0<- CCCC
9760     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9761     sll       a2,a2,16
9762     or        a1, a1, a2                   #  a1<- AAAAaaaa
9763     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9764     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9765     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9766     # is resolved entry null?
9767     bnez      a0, .LOP_IPUT_BYTE_JUMBO_finish       #  no, already resolved
9768     LOAD_rSELF_method(a2)                  #  a2 <- current method
9769     EXPORT_PC()                            #  resolve() could throw
9770     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9771     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9772     b       .LOP_IPUT_BYTE_JUMBO_resolved           # resolved, continue
9773
9774
9775
9776 /* ------------------------------ */
9777     .balign 128
9778 .L_OP_IPUT_CHAR_JUMBO: /* 0x112 */
9779 /* File: mips/OP_IPUT_CHAR_JUMBO.S */
9780 /* File: mips/OP_IPUT_JUMBO.S */
9781     /*
9782      * Jumbo 32-bit instance field put.
9783      *
9784      * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
9785      *      iput-short/jumbo
9786      */
9787     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9788     FETCH(a1, 1)                           # a1<- aaaa (lo)
9789     FETCH(a2, 2)                           # a2<- AAAA (hi)
9790     FETCH(a0, 4)                           # a0<- CCCC
9791     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9792     sll       a2,a2,16
9793     or        a1, a1, a2                   #  a1<- AAAAaaaa
9794     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9795     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9796     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9797     # is resolved entry null?
9798     bnez      a0, .LOP_IPUT_CHAR_JUMBO_finish       #  no, already resolved
9799     LOAD_rSELF_method(a2)                  #  a2 <- current method
9800     EXPORT_PC()                            #  resolve() could throw
9801     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9802     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9803     b       .LOP_IPUT_CHAR_JUMBO_resolved           # resolved, continue
9804
9805
9806
9807 /* ------------------------------ */
9808     .balign 128
9809 .L_OP_IPUT_SHORT_JUMBO: /* 0x113 */
9810 /* File: mips/OP_IPUT_SHORT_JUMBO.S */
9811 /* File: mips/OP_IPUT_JUMBO.S */
9812     /*
9813      * Jumbo 32-bit instance field put.
9814      *
9815      * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
9816      *      iput-short/jumbo
9817      */
9818     /* exop vBBBB, vCCCC, field@AAAAAAAA */
9819     FETCH(a1, 1)                           # a1<- aaaa (lo)
9820     FETCH(a2, 2)                           # a2<- AAAA (hi)
9821     FETCH(a0, 4)                           # a0<- CCCC
9822     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
9823     sll       a2,a2,16
9824     or        a1, a1, a2                   #  a1<- AAAAaaaa
9825     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
9826     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
9827     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
9828     # is resolved entry null?
9829     bnez      a0, .LOP_IPUT_SHORT_JUMBO_finish       #  no, already resolved
9830     LOAD_rSELF_method(a2)                  #  a2 <- current method
9831     EXPORT_PC()                            #  resolve() could throw
9832     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9833     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
9834     b       .LOP_IPUT_SHORT_JUMBO_resolved           # resolved, continue
9835
9836
9837
9838 /* ------------------------------ */
9839     .balign 128
9840 .L_OP_SGET_JUMBO: /* 0x114 */
9841 /* File: mips/OP_SGET_JUMBO.S */
9842      /*
9843      * Jumbo 32-bit SGET handler.
9844      *
9845      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9846      *      sget-char/jumbo, sget-short/jumbo
9847      */
9848      /* exop vBBBB, field@AAAAAAAA */
9849     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
9850     FETCH(a0, 1)                           # a0<- aaaa (lo)
9851     FETCH(a1, 2)                           # a1<- AAAA (hi)
9852     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
9853     sll       a1,a1,16
9854     or        a1, a0, a1                   # a1<- AAAAaaaa
9855     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
9856     # is resolved entry !null?
9857     bnez      a0, .LOP_SGET_JUMBO_finish
9858
9859     /*
9860      * Continuation if the field has not yet been resolved.
9861      *  a1:  AAAAAAAA field ref
9862      *  rBIX: dvmDex->pResFields
9863      */
9864     LOAD_rSELF_method(a2)                  #  a2 <- current method
9865 #if defined(WITH_JIT)
9866     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
9867 #endif
9868     EXPORT_PC()                            #  resolve() could throw, so export now
9869     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9870     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
9871     move      a0, v0
9872     # success?
9873     beqz      v0, common_exceptionThrown   #  no, handle exception
9874 #if defined(WITH_JIT)
9875     /*
9876      * If the JIT is actively building a trace we need to make sure
9877      * that the field is fully resolved before including this instruction.
9878      */
9879     JAL(common_verifyField)
9880 #endif
9881     b        .LOP_SGET_JUMBO_finish            # resume
9882
9883 /* ------------------------------ */
9884     .balign 128
9885 .L_OP_SGET_WIDE_JUMBO: /* 0x115 */
9886 /* File: mips/OP_SGET_WIDE_JUMBO.S */
9887     /*
9888      * Jumbo 64-bit SGET handler.
9889      */
9890     /* sget-wide/jumbo vBBBB, field@AAAAAAAA */
9891     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
9892     FETCH(a0, 1)                           # a0<- aaaa (lo)
9893     FETCH(a1, 2)                           # a1<- AAAA (hi)
9894     LOAD_base_offDvmDex_pResFields(a2, a2) #  a2 <- dvmDex->pResFields
9895     sll       a1,a1,16
9896     or        a1, a0, a1                 # a1<- AAAAaaaa
9897     LOAD_eas2(a0, a2, a1)                #  a0 <- resolved StaticField ptr
9898     # is resolved entry null?
9899     bnez      a0, .LOP_SGET_WIDE_JUMBO_finish
9900
9901     /*
9902      * Continuation if the field has not yet been resolved.
9903      *  a1:  AAAAAAAA field ref
9904      *
9905      * Returns StaticField pointer in v0.
9906      */
9907     LOAD_rSELF_method(a2)                  #  a2 <- current method
9908     EXPORT_PC()                            #  resolve() could throw, so export now
9909     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9910     JAL(dvmResolveStaticField)             #  a0 <- resolved StaticField ptr
9911     move      a0, v0
9912     # success?
9913     beqz      v0, common_exceptionThrown   #  no, handle exception
9914     b        .LOP_SGET_WIDE_JUMBO_finish            # resume
9915
9916 /* ------------------------------ */
9917     .balign 128
9918 .L_OP_SGET_OBJECT_JUMBO: /* 0x116 */
9919 /* File: mips/OP_SGET_OBJECT_JUMBO.S */
9920 /* File: mips/OP_SGET_JUMBO.S */
9921      /*
9922      * Jumbo 32-bit SGET handler.
9923      *
9924      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9925      *      sget-char/jumbo, sget-short/jumbo
9926      */
9927      /* exop vBBBB, field@AAAAAAAA */
9928     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
9929     FETCH(a0, 1)                           # a0<- aaaa (lo)
9930     FETCH(a1, 2)                           # a1<- AAAA (hi)
9931     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
9932     sll       a1,a1,16
9933     or        a1, a0, a1                   # a1<- AAAAaaaa
9934     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
9935     # is resolved entry !null?
9936     bnez      a0, .LOP_SGET_OBJECT_JUMBO_finish
9937
9938     /*
9939      * Continuation if the field has not yet been resolved.
9940      *  a1:  AAAAAAAA field ref
9941      *  rBIX: dvmDex->pResFields
9942      */
9943     LOAD_rSELF_method(a2)                  #  a2 <- current method
9944 #if defined(WITH_JIT)
9945     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
9946 #endif
9947     EXPORT_PC()                            #  resolve() could throw, so export now
9948     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9949     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
9950     move      a0, v0
9951     # success?
9952     beqz      v0, common_exceptionThrown   #  no, handle exception
9953 #if defined(WITH_JIT)
9954     /*
9955      * If the JIT is actively building a trace we need to make sure
9956      * that the field is fully resolved before including this instruction.
9957      */
9958     JAL(common_verifyField)
9959 #endif
9960     b        .LOP_SGET_OBJECT_JUMBO_finish            # resume
9961
9962
9963 /* ------------------------------ */
9964     .balign 128
9965 .L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */
9966 /* File: mips/OP_SGET_BOOLEAN_JUMBO.S */
9967 /* File: mips/OP_SGET_JUMBO.S */
9968      /*
9969      * Jumbo 32-bit SGET handler.
9970      *
9971      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9972      *      sget-char/jumbo, sget-short/jumbo
9973      */
9974      /* exop vBBBB, field@AAAAAAAA */
9975     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
9976     FETCH(a0, 1)                           # a0<- aaaa (lo)
9977     FETCH(a1, 2)                           # a1<- AAAA (hi)
9978     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
9979     sll       a1,a1,16
9980     or        a1, a0, a1                   # a1<- AAAAaaaa
9981     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
9982     # is resolved entry !null?
9983     bnez      a0, .LOP_SGET_BOOLEAN_JUMBO_finish
9984
9985     /*
9986      * Continuation if the field has not yet been resolved.
9987      *  a1:  AAAAAAAA field ref
9988      *  rBIX: dvmDex->pResFields
9989      */
9990     LOAD_rSELF_method(a2)                  #  a2 <- current method
9991 #if defined(WITH_JIT)
9992     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
9993 #endif
9994     EXPORT_PC()                            #  resolve() could throw, so export now
9995     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
9996     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
9997     move      a0, v0
9998     # success?
9999     beqz      v0, common_exceptionThrown   #  no, handle exception
10000 #if defined(WITH_JIT)
10001     /*
10002      * If the JIT is actively building a trace we need to make sure
10003      * that the field is fully resolved before including this instruction.
10004      */
10005     JAL(common_verifyField)
10006 #endif
10007     b        .LOP_SGET_BOOLEAN_JUMBO_finish            # resume
10008
10009
10010 /* ------------------------------ */
10011     .balign 128
10012 .L_OP_SGET_BYTE_JUMBO: /* 0x118 */
10013 /* File: mips/OP_SGET_BYTE_JUMBO.S */
10014 /* File: mips/OP_SGET_JUMBO.S */
10015      /*
10016      * Jumbo 32-bit SGET handler.
10017      *
10018      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
10019      *      sget-char/jumbo, sget-short/jumbo
10020      */
10021      /* exop vBBBB, field@AAAAAAAA */
10022     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10023     FETCH(a0, 1)                           # a0<- aaaa (lo)
10024     FETCH(a1, 2)                           # a1<- AAAA (hi)
10025     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10026     sll       a1,a1,16
10027     or        a1, a0, a1                   # a1<- AAAAaaaa
10028     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10029     # is resolved entry !null?
10030     bnez      a0, .LOP_SGET_BYTE_JUMBO_finish
10031
10032     /*
10033      * Continuation if the field has not yet been resolved.
10034      *  a1:  AAAAAAAA field ref
10035      *  rBIX: dvmDex->pResFields
10036      */
10037     LOAD_rSELF_method(a2)                  #  a2 <- current method
10038 #if defined(WITH_JIT)
10039     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10040 #endif
10041     EXPORT_PC()                            #  resolve() could throw, so export now
10042     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10043     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10044     move      a0, v0
10045     # success?
10046     beqz      v0, common_exceptionThrown   #  no, handle exception
10047 #if defined(WITH_JIT)
10048     /*
10049      * If the JIT is actively building a trace we need to make sure
10050      * that the field is fully resolved before including this instruction.
10051      */
10052     JAL(common_verifyField)
10053 #endif
10054     b        .LOP_SGET_BYTE_JUMBO_finish            # resume
10055
10056
10057 /* ------------------------------ */
10058     .balign 128
10059 .L_OP_SGET_CHAR_JUMBO: /* 0x119 */
10060 /* File: mips/OP_SGET_CHAR_JUMBO.S */
10061 /* File: mips/OP_SGET_JUMBO.S */
10062      /*
10063      * Jumbo 32-bit SGET handler.
10064      *
10065      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
10066      *      sget-char/jumbo, sget-short/jumbo
10067      */
10068      /* exop vBBBB, field@AAAAAAAA */
10069     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10070     FETCH(a0, 1)                           # a0<- aaaa (lo)
10071     FETCH(a1, 2)                           # a1<- AAAA (hi)
10072     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10073     sll       a1,a1,16
10074     or        a1, a0, a1                   # a1<- AAAAaaaa
10075     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10076     # is resolved entry !null?
10077     bnez      a0, .LOP_SGET_CHAR_JUMBO_finish
10078
10079     /*
10080      * Continuation if the field has not yet been resolved.
10081      *  a1:  AAAAAAAA field ref
10082      *  rBIX: dvmDex->pResFields
10083      */
10084     LOAD_rSELF_method(a2)                  #  a2 <- current method
10085 #if defined(WITH_JIT)
10086     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10087 #endif
10088     EXPORT_PC()                            #  resolve() could throw, so export now
10089     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10090     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10091     move      a0, v0
10092     # success?
10093     beqz      v0, common_exceptionThrown   #  no, handle exception
10094 #if defined(WITH_JIT)
10095     /*
10096      * If the JIT is actively building a trace we need to make sure
10097      * that the field is fully resolved before including this instruction.
10098      */
10099     JAL(common_verifyField)
10100 #endif
10101     b        .LOP_SGET_CHAR_JUMBO_finish            # resume
10102
10103
10104 /* ------------------------------ */
10105     .balign 128
10106 .L_OP_SGET_SHORT_JUMBO: /* 0x11a */
10107 /* File: mips/OP_SGET_SHORT_JUMBO.S */
10108 /* File: mips/OP_SGET_JUMBO.S */
10109      /*
10110      * Jumbo 32-bit SGET handler.
10111      *
10112      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
10113      *      sget-char/jumbo, sget-short/jumbo
10114      */
10115      /* exop vBBBB, field@AAAAAAAA */
10116     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10117     FETCH(a0, 1)                           # a0<- aaaa (lo)
10118     FETCH(a1, 2)                           # a1<- AAAA (hi)
10119     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10120     sll       a1,a1,16
10121     or        a1, a0, a1                   # a1<- AAAAaaaa
10122     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10123     # is resolved entry !null?
10124     bnez      a0, .LOP_SGET_SHORT_JUMBO_finish
10125
10126     /*
10127      * Continuation if the field has not yet been resolved.
10128      *  a1:  AAAAAAAA field ref
10129      *  rBIX: dvmDex->pResFields
10130      */
10131     LOAD_rSELF_method(a2)                  #  a2 <- current method
10132 #if defined(WITH_JIT)
10133     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10134 #endif
10135     EXPORT_PC()                            #  resolve() could throw, so export now
10136     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10137     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10138     move      a0, v0
10139     # success?
10140     beqz      v0, common_exceptionThrown   #  no, handle exception
10141 #if defined(WITH_JIT)
10142     /*
10143      * If the JIT is actively building a trace we need to make sure
10144      * that the field is fully resolved before including this instruction.
10145      */
10146     JAL(common_verifyField)
10147 #endif
10148     b        .LOP_SGET_SHORT_JUMBO_finish            # resume
10149
10150
10151 /* ------------------------------ */
10152     .balign 128
10153 .L_OP_SPUT_JUMBO: /* 0x11b */
10154 /* File: mips/OP_SPUT_JUMBO.S */
10155     /*
10156      * Jumbo 32-bit SPUT handler.
10157      *
10158      * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
10159      *      sput-short/jumbo
10160      */
10161     /* exop vBBBB, field@AAAAAAAA */
10162     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10163     FETCH(a0, 1)                           # a0<- aaaa (lo)
10164     FETCH(a1, 2)                           # a1<- AAAA (hi)
10165     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10166     sll       a1,a1,16
10167     or        a1, a0, a1                   # a1<- AAAAaaaa
10168     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10169     bnez      a0, .LOP_SPUT_JUMBO_finish       #  is resolved entry null?
10170
10171     /*
10172      * Continuation if the field has not yet been resolved.
10173      *  a1:  AAAAAAAA field ref
10174      *  rBIX: dvmDex->pResFields
10175      */
10176     LOAD_rSELF_method(a2)                  #  a2 <- current method
10177 #if defined(WITH_JIT)
10178     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10179 #endif
10180     EXPORT_PC()                            #  resolve() may throw, so export now
10181     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10182     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10183     move      a0, v0
10184     beqz      v0, common_exceptionThrown   #  success? no, handle exception
10185 #if defined(WITH_JIT)
10186     /*
10187      * If the JIT is actively building a trace we need to make sure
10188      * that the field is fully resolved before including this instruction.
10189      */
10190     JAL(common_verifyField)
10191 #endif
10192     b        .LOP_SPUT_JUMBO_finish            # resume
10193
10194 /* ------------------------------ */
10195     .balign 128
10196 .L_OP_SPUT_WIDE_JUMBO: /* 0x11c */
10197 /* File: mips/OP_SPUT_WIDE_JUMBO.S */
10198     /*
10199      * Jumbo 64-bit SPUT handler.
10200      */
10201     /* sput-wide/jumbo vBBBB, field@AAAAAAAA */
10202     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10203     FETCH(a1, 1)                           # a1<- aaaa (lo)
10204     FETCH(a2, 2)                           # a2<- AAAA (hi)
10205     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10206     sll     a2,a2,16
10207     or      a1, a1, a2                    # a1<- AAAAaaaa
10208     FETCH(rOBJ, 3)                        # rOBJ<- BBBB    solved StaticField ptr
10209     EAS2(rOBJ, rFP, t0)                    #  rOBJ<- &fp[BBBB]
10210     # is resolved entry null?
10211     beqz      a2, .LOP_SPUT_WIDE_JUMBO_resolve      #  yes, do resolve
10212 .LOP_SPUT_WIDE_JUMBO_finish:                        #  field ptr in a2, BBBB in rOBJ
10213     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
10214     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vBBBB/vBBBB+1
10215     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
10216     .if 0
10217     addu    a2, offStaticField_value       #  a2<- pointer to data
10218     JAL(dvmQuasiAtomicSwap64Sync)          #  stores a0/a1 into addr a2
10219     .else
10220     STORE64_off(a0, a1, a2, offStaticField_value) #  field <- vBBBB/vBBBB+1
10221     .endif
10222     GOTO_OPCODE(rBIX)                      #  jump to next instruction
10223
10224 /* ------------------------------ */
10225     .balign 128
10226 .L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */
10227 /* File: mips/OP_SPUT_OBJECT_JUMBO.S */
10228     /*
10229      * Jumbo 32-bit SPUT handler for objects
10230      */
10231     /* sput-object/jumbo vBBBB, field@AAAAAAAA */
10232     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10233     FETCH(a0, 1)                           # a0<- aaaa (lo)
10234     FETCH(a1, 2)                           # a1<- AAAA (hi)
10235     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10236     sll     a1,a1,16
10237     or      a1,a0,a1                       # a1<- AAAAaaaa
10238
10239     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10240     bnez      a0, .LOP_SPUT_OBJECT_JUMBO_finish       #  is resolved entry null?
10241
10242     /* Continuation if the field has not yet been resolved.
10243      * a1:  BBBB field ref
10244      * rBIX: dvmDex->pResFields
10245      */
10246     LOAD_rSELF_method(a2)                  #  a2 <- current method
10247 #if defined(WITH_JIT)
10248     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10249 #endif
10250     EXPORT_PC()                            #  resolve() may throw, so export now
10251     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10252     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10253     move      a0, v0
10254     beqz      v0, common_exceptionThrown   #  success? no, handle exception
10255 #if defined(WITH_JIT)
10256     /*
10257      * If the JIT is actively building a trace we need to make sure
10258      * that the field is fully resolved before including this instruction.
10259      */
10260     JAL(common_verifyField)
10261 #endif
10262     b         .LOP_SPUT_OBJECT_JUMBO_finish           #  resume
10263
10264
10265 /* ------------------------------ */
10266     .balign 128
10267 .L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */
10268 /* File: mips/OP_SPUT_BOOLEAN_JUMBO.S */
10269 /* File: mips/OP_SPUT_JUMBO.S */
10270     /*
10271      * Jumbo 32-bit SPUT handler.
10272      *
10273      * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
10274      *      sput-short/jumbo
10275      */
10276     /* exop vBBBB, field@AAAAAAAA */
10277     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10278     FETCH(a0, 1)                           # a0<- aaaa (lo)
10279     FETCH(a1, 2)                           # a1<- AAAA (hi)
10280     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10281     sll       a1,a1,16
10282     or        a1, a0, a1                   # a1<- AAAAaaaa
10283     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10284     bnez      a0, .LOP_SPUT_BOOLEAN_JUMBO_finish       #  is resolved entry null?
10285
10286     /*
10287      * Continuation if the field has not yet been resolved.
10288      *  a1:  AAAAAAAA field ref
10289      *  rBIX: dvmDex->pResFields
10290      */
10291     LOAD_rSELF_method(a2)                  #  a2 <- current method
10292 #if defined(WITH_JIT)
10293     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10294 #endif
10295     EXPORT_PC()                            #  resolve() may throw, so export now
10296     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10297     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10298     move      a0, v0
10299     beqz      v0, common_exceptionThrown   #  success? no, handle exception
10300 #if defined(WITH_JIT)
10301     /*
10302      * If the JIT is actively building a trace we need to make sure
10303      * that the field is fully resolved before including this instruction.
10304      */
10305     JAL(common_verifyField)
10306 #endif
10307     b        .LOP_SPUT_BOOLEAN_JUMBO_finish            # resume
10308
10309
10310 /* ------------------------------ */
10311     .balign 128
10312 .L_OP_SPUT_BYTE_JUMBO: /* 0x11f */
10313 /* File: mips/OP_SPUT_BYTE_JUMBO.S */
10314 /* File: mips/OP_SPUT_JUMBO.S */
10315     /*
10316      * Jumbo 32-bit SPUT handler.
10317      *
10318      * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
10319      *      sput-short/jumbo
10320      */
10321     /* exop vBBBB, field@AAAAAAAA */
10322     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10323     FETCH(a0, 1)                           # a0<- aaaa (lo)
10324     FETCH(a1, 2)                           # a1<- AAAA (hi)
10325     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10326     sll       a1,a1,16
10327     or        a1, a0, a1                   # a1<- AAAAaaaa
10328     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10329     bnez      a0, .LOP_SPUT_BYTE_JUMBO_finish       #  is resolved entry null?
10330
10331     /*
10332      * Continuation if the field has not yet been resolved.
10333      *  a1:  AAAAAAAA field ref
10334      *  rBIX: dvmDex->pResFields
10335      */
10336     LOAD_rSELF_method(a2)                  #  a2 <- current method
10337 #if defined(WITH_JIT)
10338     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10339 #endif
10340     EXPORT_PC()                            #  resolve() may throw, so export now
10341     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10342     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10343     move      a0, v0
10344     beqz      v0, common_exceptionThrown   #  success? no, handle exception
10345 #if defined(WITH_JIT)
10346     /*
10347      * If the JIT is actively building a trace we need to make sure
10348      * that the field is fully resolved before including this instruction.
10349      */
10350     JAL(common_verifyField)
10351 #endif
10352     b        .LOP_SPUT_BYTE_JUMBO_finish            # resume
10353
10354
10355 /* ------------------------------ */
10356     .balign 128
10357 .L_OP_SPUT_CHAR_JUMBO: /* 0x120 */
10358 /* File: mips/OP_SPUT_CHAR_JUMBO.S */
10359 /* File: mips/OP_SPUT_JUMBO.S */
10360     /*
10361      * Jumbo 32-bit SPUT handler.
10362      *
10363      * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
10364      *      sput-short/jumbo
10365      */
10366     /* exop vBBBB, field@AAAAAAAA */
10367     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10368     FETCH(a0, 1)                           # a0<- aaaa (lo)
10369     FETCH(a1, 2)                           # a1<- AAAA (hi)
10370     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10371     sll       a1,a1,16
10372     or        a1, a0, a1                   # a1<- AAAAaaaa
10373     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10374     bnez      a0, .LOP_SPUT_CHAR_JUMBO_finish       #  is resolved entry null?
10375
10376     /*
10377      * Continuation if the field has not yet been resolved.
10378      *  a1:  AAAAAAAA field ref
10379      *  rBIX: dvmDex->pResFields
10380      */
10381     LOAD_rSELF_method(a2)                  #  a2 <- current method
10382 #if defined(WITH_JIT)
10383     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10384 #endif
10385     EXPORT_PC()                            #  resolve() may throw, so export now
10386     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10387     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10388     move      a0, v0
10389     beqz      v0, common_exceptionThrown   #  success? no, handle exception
10390 #if defined(WITH_JIT)
10391     /*
10392      * If the JIT is actively building a trace we need to make sure
10393      * that the field is fully resolved before including this instruction.
10394      */
10395     JAL(common_verifyField)
10396 #endif
10397     b        .LOP_SPUT_CHAR_JUMBO_finish            # resume
10398
10399
10400 /* ------------------------------ */
10401     .balign 128
10402 .L_OP_SPUT_SHORT_JUMBO: /* 0x121 */
10403 /* File: mips/OP_SPUT_SHORT_JUMBO.S */
10404 /* File: mips/OP_SPUT_JUMBO.S */
10405     /*
10406      * Jumbo 32-bit SPUT handler.
10407      *
10408      * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
10409      *      sput-short/jumbo
10410      */
10411     /* exop vBBBB, field@AAAAAAAA */
10412     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
10413     FETCH(a0, 1)                           # a0<- aaaa (lo)
10414     FETCH(a1, 2)                           # a1<- AAAA (hi)
10415     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
10416     sll       a1,a1,16
10417     or        a1, a0, a1                   # a1<- AAAAaaaa
10418     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
10419     bnez      a0, .LOP_SPUT_SHORT_JUMBO_finish       #  is resolved entry null?
10420
10421     /*
10422      * Continuation if the field has not yet been resolved.
10423      *  a1:  AAAAAAAA field ref
10424      *  rBIX: dvmDex->pResFields
10425      */
10426     LOAD_rSELF_method(a2)                  #  a2 <- current method
10427 #if defined(WITH_JIT)
10428     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
10429 #endif
10430     EXPORT_PC()                            #  resolve() may throw, so export now
10431     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
10432     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
10433     move      a0, v0
10434     beqz      v0, common_exceptionThrown   #  success? no, handle exception
10435 #if defined(WITH_JIT)
10436     /*
10437      * If the JIT is actively building a trace we need to make sure
10438      * that the field is fully resolved before including this instruction.
10439      */
10440     JAL(common_verifyField)
10441 #endif
10442     b        .LOP_SPUT_SHORT_JUMBO_finish            # resume
10443
10444
10445 /* ------------------------------ */
10446     .balign 128
10447 .L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */
10448 /* File: mips/OP_INVOKE_VIRTUAL_JUMBO.S */
10449     /*
10450      * Handle a virtual method call.
10451      */
10452      /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
10453     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
10454     FETCH(a0, 1)                           # a0<- aaaa (lo)
10455     FETCH(a1, 2)                           # a1<- AAAA (hi)
10456     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
10457     sll     a1,a1,16
10458     or      a1, a0, a1                     # a1<- AAAAaaaa
10459     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
10460     EXPORT_PC()                            #  must export for invoke
10461     # already resolved?
10462     bnez      a0, .LOP_INVOKE_VIRTUAL_JUMBO_continue     #  yes, continue on
10463
10464     LOAD_rSELF_method(a3)                  #  a3 <- self->method
10465     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
10466     li        a2, METHOD_VIRTUAL           #  resolver method type
10467     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
10468     move      a0, v0
10469     # got null?
10470     bnez      v0, .LOP_INVOKE_VIRTUAL_JUMBO_continue     #  no, continue
10471     b         common_exceptionThrown       #  yes, handle exception
10472
10473 /* ------------------------------ */
10474     .balign 128
10475 .L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */
10476 /* File: mips/OP_INVOKE_SUPER_JUMBO.S */
10477     /*
10478      * Handle a "super" method call.
10479     */
10480     /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
10481     FETCH(t0, 4)                           # t0<- CCCC
10482     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
10483     FETCH(a0, 1)                           # a0<- aaaa (lo)
10484     FETCH(a1, 2)                           # a1<- AAAA (hi)
10485     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
10486     sll       a1,a1,16
10487     or        a1, a0, a1                   # a1<- AAAAaaaa
10488     GET_VREG(rOBJ, t0)                     #  rOBJ <- "this" ptr
10489     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved baseMethod
10490     # null "this"?
10491     LOAD_rSELF_method(t1)                  #  t1 <- current method
10492     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
10493     # cmp a0, 0; already resolved?
10494     LOAD_base_offMethod_clazz(rBIX, t1)    #  rBIX <- method->clazz
10495     EXPORT_PC()                            #  must export for invoke
10496     bnez      a0, .LOP_INVOKE_SUPER_JUMBO_continue     #  resolved, continue on
10497
10498     move      a0, rBIX                     #  a0 <- method->clazz
10499     li        a2, METHOD_VIRTUAL           #  resolver method type
10500     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
10501     move      a0, v0
10502     # got null?
10503     beqz      v0, common_exceptionThrown   #  yes, handle exception
10504     b         .LOP_INVOKE_SUPER_JUMBO_continue
10505
10506 /* ------------------------------ */
10507     .balign 128
10508 .L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */
10509 /* File: mips/OP_INVOKE_DIRECT_JUMBO.S */
10510     /*
10511      * Handle a direct method call.
10512      *
10513      * (We could defer the "is 'this' pointer null" test to the common
10514      * method invocation code, and use a flag to indicate that static
10515      * calls don't count.  If we do this as part of copying the arguments
10516      * out we could avoiding loading the first arg twice.)
10517      *
10518      */
10519      /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
10520     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
10521     FETCH(a0, 1)                           # a0<- aaaa (lo)
10522     FETCH(a1, 2)                           # a1<- AAAA (hi)
10523     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
10524     sll     a1,a1,16
10525     or      a1, a0, a1                     # a1<- AAAAaaaa
10526     FETCH(rBIX, 4)                         #  rBIX <- GFED or CCCC
10527     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
10528     .if (!0)
10529     and       rBIX, rBIX, 15               #  rBIX <- D (or stays CCCC)
10530     .endif
10531     EXPORT_PC()                            #  must export for invoke
10532     GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
10533     # already resolved?
10534     bnez      a0, 1f                       #  resolved, call the function
10535
10536     lw        a3, offThread_method(rSELF)  #  a3 <- self->method
10537     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
10538     li        a2, METHOD_DIRECT            #  resolver method type
10539     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
10540     move      a0, v0
10541     # got null?
10542     beqz      v0, common_exceptionThrown   #  yes, handle exception
10543
10544 1:
10545     bnez      rOBJ, common_invokeMethodJumbo #  a0=method, rOBJ="this"
10546     b         common_errNullObject         #  yes, throw exception
10547
10548
10549
10550
10551 /* ------------------------------ */
10552     .balign 128
10553 .L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */
10554 /* File: mips/OP_INVOKE_STATIC_JUMBO.S */
10555     /*
10556      * Handle a static method call.
10557      */
10558      /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
10559     LOAD_rSELF_methodClassDex(a3)          #  a3 <- pDvmDex
10560     FETCH(a0, 1)                           # a0<- aaaa (lo)
10561     FETCH(a1, 2)                           # a1<- AAAA (hi)
10562     LOAD_base_offDvmDex_pResMethods(a3, a3) #  a3 <- pDvmDex->pResMethods
10563     sll     a1,a1,16
10564     or      a1, a0, a1                     # r1<- AAAAaaaa
10565     li      rOBJ, 0                       #  null "this" in delay slot
10566     LOAD_eas2(a0, a3, a1)                  #  a0 <- resolved methodToCall
10567 #if defined(WITH_JIT)
10568     EAS2(rBIX, a3, a1)                     #  rBIX<- &resolved_metherToCall
10569 #endif
10570     EXPORT_PC()                            #  must export for invoke
10571     # already resolved?
10572     bnez      a0, common_invokeMethodJumboNoThis #  (a0 = method)
10573     b         .LOP_INVOKE_STATIC_JUMBO_resolve
10574
10575 /* ------------------------------ */
10576     .balign 128
10577 .L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */
10578 /* File: mips/OP_INVOKE_INTERFACE_JUMBO.S */
10579     /*
10580      * Handle an interface method call.
10581      */
10582     /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
10583     FETCH(a2, 4)                           # a2<- CCCC
10584     FETCH(a0, 1)                           # a0<- aaaa (lo)
10585     FETCH(a1, 2)                           # a1<- AAAA (hi)
10586     EXPORT_PC()                            #  must export for invoke
10587     sll       a1,a1,16
10588     or        a1, a0, a1                   #  a1<- AAAAaaaa
10589     GET_VREG(rOBJ, a2)                     #  rOBJ <- first arg ("this")
10590     LOAD_rSELF_methodClassDex(a3)          #  a3 <- methodClassDex
10591     LOAD_rSELF_method(a2)                  #  a2 <- method
10592     # null obj?
10593     beqz      rOBJ, common_errNullObject   #  yes, fail
10594     LOAD_base_offObject_clazz(a0, rOBJ)      #  a0 <- thisPtr->clazz
10595     JAL(dvmFindInterfaceMethodInCache)     #  v0 <- call(class, ref, method, dex)
10596     move      a0, v0
10597     # failed?
10598     beqz      v0, common_exceptionThrown   #  yes, handle exception
10599     b         common_invokeMethodJumbo #  (a0=method, rOBJ="this")
10600
10601 /* ------------------------------ */
10602     .balign 128
10603 .L_OP_UNUSED_27FF: /* 0x127 */
10604 /* File: mips/OP_UNUSED_27FF.S */
10605 /* File: mips/unused.S */
10606     BAL(common_abort)
10607
10608
10609
10610 /* ------------------------------ */
10611     .balign 128
10612 .L_OP_UNUSED_28FF: /* 0x128 */
10613 /* File: mips/OP_UNUSED_28FF.S */
10614 /* File: mips/unused.S */
10615     BAL(common_abort)
10616
10617
10618
10619 /* ------------------------------ */
10620     .balign 128
10621 .L_OP_UNUSED_29FF: /* 0x129 */
10622 /* File: mips/OP_UNUSED_29FF.S */
10623 /* File: mips/unused.S */
10624     BAL(common_abort)
10625
10626
10627
10628 /* ------------------------------ */
10629     .balign 128
10630 .L_OP_UNUSED_2AFF: /* 0x12a */
10631 /* File: mips/OP_UNUSED_2AFF.S */
10632 /* File: mips/unused.S */
10633     BAL(common_abort)
10634
10635
10636
10637 /* ------------------------------ */
10638     .balign 128
10639 .L_OP_UNUSED_2BFF: /* 0x12b */
10640 /* File: mips/OP_UNUSED_2BFF.S */
10641 /* File: mips/unused.S */
10642     BAL(common_abort)
10643
10644
10645
10646 /* ------------------------------ */
10647     .balign 128
10648 .L_OP_UNUSED_2CFF: /* 0x12c */
10649 /* File: mips/OP_UNUSED_2CFF.S */
10650 /* File: mips/unused.S */
10651     BAL(common_abort)
10652
10653
10654
10655 /* ------------------------------ */
10656     .balign 128
10657 .L_OP_UNUSED_2DFF: /* 0x12d */
10658 /* File: mips/OP_UNUSED_2DFF.S */
10659 /* File: mips/unused.S */
10660     BAL(common_abort)
10661
10662
10663
10664 /* ------------------------------ */
10665     .balign 128
10666 .L_OP_UNUSED_2EFF: /* 0x12e */
10667 /* File: mips/OP_UNUSED_2EFF.S */
10668 /* File: mips/unused.S */
10669     BAL(common_abort)
10670
10671
10672
10673 /* ------------------------------ */
10674     .balign 128
10675 .L_OP_UNUSED_2FFF: /* 0x12f */
10676 /* File: mips/OP_UNUSED_2FFF.S */
10677 /* File: mips/unused.S */
10678     BAL(common_abort)
10679
10680
10681
10682 /* ------------------------------ */
10683     .balign 128
10684 .L_OP_UNUSED_30FF: /* 0x130 */
10685 /* File: mips/OP_UNUSED_30FF.S */
10686 /* File: mips/unused.S */
10687     BAL(common_abort)
10688
10689
10690
10691 /* ------------------------------ */
10692     .balign 128
10693 .L_OP_UNUSED_31FF: /* 0x131 */
10694 /* File: mips/OP_UNUSED_31FF.S */
10695 /* File: mips/unused.S */
10696     BAL(common_abort)
10697
10698
10699
10700 /* ------------------------------ */
10701     .balign 128
10702 .L_OP_UNUSED_32FF: /* 0x132 */
10703 /* File: mips/OP_UNUSED_32FF.S */
10704 /* File: mips/unused.S */
10705     BAL(common_abort)
10706
10707
10708
10709 /* ------------------------------ */
10710     .balign 128
10711 .L_OP_UNUSED_33FF: /* 0x133 */
10712 /* File: mips/OP_UNUSED_33FF.S */
10713 /* File: mips/unused.S */
10714     BAL(common_abort)
10715
10716
10717
10718 /* ------------------------------ */
10719     .balign 128
10720 .L_OP_UNUSED_34FF: /* 0x134 */
10721 /* File: mips/OP_UNUSED_34FF.S */
10722 /* File: mips/unused.S */
10723     BAL(common_abort)
10724
10725
10726
10727 /* ------------------------------ */
10728     .balign 128
10729 .L_OP_UNUSED_35FF: /* 0x135 */
10730 /* File: mips/OP_UNUSED_35FF.S */
10731 /* File: mips/unused.S */
10732     BAL(common_abort)
10733
10734
10735
10736 /* ------------------------------ */
10737     .balign 128
10738 .L_OP_UNUSED_36FF: /* 0x136 */
10739 /* File: mips/OP_UNUSED_36FF.S */
10740 /* File: mips/unused.S */
10741     BAL(common_abort)
10742
10743
10744
10745 /* ------------------------------ */
10746     .balign 128
10747 .L_OP_UNUSED_37FF: /* 0x137 */
10748 /* File: mips/OP_UNUSED_37FF.S */
10749 /* File: mips/unused.S */
10750     BAL(common_abort)
10751
10752
10753
10754 /* ------------------------------ */
10755     .balign 128
10756 .L_OP_UNUSED_38FF: /* 0x138 */
10757 /* File: mips/OP_UNUSED_38FF.S */
10758 /* File: mips/unused.S */
10759     BAL(common_abort)
10760
10761
10762
10763 /* ------------------------------ */
10764     .balign 128
10765 .L_OP_UNUSED_39FF: /* 0x139 */
10766 /* File: mips/OP_UNUSED_39FF.S */
10767 /* File: mips/unused.S */
10768     BAL(common_abort)
10769
10770
10771
10772 /* ------------------------------ */
10773     .balign 128
10774 .L_OP_UNUSED_3AFF: /* 0x13a */
10775 /* File: mips/OP_UNUSED_3AFF.S */
10776 /* File: mips/unused.S */
10777     BAL(common_abort)
10778
10779
10780
10781 /* ------------------------------ */
10782     .balign 128
10783 .L_OP_UNUSED_3BFF: /* 0x13b */
10784 /* File: mips/OP_UNUSED_3BFF.S */
10785 /* File: mips/unused.S */
10786     BAL(common_abort)
10787
10788
10789
10790 /* ------------------------------ */
10791     .balign 128
10792 .L_OP_UNUSED_3CFF: /* 0x13c */
10793 /* File: mips/OP_UNUSED_3CFF.S */
10794 /* File: mips/unused.S */
10795     BAL(common_abort)
10796
10797
10798
10799 /* ------------------------------ */
10800     .balign 128
10801 .L_OP_UNUSED_3DFF: /* 0x13d */
10802 /* File: mips/OP_UNUSED_3DFF.S */
10803 /* File: mips/unused.S */
10804     BAL(common_abort)
10805
10806
10807
10808 /* ------------------------------ */
10809     .balign 128
10810 .L_OP_UNUSED_3EFF: /* 0x13e */
10811 /* File: mips/OP_UNUSED_3EFF.S */
10812 /* File: mips/unused.S */
10813     BAL(common_abort)
10814
10815
10816
10817 /* ------------------------------ */
10818     .balign 128
10819 .L_OP_UNUSED_3FFF: /* 0x13f */
10820 /* File: mips/OP_UNUSED_3FFF.S */
10821 /* File: mips/unused.S */
10822     BAL(common_abort)
10823
10824
10825
10826 /* ------------------------------ */
10827     .balign 128
10828 .L_OP_UNUSED_40FF: /* 0x140 */
10829 /* File: mips/OP_UNUSED_40FF.S */
10830 /* File: mips/unused.S */
10831     BAL(common_abort)
10832
10833
10834
10835 /* ------------------------------ */
10836     .balign 128
10837 .L_OP_UNUSED_41FF: /* 0x141 */
10838 /* File: mips/OP_UNUSED_41FF.S */
10839 /* File: mips/unused.S */
10840     BAL(common_abort)
10841
10842
10843
10844 /* ------------------------------ */
10845     .balign 128
10846 .L_OP_UNUSED_42FF: /* 0x142 */
10847 /* File: mips/OP_UNUSED_42FF.S */
10848 /* File: mips/unused.S */
10849     BAL(common_abort)
10850
10851
10852
10853 /* ------------------------------ */
10854     .balign 128
10855 .L_OP_UNUSED_43FF: /* 0x143 */
10856 /* File: mips/OP_UNUSED_43FF.S */
10857 /* File: mips/unused.S */
10858     BAL(common_abort)
10859
10860
10861
10862 /* ------------------------------ */
10863     .balign 128
10864 .L_OP_UNUSED_44FF: /* 0x144 */
10865 /* File: mips/OP_UNUSED_44FF.S */
10866 /* File: mips/unused.S */
10867     BAL(common_abort)
10868
10869
10870
10871 /* ------------------------------ */
10872     .balign 128
10873 .L_OP_UNUSED_45FF: /* 0x145 */
10874 /* File: mips/OP_UNUSED_45FF.S */
10875 /* File: mips/unused.S */
10876     BAL(common_abort)
10877
10878
10879
10880 /* ------------------------------ */
10881     .balign 128
10882 .L_OP_UNUSED_46FF: /* 0x146 */
10883 /* File: mips/OP_UNUSED_46FF.S */
10884 /* File: mips/unused.S */
10885     BAL(common_abort)
10886
10887
10888
10889 /* ------------------------------ */
10890     .balign 128
10891 .L_OP_UNUSED_47FF: /* 0x147 */
10892 /* File: mips/OP_UNUSED_47FF.S */
10893 /* File: mips/unused.S */
10894     BAL(common_abort)
10895
10896
10897
10898 /* ------------------------------ */
10899     .balign 128
10900 .L_OP_UNUSED_48FF: /* 0x148 */
10901 /* File: mips/OP_UNUSED_48FF.S */
10902 /* File: mips/unused.S */
10903     BAL(common_abort)
10904
10905
10906
10907 /* ------------------------------ */
10908     .balign 128
10909 .L_OP_UNUSED_49FF: /* 0x149 */
10910 /* File: mips/OP_UNUSED_49FF.S */
10911 /* File: mips/unused.S */
10912     BAL(common_abort)
10913
10914
10915
10916 /* ------------------------------ */
10917     .balign 128
10918 .L_OP_UNUSED_4AFF: /* 0x14a */
10919 /* File: mips/OP_UNUSED_4AFF.S */
10920 /* File: mips/unused.S */
10921     BAL(common_abort)
10922
10923
10924
10925 /* ------------------------------ */
10926     .balign 128
10927 .L_OP_UNUSED_4BFF: /* 0x14b */
10928 /* File: mips/OP_UNUSED_4BFF.S */
10929 /* File: mips/unused.S */
10930     BAL(common_abort)
10931
10932
10933
10934 /* ------------------------------ */
10935     .balign 128
10936 .L_OP_UNUSED_4CFF: /* 0x14c */
10937 /* File: mips/OP_UNUSED_4CFF.S */
10938 /* File: mips/unused.S */
10939     BAL(common_abort)
10940
10941
10942
10943 /* ------------------------------ */
10944     .balign 128
10945 .L_OP_UNUSED_4DFF: /* 0x14d */
10946 /* File: mips/OP_UNUSED_4DFF.S */
10947 /* File: mips/unused.S */
10948     BAL(common_abort)
10949
10950
10951
10952 /* ------------------------------ */
10953     .balign 128
10954 .L_OP_UNUSED_4EFF: /* 0x14e */
10955 /* File: mips/OP_UNUSED_4EFF.S */
10956 /* File: mips/unused.S */
10957     BAL(common_abort)
10958
10959
10960
10961 /* ------------------------------ */
10962     .balign 128
10963 .L_OP_UNUSED_4FFF: /* 0x14f */
10964 /* File: mips/OP_UNUSED_4FFF.S */
10965 /* File: mips/unused.S */
10966     BAL(common_abort)
10967
10968
10969
10970 /* ------------------------------ */
10971     .balign 128
10972 .L_OP_UNUSED_50FF: /* 0x150 */
10973 /* File: mips/OP_UNUSED_50FF.S */
10974 /* File: mips/unused.S */
10975     BAL(common_abort)
10976
10977
10978
10979 /* ------------------------------ */
10980     .balign 128
10981 .L_OP_UNUSED_51FF: /* 0x151 */
10982 /* File: mips/OP_UNUSED_51FF.S */
10983 /* File: mips/unused.S */
10984     BAL(common_abort)
10985
10986
10987
10988 /* ------------------------------ */
10989     .balign 128
10990 .L_OP_UNUSED_52FF: /* 0x152 */
10991 /* File: mips/OP_UNUSED_52FF.S */
10992 /* File: mips/unused.S */
10993     BAL(common_abort)
10994
10995
10996
10997 /* ------------------------------ */
10998     .balign 128
10999 .L_OP_UNUSED_53FF: /* 0x153 */
11000 /* File: mips/OP_UNUSED_53FF.S */
11001 /* File: mips/unused.S */
11002     BAL(common_abort)
11003
11004
11005
11006 /* ------------------------------ */
11007     .balign 128
11008 .L_OP_UNUSED_54FF: /* 0x154 */
11009 /* File: mips/OP_UNUSED_54FF.S */
11010 /* File: mips/unused.S */
11011     BAL(common_abort)
11012
11013
11014
11015 /* ------------------------------ */
11016     .balign 128
11017 .L_OP_UNUSED_55FF: /* 0x155 */
11018 /* File: mips/OP_UNUSED_55FF.S */
11019 /* File: mips/unused.S */
11020     BAL(common_abort)
11021
11022
11023
11024 /* ------------------------------ */
11025     .balign 128
11026 .L_OP_UNUSED_56FF: /* 0x156 */
11027 /* File: mips/OP_UNUSED_56FF.S */
11028 /* File: mips/unused.S */
11029     BAL(common_abort)
11030
11031
11032
11033 /* ------------------------------ */
11034     .balign 128
11035 .L_OP_UNUSED_57FF: /* 0x157 */
11036 /* File: mips/OP_UNUSED_57FF.S */
11037 /* File: mips/unused.S */
11038     BAL(common_abort)
11039
11040
11041
11042 /* ------------------------------ */
11043     .balign 128
11044 .L_OP_UNUSED_58FF: /* 0x158 */
11045 /* File: mips/OP_UNUSED_58FF.S */
11046 /* File: mips/unused.S */
11047     BAL(common_abort)
11048
11049
11050
11051 /* ------------------------------ */
11052     .balign 128
11053 .L_OP_UNUSED_59FF: /* 0x159 */
11054 /* File: mips/OP_UNUSED_59FF.S */
11055 /* File: mips/unused.S */
11056     BAL(common_abort)
11057
11058
11059
11060 /* ------------------------------ */
11061     .balign 128
11062 .L_OP_UNUSED_5AFF: /* 0x15a */
11063 /* File: mips/OP_UNUSED_5AFF.S */
11064 /* File: mips/unused.S */
11065     BAL(common_abort)
11066
11067
11068
11069 /* ------------------------------ */
11070     .balign 128
11071 .L_OP_UNUSED_5BFF: /* 0x15b */
11072 /* File: mips/OP_UNUSED_5BFF.S */
11073 /* File: mips/unused.S */
11074     BAL(common_abort)
11075
11076
11077
11078 /* ------------------------------ */
11079     .balign 128
11080 .L_OP_UNUSED_5CFF: /* 0x15c */
11081 /* File: mips/OP_UNUSED_5CFF.S */
11082 /* File: mips/unused.S */
11083     BAL(common_abort)
11084
11085
11086
11087 /* ------------------------------ */
11088     .balign 128
11089 .L_OP_UNUSED_5DFF: /* 0x15d */
11090 /* File: mips/OP_UNUSED_5DFF.S */
11091 /* File: mips/unused.S */
11092     BAL(common_abort)
11093
11094
11095
11096 /* ------------------------------ */
11097     .balign 128
11098 .L_OP_UNUSED_5EFF: /* 0x15e */
11099 /* File: mips/OP_UNUSED_5EFF.S */
11100 /* File: mips/unused.S */
11101     BAL(common_abort)
11102
11103
11104
11105 /* ------------------------------ */
11106     .balign 128
11107 .L_OP_UNUSED_5FFF: /* 0x15f */
11108 /* File: mips/OP_UNUSED_5FFF.S */
11109 /* File: mips/unused.S */
11110     BAL(common_abort)
11111
11112
11113
11114 /* ------------------------------ */
11115     .balign 128
11116 .L_OP_UNUSED_60FF: /* 0x160 */
11117 /* File: mips/OP_UNUSED_60FF.S */
11118 /* File: mips/unused.S */
11119     BAL(common_abort)
11120
11121
11122
11123 /* ------------------------------ */
11124     .balign 128
11125 .L_OP_UNUSED_61FF: /* 0x161 */
11126 /* File: mips/OP_UNUSED_61FF.S */
11127 /* File: mips/unused.S */
11128     BAL(common_abort)
11129
11130
11131
11132 /* ------------------------------ */
11133     .balign 128
11134 .L_OP_UNUSED_62FF: /* 0x162 */
11135 /* File: mips/OP_UNUSED_62FF.S */
11136 /* File: mips/unused.S */
11137     BAL(common_abort)
11138
11139
11140
11141 /* ------------------------------ */
11142     .balign 128
11143 .L_OP_UNUSED_63FF: /* 0x163 */
11144 /* File: mips/OP_UNUSED_63FF.S */
11145 /* File: mips/unused.S */
11146     BAL(common_abort)
11147
11148
11149
11150 /* ------------------------------ */
11151     .balign 128
11152 .L_OP_UNUSED_64FF: /* 0x164 */
11153 /* File: mips/OP_UNUSED_64FF.S */
11154 /* File: mips/unused.S */
11155     BAL(common_abort)
11156
11157
11158
11159 /* ------------------------------ */
11160     .balign 128
11161 .L_OP_UNUSED_65FF: /* 0x165 */
11162 /* File: mips/OP_UNUSED_65FF.S */
11163 /* File: mips/unused.S */
11164     BAL(common_abort)
11165
11166
11167
11168 /* ------------------------------ */
11169     .balign 128
11170 .L_OP_UNUSED_66FF: /* 0x166 */
11171 /* File: mips/OP_UNUSED_66FF.S */
11172 /* File: mips/unused.S */
11173     BAL(common_abort)
11174
11175
11176
11177 /* ------------------------------ */
11178     .balign 128
11179 .L_OP_UNUSED_67FF: /* 0x167 */
11180 /* File: mips/OP_UNUSED_67FF.S */
11181 /* File: mips/unused.S */
11182     BAL(common_abort)
11183
11184
11185
11186 /* ------------------------------ */
11187     .balign 128
11188 .L_OP_UNUSED_68FF: /* 0x168 */
11189 /* File: mips/OP_UNUSED_68FF.S */
11190 /* File: mips/unused.S */
11191     BAL(common_abort)
11192
11193
11194
11195 /* ------------------------------ */
11196     .balign 128
11197 .L_OP_UNUSED_69FF: /* 0x169 */
11198 /* File: mips/OP_UNUSED_69FF.S */
11199 /* File: mips/unused.S */
11200     BAL(common_abort)
11201
11202
11203
11204 /* ------------------------------ */
11205     .balign 128
11206 .L_OP_UNUSED_6AFF: /* 0x16a */
11207 /* File: mips/OP_UNUSED_6AFF.S */
11208 /* File: mips/unused.S */
11209     BAL(common_abort)
11210
11211
11212
11213 /* ------------------------------ */
11214     .balign 128
11215 .L_OP_UNUSED_6BFF: /* 0x16b */
11216 /* File: mips/OP_UNUSED_6BFF.S */
11217 /* File: mips/unused.S */
11218     BAL(common_abort)
11219
11220
11221
11222 /* ------------------------------ */
11223     .balign 128
11224 .L_OP_UNUSED_6CFF: /* 0x16c */
11225 /* File: mips/OP_UNUSED_6CFF.S */
11226 /* File: mips/unused.S */
11227     BAL(common_abort)
11228
11229
11230
11231 /* ------------------------------ */
11232     .balign 128
11233 .L_OP_UNUSED_6DFF: /* 0x16d */
11234 /* File: mips/OP_UNUSED_6DFF.S */
11235 /* File: mips/unused.S */
11236     BAL(common_abort)
11237
11238
11239
11240 /* ------------------------------ */
11241     .balign 128
11242 .L_OP_UNUSED_6EFF: /* 0x16e */
11243 /* File: mips/OP_UNUSED_6EFF.S */
11244 /* File: mips/unused.S */
11245     BAL(common_abort)
11246
11247
11248
11249 /* ------------------------------ */
11250     .balign 128
11251 .L_OP_UNUSED_6FFF: /* 0x16f */
11252 /* File: mips/OP_UNUSED_6FFF.S */
11253 /* File: mips/unused.S */
11254     BAL(common_abort)
11255
11256
11257
11258 /* ------------------------------ */
11259     .balign 128
11260 .L_OP_UNUSED_70FF: /* 0x170 */
11261 /* File: mips/OP_UNUSED_70FF.S */
11262 /* File: mips/unused.S */
11263     BAL(common_abort)
11264
11265
11266
11267 /* ------------------------------ */
11268     .balign 128
11269 .L_OP_UNUSED_71FF: /* 0x171 */
11270 /* File: mips/OP_UNUSED_71FF.S */
11271 /* File: mips/unused.S */
11272     BAL(common_abort)
11273
11274
11275
11276 /* ------------------------------ */
11277     .balign 128
11278 .L_OP_UNUSED_72FF: /* 0x172 */
11279 /* File: mips/OP_UNUSED_72FF.S */
11280 /* File: mips/unused.S */
11281     BAL(common_abort)
11282
11283
11284
11285 /* ------------------------------ */
11286     .balign 128
11287 .L_OP_UNUSED_73FF: /* 0x173 */
11288 /* File: mips/OP_UNUSED_73FF.S */
11289 /* File: mips/unused.S */
11290     BAL(common_abort)
11291
11292
11293
11294 /* ------------------------------ */
11295     .balign 128
11296 .L_OP_UNUSED_74FF: /* 0x174 */
11297 /* File: mips/OP_UNUSED_74FF.S */
11298 /* File: mips/unused.S */
11299     BAL(common_abort)
11300
11301
11302
11303 /* ------------------------------ */
11304     .balign 128
11305 .L_OP_UNUSED_75FF: /* 0x175 */
11306 /* File: mips/OP_UNUSED_75FF.S */
11307 /* File: mips/unused.S */
11308     BAL(common_abort)
11309
11310
11311
11312 /* ------------------------------ */
11313     .balign 128
11314 .L_OP_UNUSED_76FF: /* 0x176 */
11315 /* File: mips/OP_UNUSED_76FF.S */
11316 /* File: mips/unused.S */
11317     BAL(common_abort)
11318
11319
11320
11321 /* ------------------------------ */
11322     .balign 128
11323 .L_OP_UNUSED_77FF: /* 0x177 */
11324 /* File: mips/OP_UNUSED_77FF.S */
11325 /* File: mips/unused.S */
11326     BAL(common_abort)
11327
11328
11329
11330 /* ------------------------------ */
11331     .balign 128
11332 .L_OP_UNUSED_78FF: /* 0x178 */
11333 /* File: mips/OP_UNUSED_78FF.S */
11334 /* File: mips/unused.S */
11335     BAL(common_abort)
11336
11337
11338
11339 /* ------------------------------ */
11340     .balign 128
11341 .L_OP_UNUSED_79FF: /* 0x179 */
11342 /* File: mips/OP_UNUSED_79FF.S */
11343 /* File: mips/unused.S */
11344     BAL(common_abort)
11345
11346
11347
11348 /* ------------------------------ */
11349     .balign 128
11350 .L_OP_UNUSED_7AFF: /* 0x17a */
11351 /* File: mips/OP_UNUSED_7AFF.S */
11352 /* File: mips/unused.S */
11353     BAL(common_abort)
11354
11355
11356
11357 /* ------------------------------ */
11358     .balign 128
11359 .L_OP_UNUSED_7BFF: /* 0x17b */
11360 /* File: mips/OP_UNUSED_7BFF.S */
11361 /* File: mips/unused.S */
11362     BAL(common_abort)
11363
11364
11365
11366 /* ------------------------------ */
11367     .balign 128
11368 .L_OP_UNUSED_7CFF: /* 0x17c */
11369 /* File: mips/OP_UNUSED_7CFF.S */
11370 /* File: mips/unused.S */
11371     BAL(common_abort)
11372
11373
11374
11375 /* ------------------------------ */
11376     .balign 128
11377 .L_OP_UNUSED_7DFF: /* 0x17d */
11378 /* File: mips/OP_UNUSED_7DFF.S */
11379 /* File: mips/unused.S */
11380     BAL(common_abort)
11381
11382
11383
11384 /* ------------------------------ */
11385     .balign 128
11386 .L_OP_UNUSED_7EFF: /* 0x17e */
11387 /* File: mips/OP_UNUSED_7EFF.S */
11388 /* File: mips/unused.S */
11389     BAL(common_abort)
11390
11391
11392
11393 /* ------------------------------ */
11394     .balign 128
11395 .L_OP_UNUSED_7FFF: /* 0x17f */
11396 /* File: mips/OP_UNUSED_7FFF.S */
11397 /* File: mips/unused.S */
11398     BAL(common_abort)
11399
11400
11401
11402 /* ------------------------------ */
11403     .balign 128
11404 .L_OP_UNUSED_80FF: /* 0x180 */
11405 /* File: mips/OP_UNUSED_80FF.S */
11406 /* File: mips/unused.S */
11407     BAL(common_abort)
11408
11409
11410
11411 /* ------------------------------ */
11412     .balign 128
11413 .L_OP_UNUSED_81FF: /* 0x181 */
11414 /* File: mips/OP_UNUSED_81FF.S */
11415 /* File: mips/unused.S */
11416     BAL(common_abort)
11417
11418
11419
11420 /* ------------------------------ */
11421     .balign 128
11422 .L_OP_UNUSED_82FF: /* 0x182 */
11423 /* File: mips/OP_UNUSED_82FF.S */
11424 /* File: mips/unused.S */
11425     BAL(common_abort)
11426
11427
11428
11429 /* ------------------------------ */
11430     .balign 128
11431 .L_OP_UNUSED_83FF: /* 0x183 */
11432 /* File: mips/OP_UNUSED_83FF.S */
11433 /* File: mips/unused.S */
11434     BAL(common_abort)
11435
11436
11437
11438 /* ------------------------------ */
11439     .balign 128
11440 .L_OP_UNUSED_84FF: /* 0x184 */
11441 /* File: mips/OP_UNUSED_84FF.S */
11442 /* File: mips/unused.S */
11443     BAL(common_abort)
11444
11445
11446
11447 /* ------------------------------ */
11448     .balign 128
11449 .L_OP_UNUSED_85FF: /* 0x185 */
11450 /* File: mips/OP_UNUSED_85FF.S */
11451 /* File: mips/unused.S */
11452     BAL(common_abort)
11453
11454
11455
11456 /* ------------------------------ */
11457     .balign 128
11458 .L_OP_UNUSED_86FF: /* 0x186 */
11459 /* File: mips/OP_UNUSED_86FF.S */
11460 /* File: mips/unused.S */
11461     BAL(common_abort)
11462
11463
11464
11465 /* ------------------------------ */
11466     .balign 128
11467 .L_OP_UNUSED_87FF: /* 0x187 */
11468 /* File: mips/OP_UNUSED_87FF.S */
11469 /* File: mips/unused.S */
11470     BAL(common_abort)
11471
11472
11473
11474 /* ------------------------------ */
11475     .balign 128
11476 .L_OP_UNUSED_88FF: /* 0x188 */
11477 /* File: mips/OP_UNUSED_88FF.S */
11478 /* File: mips/unused.S */
11479     BAL(common_abort)
11480
11481
11482
11483 /* ------------------------------ */
11484     .balign 128
11485 .L_OP_UNUSED_89FF: /* 0x189 */
11486 /* File: mips/OP_UNUSED_89FF.S */
11487 /* File: mips/unused.S */
11488     BAL(common_abort)
11489
11490
11491
11492 /* ------------------------------ */
11493     .balign 128
11494 .L_OP_UNUSED_8AFF: /* 0x18a */
11495 /* File: mips/OP_UNUSED_8AFF.S */
11496 /* File: mips/unused.S */
11497     BAL(common_abort)
11498
11499
11500
11501 /* ------------------------------ */
11502     .balign 128
11503 .L_OP_UNUSED_8BFF: /* 0x18b */
11504 /* File: mips/OP_UNUSED_8BFF.S */
11505 /* File: mips/unused.S */
11506     BAL(common_abort)
11507
11508
11509
11510 /* ------------------------------ */
11511     .balign 128
11512 .L_OP_UNUSED_8CFF: /* 0x18c */
11513 /* File: mips/OP_UNUSED_8CFF.S */
11514 /* File: mips/unused.S */
11515     BAL(common_abort)
11516
11517
11518
11519 /* ------------------------------ */
11520     .balign 128
11521 .L_OP_UNUSED_8DFF: /* 0x18d */
11522 /* File: mips/OP_UNUSED_8DFF.S */
11523 /* File: mips/unused.S */
11524     BAL(common_abort)
11525
11526
11527
11528 /* ------------------------------ */
11529     .balign 128
11530 .L_OP_UNUSED_8EFF: /* 0x18e */
11531 /* File: mips/OP_UNUSED_8EFF.S */
11532 /* File: mips/unused.S */
11533     BAL(common_abort)
11534
11535
11536
11537 /* ------------------------------ */
11538     .balign 128
11539 .L_OP_UNUSED_8FFF: /* 0x18f */
11540 /* File: mips/OP_UNUSED_8FFF.S */
11541 /* File: mips/unused.S */
11542     BAL(common_abort)
11543
11544
11545
11546 /* ------------------------------ */
11547     .balign 128
11548 .L_OP_UNUSED_90FF: /* 0x190 */
11549 /* File: mips/OP_UNUSED_90FF.S */
11550 /* File: mips/unused.S */
11551     BAL(common_abort)
11552
11553
11554
11555 /* ------------------------------ */
11556     .balign 128
11557 .L_OP_UNUSED_91FF: /* 0x191 */
11558 /* File: mips/OP_UNUSED_91FF.S */
11559 /* File: mips/unused.S */
11560     BAL(common_abort)
11561
11562
11563
11564 /* ------------------------------ */
11565     .balign 128
11566 .L_OP_UNUSED_92FF: /* 0x192 */
11567 /* File: mips/OP_UNUSED_92FF.S */
11568 /* File: mips/unused.S */
11569     BAL(common_abort)
11570
11571
11572
11573 /* ------------------------------ */
11574     .balign 128
11575 .L_OP_UNUSED_93FF: /* 0x193 */
11576 /* File: mips/OP_UNUSED_93FF.S */
11577 /* File: mips/unused.S */
11578     BAL(common_abort)
11579
11580
11581
11582 /* ------------------------------ */
11583     .balign 128
11584 .L_OP_UNUSED_94FF: /* 0x194 */
11585 /* File: mips/OP_UNUSED_94FF.S */
11586 /* File: mips/unused.S */
11587     BAL(common_abort)
11588
11589
11590
11591 /* ------------------------------ */
11592     .balign 128
11593 .L_OP_UNUSED_95FF: /* 0x195 */
11594 /* File: mips/OP_UNUSED_95FF.S */
11595 /* File: mips/unused.S */
11596     BAL(common_abort)
11597
11598
11599
11600 /* ------------------------------ */
11601     .balign 128
11602 .L_OP_UNUSED_96FF: /* 0x196 */
11603 /* File: mips/OP_UNUSED_96FF.S */
11604 /* File: mips/unused.S */
11605     BAL(common_abort)
11606
11607
11608
11609 /* ------------------------------ */
11610     .balign 128
11611 .L_OP_UNUSED_97FF: /* 0x197 */
11612 /* File: mips/OP_UNUSED_97FF.S */
11613 /* File: mips/unused.S */
11614     BAL(common_abort)
11615
11616
11617
11618 /* ------------------------------ */
11619     .balign 128
11620 .L_OP_UNUSED_98FF: /* 0x198 */
11621 /* File: mips/OP_UNUSED_98FF.S */
11622 /* File: mips/unused.S */
11623     BAL(common_abort)
11624
11625
11626
11627 /* ------------------------------ */
11628     .balign 128
11629 .L_OP_UNUSED_99FF: /* 0x199 */
11630 /* File: mips/OP_UNUSED_99FF.S */
11631 /* File: mips/unused.S */
11632     BAL(common_abort)
11633
11634
11635
11636 /* ------------------------------ */
11637     .balign 128
11638 .L_OP_UNUSED_9AFF: /* 0x19a */
11639 /* File: mips/OP_UNUSED_9AFF.S */
11640 /* File: mips/unused.S */
11641     BAL(common_abort)
11642
11643
11644
11645 /* ------------------------------ */
11646     .balign 128
11647 .L_OP_UNUSED_9BFF: /* 0x19b */
11648 /* File: mips/OP_UNUSED_9BFF.S */
11649 /* File: mips/unused.S */
11650     BAL(common_abort)
11651
11652
11653
11654 /* ------------------------------ */
11655     .balign 128
11656 .L_OP_UNUSED_9CFF: /* 0x19c */
11657 /* File: mips/OP_UNUSED_9CFF.S */
11658 /* File: mips/unused.S */
11659     BAL(common_abort)
11660
11661
11662
11663 /* ------------------------------ */
11664     .balign 128
11665 .L_OP_UNUSED_9DFF: /* 0x19d */
11666 /* File: mips/OP_UNUSED_9DFF.S */
11667 /* File: mips/unused.S */
11668     BAL(common_abort)
11669
11670
11671
11672 /* ------------------------------ */
11673     .balign 128
11674 .L_OP_UNUSED_9EFF: /* 0x19e */
11675 /* File: mips/OP_UNUSED_9EFF.S */
11676 /* File: mips/unused.S */
11677     BAL(common_abort)
11678
11679
11680
11681 /* ------------------------------ */
11682     .balign 128
11683 .L_OP_UNUSED_9FFF: /* 0x19f */
11684 /* File: mips/OP_UNUSED_9FFF.S */
11685 /* File: mips/unused.S */
11686     BAL(common_abort)
11687
11688
11689
11690 /* ------------------------------ */
11691     .balign 128
11692 .L_OP_UNUSED_A0FF: /* 0x1a0 */
11693 /* File: mips/OP_UNUSED_A0FF.S */
11694 /* File: mips/unused.S */
11695     BAL(common_abort)
11696
11697
11698
11699 /* ------------------------------ */
11700     .balign 128
11701 .L_OP_UNUSED_A1FF: /* 0x1a1 */
11702 /* File: mips/OP_UNUSED_A1FF.S */
11703 /* File: mips/unused.S */
11704     BAL(common_abort)
11705
11706
11707
11708 /* ------------------------------ */
11709     .balign 128
11710 .L_OP_UNUSED_A2FF: /* 0x1a2 */
11711 /* File: mips/OP_UNUSED_A2FF.S */
11712 /* File: mips/unused.S */
11713     BAL(common_abort)
11714
11715
11716
11717 /* ------------------------------ */
11718     .balign 128
11719 .L_OP_UNUSED_A3FF: /* 0x1a3 */
11720 /* File: mips/OP_UNUSED_A3FF.S */
11721 /* File: mips/unused.S */
11722     BAL(common_abort)
11723
11724
11725
11726 /* ------------------------------ */
11727     .balign 128
11728 .L_OP_UNUSED_A4FF: /* 0x1a4 */
11729 /* File: mips/OP_UNUSED_A4FF.S */
11730 /* File: mips/unused.S */
11731     BAL(common_abort)
11732
11733
11734
11735 /* ------------------------------ */
11736     .balign 128
11737 .L_OP_UNUSED_A5FF: /* 0x1a5 */
11738 /* File: mips/OP_UNUSED_A5FF.S */
11739 /* File: mips/unused.S */
11740     BAL(common_abort)
11741
11742
11743
11744 /* ------------------------------ */
11745     .balign 128
11746 .L_OP_UNUSED_A6FF: /* 0x1a6 */
11747 /* File: mips/OP_UNUSED_A6FF.S */
11748 /* File: mips/unused.S */
11749     BAL(common_abort)
11750
11751
11752
11753 /* ------------------------------ */
11754     .balign 128
11755 .L_OP_UNUSED_A7FF: /* 0x1a7 */
11756 /* File: mips/OP_UNUSED_A7FF.S */
11757 /* File: mips/unused.S */
11758     BAL(common_abort)
11759
11760
11761
11762 /* ------------------------------ */
11763     .balign 128
11764 .L_OP_UNUSED_A8FF: /* 0x1a8 */
11765 /* File: mips/OP_UNUSED_A8FF.S */
11766 /* File: mips/unused.S */
11767     BAL(common_abort)
11768
11769
11770
11771 /* ------------------------------ */
11772     .balign 128
11773 .L_OP_UNUSED_A9FF: /* 0x1a9 */
11774 /* File: mips/OP_UNUSED_A9FF.S */
11775 /* File: mips/unused.S */
11776     BAL(common_abort)
11777
11778
11779
11780 /* ------------------------------ */
11781     .balign 128
11782 .L_OP_UNUSED_AAFF: /* 0x1aa */
11783 /* File: mips/OP_UNUSED_AAFF.S */
11784 /* File: mips/unused.S */
11785     BAL(common_abort)
11786
11787
11788
11789 /* ------------------------------ */
11790     .balign 128
11791 .L_OP_UNUSED_ABFF: /* 0x1ab */
11792 /* File: mips/OP_UNUSED_ABFF.S */
11793 /* File: mips/unused.S */
11794     BAL(common_abort)
11795
11796
11797
11798 /* ------------------------------ */
11799     .balign 128
11800 .L_OP_UNUSED_ACFF: /* 0x1ac */
11801 /* File: mips/OP_UNUSED_ACFF.S */
11802 /* File: mips/unused.S */
11803     BAL(common_abort)
11804
11805
11806
11807 /* ------------------------------ */
11808     .balign 128
11809 .L_OP_UNUSED_ADFF: /* 0x1ad */
11810 /* File: mips/OP_UNUSED_ADFF.S */
11811 /* File: mips/unused.S */
11812     BAL(common_abort)
11813
11814
11815
11816 /* ------------------------------ */
11817     .balign 128
11818 .L_OP_UNUSED_AEFF: /* 0x1ae */
11819 /* File: mips/OP_UNUSED_AEFF.S */
11820 /* File: mips/unused.S */
11821     BAL(common_abort)
11822
11823
11824
11825 /* ------------------------------ */
11826     .balign 128
11827 .L_OP_UNUSED_AFFF: /* 0x1af */
11828 /* File: mips/OP_UNUSED_AFFF.S */
11829 /* File: mips/unused.S */
11830     BAL(common_abort)
11831
11832
11833
11834 /* ------------------------------ */
11835     .balign 128
11836 .L_OP_UNUSED_B0FF: /* 0x1b0 */
11837 /* File: mips/OP_UNUSED_B0FF.S */
11838 /* File: mips/unused.S */
11839     BAL(common_abort)
11840
11841
11842
11843 /* ------------------------------ */
11844     .balign 128
11845 .L_OP_UNUSED_B1FF: /* 0x1b1 */
11846 /* File: mips/OP_UNUSED_B1FF.S */
11847 /* File: mips/unused.S */
11848     BAL(common_abort)
11849
11850
11851
11852 /* ------------------------------ */
11853     .balign 128
11854 .L_OP_UNUSED_B2FF: /* 0x1b2 */
11855 /* File: mips/OP_UNUSED_B2FF.S */
11856 /* File: mips/unused.S */
11857     BAL(common_abort)
11858
11859
11860
11861 /* ------------------------------ */
11862     .balign 128
11863 .L_OP_UNUSED_B3FF: /* 0x1b3 */
11864 /* File: mips/OP_UNUSED_B3FF.S */
11865 /* File: mips/unused.S */
11866     BAL(common_abort)
11867
11868
11869
11870 /* ------------------------------ */
11871     .balign 128
11872 .L_OP_UNUSED_B4FF: /* 0x1b4 */
11873 /* File: mips/OP_UNUSED_B4FF.S */
11874 /* File: mips/unused.S */
11875     BAL(common_abort)
11876
11877
11878
11879 /* ------------------------------ */
11880     .balign 128
11881 .L_OP_UNUSED_B5FF: /* 0x1b5 */
11882 /* File: mips/OP_UNUSED_B5FF.S */
11883 /* File: mips/unused.S */
11884     BAL(common_abort)
11885
11886
11887
11888 /* ------------------------------ */
11889     .balign 128
11890 .L_OP_UNUSED_B6FF: /* 0x1b6 */
11891 /* File: mips/OP_UNUSED_B6FF.S */
11892 /* File: mips/unused.S */
11893     BAL(common_abort)
11894
11895
11896
11897 /* ------------------------------ */
11898     .balign 128
11899 .L_OP_UNUSED_B7FF: /* 0x1b7 */
11900 /* File: mips/OP_UNUSED_B7FF.S */
11901 /* File: mips/unused.S */
11902     BAL(common_abort)
11903
11904
11905
11906 /* ------------------------------ */
11907     .balign 128
11908 .L_OP_UNUSED_B8FF: /* 0x1b8 */
11909 /* File: mips/OP_UNUSED_B8FF.S */
11910 /* File: mips/unused.S */
11911     BAL(common_abort)
11912
11913
11914
11915 /* ------------------------------ */
11916     .balign 128
11917 .L_OP_UNUSED_B9FF: /* 0x1b9 */
11918 /* File: mips/OP_UNUSED_B9FF.S */
11919 /* File: mips/unused.S */
11920     BAL(common_abort)
11921
11922
11923
11924 /* ------------------------------ */
11925     .balign 128
11926 .L_OP_UNUSED_BAFF: /* 0x1ba */
11927 /* File: mips/OP_UNUSED_BAFF.S */
11928 /* File: mips/unused.S */
11929     BAL(common_abort)
11930
11931
11932
11933 /* ------------------------------ */
11934     .balign 128
11935 .L_OP_UNUSED_BBFF: /* 0x1bb */
11936 /* File: mips/OP_UNUSED_BBFF.S */
11937 /* File: mips/unused.S */
11938     BAL(common_abort)
11939
11940
11941
11942 /* ------------------------------ */
11943     .balign 128
11944 .L_OP_UNUSED_BCFF: /* 0x1bc */
11945 /* File: mips/OP_UNUSED_BCFF.S */
11946 /* File: mips/unused.S */
11947     BAL(common_abort)
11948
11949
11950
11951 /* ------------------------------ */
11952     .balign 128
11953 .L_OP_UNUSED_BDFF: /* 0x1bd */
11954 /* File: mips/OP_UNUSED_BDFF.S */
11955 /* File: mips/unused.S */
11956     BAL(common_abort)
11957
11958
11959
11960 /* ------------------------------ */
11961     .balign 128
11962 .L_OP_UNUSED_BEFF: /* 0x1be */
11963 /* File: mips/OP_UNUSED_BEFF.S */
11964 /* File: mips/unused.S */
11965     BAL(common_abort)
11966
11967
11968
11969 /* ------------------------------ */
11970     .balign 128
11971 .L_OP_UNUSED_BFFF: /* 0x1bf */
11972 /* File: mips/OP_UNUSED_BFFF.S */
11973 /* File: mips/unused.S */
11974     BAL(common_abort)
11975
11976
11977
11978 /* ------------------------------ */
11979     .balign 128
11980 .L_OP_UNUSED_C0FF: /* 0x1c0 */
11981 /* File: mips/OP_UNUSED_C0FF.S */
11982 /* File: mips/unused.S */
11983     BAL(common_abort)
11984
11985
11986
11987 /* ------------------------------ */
11988     .balign 128
11989 .L_OP_UNUSED_C1FF: /* 0x1c1 */
11990 /* File: mips/OP_UNUSED_C1FF.S */
11991 /* File: mips/unused.S */
11992     BAL(common_abort)
11993
11994
11995
11996 /* ------------------------------ */
11997     .balign 128
11998 .L_OP_UNUSED_C2FF: /* 0x1c2 */
11999 /* File: mips/OP_UNUSED_C2FF.S */
12000 /* File: mips/unused.S */
12001     BAL(common_abort)
12002
12003
12004
12005 /* ------------------------------ */
12006     .balign 128
12007 .L_OP_UNUSED_C3FF: /* 0x1c3 */
12008 /* File: mips/OP_UNUSED_C3FF.S */
12009 /* File: mips/unused.S */
12010     BAL(common_abort)
12011
12012
12013
12014 /* ------------------------------ */
12015     .balign 128
12016 .L_OP_UNUSED_C4FF: /* 0x1c4 */
12017 /* File: mips/OP_UNUSED_C4FF.S */
12018 /* File: mips/unused.S */
12019     BAL(common_abort)
12020
12021
12022
12023 /* ------------------------------ */
12024     .balign 128
12025 .L_OP_UNUSED_C5FF: /* 0x1c5 */
12026 /* File: mips/OP_UNUSED_C5FF.S */
12027 /* File: mips/unused.S */
12028     BAL(common_abort)
12029
12030
12031
12032 /* ------------------------------ */
12033     .balign 128
12034 .L_OP_UNUSED_C6FF: /* 0x1c6 */
12035 /* File: mips/OP_UNUSED_C6FF.S */
12036 /* File: mips/unused.S */
12037     BAL(common_abort)
12038
12039
12040
12041 /* ------------------------------ */
12042     .balign 128
12043 .L_OP_UNUSED_C7FF: /* 0x1c7 */
12044 /* File: mips/OP_UNUSED_C7FF.S */
12045 /* File: mips/unused.S */
12046     BAL(common_abort)
12047
12048
12049
12050 /* ------------------------------ */
12051     .balign 128
12052 .L_OP_UNUSED_C8FF: /* 0x1c8 */
12053 /* File: mips/OP_UNUSED_C8FF.S */
12054 /* File: mips/unused.S */
12055     BAL(common_abort)
12056
12057
12058
12059 /* ------------------------------ */
12060     .balign 128
12061 .L_OP_UNUSED_C9FF: /* 0x1c9 */
12062 /* File: mips/OP_UNUSED_C9FF.S */
12063 /* File: mips/unused.S */
12064     BAL(common_abort)
12065
12066
12067
12068 /* ------------------------------ */
12069     .balign 128
12070 .L_OP_UNUSED_CAFF: /* 0x1ca */
12071 /* File: mips/OP_UNUSED_CAFF.S */
12072 /* File: mips/unused.S */
12073     BAL(common_abort)
12074
12075
12076
12077 /* ------------------------------ */
12078     .balign 128
12079 .L_OP_UNUSED_CBFF: /* 0x1cb */
12080 /* File: mips/OP_UNUSED_CBFF.S */
12081 /* File: mips/unused.S */
12082     BAL(common_abort)
12083
12084
12085
12086 /* ------------------------------ */
12087     .balign 128
12088 .L_OP_UNUSED_CCFF: /* 0x1cc */
12089 /* File: mips/OP_UNUSED_CCFF.S */
12090 /* File: mips/unused.S */
12091     BAL(common_abort)
12092
12093
12094
12095 /* ------------------------------ */
12096     .balign 128
12097 .L_OP_UNUSED_CDFF: /* 0x1cd */
12098 /* File: mips/OP_UNUSED_CDFF.S */
12099 /* File: mips/unused.S */
12100     BAL(common_abort)
12101
12102
12103
12104 /* ------------------------------ */
12105     .balign 128
12106 .L_OP_UNUSED_CEFF: /* 0x1ce */
12107 /* File: mips/OP_UNUSED_CEFF.S */
12108 /* File: mips/unused.S */
12109     BAL(common_abort)
12110
12111
12112
12113 /* ------------------------------ */
12114     .balign 128
12115 .L_OP_UNUSED_CFFF: /* 0x1cf */
12116 /* File: mips/OP_UNUSED_CFFF.S */
12117 /* File: mips/unused.S */
12118     BAL(common_abort)
12119
12120
12121
12122 /* ------------------------------ */
12123     .balign 128
12124 .L_OP_UNUSED_D0FF: /* 0x1d0 */
12125 /* File: mips/OP_UNUSED_D0FF.S */
12126 /* File: mips/unused.S */
12127     BAL(common_abort)
12128
12129
12130
12131 /* ------------------------------ */
12132     .balign 128
12133 .L_OP_UNUSED_D1FF: /* 0x1d1 */
12134 /* File: mips/OP_UNUSED_D1FF.S */
12135 /* File: mips/unused.S */
12136     BAL(common_abort)
12137
12138
12139
12140 /* ------------------------------ */
12141     .balign 128
12142 .L_OP_UNUSED_D2FF: /* 0x1d2 */
12143 /* File: mips/OP_UNUSED_D2FF.S */
12144 /* File: mips/unused.S */
12145     BAL(common_abort)
12146
12147
12148
12149 /* ------------------------------ */
12150     .balign 128
12151 .L_OP_UNUSED_D3FF: /* 0x1d3 */
12152 /* File: mips/OP_UNUSED_D3FF.S */
12153 /* File: mips/unused.S */
12154     BAL(common_abort)
12155
12156
12157
12158 /* ------------------------------ */
12159     .balign 128
12160 .L_OP_UNUSED_D4FF: /* 0x1d4 */
12161 /* File: mips/OP_UNUSED_D4FF.S */
12162 /* File: mips/unused.S */
12163     BAL(common_abort)
12164
12165
12166
12167 /* ------------------------------ */
12168     .balign 128
12169 .L_OP_UNUSED_D5FF: /* 0x1d5 */
12170 /* File: mips/OP_UNUSED_D5FF.S */
12171 /* File: mips/unused.S */
12172     BAL(common_abort)
12173
12174
12175
12176 /* ------------------------------ */
12177     .balign 128
12178 .L_OP_UNUSED_D6FF: /* 0x1d6 */
12179 /* File: mips/OP_UNUSED_D6FF.S */
12180 /* File: mips/unused.S */
12181     BAL(common_abort)
12182
12183
12184
12185 /* ------------------------------ */
12186     .balign 128
12187 .L_OP_UNUSED_D7FF: /* 0x1d7 */
12188 /* File: mips/OP_UNUSED_D7FF.S */
12189 /* File: mips/unused.S */
12190     BAL(common_abort)
12191
12192
12193
12194 /* ------------------------------ */
12195     .balign 128
12196 .L_OP_UNUSED_D8FF: /* 0x1d8 */
12197 /* File: mips/OP_UNUSED_D8FF.S */
12198 /* File: mips/unused.S */
12199     BAL(common_abort)
12200
12201
12202
12203 /* ------------------------------ */
12204     .balign 128
12205 .L_OP_UNUSED_D9FF: /* 0x1d9 */
12206 /* File: mips/OP_UNUSED_D9FF.S */
12207 /* File: mips/unused.S */
12208     BAL(common_abort)
12209
12210
12211
12212 /* ------------------------------ */
12213     .balign 128
12214 .L_OP_UNUSED_DAFF: /* 0x1da */
12215 /* File: mips/OP_UNUSED_DAFF.S */
12216 /* File: mips/unused.S */
12217     BAL(common_abort)
12218
12219
12220
12221 /* ------------------------------ */
12222     .balign 128
12223 .L_OP_UNUSED_DBFF: /* 0x1db */
12224 /* File: mips/OP_UNUSED_DBFF.S */
12225 /* File: mips/unused.S */
12226     BAL(common_abort)
12227
12228
12229
12230 /* ------------------------------ */
12231     .balign 128
12232 .L_OP_UNUSED_DCFF: /* 0x1dc */
12233 /* File: mips/OP_UNUSED_DCFF.S */
12234 /* File: mips/unused.S */
12235     BAL(common_abort)
12236
12237
12238
12239 /* ------------------------------ */
12240     .balign 128
12241 .L_OP_UNUSED_DDFF: /* 0x1dd */
12242 /* File: mips/OP_UNUSED_DDFF.S */
12243 /* File: mips/unused.S */
12244     BAL(common_abort)
12245
12246
12247
12248 /* ------------------------------ */
12249     .balign 128
12250 .L_OP_UNUSED_DEFF: /* 0x1de */
12251 /* File: mips/OP_UNUSED_DEFF.S */
12252 /* File: mips/unused.S */
12253     BAL(common_abort)
12254
12255
12256
12257 /* ------------------------------ */
12258     .balign 128
12259 .L_OP_UNUSED_DFFF: /* 0x1df */
12260 /* File: mips/OP_UNUSED_DFFF.S */
12261 /* File: mips/unused.S */
12262     BAL(common_abort)
12263
12264
12265
12266 /* ------------------------------ */
12267     .balign 128
12268 .L_OP_UNUSED_E0FF: /* 0x1e0 */
12269 /* File: mips/OP_UNUSED_E0FF.S */
12270 /* File: mips/unused.S */
12271     BAL(common_abort)
12272
12273
12274
12275 /* ------------------------------ */
12276     .balign 128
12277 .L_OP_UNUSED_E1FF: /* 0x1e1 */
12278 /* File: mips/OP_UNUSED_E1FF.S */
12279 /* File: mips/unused.S */
12280     BAL(common_abort)
12281
12282
12283
12284 /* ------------------------------ */
12285     .balign 128
12286 .L_OP_UNUSED_E2FF: /* 0x1e2 */
12287 /* File: mips/OP_UNUSED_E2FF.S */
12288 /* File: mips/unused.S */
12289     BAL(common_abort)
12290
12291
12292
12293 /* ------------------------------ */
12294     .balign 128
12295 .L_OP_UNUSED_E3FF: /* 0x1e3 */
12296 /* File: mips/OP_UNUSED_E3FF.S */
12297 /* File: mips/unused.S */
12298     BAL(common_abort)
12299
12300
12301
12302 /* ------------------------------ */
12303     .balign 128
12304 .L_OP_UNUSED_E4FF: /* 0x1e4 */
12305 /* File: mips/OP_UNUSED_E4FF.S */
12306 /* File: mips/unused.S */
12307     BAL(common_abort)
12308
12309
12310
12311 /* ------------------------------ */
12312     .balign 128
12313 .L_OP_UNUSED_E5FF: /* 0x1e5 */
12314 /* File: mips/OP_UNUSED_E5FF.S */
12315 /* File: mips/unused.S */
12316     BAL(common_abort)
12317
12318
12319
12320 /* ------------------------------ */
12321     .balign 128
12322 .L_OP_UNUSED_E6FF: /* 0x1e6 */
12323 /* File: mips/OP_UNUSED_E6FF.S */
12324 /* File: mips/unused.S */
12325     BAL(common_abort)
12326
12327
12328
12329 /* ------------------------------ */
12330     .balign 128
12331 .L_OP_UNUSED_E7FF: /* 0x1e7 */
12332 /* File: mips/OP_UNUSED_E7FF.S */
12333 /* File: mips/unused.S */
12334     BAL(common_abort)
12335
12336
12337
12338 /* ------------------------------ */
12339     .balign 128
12340 .L_OP_UNUSED_E8FF: /* 0x1e8 */
12341 /* File: mips/OP_UNUSED_E8FF.S */
12342 /* File: mips/unused.S */
12343     BAL(common_abort)
12344
12345
12346
12347 /* ------------------------------ */
12348     .balign 128
12349 .L_OP_UNUSED_E9FF: /* 0x1e9 */
12350 /* File: mips/OP_UNUSED_E9FF.S */
12351 /* File: mips/unused.S */
12352     BAL(common_abort)
12353
12354
12355
12356 /* ------------------------------ */
12357     .balign 128
12358 .L_OP_UNUSED_EAFF: /* 0x1ea */
12359 /* File: mips/OP_UNUSED_EAFF.S */
12360 /* File: mips/unused.S */
12361     BAL(common_abort)
12362
12363
12364
12365 /* ------------------------------ */
12366     .balign 128
12367 .L_OP_UNUSED_EBFF: /* 0x1eb */
12368 /* File: mips/OP_UNUSED_EBFF.S */
12369 /* File: mips/unused.S */
12370     BAL(common_abort)
12371
12372
12373
12374 /* ------------------------------ */
12375     .balign 128
12376 .L_OP_UNUSED_ECFF: /* 0x1ec */
12377 /* File: mips/OP_UNUSED_ECFF.S */
12378 /* File: mips/unused.S */
12379     BAL(common_abort)
12380
12381
12382
12383 /* ------------------------------ */
12384     .balign 128
12385 .L_OP_UNUSED_EDFF: /* 0x1ed */
12386 /* File: mips/OP_UNUSED_EDFF.S */
12387 /* File: mips/unused.S */
12388     BAL(common_abort)
12389
12390
12391
12392 /* ------------------------------ */
12393     .balign 128
12394 .L_OP_UNUSED_EEFF: /* 0x1ee */
12395 /* File: mips/OP_UNUSED_EEFF.S */
12396 /* File: mips/unused.S */
12397     BAL(common_abort)
12398
12399
12400
12401 /* ------------------------------ */
12402     .balign 128
12403 .L_OP_UNUSED_EFFF: /* 0x1ef */
12404 /* File: mips/OP_UNUSED_EFFF.S */
12405 /* File: mips/unused.S */
12406     BAL(common_abort)
12407
12408
12409
12410 /* ------------------------------ */
12411     .balign 128
12412 .L_OP_UNUSED_F0FF: /* 0x1f0 */
12413 /* File: mips/OP_UNUSED_F0FF.S */
12414 /* File: mips/unused.S */
12415     BAL(common_abort)
12416
12417
12418
12419 /* ------------------------------ */
12420     .balign 128
12421 .L_OP_UNUSED_F1FF: /* 0x1f1 */
12422 /* File: mips/OP_UNUSED_F1FF.S */
12423 /* File: mips/unused.S */
12424     BAL(common_abort)
12425
12426
12427
12428 /* ------------------------------ */
12429     .balign 128
12430 .L_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */
12431 /* File: mips/OP_INVOKE_OBJECT_INIT_JUMBO.S */
12432 /* File: mips/OP_INVOKE_OBJECT_INIT_RANGE.S */
12433     /*
12434      * Invoke Object.<init> on an object.  In practice we know that
12435      * Object's nullary constructor doesn't do anything, so we just
12436      * skip it unless a debugger is active.
12437      */
12438     FETCH(a1, 4)                  # a1<- CCCC
12439     GET_VREG(a0, a1)                    # a0<- "this" ptr
12440     # check for NULL
12441     beqz    a0, common_errNullObject    # export PC and throw NPE
12442     LOAD_base_offObject_clazz(a1, a0)   # a1<- obj->clazz
12443     LOAD_base_offClassObject_accessFlags(a2, a1) # a2<- clazz->accessFlags
12444     and     a2, CLASS_ISFINALIZABLE     # is this class finalizable?
12445     beqz    a2, .LOP_INVOKE_OBJECT_INIT_JUMBO_finish      # no, go
12446
12447 .LOP_INVOKE_OBJECT_INIT_JUMBO_setFinal:
12448     EXPORT_PC()                         # can throw
12449     JAL(dvmSetFinalizable)              # call dvmSetFinalizable(obj)
12450     LOAD_offThread_exception(a0, rSELF) # a0<- self->exception
12451     # exception pending?
12452     bnez    a0, common_exceptionThrown  # yes, handle it
12453
12454 .LOP_INVOKE_OBJECT_INIT_JUMBO_finish:
12455     lhu     a1, offThread_subMode(rSELF)
12456     and     a1, kSubModeDebuggerActive  # debugger active?
12457     bnez    a1, .LOP_INVOKE_OBJECT_INIT_JUMBO_debugger    # Yes - skip optimization
12458     FETCH_ADVANCE_INST(4+1)       # advance to next instr, load rINST
12459     GET_INST_OPCODE(t0)                 # t0<- opcode from rINST
12460     GOTO_OPCODE(t0)                     # execute it
12461
12462
12463
12464 /* ------------------------------ */
12465     .balign 128
12466 .L_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */
12467 /* File: mips/OP_IGET_VOLATILE_JUMBO.S */
12468 /* File: mips/OP_IGET_JUMBO.S */
12469     /*
12470      * Jumbo 32-bit instance field get.
12471      *
12472      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
12473      *      iget-char/jumbo, iget-short/jumbo
12474      */
12475     /* exop vBBBB, vCCCC, field@AAAAAAAA */
12476     FETCH(a1, 1)                           # a1<- aaaa (lo)
12477     FETCH(a2, 2)                           # a2<- AAAA (hi)
12478     FETCH(a0, 4)                           # a0<- CCCC
12479     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
12480     sll     a2,a2,16
12481     or      a1, a1, a2                     # a1<- AAAAaaaa
12482     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
12483     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
12484     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
12485     # is resolved entry null?
12486     bnez      a0, .LOP_IGET_VOLATILE_JUMBO_finish       #  no, already resolved
12487     LOAD_rSELF_method(a2)                  #  a2 <- current method
12488     EXPORT_PC()                            #  resolve() could throw
12489     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12490     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
12491     b       .LOP_IGET_VOLATILE_JUMBO_resolved        # resolved, continue
12492
12493
12494
12495 /* ------------------------------ */
12496     .balign 128
12497 .L_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */
12498 /* File: mips/OP_IGET_WIDE_VOLATILE_JUMBO.S */
12499 /* File: mips/OP_IGET_WIDE_JUMBO.S */
12500     /*
12501      * Jumbo 64-bit instance field get.
12502      */
12503     /* iget-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
12504     FETCH(a1, 1)                           # a1<- aaaa (lo)
12505     FETCH(a2, 2)                           # a2<- AAAA (hi)
12506     FETCH(a0, 4)                           # a0<- CCCC
12507     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
12508     sll    a2,a2,16
12509     or     a1, a1, a2                      # a1<- AAAAaaaa
12510     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
12511     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[CCCC], the object pointer
12512     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
12513     # is resolved entry null?
12514     bnez      a0, .LOP_IGET_WIDE_VOLATILE_JUMBO_finish       #  no, already resolved
12515     LOAD_rSELF_method(a2)                  #  a2 <- current method
12516     EXPORT_PC()                            #  resolve() could throw
12517     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12518     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
12519     b       .LOP_IGET_WIDE_VOLATILE_JUMBO_resolved           # resolved, continue
12520
12521
12522
12523 /* ------------------------------ */
12524     .balign 128
12525 .L_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */
12526 /* File: mips/OP_IGET_OBJECT_VOLATILE_JUMBO.S */
12527 /* File: mips/OP_IGET_OBJECT_JUMBO.S */
12528 /* File: mips/OP_IGET_JUMBO.S */
12529     /*
12530      * Jumbo 32-bit instance field get.
12531      *
12532      * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
12533      *      iget-char/jumbo, iget-short/jumbo
12534      */
12535     /* exop vBBBB, vCCCC, field@AAAAAAAA */
12536     FETCH(a1, 1)                           # a1<- aaaa (lo)
12537     FETCH(a2, 2)                           # a2<- AAAA (hi)
12538     FETCH(a0, 4)                           # a0<- CCCC
12539     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
12540     sll     a2,a2,16
12541     or      a1, a1, a2                     # a1<- AAAAaaaa
12542     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
12543     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
12544     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
12545     # is resolved entry null?
12546     bnez      a0, .LOP_IGET_OBJECT_VOLATILE_JUMBO_finish       #  no, already resolved
12547     LOAD_rSELF_method(a2)                  #  a2 <- current method
12548     EXPORT_PC()                            #  resolve() could throw
12549     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12550     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
12551     b       .LOP_IGET_OBJECT_VOLATILE_JUMBO_resolved        # resolved, continue
12552
12553
12554
12555
12556 /* ------------------------------ */
12557     .balign 128
12558 .L_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */
12559 /* File: mips/OP_IPUT_VOLATILE_JUMBO.S */
12560 /* File: mips/OP_IPUT_JUMBO.S */
12561     /*
12562      * Jumbo 32-bit instance field put.
12563      *
12564      * for: iput/jumbo, iput-boolean/jumbo, iput-byte/jumbo, iput-char/jumbo,
12565      *      iput-short/jumbo
12566      */
12567     /* exop vBBBB, vCCCC, field@AAAAAAAA */
12568     FETCH(a1, 1)                           # a1<- aaaa (lo)
12569     FETCH(a2, 2)                           # a2<- AAAA (hi)
12570     FETCH(a0, 4)                           # a0<- CCCC
12571     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
12572     sll       a2,a2,16
12573     or        a1, a1, a2                   #  a1<- AAAAaaaa
12574     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
12575     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
12576     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
12577     # is resolved entry null?
12578     bnez      a0, .LOP_IPUT_VOLATILE_JUMBO_finish       #  no, already resolved
12579     LOAD_rSELF_method(a2)                  #  a2 <- current method
12580     EXPORT_PC()                            #  resolve() could throw
12581     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12582     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
12583     b       .LOP_IPUT_VOLATILE_JUMBO_resolved           # resolved, continue
12584
12585
12586
12587 /* ------------------------------ */
12588     .balign 128
12589 .L_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */
12590 /* File: mips/OP_IPUT_WIDE_VOLATILE_JUMBO.S */
12591 /* File: mips/OP_IPUT_WIDE_JUMBO.S */
12592     /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
12593     FETCH(a1, 1)                           # a1<- aaaa (lo)
12594     FETCH(a2, 2)                           # a2<- AAAA (hi)
12595     FETCH(a0, 4)                           # a0<- CCCC
12596     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
12597     sll       a2,a2,16
12598     or        a1, a1, a2                   # a1<- AAAAaaaa
12599
12600     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pResFields
12601     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
12602     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
12603     # is resolved entry null?
12604     bnez      a0, .LOP_IPUT_WIDE_VOLATILE_JUMBO_finish       #  no, already resolved
12605     LOAD_rSELF_method(a2)                  #  a2 <- current method
12606     EXPORT_PC()                            #  resolve() could throw
12607     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12608     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
12609     b       .LOP_IPUT_WIDE_VOLATILE_JUMBO_resolved           # resolved, continue
12610
12611
12612
12613 /* ------------------------------ */
12614     .balign 128
12615 .L_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */
12616 /* File: mips/OP_IPUT_OBJECT_VOLATILE_JUMBO.S */
12617 /* File: mips/OP_IPUT_OBJECT_JUMBO.S */
12618     /*
12619      * Jumbo 32-bit instance field put.
12620      */
12621     /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */
12622     FETCH(a1, 1)                           # a1<- aaaa (lo)
12623     FETCH(a2, 2)                           # a2<- AAAA (hi)
12624     FETCH(a0, 4)                           # a0<- CCCC
12625     LOAD_rSELF_methodClassDex(a3)          #  a3 <- DvmDex
12626     sll      a1,a1,16
12627     or       a1, a1, a2                    # a1<- AAAAaaaa
12628     LOAD_base_offDvmDex_pResFields(a2, a3) #  a2 <- pDvmDex->pResFields
12629     GET_VREG(rOBJ, a0)                     #  rOBJ <- fp[B], the object pointer
12630     LOAD_eas2(a0, a2, a1)                  #  a0 <- resolved InstField ptr
12631     # is resolved entry null?
12632     bnez      a0, .LOP_IPUT_OBJECT_VOLATILE_JUMBO_finish       #  no, already resolved
12633     LOAD_rSELF_method(a2)                  #  a2 <- current method
12634     EXPORT_PC()                            #  resolve() could throw
12635     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12636     JAL(dvmResolveInstField)               #  v0 <- resolved InstField ptr
12637     b         .LOP_IPUT_OBJECT_VOLATILE_JUMBO_resolved
12638
12639
12640
12641 /* ------------------------------ */
12642     .balign 128
12643 .L_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */
12644 /* File: mips/OP_SGET_VOLATILE_JUMBO.S */
12645 /* File: mips/OP_SGET_JUMBO.S */
12646      /*
12647      * Jumbo 32-bit SGET handler.
12648      *
12649      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
12650      *      sget-char/jumbo, sget-short/jumbo
12651      */
12652      /* exop vBBBB, field@AAAAAAAA */
12653     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
12654     FETCH(a0, 1)                           # a0<- aaaa (lo)
12655     FETCH(a1, 2)                           # a1<- AAAA (hi)
12656     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
12657     sll       a1,a1,16
12658     or        a1, a0, a1                   # a1<- AAAAaaaa
12659     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
12660     # is resolved entry !null?
12661     bnez      a0, .LOP_SGET_VOLATILE_JUMBO_finish
12662
12663     /*
12664      * Continuation if the field has not yet been resolved.
12665      *  a1:  AAAAAAAA field ref
12666      *  rBIX: dvmDex->pResFields
12667      */
12668     LOAD_rSELF_method(a2)                  #  a2 <- current method
12669 #if defined(WITH_JIT)
12670     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
12671 #endif
12672     EXPORT_PC()                            #  resolve() could throw, so export now
12673     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12674     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
12675     move      a0, v0
12676     # success?
12677     beqz      v0, common_exceptionThrown   #  no, handle exception
12678 #if defined(WITH_JIT)
12679     /*
12680      * If the JIT is actively building a trace we need to make sure
12681      * that the field is fully resolved before including this instruction.
12682      */
12683     JAL(common_verifyField)
12684 #endif
12685     b        .LOP_SGET_VOLATILE_JUMBO_finish            # resume
12686
12687
12688 /* ------------------------------ */
12689     .balign 128
12690 .L_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */
12691 /* File: mips/OP_SGET_WIDE_VOLATILE_JUMBO.S */
12692 /* File: mips/OP_SGET_WIDE_JUMBO.S */
12693     /*
12694      * Jumbo 64-bit SGET handler.
12695      */
12696     /* sget-wide/jumbo vBBBB, field@AAAAAAAA */
12697     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
12698     FETCH(a0, 1)                           # a0<- aaaa (lo)
12699     FETCH(a1, 2)                           # a1<- AAAA (hi)
12700     LOAD_base_offDvmDex_pResFields(a2, a2) #  a2 <- dvmDex->pResFields
12701     sll       a1,a1,16
12702     or        a1, a0, a1                 # a1<- AAAAaaaa
12703     LOAD_eas2(a0, a2, a1)                #  a0 <- resolved StaticField ptr
12704     # is resolved entry null?
12705     bnez      a0, .LOP_SGET_WIDE_VOLATILE_JUMBO_finish
12706
12707     /*
12708      * Continuation if the field has not yet been resolved.
12709      *  a1:  AAAAAAAA field ref
12710      *
12711      * Returns StaticField pointer in v0.
12712      */
12713     LOAD_rSELF_method(a2)                  #  a2 <- current method
12714     EXPORT_PC()                            #  resolve() could throw, so export now
12715     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12716     JAL(dvmResolveStaticField)             #  a0 <- resolved StaticField ptr
12717     move      a0, v0
12718     # success?
12719     beqz      v0, common_exceptionThrown   #  no, handle exception
12720     b        .LOP_SGET_WIDE_VOLATILE_JUMBO_finish            # resume
12721
12722
12723 /* ------------------------------ */
12724     .balign 128
12725 .L_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */
12726 /* File: mips/OP_SGET_OBJECT_VOLATILE_JUMBO.S */
12727 /* File: mips/OP_SGET_OBJECT_JUMBO.S */
12728 /* File: mips/OP_SGET_JUMBO.S */
12729      /*
12730      * Jumbo 32-bit SGET handler.
12731      *
12732      * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
12733      *      sget-char/jumbo, sget-short/jumbo
12734      */
12735      /* exop vBBBB, field@AAAAAAAA */
12736     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
12737     FETCH(a0, 1)                           # a0<- aaaa (lo)
12738     FETCH(a1, 2)                           # a1<- AAAA (hi)
12739     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
12740     sll       a1,a1,16
12741     or        a1, a0, a1                   # a1<- AAAAaaaa
12742     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
12743     # is resolved entry !null?
12744     bnez      a0, .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish
12745
12746     /*
12747      * Continuation if the field has not yet been resolved.
12748      *  a1:  AAAAAAAA field ref
12749      *  rBIX: dvmDex->pResFields
12750      */
12751     LOAD_rSELF_method(a2)                  #  a2 <- current method
12752 #if defined(WITH_JIT)
12753     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
12754 #endif
12755     EXPORT_PC()                            #  resolve() could throw, so export now
12756     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12757     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
12758     move      a0, v0
12759     # success?
12760     beqz      v0, common_exceptionThrown   #  no, handle exception
12761 #if defined(WITH_JIT)
12762     /*
12763      * If the JIT is actively building a trace we need to make sure
12764      * that the field is fully resolved before including this instruction.
12765      */
12766     JAL(common_verifyField)
12767 #endif
12768     b        .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish            # resume
12769
12770
12771
12772 /* ------------------------------ */
12773     .balign 128
12774 .L_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */
12775 /* File: mips/OP_SPUT_VOLATILE_JUMBO.S */
12776 /* File: mips/OP_SPUT_JUMBO.S */
12777     /*
12778      * Jumbo 32-bit SPUT handler.
12779      *
12780      * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
12781      *      sput-short/jumbo
12782      */
12783     /* exop vBBBB, field@AAAAAAAA */
12784     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
12785     FETCH(a0, 1)                           # a0<- aaaa (lo)
12786     FETCH(a1, 2)                           # a1<- AAAA (hi)
12787     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
12788     sll       a1,a1,16
12789     or        a1, a0, a1                   # a1<- AAAAaaaa
12790     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
12791     bnez      a0, .LOP_SPUT_VOLATILE_JUMBO_finish       #  is resolved entry null?
12792
12793     /*
12794      * Continuation if the field has not yet been resolved.
12795      *  a1:  AAAAAAAA field ref
12796      *  rBIX: dvmDex->pResFields
12797      */
12798     LOAD_rSELF_method(a2)                  #  a2 <- current method
12799 #if defined(WITH_JIT)
12800     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
12801 #endif
12802     EXPORT_PC()                            #  resolve() may throw, so export now
12803     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12804     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
12805     move      a0, v0
12806     beqz      v0, common_exceptionThrown   #  success? no, handle exception
12807 #if defined(WITH_JIT)
12808     /*
12809      * If the JIT is actively building a trace we need to make sure
12810      * that the field is fully resolved before including this instruction.
12811      */
12812     JAL(common_verifyField)
12813 #endif
12814     b        .LOP_SPUT_VOLATILE_JUMBO_finish            # resume
12815
12816
12817 /* ------------------------------ */
12818     .balign 128
12819 .L_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */
12820 /* File: mips/OP_SPUT_WIDE_VOLATILE_JUMBO.S */
12821 /* File: mips/OP_SPUT_WIDE_JUMBO.S */
12822     /*
12823      * Jumbo 64-bit SPUT handler.
12824      */
12825     /* sput-wide/jumbo vBBBB, field@AAAAAAAA */
12826     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
12827     FETCH(a1, 1)                           # a1<- aaaa (lo)
12828     FETCH(a2, 2)                           # a2<- AAAA (hi)
12829     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
12830     sll     a2,a2,16
12831     or      a1, a1, a2                    # a1<- AAAAaaaa
12832     FETCH(rOBJ, 3)                        # rOBJ<- BBBB    solved StaticField ptr
12833     EAS2(rOBJ, rFP, t0)                    #  rOBJ<- &fp[BBBB]
12834     # is resolved entry null?
12835     beqz      a2, .LOP_SPUT_WIDE_VOLATILE_JUMBO_resolve      #  yes, do resolve
12836 .LOP_SPUT_WIDE_VOLATILE_JUMBO_finish:                        #  field ptr in a2, BBBB in rOBJ
12837     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
12838     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- vBBBB/vBBBB+1
12839     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
12840     .if 1
12841     addu    a2, offStaticField_value       #  a2<- pointer to data
12842     JAL(dvmQuasiAtomicSwap64Sync)          #  stores a0/a1 into addr a2
12843     .else
12844     STORE64_off(a0, a1, a2, offStaticField_value) #  field <- vBBBB/vBBBB+1
12845     .endif
12846     GOTO_OPCODE(rBIX)                      #  jump to next instruction
12847
12848
12849 /* ------------------------------ */
12850     .balign 128
12851 .L_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */
12852 /* File: mips/OP_SPUT_OBJECT_VOLATILE_JUMBO.S */
12853 /* File: mips/OP_SPUT_OBJECT_JUMBO.S */
12854     /*
12855      * Jumbo 32-bit SPUT handler for objects
12856      */
12857     /* sput-object/jumbo vBBBB, field@AAAAAAAA */
12858     LOAD_rSELF_methodClassDex(a2)          #  a2 <- DvmDex
12859     FETCH(a0, 1)                           # a0<- aaaa (lo)
12860     FETCH(a1, 2)                           # a1<- AAAA (hi)
12861     LOAD_base_offDvmDex_pResFields(rBIX, a2) #  rBIX <- dvmDex->pResFields
12862     sll     a1,a1,16
12863     or      a1,a0,a1                       # a1<- AAAAaaaa
12864
12865     LOAD_eas2(a0, rBIX, a1)                #  a0 <- resolved StaticField ptr
12866     bnez      a0, .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish       #  is resolved entry null?
12867
12868     /* Continuation if the field has not yet been resolved.
12869      * a1:  BBBB field ref
12870      * rBIX: dvmDex->pResFields
12871      */
12872     LOAD_rSELF_method(a2)                  #  a2 <- current method
12873 #if defined(WITH_JIT)
12874     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
12875 #endif
12876     EXPORT_PC()                            #  resolve() may throw, so export now
12877     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
12878     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
12879     move      a0, v0
12880     beqz      v0, common_exceptionThrown   #  success? no, handle exception
12881 #if defined(WITH_JIT)
12882     /*
12883      * If the JIT is actively building a trace we need to make sure
12884      * that the field is fully resolved before including this instruction.
12885      */
12886     JAL(common_verifyField)
12887 #endif
12888     b         .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish           #  resume
12889
12890
12891
12892 /* ------------------------------ */
12893     .balign 128
12894 .L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */
12895 /* File: mips/OP_THROW_VERIFICATION_ERROR_JUMBO.S */
12896     /*
12897      * Handle a jumbo throw-verification-error instruction.  This throws an
12898      * exception for an error discovered during verification.  The
12899      * exception is indicated by BBBB, with some detail provided by AAAAAAAA.
12900      */
12901      /* exop BBBB, Class@AAAAAAAA */
12902     FETCH(a1, 1)                           # a1<- aaaa (lo)
12903     FETCH(a2, 2)                           # a2<- AAAA (hi)
12904     LOAD_rSELF_method(a0)                  #  a0 <- self->method
12905     sll    a2,a2,16
12906     or     a2, a1, a2                      # a2<- AAAAaaaa
12907     EXPORT_PC()                            #  export the PC
12908     FETCH(a1, 3)                           # a1<- BBBB
12909     JAL(dvmThrowVerificationError)         #  always throws
12910     b         common_exceptionThrown       #  handle exception
12911
12912
12913     .balign 128
12914     .size   dvmAsmInstructionStart, .-dvmAsmInstructionStart
12915     .global dvmAsmInstructionEnd
12916 dvmAsmInstructionEnd:
12917
12918 /*
12919  * ===========================================================================
12920  *  Sister implementations
12921  * ===========================================================================
12922  */
12923     .global dvmAsmSisterStart
12924     .type   dvmAsmSisterStart, %function
12925     .text
12926     .balign 4
12927 dvmAsmSisterStart:
12928
12929 /* continuation for OP_CHECK_CAST */
12930
12931 .LOP_CHECK_CAST_castfailure:
12932     # A cast has failed. We need to throw a ClassCastException with the
12933     # class of the object that failed to be cast.
12934     EXPORT_PC()                            #  about to throw
12935     LOAD_base_offObject_clazz(a0, rOBJ)    #  a0 <- obj->clazz
12936     move      a1,rBIX                      #  r1<- desired class
12937     JAL(dvmThrowClassCastException)
12938     b         common_exceptionThrown
12939
12940     /*
12941      * Resolution required.  This is the least-likely path.
12942      *
12943      *  a2   holds BBBB
12944      *  rOBJ holds object
12945      */
12946 .LOP_CHECK_CAST_resolve:
12947     EXPORT_PC()                            #  resolve() could throw
12948     LOAD_rSELF_method(a3)                  #  a3 <- self->method
12949     move      a1, a2                       #  a1 <- BBBB
12950     li        a2, 0                        #  a2 <- false
12951     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
12952     JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
12953     # got null?
12954     beqz      v0, common_exceptionThrown   #  yes, handle exception
12955     move      a1, v0                       #  a1 <- class resolved from BBB
12956     LOAD_base_offObject_clazz(a0, rOBJ)    #  a0 <- obj->clazz
12957     b         .LOP_CHECK_CAST_resolved         #  pick up where we left off
12958
12959 /* continuation for OP_INSTANCE_OF */
12960
12961     /*
12962      * Trivial test failed, need to perform full check.  This is common.
12963      *  a0   holds obj->clazz
12964      *  a1   holds class resolved from BBBB
12965      *  rOBJ holds A
12966      */
12967 .LOP_INSTANCE_OF_fullcheck:
12968     JAL(dvmInstanceofNonTrivial)           #  v0 <- boolean result
12969     move      a0, v0                       #  fall through to OP_INSTANCE_OF_store
12970     b         .LOP_INSTANCE_OF_store
12971
12972     /*
12973      * Resolution required.  This is the least-likely path.
12974      *
12975      *  a3   holds BBBB
12976      *  rOBJ holds A
12977      */
12978 .LOP_INSTANCE_OF_resolve:
12979     EXPORT_PC()                            #  resolve() could throw
12980     LOAD_rSELF_method(a0)                  #  a0 <- self->method
12981     move      a1, a3                       #  a1 <- BBBB
12982     li        a2, 1                        #  a2 <- true
12983     LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
12984     JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
12985     # got null?
12986     move      a1, v0                       #  a1 <- class resolved from BBB
12987     beqz      v0, common_exceptionThrown   #  yes, handle exception
12988     GET_OPB(a3)                            #  a3 <- B
12989     GET_VREG(a0, a3)                       #  a0 <- vB (object)
12990     LOAD_base_offObject_clazz(a0, a0)      #  a0 <- obj->clazz
12991     b         .LOP_INSTANCE_OF_resolved         #  pick up where we left off
12992
12993
12994 /* continuation for OP_NEW_INSTANCE */
12995
12996 .LOP_NEW_INSTANCE_continue:
12997     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
12998     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
12999     SET_VREG(v0, a3)                       #  vAA <- v0
13000     GOTO_OPCODE(t0)                        #  jump to next instruction
13001
13002 #if defined(WITH_JIT)
13003     /*
13004      * Check to see if we need to stop the trace building early.
13005      * v0: new object
13006      * a3: vAA
13007      */
13008 .LOP_NEW_INSTANCE_jitCheck:
13009     lw        a1, 0(rBIX)                  #  reload resolved class
13010     # okay?
13011     bnez      a1, .LOP_NEW_INSTANCE_continue     #  yes, finish
13012     move      rOBJ, v0                     #  preserve new object
13013     move      rBIX, a3                     #  preserve vAA
13014     move      a0, rSELF
13015     move      a1, rPC
13016     JAL(dvmJitEndTraceSelect)              #  (self, pc)
13017     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13018     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13019     SET_VREG(rOBJ, rBIX)                   #  vAA <- new object
13020     GOTO_OPCODE(t0)                        #  jump to next instruction
13021 #endif
13022
13023     /*
13024      * Class initialization required.
13025      *
13026      *  a0 holds class object
13027      */
13028 .LOP_NEW_INSTANCE_needinit:
13029     JAL(dvmInitClass)                      #  initialize class
13030     move      a0, rOBJ                     #  restore a0
13031     # check boolean result
13032     bnez      v0, .LOP_NEW_INSTANCE_initialized  #  success, continue
13033     b         common_exceptionThrown       #  failed, deal with init exception
13034
13035
13036     /*
13037      * Resolution required.  This is the least-likely path.
13038      *
13039      *  a1 holds BBBB
13040      */
13041 .LOP_NEW_INSTANCE_resolve:
13042     LOAD_rSELF_method(a3)                  #  a3 <- self->method
13043     li        a2, 0                        #  a2 <- false
13044     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
13045     JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
13046     move      a0, v0
13047     # got null?
13048     bnez      v0, .LOP_NEW_INSTANCE_resolved     #  no, continue
13049     b         common_exceptionThrown       #  yes, handle exception
13050
13051 /* continuation for OP_NEW_ARRAY */
13052
13053     /*
13054      * Resolve class.  (This is an uncommon case.)
13055      *
13056      *  a1 holds array length
13057      *  a2 holds class ref CCCC
13058      */
13059 .LOP_NEW_ARRAY_resolve:
13060     LOAD_rSELF_method(a3)                  #  a3 <- self->method
13061     move      rOBJ, a1                     #  rOBJ <- length (save)
13062     move      a1, a2                       #  a1 <- CCCC
13063     li        a2, 0                        #  a2 <- false
13064     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
13065     JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
13066     move      a1, rOBJ                     #  a1 <- length (restore)
13067     # got null?
13068     beqz      v0, common_exceptionThrown   #  yes, handle exception
13069     move      a0, v0
13070     b         .LOP_NEW_ARRAY_finish           #  continue with OP_NEW_ARRAY_finish
13071
13072
13073
13074 /* continuation for OP_FILLED_NEW_ARRAY */
13075
13076     /*
13077      * On entry:
13078      *  a0 holds array class
13079      *  rOBJ holds AA or BA
13080      */
13081 .LOP_FILLED_NEW_ARRAY_continue:
13082     LOAD_base_offClassObject_descriptor(a3, a0) #  a3 <- arrayClass->descriptor
13083     li        a2, ALLOC_DONT_TRACK         #  a2 <- alloc flags
13084     lbu       rINST, 1(a3)                 #  rINST <- descriptor[1]
13085     .if 0
13086     move      a1, rOBJ                     #  a1 <- AA (length)
13087     .else
13088     srl       a1, rOBJ, 4                  #  rOBJ <- B (length)
13089     .endif
13090     seq       t0, rINST, 'I'               #  array of ints?
13091     seq       t1, rINST, 'L'               #  array of objects?
13092     or        t0, t1
13093     seq       t1, rINST, '['               #  array of arrays?
13094     or        t0, t1
13095     move      rBIX, a1                     #  save length in rBIX
13096     beqz      t0, .LOP_FILLED_NEW_ARRAY_notimpl      #  no, not handled yet
13097     JAL(dvmAllocArrayByClass)              #  v0 <- call(arClass, length, flags)
13098     # null return?
13099     beqz      v0, common_exceptionThrown   #  alloc failed, handle exception
13100
13101     FETCH(a1, 2)                           #  a1 <- FEDC or CCCC
13102     sw        v0, offThread_retval(rSELF)  #  retval.l <- new array
13103     sw        rINST, (offThread_retval+4)(rSELF) #  retval.h <- type
13104     addu      a0, v0, offArrayObject_contents #  a0 <- newArray->contents
13105     subu      rBIX, rBIX, 1                #  length--, check for neg
13106     FETCH_ADVANCE_INST(3)                  #  advance to next instr, load rINST
13107     bltz      rBIX, 2f                     #  was zero, bail
13108
13109     # copy values from registers into the array
13110     # a0=array, a1=CCCC/FEDC, t0=length (from AA or B), rOBJ=AA/BA
13111     move      t0, rBIX
13112     .if 0
13113     EAS2(a2, rFP, a1)                      #  a2 <- &fp[CCCC]
13114 1:
13115     lw        a3, 0(a2)                    #  a3 <- *a2++
13116     addu      a2, 4
13117     subu      t0, t0, 1                    #  count--
13118     sw        a3, (a0)                     #  *contents++ = vX
13119     addu      a0, 4
13120     bgez      t0, 1b
13121
13122     # continue at 2
13123     .else
13124     slt       t1, t0, 4                    #  length was initially 5?
13125     and       a2, rOBJ, 15                 #  a2 <- A
13126     bnez      t1, 1f                       #  <= 4 args, branch
13127     GET_VREG(a3, a2)                       #  a3 <- vA
13128     subu      t0, t0, 1                    #  count--
13129     sw        a3, 16(a0)                   #  contents[4] = vA
13130 1:
13131     and       a2, a1, 15                   #  a2 <- F/E/D/C
13132     GET_VREG(a3, a2)                       #  a3 <- vF/vE/vD/vC
13133     srl       a1, a1, 4                    #  a1 <- next reg in low 4
13134     subu      t0, t0, 1                    #  count--
13135     sw        a3, 0(a0)                    #  *contents++ = vX
13136     addu      a0, a0, 4
13137     bgez      t0, 1b
13138     # continue at 2
13139     .endif
13140
13141 2:
13142     lw        a0, offThread_retval(rSELF)  #  a0 <- object
13143     lw        a1, (offThread_retval+4)(rSELF) #  a1 <- type
13144     seq       t1, a1, 'I'                  #  Is int array?
13145     bnez      t1, 3f
13146     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
13147     srl       t3, a0, GC_CARD_SHIFT
13148     addu      t2, a2, t3
13149     sb        a2, (t2)
13150 3:
13151     GET_INST_OPCODE(t0)                    #  ip <- opcode from rINST
13152     GOTO_OPCODE(t0)                        #  execute it
13153
13154
13155     /*
13156      * Throw an exception indicating that we have not implemented this
13157      * mode of filled-new-array.
13158      */
13159 .LOP_FILLED_NEW_ARRAY_notimpl:
13160     la        a0, .LstrFilledNewArrayNotImpl
13161     JAL(dvmThrowInternalError)
13162     b         common_exceptionThrown
13163
13164     /*
13165      * Ideally we'd only define this once, but depending on layout we can
13166      * exceed the range of the load above.
13167      */
13168
13169 /* continuation for OP_FILLED_NEW_ARRAY_RANGE */
13170
13171     /*
13172      * On entry:
13173      *  a0 holds array class
13174      *  rOBJ holds AA or BA
13175      */
13176 .LOP_FILLED_NEW_ARRAY_RANGE_continue:
13177     LOAD_base_offClassObject_descriptor(a3, a0) #  a3 <- arrayClass->descriptor
13178     li        a2, ALLOC_DONT_TRACK         #  a2 <- alloc flags
13179     lbu       rINST, 1(a3)                 #  rINST <- descriptor[1]
13180     .if 1
13181     move      a1, rOBJ                     #  a1 <- AA (length)
13182     .else
13183     srl       a1, rOBJ, 4                  #  rOBJ <- B (length)
13184     .endif
13185     seq       t0, rINST, 'I'               #  array of ints?
13186     seq       t1, rINST, 'L'               #  array of objects?
13187     or        t0, t1
13188     seq       t1, rINST, '['               #  array of arrays?
13189     or        t0, t1
13190     move      rBIX, a1                     #  save length in rBIX
13191     beqz      t0, .LOP_FILLED_NEW_ARRAY_RANGE_notimpl      #  no, not handled yet
13192     JAL(dvmAllocArrayByClass)              #  v0 <- call(arClass, length, flags)
13193     # null return?
13194     beqz      v0, common_exceptionThrown   #  alloc failed, handle exception
13195
13196     FETCH(a1, 2)                           #  a1 <- FEDC or CCCC
13197     sw        v0, offThread_retval(rSELF)  #  retval.l <- new array
13198     sw        rINST, (offThread_retval+4)(rSELF) #  retval.h <- type
13199     addu      a0, v0, offArrayObject_contents #  a0 <- newArray->contents
13200     subu      rBIX, rBIX, 1                #  length--, check for neg
13201     FETCH_ADVANCE_INST(3)                  #  advance to next instr, load rINST
13202     bltz      rBIX, 2f                     #  was zero, bail
13203
13204     # copy values from registers into the array
13205     # a0=array, a1=CCCC/FEDC, t0=length (from AA or B), rOBJ=AA/BA
13206     move      t0, rBIX
13207     .if 1
13208     EAS2(a2, rFP, a1)                      #  a2 <- &fp[CCCC]
13209 1:
13210     lw        a3, 0(a2)                    #  a3 <- *a2++
13211     addu      a2, 4
13212     subu      t0, t0, 1                    #  count--
13213     sw        a3, (a0)                     #  *contents++ = vX
13214     addu      a0, 4
13215     bgez      t0, 1b
13216
13217     # continue at 2
13218     .else
13219     slt       t1, t0, 4                    #  length was initially 5?
13220     and       a2, rOBJ, 15                 #  a2 <- A
13221     bnez      t1, 1f                       #  <= 4 args, branch
13222     GET_VREG(a3, a2)                       #  a3 <- vA
13223     subu      t0, t0, 1                    #  count--
13224     sw        a3, 16(a0)                   #  contents[4] = vA
13225 1:
13226     and       a2, a1, 15                   #  a2 <- F/E/D/C
13227     GET_VREG(a3, a2)                       #  a3 <- vF/vE/vD/vC
13228     srl       a1, a1, 4                    #  a1 <- next reg in low 4
13229     subu      t0, t0, 1                    #  count--
13230     sw        a3, 0(a0)                    #  *contents++ = vX
13231     addu      a0, a0, 4
13232     bgez      t0, 1b
13233     # continue at 2
13234     .endif
13235
13236 2:
13237     lw        a0, offThread_retval(rSELF)  #  a0 <- object
13238     lw        a1, (offThread_retval+4)(rSELF) #  a1 <- type
13239     seq       t1, a1, 'I'                  #  Is int array?
13240     bnez      t1, 3f
13241     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
13242     srl       t3, a0, GC_CARD_SHIFT
13243     addu      t2, a2, t3
13244     sb        a2, (t2)
13245 3:
13246     GET_INST_OPCODE(t0)                    #  ip <- opcode from rINST
13247     GOTO_OPCODE(t0)                        #  execute it
13248
13249
13250     /*
13251      * Throw an exception indicating that we have not implemented this
13252      * mode of filled-new-array.
13253      */
13254 .LOP_FILLED_NEW_ARRAY_RANGE_notimpl:
13255     la        a0, .LstrFilledNewArrayNotImpl
13256     JAL(dvmThrowInternalError)
13257     b         common_exceptionThrown
13258
13259     /*
13260      * Ideally we'd only define this once, but depending on layout we can
13261      * exceed the range of the load above.
13262      */
13263
13264 /* continuation for OP_CMPL_FLOAT */
13265
13266 OP_CMPL_FLOAT_nan:
13267     li rTEMP, -1
13268     b         OP_CMPL_FLOAT_finish
13269
13270 #ifdef SOFT_FLOAT
13271 OP_CMPL_FLOAT_continue:
13272     JAL(__gtsf2)                           #  v0 <- (vBB > vCC)
13273     li        rTEMP, 1                     #  rTEMP = 1 if v0 != 0
13274     bgtz      v0, OP_CMPL_FLOAT_finish
13275     b         OP_CMPL_FLOAT_nan
13276 #endif
13277
13278 OP_CMPL_FLOAT_finish:
13279     GET_OPA(t0)
13280     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13281     SET_VREG(rTEMP, t0)                    #  vAA <- rTEMP
13282     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13283     GOTO_OPCODE(t0)
13284
13285 /* continuation for OP_CMPG_FLOAT */
13286
13287 OP_CMPG_FLOAT_nan:
13288     li rTEMP, 1
13289     b         OP_CMPG_FLOAT_finish
13290
13291 #ifdef SOFT_FLOAT
13292 OP_CMPG_FLOAT_continue:
13293     JAL(__gtsf2)                           #  v0 <- (vBB > vCC)
13294     li        rTEMP, 1                     #  rTEMP = 1 if v0 != 0
13295     bgtz      v0, OP_CMPG_FLOAT_finish
13296     b         OP_CMPG_FLOAT_nan
13297 #endif
13298
13299 OP_CMPG_FLOAT_finish:
13300     GET_OPA(t0)
13301     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13302     SET_VREG(rTEMP, t0)                    #  vAA <- rTEMP
13303     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13304     GOTO_OPCODE(t0)
13305
13306 /* continuation for OP_CMPL_DOUBLE */
13307
13308 OP_CMPL_DOUBLE_nan:
13309     li rTEMP, -1
13310     b         OP_CMPL_DOUBLE_finish
13311
13312 #ifdef SOFT_FLOAT
13313 OP_CMPL_DOUBLE_continue:
13314     LOAD64(rARG2, rARG3, rBIX)             #  a2/a3 <- vCC/vCC+1
13315     JAL(__gtdf2)                           #  fallthru
13316     li        rTEMP, 1                     #  rTEMP = 1 if v0 != 0
13317     blez      v0, OP_CMPL_DOUBLE_nan            #  fall thru for finish
13318 #endif
13319
13320 OP_CMPL_DOUBLE_finish:
13321     GET_OPA(rOBJ)
13322     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13323     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13324     SET_VREG_GOTO(rTEMP, rOBJ, t0)         #  vAA <- rTEMP
13325
13326 /* continuation for OP_CMPG_DOUBLE */
13327
13328 OP_CMPG_DOUBLE_nan:
13329     li rTEMP, 1
13330     b         OP_CMPG_DOUBLE_finish
13331
13332 #ifdef SOFT_FLOAT
13333 OP_CMPG_DOUBLE_continue:
13334     LOAD64(rARG2, rARG3, rBIX)             #  a2/a3 <- vCC/vCC+1
13335     JAL(__gtdf2)                           #  fallthru
13336     li        rTEMP, 1                     #  rTEMP = 1 if v0 != 0
13337     blez      v0, OP_CMPG_DOUBLE_nan            #  fall thru for finish
13338 #endif
13339
13340 OP_CMPG_DOUBLE_finish:
13341     GET_OPA(rOBJ)
13342     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13343     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13344     SET_VREG_GOTO(rTEMP, rOBJ, t0)         #  vAA <- rTEMP
13345
13346 /* continuation for OP_APUT_OBJECT */
13347 .LOP_APUT_OBJECT_checks:
13348     LOAD_base_offObject_clazz(a0, rBIX)    #  a0 <- obj->clazz
13349     LOAD_base_offObject_clazz(a1, rINST)   #  a1 <- arrayObj->clazz
13350     JAL(dvmCanPutArrayElement)             #  test object type vs. array type
13351     beqz      v0, .LOP_APUT_OBJECT_throw        #  okay ?
13352     lw        a2, offThread_cardTable(rSELF)
13353     srl       t1, rINST, GC_CARD_SHIFT
13354     addu      t2, a2, t1
13355     sb        a2, (t2)
13356     b         .LOP_APUT_OBJECT_finish           #  yes, skip type checks
13357 .LOP_APUT_OBJECT_throw:
13358     LOAD_base_offObject_clazz(a0, rBIX)    #  a0 <- obj->clazz
13359     LOAD_base_offObject_clazz(a1, rINST)   #  a1 <- arrayObj->clazz
13360     EXPORT_PC()
13361     JAL(dvmThrowArrayStoreExceptionIncompatibleElement)
13362     b         common_exceptionThrown
13363
13364 /* continuation for OP_IGET */
13365
13366     /*
13367      * Currently:
13368      *  v0 holds resolved field
13369      *  rOBJ holds object (caller saved)
13370      */
13371 .LOP_IGET_finish:
13372     #BAL(common_squeak0)
13373     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13374     # check object for null
13375     beqz      rOBJ, common_errNullObject   #  object was null
13376     addu      a3, a3, rOBJ                 #  form address
13377     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
13378          # noop                               #  acquiring load
13379     GET_OPA4(a2)                           #  a2 <- A+
13380     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13381     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13382     SET_VREG(a0, a2)                       #  fp[A] <- a0
13383     GOTO_OPCODE(t0)                        #  jump to next instruction
13384
13385
13386 /* continuation for OP_IGET_WIDE */
13387
13388     /*
13389      * Currently:
13390      *  a0   holds resolved field
13391      *  rOBJ holds object
13392      */
13393 .LOP_IGET_WIDE_finish:
13394     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13395     beqz      rOBJ, common_errNullObject   #  object was null
13396     GET_OPA4(a2)                           #  a2 <- A+
13397     addu      rOBJ, rOBJ, a3               #  form address
13398     .if 0
13399     vLOAD64(a0, a1, rOBJ)                  #  a0/a1 <- obj.field (64-bit align ok)
13400     .else
13401     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- obj.field (64-bit align ok)
13402     .endif
13403     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13404     EAS2(a3, rFP, a2)                      #  a3 <- &fp[A]
13405     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13406     STORE64(a0, a1, a3)                    #  fp[A] <- a0/a1
13407     GOTO_OPCODE(t0)                        #  jump to next instruction
13408
13409
13410 /* continuation for OP_IGET_OBJECT */
13411
13412     /*
13413      * Currently:
13414      *  v0 holds resolved field
13415      *  rOBJ holds object (caller saved)
13416      */
13417 .LOP_IGET_OBJECT_finish:
13418     #BAL(common_squeak0)
13419     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13420     # check object for null
13421     beqz      rOBJ, common_errNullObject   #  object was null
13422     addu      a3, a3, rOBJ                 #  form address
13423     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
13424          # noop                               #  acquiring load
13425     GET_OPA4(a2)                           #  a2 <- A+
13426     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13427     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13428     SET_VREG(a0, a2)                       #  fp[A] <- a0
13429     GOTO_OPCODE(t0)                        #  jump to next instruction
13430
13431
13432 /* continuation for OP_IGET_BOOLEAN */
13433
13434     /*
13435      * Currently:
13436      *  v0 holds resolved field
13437      *  rOBJ holds object (caller saved)
13438      */
13439 .LOP_IGET_BOOLEAN_finish:
13440     #BAL(common_squeak0)
13441     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13442     # check object for null
13443     beqz      rOBJ, common_errNullObject   #  object was null
13444     addu      a3, a3, rOBJ                 #  form address
13445     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
13446          # noop                               #  acquiring load
13447     GET_OPA4(a2)                           #  a2 <- A+
13448     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13449     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13450     SET_VREG(a0, a2)                       #  fp[A] <- a0
13451     GOTO_OPCODE(t0)                        #  jump to next instruction
13452
13453
13454 /* continuation for OP_IGET_BYTE */
13455
13456     /*
13457      * Currently:
13458      *  v0 holds resolved field
13459      *  rOBJ holds object (caller saved)
13460      */
13461 .LOP_IGET_BYTE_finish:
13462     #BAL(common_squeak0)
13463     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13464     # check object for null
13465     beqz      rOBJ, common_errNullObject   #  object was null
13466     addu      a3, a3, rOBJ                 #  form address
13467     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
13468          # noop                               #  acquiring load
13469     GET_OPA4(a2)                           #  a2 <- A+
13470     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13471     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13472     SET_VREG(a0, a2)                       #  fp[A] <- a0
13473     GOTO_OPCODE(t0)                        #  jump to next instruction
13474
13475
13476 /* continuation for OP_IGET_CHAR */
13477
13478     /*
13479      * Currently:
13480      *  v0 holds resolved field
13481      *  rOBJ holds object (caller saved)
13482      */
13483 .LOP_IGET_CHAR_finish:
13484     #BAL(common_squeak0)
13485     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13486     # check object for null
13487     beqz      rOBJ, common_errNullObject   #  object was null
13488     addu      a3, a3, rOBJ                 #  form address
13489     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
13490          # noop                               #  acquiring load
13491     GET_OPA4(a2)                           #  a2 <- A+
13492     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13493     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13494     SET_VREG(a0, a2)                       #  fp[A] <- a0
13495     GOTO_OPCODE(t0)                        #  jump to next instruction
13496
13497
13498 /* continuation for OP_IGET_SHORT */
13499
13500     /*
13501      * Currently:
13502      *  v0 holds resolved field
13503      *  rOBJ holds object (caller saved)
13504      */
13505 .LOP_IGET_SHORT_finish:
13506     #BAL(common_squeak0)
13507     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13508     # check object for null
13509     beqz      rOBJ, common_errNullObject   #  object was null
13510     addu      a3, a3, rOBJ                 #  form address
13511     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
13512          # noop                               #  acquiring load
13513     GET_OPA4(a2)                           #  a2 <- A+
13514     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13515     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13516     SET_VREG(a0, a2)                       #  fp[A] <- a0
13517     GOTO_OPCODE(t0)                        #  jump to next instruction
13518
13519
13520 /* continuation for OP_IPUT */
13521
13522     /*
13523      * Currently:
13524      *  a0 holds resolved field
13525      *  rOBJ holds object
13526      */
13527 .LOP_IPUT_finish:
13528     #BAL(common_squeak0)
13529     GET_OPA4(a1)                           #  a1 <- A+
13530     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13531     GET_VREG(a0, a1)                       #  a0 <- fp[A]
13532     # check object for null
13533     beqz      rOBJ, common_errNullObject   #  object was null
13534     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13535     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13536     addu      rOBJ, rOBJ, a3               #  form address
13537         #  noop                            #  releasing store
13538     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
13539         #  noop
13540     GOTO_OPCODE(t0)                        #  jump to next instruction
13541
13542
13543 /* continuation for OP_IPUT_WIDE */
13544
13545     /*
13546      * Currently:
13547      *  a0   holds resolved field
13548      *  rOBJ holds object
13549      */
13550 .LOP_IPUT_WIDE_finish:
13551     GET_OPA4(a2)                           #  a2 <- A+
13552     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13553     EAS2(a2, rFP, a2)                      #  a2 <- &fp[A]
13554     # check object for null
13555     beqz      rOBJ, common_errNullObject   #  object was null
13556     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13557     LOAD64(a0, a1, a2)                     #  a0/a1 <- fp[A]
13558     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
13559     addu      a2, rOBJ, a3                 #  form address
13560     .if 0
13561     JAL(dvmQuasiAtomicSwap64Sync)          # stores r0/r1 into addr r2
13562 #    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
13563     .else
13564     STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
13565     .endif
13566     GOTO_OPCODE(rBIX)                      #  jump to next instruction
13567
13568
13569 /* continuation for OP_IPUT_OBJECT */
13570
13571     /*
13572      * Currently:
13573      *  a0 holds resolved field
13574      *  rOBJ holds object
13575      */
13576 .LOP_IPUT_OBJECT_finish:
13577     #BAL(common_squeak0)
13578     GET_OPA4(a1)                           #  a1 <- A+
13579     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13580     GET_VREG(a0, a1)                       #  a0 <- fp[A]
13581     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
13582     # check object for null
13583     beqz      rOBJ, common_errNullObject   #  object was null
13584     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13585     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13586     addu      t2, rOBJ, a3                 #  form address
13587         #  noop                            #  releasing store
13588     sw a0, (t2)                        #  obj.field (32 bits) <- a0
13589         #  noop
13590     beqz      a0, 1f                       #  stored a null reference?
13591     srl       t1, rOBJ, GC_CARD_SHIFT
13592     addu      t2, a2, t1
13593     sb        a2, (t2)                     #  mark card if not
13594 1:
13595     GOTO_OPCODE(t0)                        #  jump to next instruction
13596
13597
13598 /* continuation for OP_IPUT_BOOLEAN */
13599
13600     /*
13601      * Currently:
13602      *  a0 holds resolved field
13603      *  rOBJ holds object
13604      */
13605 .LOP_IPUT_BOOLEAN_finish:
13606     #BAL(common_squeak0)
13607     GET_OPA4(a1)                           #  a1 <- A+
13608     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13609     GET_VREG(a0, a1)                       #  a0 <- fp[A]
13610     # check object for null
13611     beqz      rOBJ, common_errNullObject   #  object was null
13612     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13613     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13614     addu      rOBJ, rOBJ, a3               #  form address
13615         #  noop                            #  releasing store
13616     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
13617         #  noop
13618     GOTO_OPCODE(t0)                        #  jump to next instruction
13619
13620
13621 /* continuation for OP_IPUT_BYTE */
13622
13623     /*
13624      * Currently:
13625      *  a0 holds resolved field
13626      *  rOBJ holds object
13627      */
13628 .LOP_IPUT_BYTE_finish:
13629     #BAL(common_squeak0)
13630     GET_OPA4(a1)                           #  a1 <- A+
13631     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13632     GET_VREG(a0, a1)                       #  a0 <- fp[A]
13633     # check object for null
13634     beqz      rOBJ, common_errNullObject   #  object was null
13635     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13636     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13637     addu      rOBJ, rOBJ, a3               #  form address
13638         #  noop                            #  releasing store
13639     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
13640         #  noop
13641     GOTO_OPCODE(t0)                        #  jump to next instruction
13642
13643
13644 /* continuation for OP_IPUT_CHAR */
13645
13646     /*
13647      * Currently:
13648      *  a0 holds resolved field
13649      *  rOBJ holds object
13650      */
13651 .LOP_IPUT_CHAR_finish:
13652     #BAL(common_squeak0)
13653     GET_OPA4(a1)                           #  a1 <- A+
13654     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13655     GET_VREG(a0, a1)                       #  a0 <- fp[A]
13656     # check object for null
13657     beqz      rOBJ, common_errNullObject   #  object was null
13658     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13659     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13660     addu      rOBJ, rOBJ, a3               #  form address
13661         #  noop                            #  releasing store
13662     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
13663         #  noop
13664     GOTO_OPCODE(t0)                        #  jump to next instruction
13665
13666
13667 /* continuation for OP_IPUT_SHORT */
13668
13669     /*
13670      * Currently:
13671      *  a0 holds resolved field
13672      *  rOBJ holds object
13673      */
13674 .LOP_IPUT_SHORT_finish:
13675     #BAL(common_squeak0)
13676     GET_OPA4(a1)                           #  a1 <- A+
13677     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
13678     GET_VREG(a0, a1)                       #  a0 <- fp[A]
13679     # check object for null
13680     beqz      rOBJ, common_errNullObject   #  object was null
13681     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13682     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13683     addu      rOBJ, rOBJ, a3               #  form address
13684         #  noop                            #  releasing store
13685     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
13686         #  noop
13687     GOTO_OPCODE(t0)                        #  jump to next instruction
13688
13689
13690 /* continuation for OP_SGET */
13691
13692 .LOP_SGET_finish:
13693     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
13694                       #  no-op                                #  acquiring load
13695     GET_OPA(a2)                            #  a2 <- AA
13696     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13697     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13698     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
13699
13700 /* continuation for OP_SGET_WIDE */
13701
13702 .LOP_SGET_WIDE_finish:
13703     GET_OPA(a1)                            #  a1 <- AA
13704     .if 0
13705     vLOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
13706     .else
13707     LOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
13708     .endif
13709     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13710     EAS2(a1, rFP, a1)                      #  a1 <- &fp[AA]
13711     STORE64(a2, a3, a1)                    #  vAA/vAA+1 <- a2/a3
13712     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13713     GOTO_OPCODE(t0)                        #  jump to next instruction
13714
13715
13716
13717 /* continuation for OP_SGET_OBJECT */
13718
13719 .LOP_SGET_OBJECT_finish:
13720     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
13721                       #  no-op                                #  acquiring load
13722     GET_OPA(a2)                            #  a2 <- AA
13723     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13724     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13725     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
13726
13727 /* continuation for OP_SGET_BOOLEAN */
13728
13729 .LOP_SGET_BOOLEAN_finish:
13730     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
13731                       #  no-op                                #  acquiring load
13732     GET_OPA(a2)                            #  a2 <- AA
13733     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13734     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13735     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
13736
13737 /* continuation for OP_SGET_BYTE */
13738
13739 .LOP_SGET_BYTE_finish:
13740     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
13741                       #  no-op                                #  acquiring load
13742     GET_OPA(a2)                            #  a2 <- AA
13743     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13744     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13745     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
13746
13747 /* continuation for OP_SGET_CHAR */
13748
13749 .LOP_SGET_CHAR_finish:
13750     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
13751                       #  no-op                                #  acquiring load
13752     GET_OPA(a2)                            #  a2 <- AA
13753     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13754     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13755     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
13756
13757 /* continuation for OP_SGET_SHORT */
13758
13759 .LOP_SGET_SHORT_finish:
13760     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
13761                       #  no-op                                #  acquiring load
13762     GET_OPA(a2)                            #  a2 <- AA
13763     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13764     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13765     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
13766
13767 /* continuation for OP_SPUT */
13768
13769 .LOP_SPUT_finish:
13770     # field ptr in a0
13771     GET_OPA(a2)                            #  a2 <- AA
13772     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13773     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
13774     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13775     #  no-op                            #  releasing store
13776     sw        a1, offStaticField_value(a0) #  field <- vAA
13777     #  no-op
13778     GOTO_OPCODE(t0)                        #  jump to next instruction
13779
13780 /* continuation for OP_SPUT_WIDE */
13781
13782     /*
13783      * Continuation if the field has not yet been resolved.
13784      *  a1:  BBBB field ref
13785      *  rOBJ:  &fp[AA]
13786      *  rBIX: dvmDex->pResFields
13787      *
13788      * Returns StaticField pointer in a2.
13789      */
13790 .LOP_SPUT_WIDE_resolve:
13791     LOAD_rSELF_method(a2)                  #  a2 <- current method
13792 #if defined(WITH_JIT)
13793     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
13794 #endif
13795     EXPORT_PC()                            #  resolve() could throw, so export now
13796     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
13797     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
13798     # success ?
13799     move      a0, v0
13800     beqz      v0, common_exceptionThrown   #  no, handle exception
13801 #if defined(WITH_JIT)
13802     /*
13803      * If the JIT is actively building a trace we need to make sure
13804      * that the field is fully resolved before including this instruction.
13805      */
13806     JAL(common_verifyField)
13807 #endif
13808     move      a2, v0
13809     b         .LOP_SPUT_WIDE_finish           # resume
13810
13811 /* continuation for OP_SPUT_OBJECT */
13812 .LOP_SPUT_OBJECT_finish:                        #  field ptr in a0
13813     GET_OPA(a2)                            #  a2 <- AA
13814     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13815     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
13816     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
13817     lw        t1, offField_clazz(a0)       #  t1 <- field->clazz
13818     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13819     #  no-op                            #  releasing store
13820     sw        a1, offStaticField_value(a0) #  field <- vAA
13821     #  no-op
13822     beqz      a1, 1f
13823     srl       t2, t1, GC_CARD_SHIFT
13824     addu      t3, a2, t2
13825     sb        a2, (t3)
13826 1:
13827     GOTO_OPCODE(t0)                        #  jump to next instruction
13828
13829 /* continuation for OP_SPUT_BOOLEAN */
13830
13831 .LOP_SPUT_BOOLEAN_finish:
13832     # field ptr in a0
13833     GET_OPA(a2)                            #  a2 <- AA
13834     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13835     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
13836     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13837     #  no-op                            #  releasing store
13838     sw        a1, offStaticField_value(a0) #  field <- vAA
13839     #  no-op
13840     GOTO_OPCODE(t0)                        #  jump to next instruction
13841
13842 /* continuation for OP_SPUT_BYTE */
13843
13844 .LOP_SPUT_BYTE_finish:
13845     # field ptr in a0
13846     GET_OPA(a2)                            #  a2 <- AA
13847     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13848     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
13849     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13850     #  no-op                            #  releasing store
13851     sw        a1, offStaticField_value(a0) #  field <- vAA
13852     #  no-op
13853     GOTO_OPCODE(t0)                        #  jump to next instruction
13854
13855 /* continuation for OP_SPUT_CHAR */
13856
13857 .LOP_SPUT_CHAR_finish:
13858     # field ptr in a0
13859     GET_OPA(a2)                            #  a2 <- AA
13860     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13861     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
13862     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13863     #  no-op                            #  releasing store
13864     sw        a1, offStaticField_value(a0) #  field <- vAA
13865     #  no-op
13866     GOTO_OPCODE(t0)                        #  jump to next instruction
13867
13868 /* continuation for OP_SPUT_SHORT */
13869
13870 .LOP_SPUT_SHORT_finish:
13871     # field ptr in a0
13872     GET_OPA(a2)                            #  a2 <- AA
13873     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
13874     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
13875     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
13876     #  no-op                            #  releasing store
13877     sw        a1, offStaticField_value(a0) #  field <- vAA
13878     #  no-op
13879     GOTO_OPCODE(t0)                        #  jump to next instruction
13880
13881 /* continuation for OP_INVOKE_VIRTUAL */
13882
13883     /*
13884      * At this point:
13885      *  a0 = resolved base method
13886      *  rBIX= C or CCCC (index of first arg, which is the "this" ptr)
13887      */
13888 .LOP_INVOKE_VIRTUAL_continue:
13889     GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
13890     LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
13891     # is "this" null?
13892     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
13893     LOAD_base_offObject_clazz(a3, rOBJ)    #  a3 <- thisPtr->clazz
13894     LOAD_base_offClassObject_vtable(a3, a3) #  a3 <- thisPtr->clazz->vtable
13895     LOAD_eas2(a0, a3, a2)                  #  a0 <- vtable[methodIndex]
13896     b         common_invokeMethodNoRange #  (a0=method, rOBJ="this")
13897
13898
13899 /* continuation for OP_INVOKE_SUPER */
13900
13901     /*
13902      * At this point:
13903      *  a0 = resolved base method
13904      *  rBIX = method->clazz
13905      */
13906 .LOP_INVOKE_SUPER_continue:
13907     LOAD_base_offClassObject_super(a1, rBIX) #  a1 <- method->clazz->super
13908     LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
13909     LOAD_base_offClassObject_vtableCount(a3, a1) #  a3 <- super->vtableCount
13910     EXPORT_PC()                            #  must export for invoke
13911     # compare (methodIndex, vtableCount)
13912     bgeu      a2, a3, .LOP_INVOKE_SUPER_nsm      #  method not present in superclass
13913     LOAD_base_offClassObject_vtable(a1, a1) #  a1 <- ...clazz->super->vtable
13914     LOAD_eas2(a0, a1, a2)                  #  a0 <- vtable[methodIndex]
13915     b         common_invokeMethodNoRange #  continue on
13916
13917     /*
13918      * Throw a NoSuchMethodError with the method name as the message.
13919      *  a0 = resolved base method
13920      */
13921 .LOP_INVOKE_SUPER_nsm:
13922     LOAD_base_offMethod_name(a1, a0)       #  a1 <- method name
13923     b         common_errNoSuchMethod
13924
13925
13926 /* continuation for OP_INVOKE_STATIC */
13927
13928 .LOP_INVOKE_STATIC_resolve:
13929     LOAD_rSELF_method(a3)                  #  a3 <- self->method
13930     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
13931     li        a2, METHOD_STATIC            #  resolver method type
13932     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
13933     move      a0, v0
13934 #if defined(WITH_JIT)
13935     /*
13936      * Check to see if we're actively building a trace.  If so,
13937      * we need to keep this instruction out of it.
13938      * rBIX: &resolved_methodToCall
13939      */
13940     lhu       a2, offThread_subMode(rSELF)
13941     beqz      v0, common_exceptionThrown   #  null, handle exception
13942     and       a2, kSubModeJitTraceBuild    #  trace under construction?
13943     beqz      a2, common_invokeMethodNoRange #  no, (a0=method, rOBJ="this")
13944     lw        a1, 0(rBIX)                  #  reload resolved method
13945     # finished resloving?
13946     bnez      a1, common_invokeMethodNoRange #  yes, (a0=method, rOBJ="this")
13947     move      rBIX, a0                     #  preserve method
13948     move      a0, rSELF
13949     move      a1, rPC
13950     JAL(dvmJitEndTraceSelect)              #  (self, pc)
13951     move      a0, rBIX
13952     b         common_invokeMethodNoRange #  whew, finally!
13953 #else
13954     # got null?
13955     bnez      v0, common_invokeMethodNoRange #  (a0=method, rOBJ="this")
13956     b         common_exceptionThrown       #  yes, handle exception
13957 #endif
13958
13959 /* continuation for OP_INVOKE_VIRTUAL_RANGE */
13960
13961     /*
13962      * At this point:
13963      *  a0 = resolved base method
13964      *  rBIX= C or CCCC (index of first arg, which is the "this" ptr)
13965      */
13966 .LOP_INVOKE_VIRTUAL_RANGE_continue:
13967     GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
13968     LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
13969     # is "this" null?
13970     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
13971     LOAD_base_offObject_clazz(a3, rOBJ)    #  a3 <- thisPtr->clazz
13972     LOAD_base_offClassObject_vtable(a3, a3) #  a3 <- thisPtr->clazz->vtable
13973     LOAD_eas2(a0, a3, a2)                  #  a0 <- vtable[methodIndex]
13974     b         common_invokeMethodRange #  (a0=method, rOBJ="this")
13975
13976
13977 /* continuation for OP_INVOKE_SUPER_RANGE */
13978
13979     /*
13980      * At this point:
13981      *  a0 = resolved base method
13982      *  rBIX = method->clazz
13983      */
13984 .LOP_INVOKE_SUPER_RANGE_continue:
13985     LOAD_base_offClassObject_super(a1, rBIX) #  a1 <- method->clazz->super
13986     LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
13987     LOAD_base_offClassObject_vtableCount(a3, a1) #  a3 <- super->vtableCount
13988     EXPORT_PC()                            #  must export for invoke
13989     # compare (methodIndex, vtableCount)
13990     bgeu      a2, a3, .LOP_INVOKE_SUPER_RANGE_nsm      #  method not present in superclass
13991     LOAD_base_offClassObject_vtable(a1, a1) #  a1 <- ...clazz->super->vtable
13992     LOAD_eas2(a0, a1, a2)                  #  a0 <- vtable[methodIndex]
13993     b         common_invokeMethodRange #  continue on
13994
13995     /*
13996      * Throw a NoSuchMethodError with the method name as the message.
13997      *  a0 = resolved base method
13998      */
13999 .LOP_INVOKE_SUPER_RANGE_nsm:
14000     LOAD_base_offMethod_name(a1, a0)       #  a1 <- method name
14001     b         common_errNoSuchMethod
14002
14003
14004 /* continuation for OP_INVOKE_STATIC_RANGE */
14005
14006 .LOP_INVOKE_STATIC_RANGE_resolve:
14007     LOAD_rSELF_method(a3)                  #  a3 <- self->method
14008     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
14009     li        a2, METHOD_STATIC            #  resolver method type
14010     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
14011     move      a0, v0
14012 #if defined(WITH_JIT)
14013     /*
14014      * Check to see if we're actively building a trace.  If so,
14015      * we need to keep this instruction out of it.
14016      * rBIX: &resolved_methodToCall
14017      */
14018     lhu       a2, offThread_subMode(rSELF)
14019     beqz      v0, common_exceptionThrown   #  null, handle exception
14020     and       a2, kSubModeJitTraceBuild    #  trace under construction?
14021     beqz      a2, common_invokeMethodRange #  no, (a0=method, rOBJ="this")
14022     lw        a1, 0(rBIX)                  #  reload resolved method
14023     # finished resloving?
14024     bnez      a1, common_invokeMethodRange #  yes, (a0=method, rOBJ="this")
14025     move      rBIX, a0                     #  preserve method
14026     move      a0, rSELF
14027     move      a1, rPC
14028     JAL(dvmJitEndTraceSelect)              #  (self, pc)
14029     move      a0, rBIX
14030     b         common_invokeMethodRange #  whew, finally!
14031 #else
14032     # got null?
14033     bnez      v0, common_invokeMethodRange #  (a0=method, rOBJ="this")
14034     b         common_exceptionThrown       #  yes, handle exception
14035 #endif
14036
14037 /* continuation for OP_FLOAT_TO_INT */
14038
14039 /*
14040  * Not an entry point as it is used only once !!
14041  */
14042 f2i_doconv:
14043 #ifdef SOFT_FLOAT
14044     li        a1, 0x4f000000               #  (float)maxint
14045     move      rBIX, a0
14046     JAL(__gesf2)                           #  is arg >= maxint?
14047     move      t0, v0
14048     li        v0, ~0x80000000              #  return maxint (7fffffff)
14049     bgez      t0, .LOP_FLOAT_TO_INT_set_vreg
14050
14051     move      a0, rBIX                     #  recover arg
14052     li        a1, 0xcf000000               #  (float)minint
14053     JAL(__lesf2)
14054
14055     move      t0, v0
14056     li        v0, 0x80000000               #  return minint (80000000)
14057     blez      t0, .LOP_FLOAT_TO_INT_set_vreg
14058     move      a0, rBIX
14059     move      a1, rBIX
14060     JAL(__nesf2)
14061
14062     move      t0, v0
14063     li        v0, 0                        #  return zero for NaN
14064     bnez      t0, .LOP_FLOAT_TO_INT_set_vreg
14065
14066     move      a0, rBIX
14067     JAL(__fixsfsi)
14068     b         .LOP_FLOAT_TO_INT_set_vreg
14069 #else
14070     l.s       fa1, .LFLOAT_TO_INT_max
14071     c.ole.s   fcc0, fa1, fa0
14072     l.s       fv0, .LFLOAT_TO_INT_ret_max
14073     bc1t      .LOP_FLOAT_TO_INT_set_vreg_f
14074
14075     l.s       fa1, .LFLOAT_TO_INT_min
14076     c.ole.s   fcc0, fa0, fa1
14077     l.s       fv0, .LFLOAT_TO_INT_ret_min
14078     bc1t      .LOP_FLOAT_TO_INT_set_vreg_f
14079
14080     mov.s     fa1, fa0
14081     c.un.s    fcc0, fa0, fa1
14082     li.s      fv0, 0
14083     bc1t      .LOP_FLOAT_TO_INT_set_vreg_f
14084
14085     trunc.w.s  fv0, fa0
14086     b         .LOP_FLOAT_TO_INT_set_vreg_f
14087 #endif
14088
14089 .LFLOAT_TO_INT_max:
14090     .word 0x4f000000
14091 .LFLOAT_TO_INT_min:
14092     .word 0xcf000000
14093 .LFLOAT_TO_INT_ret_max:
14094     .word 0x7fffffff
14095 .LFLOAT_TO_INT_ret_min:
14096     .word 0x80000000
14097
14098
14099 /* continuation for OP_FLOAT_TO_LONG */
14100
14101 f2l_doconv:
14102 #ifdef SOFT_FLOAT
14103     li        a1, 0x5f000000
14104     move      rBIX, a0
14105     JAL(__gesf2)
14106
14107     move      t0, v0
14108     li        rRESULT0, ~0
14109     li        rRESULT1, ~0x80000000
14110     bgez      t0, .LOP_FLOAT_TO_LONG_set_vreg
14111
14112     move      a0, rBIX
14113     li        a1, 0xdf000000
14114     JAL(__lesf2)
14115
14116     move      t0, v0
14117     li        rRESULT0, 0
14118     li        rRESULT1, 0x80000000
14119     blez      t0, .LOP_FLOAT_TO_LONG_set_vreg
14120
14121     move      a0, rBIX
14122     move      a1, rBIX
14123     JAL(__nesf2)
14124
14125     move      t0, v0
14126     li        rRESULT0, 0
14127     li        rRESULT1, 0
14128     bnez      t0, .LOP_FLOAT_TO_LONG_set_vreg
14129
14130     move      a0, rBIX
14131     JAL(__fixsfdi)
14132
14133 #else
14134     l.s       fa1, .LLONG_TO_max
14135     c.ole.s   fcc0, fa1, fa0
14136     li        rRESULT0, ~0
14137     li        rRESULT1, ~0x80000000
14138     bc1t      .LOP_FLOAT_TO_LONG_set_vreg
14139
14140     l.s       fa1, .LLONG_TO_min
14141     c.ole.s   fcc0, fa0, fa1
14142     li        rRESULT0, 0
14143     li        rRESULT1, 0x80000000
14144     bc1t      .LOP_FLOAT_TO_LONG_set_vreg
14145
14146     mov.s     fa1, fa0
14147     c.un.s    fcc0, fa0, fa1
14148     li        rRESULT0, 0
14149     li        rRESULT1, 0
14150     bc1t      .LOP_FLOAT_TO_LONG_set_vreg
14151
14152     JAL(__fixsfdi)
14153 #endif
14154
14155     b         .LOP_FLOAT_TO_LONG_set_vreg
14156
14157 .LLONG_TO_max:
14158     .word 0x5f000000
14159
14160 .LLONG_TO_min:
14161     .word 0xdf000000
14162
14163 /* continuation for OP_DOUBLE_TO_INT */
14164
14165
14166 d2i_doconv:
14167 #ifdef SOFT_FLOAT
14168     la        t0, .LDOUBLE_TO_INT_max
14169     LOAD64(rARG2, rARG3, t0)
14170     move      rBIX, rARG0                  #  save a0
14171     move      rTEMP, rARG1                 #  and a1
14172     JAL(__gedf2)                           #  is arg >= maxint?
14173
14174     move      t0, v0
14175     li        v0, ~0x80000000              #  return maxint (7fffffff)
14176     bgez      t0, .LOP_DOUBLE_TO_INT_set_vreg     #  nonzero == yes
14177
14178     move      rARG0, rBIX                  #  recover arg
14179     move      rARG1, rTEMP
14180     la        t0, .LDOUBLE_TO_INT_min
14181     LOAD64(rARG2, rARG3, t0)
14182     JAL(__ledf2)                           #  is arg <= minint?
14183
14184     move      t0, v0
14185     li        v0, 0x80000000               #  return minint (80000000)
14186     blez      t0, .LOP_DOUBLE_TO_INT_set_vreg     #  nonzero == yes
14187
14188     move      rARG0, rBIX                  #  recover arg
14189     move      rARG1, rTEMP
14190     move      rARG2, rBIX                  #  compare against self
14191     move      rARG3, rTEMP
14192     JAL(__nedf2)                           #  is arg == self?
14193
14194     move      t0, v0                       #  zero == no
14195     li        v0, 0
14196     bnez      t0, .LOP_DOUBLE_TO_INT_set_vreg     #  return zero for NaN
14197
14198     move      rARG0, rBIX                  #  recover arg
14199     move      rARG1, rTEMP
14200     JAL(__fixdfsi)                         #  convert double to int
14201     b         .LOP_DOUBLE_TO_INT_set_vreg
14202 #else
14203     la        t0, .LDOUBLE_TO_INT_max
14204     LOAD64_F(fa1, fa1f, t0)
14205     c.ole.d   fcc0, fa1, fa0
14206     l.s       fv0, .LDOUBLE_TO_INT_maxret
14207     bc1t      .LOP_DOUBLE_TO_INT_set_vreg_f
14208
14209     la        t0, .LDOUBLE_TO_INT_min
14210     LOAD64_F(fa1, fa1f, t0)
14211     c.ole.d   fcc0, fa0, fa1
14212     l.s       fv0, .LDOUBLE_TO_INT_minret
14213     bc1t      .LOP_DOUBLE_TO_INT_set_vreg_f
14214
14215     mov.d     fa1, fa0
14216     c.un.d    fcc0, fa0, fa1
14217     li.s      fv0, 0
14218     bc1t      .LOP_DOUBLE_TO_INT_set_vreg_f
14219
14220     trunc.w.d  fv0, fa0
14221     b         .LOP_DOUBLE_TO_INT_set_vreg_f
14222 #endif
14223
14224
14225 .LDOUBLE_TO_INT_max:
14226     .dword 0x41dfffffffc00000
14227 .LDOUBLE_TO_INT_min:
14228     .dword 0xc1e0000000000000              #  minint, as a double (high word)
14229 .LDOUBLE_TO_INT_maxret:
14230     .word 0x7fffffff
14231 .LDOUBLE_TO_INT_minret:
14232     .word 0x80000000
14233
14234 /* continuation for OP_DOUBLE_TO_LONG */
14235
14236 d2l_doconv:
14237 #ifdef SOFT_FLOAT
14238     la        t0, .LDOUBLE_TO_LONG_max
14239     LOAD64(rARG2, rARG3, t0)
14240     move      rBIX, rARG0                  #  save a0
14241     move      rTEMP, rARG1                 #  and a1
14242     JAL(__gedf2)
14243
14244     move      t1, v0
14245     la        t0, .LDOUBLE_TO_LONG_ret_max
14246     LOAD64(rRESULT0, rRESULT1, t0)
14247     bgez      t1, .LOP_DOUBLE_TO_LONG_set_vreg
14248
14249     move      rARG0, rBIX
14250     move      rARG1, rTEMP
14251     la        t0, .LDOUBLE_TO_LONG_min
14252     LOAD64(rARG2, rARG3, t0)
14253     JAL(__ledf2)
14254
14255     move      t1, v0
14256     la        t0, .LDOUBLE_TO_LONG_ret_min
14257     LOAD64(rRESULT0, rRESULT1, t0)
14258     blez      t1, .LOP_DOUBLE_TO_LONG_set_vreg
14259
14260     move      rARG0, rBIX
14261     move      rARG1, rTEMP
14262     move      rARG2, rBIX
14263     move      rARG3, rTEMP
14264     JAL(__nedf2)
14265
14266     move      t0, v0
14267     li        rRESULT0, 0
14268     li        rRESULT1, 0
14269     bnez      t0, .LOP_DOUBLE_TO_LONG_set_vreg
14270
14271     move      rARG0, rBIX
14272     move      rARG1, rTEMP
14273     JAL(__fixdfdi)
14274
14275 #else
14276     la        t0, .LDOUBLE_TO_LONG_max
14277     LOAD64_F(fa1, fa1f, t0)
14278     c.ole.d   fcc0, fa1, fa0
14279     la        t0, .LDOUBLE_TO_LONG_ret_max
14280     LOAD64(rRESULT0, rRESULT1, t0)
14281     bc1t      .LOP_DOUBLE_TO_LONG_set_vreg
14282
14283     la        t0, .LDOUBLE_TO_LONG_min
14284     LOAD64_F(fa1, fa1f, t0)
14285     c.ole.d   fcc0, fa0, fa1
14286     la        t0, .LDOUBLE_TO_LONG_ret_min
14287     LOAD64(rRESULT0, rRESULT1, t0)
14288     bc1t      .LOP_DOUBLE_TO_LONG_set_vreg
14289
14290     mov.d     fa1, fa0
14291     c.un.d    fcc0, fa0, fa1
14292     li        rRESULT0, 0
14293     li        rRESULT1, 0
14294     bc1t      .LOP_DOUBLE_TO_LONG_set_vreg
14295     JAL(__fixdfdi)
14296 #endif
14297     b         .LOP_DOUBLE_TO_LONG_set_vreg
14298
14299
14300 .LDOUBLE_TO_LONG_max:
14301     .dword 0x43e0000000000000              #  maxlong, as a double (high word)
14302 .LDOUBLE_TO_LONG_min:
14303     .dword 0xc3e0000000000000              #  minlong, as a double (high word)
14304 .LDOUBLE_TO_LONG_ret_max:
14305     .dword 0x7fffffffffffffff
14306 .LDOUBLE_TO_LONG_ret_min:
14307     .dword 0x8000000000000000
14308
14309 /* continuation for OP_MUL_LONG */
14310
14311 .LOP_MUL_LONG_finish:
14312     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14313     STORE64(v0, v1, a0)                    #  vAA::vAA+1 <- v0(low) :: v1(high)
14314     GOTO_OPCODE(t0)                        #  jump to next instruction
14315
14316
14317 /* continuation for OP_IGET_VOLATILE */
14318
14319     /*
14320      * Currently:
14321      *  v0 holds resolved field
14322      *  rOBJ holds object (caller saved)
14323      */
14324 .LOP_IGET_VOLATILE_finish:
14325     #BAL(common_squeak0)
14326     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14327     # check object for null
14328     beqz      rOBJ, common_errNullObject   #  object was null
14329     addu      a3, a3, rOBJ                 #  form address
14330     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
14331     SMP_DMB                               #  acquiring load
14332     GET_OPA4(a2)                           #  a2 <- A+
14333     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14334     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14335     SET_VREG(a0, a2)                       #  fp[A] <- a0
14336     GOTO_OPCODE(t0)                        #  jump to next instruction
14337
14338
14339 /* continuation for OP_IPUT_VOLATILE */
14340
14341     /*
14342      * Currently:
14343      *  a0 holds resolved field
14344      *  rOBJ holds object
14345      */
14346 .LOP_IPUT_VOLATILE_finish:
14347     #BAL(common_squeak0)
14348     GET_OPA4(a1)                           #  a1 <- A+
14349     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14350     GET_VREG(a0, a1)                       #  a0 <- fp[A]
14351     # check object for null
14352     beqz      rOBJ, common_errNullObject   #  object was null
14353     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14354     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14355     addu      rOBJ, rOBJ, a3               #  form address
14356     SMP_DMB_ST                            #  releasing store
14357     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
14358     SMP_DMB
14359     GOTO_OPCODE(t0)                        #  jump to next instruction
14360
14361
14362 /* continuation for OP_SGET_VOLATILE */
14363
14364 .LOP_SGET_VOLATILE_finish:
14365     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
14366     SMP_DMB                               #  acquiring load
14367     GET_OPA(a2)                            #  a2 <- AA
14368     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14369     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14370     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
14371
14372 /* continuation for OP_SPUT_VOLATILE */
14373
14374 .LOP_SPUT_VOLATILE_finish:
14375     # field ptr in a0
14376     GET_OPA(a2)                            #  a2 <- AA
14377     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14378     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
14379     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14380     SMP_DMB_ST                            #  releasing store
14381     sw        a1, offStaticField_value(a0) #  field <- vAA
14382     SMP_DMB
14383     GOTO_OPCODE(t0)                        #  jump to next instruction
14384
14385 /* continuation for OP_IGET_OBJECT_VOLATILE */
14386
14387     /*
14388      * Currently:
14389      *  v0 holds resolved field
14390      *  rOBJ holds object (caller saved)
14391      */
14392 .LOP_IGET_OBJECT_VOLATILE_finish:
14393     #BAL(common_squeak0)
14394     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14395     # check object for null
14396     beqz      rOBJ, common_errNullObject   #  object was null
14397     addu      a3, a3, rOBJ                 #  form address
14398     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
14399     SMP_DMB                               #  acquiring load
14400     GET_OPA4(a2)                           #  a2 <- A+
14401     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14402     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14403     SET_VREG(a0, a2)                       #  fp[A] <- a0
14404     GOTO_OPCODE(t0)                        #  jump to next instruction
14405
14406
14407 /* continuation for OP_IGET_WIDE_VOLATILE */
14408
14409     /*
14410      * Currently:
14411      *  a0   holds resolved field
14412      *  rOBJ holds object
14413      */
14414 .LOP_IGET_WIDE_VOLATILE_finish:
14415     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14416     beqz      rOBJ, common_errNullObject   #  object was null
14417     GET_OPA4(a2)                           #  a2 <- A+
14418     addu      rOBJ, rOBJ, a3               #  form address
14419     .if 1
14420     vLOAD64(a0, a1, rOBJ)                  #  a0/a1 <- obj.field (64-bit align ok)
14421     .else
14422     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- obj.field (64-bit align ok)
14423     .endif
14424     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14425     EAS2(a3, rFP, a2)                      #  a3 <- &fp[A]
14426     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14427     STORE64(a0, a1, a3)                    #  fp[A] <- a0/a1
14428     GOTO_OPCODE(t0)                        #  jump to next instruction
14429
14430
14431 /* continuation for OP_IPUT_WIDE_VOLATILE */
14432
14433     /*
14434      * Currently:
14435      *  a0   holds resolved field
14436      *  rOBJ holds object
14437      */
14438 .LOP_IPUT_WIDE_VOLATILE_finish:
14439     GET_OPA4(a2)                           #  a2 <- A+
14440     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14441     EAS2(a2, rFP, a2)                      #  a2 <- &fp[A]
14442     # check object for null
14443     beqz      rOBJ, common_errNullObject   #  object was null
14444     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14445     LOAD64(a0, a1, a2)                     #  a0/a1 <- fp[A]
14446     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
14447     addu      a2, rOBJ, a3                 #  form address
14448     .if 1
14449     JAL(dvmQuasiAtomicSwap64Sync)          # stores r0/r1 into addr r2
14450 #    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
14451     .else
14452     STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
14453     .endif
14454     GOTO_OPCODE(rBIX)                      #  jump to next instruction
14455
14456
14457 /* continuation for OP_SGET_WIDE_VOLATILE */
14458
14459 .LOP_SGET_WIDE_VOLATILE_finish:
14460     GET_OPA(a1)                            #  a1 <- AA
14461     .if 1
14462     vLOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
14463     .else
14464     LOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
14465     .endif
14466     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14467     EAS2(a1, rFP, a1)                      #  a1 <- &fp[AA]
14468     STORE64(a2, a3, a1)                    #  vAA/vAA+1 <- a2/a3
14469     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14470     GOTO_OPCODE(t0)                        #  jump to next instruction
14471
14472
14473
14474 /* continuation for OP_SPUT_WIDE_VOLATILE */
14475
14476     /*
14477      * Continuation if the field has not yet been resolved.
14478      *  a1:  BBBB field ref
14479      *  rOBJ:  &fp[AA]
14480      *  rBIX: dvmDex->pResFields
14481      *
14482      * Returns StaticField pointer in a2.
14483      */
14484 .LOP_SPUT_WIDE_VOLATILE_resolve:
14485     LOAD_rSELF_method(a2)                  #  a2 <- current method
14486 #if defined(WITH_JIT)
14487     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
14488 #endif
14489     EXPORT_PC()                            #  resolve() could throw, so export now
14490     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
14491     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
14492     # success ?
14493     move      a0, v0
14494     beqz      v0, common_exceptionThrown   #  no, handle exception
14495 #if defined(WITH_JIT)
14496     /*
14497      * If the JIT is actively building a trace we need to make sure
14498      * that the field is fully resolved before including this instruction.
14499      */
14500     JAL(common_verifyField)
14501 #endif
14502     move      a2, v0
14503     b         .LOP_SPUT_WIDE_VOLATILE_finish           # resume
14504
14505 /* continuation for OP_EXECUTE_INLINE */
14506
14507     /*
14508      * Extract args, call function.
14509      *  a0 = #of args (0-4)
14510      *  rBIX = call index
14511      *
14512      * Other ideas:
14513      * - Use a jump table from the main piece to jump directly into the
14514      *   AND/LW pairs.  Costs a data load, saves a branch.
14515      * - Have five separate pieces that do the loading, so we can work the
14516      *   interleave a little better.  Increases code size.
14517      */
14518 .LOP_EXECUTE_INLINE_continue:
14519     FETCH(rINST, 2)                        #  rINST <- FEDC
14520     beq       a0, 0, 0f
14521     beq       a0, 1, 1f
14522     beq       a0, 2, 2f
14523     beq       a0, 3, 3f
14524     beq       a0, 4, 4f
14525     JAL(common_abort)                      #  too many arguments
14526
14527 4:
14528     and       t0, rINST, 0xf000            #  isolate F
14529     ESRN(t1, rFP, t0, 10)
14530     lw        a3, 0(t1)                    #  a3 <- vF (shift right 12, left 2)
14531 3:
14532     and       t0, rINST, 0x0f00            #  isolate E
14533     ESRN(t1, rFP, t0, 6)
14534     lw        a2, 0(t1)                    #  a2 <- vE
14535 2:
14536     and       t0, rINST, 0x00f0            #  isolate D
14537     ESRN(t1, rFP, t0, 2)
14538     lw        a1, 0(t1)                    #  a1 <- vD
14539 1:
14540     and       t0, rINST, 0x000f            #  isolate C
14541     EASN(t1, rFP, t0, 2)
14542     lw        a0, 0(t1)                    #  a0 <- vC
14543 0:
14544     la        rINST, gDvmInlineOpsTable    #  table of InlineOperation
14545     EAS4(t1, rINST, rBIX)                  #  t1 <- rINST + rBIX<<4
14546     lw        t9, 0(t1)
14547     jr        t9                           #  sizeof=16, "func" is first entry
14548     # (not reached)
14549
14550     /*
14551      * We're debugging or profiling.
14552      * rBIX: opIndex
14553      */
14554 .LOP_EXECUTE_INLINE_debugmode:
14555     move      a0, rBIX
14556     JAL(dvmResolveInlineNative)
14557     beqz      v0, .LOP_EXECUTE_INLINE_resume       #  did it resolve? no, just move on
14558     move      rOBJ, v0                     #  remember method
14559     move      a0, v0
14560     move      a1, rSELF
14561     JAL(dvmFastMethodTraceEnter)           #  (method, self)
14562     addu      a1, rSELF, offThread_retval  #  a1<- &self->retval
14563     GET_OPB(a0)                            #  a0 <- B
14564     # Stack should have 16/20 available
14565     sw        a1, 16(sp)                   #  push &self->retval
14566     BAL(.LOP_EXECUTE_INLINE_continue)              #  make call; will return after
14567     lw        gp, STACK_OFFSET_GP(sp)      #  restore gp
14568     move      rINST, v0                    #  save result of inline
14569     move      a0, rOBJ                     #  a0<- method
14570     move      a1, rSELF                    #  a1<- self
14571     JAL(dvmFastMethodTraceExit)            #  (method, self)
14572     beqz      v0, common_exceptionThrown   #  returned false, handle exception
14573     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
14574     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14575     GOTO_OPCODE(t0)                        #  jump to next instruction
14576
14577 /* continuation for OP_EXECUTE_INLINE_RANGE */
14578
14579     /*
14580      * Extract args, call function.
14581      *  a0 = #of args (0-4)
14582      *  rBIX = call index
14583      *  ra = return addr, above  [DO NOT JAL out of here w/o preserving ra]
14584      */
14585 .LOP_EXECUTE_INLINE_RANGE_continue:
14586     FETCH(rOBJ, 2)                       # rOBJ <- CCCC
14587     beq       a0, 0, 0f
14588     beq       a0, 1, 1f
14589     beq       a0, 2, 2f
14590     beq       a0, 3, 3f
14591     beq       a0, 4, 4f
14592     JAL(common_abort)                      #  too many arguments
14593
14594 4:
14595     add       t0, rOBJ, 3
14596     GET_VREG(a3, t0)
14597 3:
14598     add       t0, rOBJ, 2
14599     GET_VREG(a2, t0)
14600 2:
14601     add       t0, rOBJ, 1
14602     GET_VREG(a1, t0)
14603 1:
14604     GET_VREG(a0, rOBJ)
14605 0:
14606     la        rOBJ, gDvmInlineOpsTable      # table of InlineOperation
14607     EAS4(t1, rOBJ, rBIX)                    # t1 <- rINST + rBIX<<4
14608     lw        t9, 0(t1)
14609     jr        t9                            # sizeof=16, "func" is first entry
14610     # not reached
14611
14612     /*
14613      * We're debugging or profiling.
14614      * rBIX: opIndex
14615      */
14616 .LOP_EXECUTE_INLINE_RANGE_debugmode:
14617     move      a0, rBIX
14618     JAL(dvmResolveInlineNative)
14619     beqz      v0, .LOP_EXECUTE_INLINE_RANGE_resume       #  did it resolve? no, just move on
14620     move      rOBJ, v0                     #  remember method
14621     move      a0, v0
14622     move      a1, rSELF
14623     JAL(dvmFastMethodTraceEnter)           #  (method, self)
14624     addu      a1, rSELF, offThread_retval  #  a1<- &self->retval
14625     GET_OPA(a0)                            #  a0 <- A
14626     # Stack should have 16/20 available
14627     sw        a1, 16(sp)                   #  push &self->retval
14628     move      rINST, rOBJ                  #  rINST<- method
14629     BAL(.LOP_EXECUTE_INLINE_RANGE_continue)              #  make call; will return after
14630     lw        gp, STACK_OFFSET_GP(sp)      #  restore gp
14631     move      rOBJ, v0                     #  save result of inline
14632     move      a0, rINST                    #  a0<- method
14633     move      a1, rSELF                    #  a1<- self
14634     JAL(dvmFastNativeMethodTraceExit)      #  (method, self)
14635     beqz      rOBJ, common_exceptionThrown #  returned false, handle exception
14636     FETCH_ADVANCE_INST(3)                  #  advance rPC, load rINST
14637     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14638     GOTO_OPCODE(t0)                        #  jump to next instruction
14639
14640 /* continuation for OP_INVOKE_OBJECT_INIT_RANGE */
14641     /*
14642      * A debugger is attached, so we need to go ahead and do
14643      * this.  For simplicity, we'll just jump directly to the
14644      * corresponding handler.  Note that we can't use
14645      * rIBASE here because it may be in single-step mode.
14646      * Load the primary table base directly.
14647      */
14648 .LOP_INVOKE_OBJECT_INIT_RANGE_debugger:
14649     lw      a1, offThread_mainHandlerTable(rSELF)
14650     .if 0
14651     li      t0, OP_INVOKE_DIRECT_JUMBO
14652     .else
14653     li      t0, OP_INVOKE_DIRECT_RANGE
14654     .endif
14655     GOTO_OPCODE_BASE(a1, t0)            # execute it
14656
14657 /* continuation for OP_IPUT_OBJECT_VOLATILE */
14658
14659     /*
14660      * Currently:
14661      *  a0 holds resolved field
14662      *  rOBJ holds object
14663      */
14664 .LOP_IPUT_OBJECT_VOLATILE_finish:
14665     #BAL(common_squeak0)
14666     GET_OPA4(a1)                           #  a1 <- A+
14667     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14668     GET_VREG(a0, a1)                       #  a0 <- fp[A]
14669     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
14670     # check object for null
14671     beqz      rOBJ, common_errNullObject   #  object was null
14672     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14673     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14674     addu      t2, rOBJ, a3                 #  form address
14675     SMP_DMB_ST                            #  releasing store
14676     sw a0, (t2)                        #  obj.field (32 bits) <- a0
14677     SMP_DMB
14678     beqz      a0, 1f                       #  stored a null reference?
14679     srl       t1, rOBJ, GC_CARD_SHIFT
14680     addu      t2, a2, t1
14681     sb        a2, (t2)                     #  mark card if not
14682 1:
14683     GOTO_OPCODE(t0)                        #  jump to next instruction
14684
14685
14686 /* continuation for OP_SGET_OBJECT_VOLATILE */
14687
14688 .LOP_SGET_OBJECT_VOLATILE_finish:
14689     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
14690     SMP_DMB                               #  acquiring load
14691     GET_OPA(a2)                            #  a2 <- AA
14692     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14693     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14694     SET_VREG_GOTO(a1, a2, t0)              #  fp[AA] <- a1
14695
14696 /* continuation for OP_SPUT_OBJECT_VOLATILE */
14697 .LOP_SPUT_OBJECT_VOLATILE_finish:                        #  field ptr in a0
14698     GET_OPA(a2)                            #  a2 <- AA
14699     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14700     GET_VREG(a1, a2)                       #  a1 <- fp[AA]
14701     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
14702     lw        t1, offField_clazz(a0)       #  t1 <- field->clazz
14703     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14704     SMP_DMB_ST                            #  releasing store
14705     sw        a1, offStaticField_value(a0) #  field <- vAA
14706     SMP_DMB
14707     beqz      a1, 1f
14708     srl       t2, t1, GC_CARD_SHIFT
14709     addu      t3, a2, t2
14710     sb        a2, (t3)
14711 1:
14712     GOTO_OPCODE(t0)                        #  jump to next instruction
14713
14714 /* continuation for OP_CHECK_CAST_JUMBO */
14715
14716
14717 .LOP_CHECK_CAST_JUMBO_castfailure:
14718     # A cast has failed.  We need to throw a ClassCastException with the
14719     # class of the object that failed to be cast.
14720     EXPORT_PC()                                 # about to throw
14721     LOAD_base_offObject_clazz(a0, rOBJ)         # a0<- obj->clazz
14722     move      a1,rBIX                      #  r1<- desired class
14723     JAL(dvmThrowClassCastException)
14724     b       common_exceptionThrown
14725
14726     /*
14727      * Advance PC and get next opcode
14728      *
14729      */
14730 .LOP_CHECK_CAST_JUMBO_okay:
14731     FETCH_ADVANCE_INST(4)                       # advance rPC, load rINST
14732     GET_INST_OPCODE(t0)                         # extract opcode from rINST
14733     GOTO_OPCODE(t0)                             # jump to next instruction
14734     /*
14735      * Resolution required.  This is the least-likely path.
14736      *
14737      *  a2   holds AAAAAAAA
14738      *  rOBJ holds object
14739      */
14740 .LOP_CHECK_CAST_JUMBO_resolve:
14741     EXPORT_PC()                                 # resolve() could throw
14742     LOAD_rSELF_method(a3)           # a3<- self->method
14743     move     a1, a2                             # a1<- AAAAAAAA
14744     li       a2, 0                              # a2<- false
14745     LOAD_base_offMethod_clazz(a0, a3)   # a0<- method->clazz
14746     JAL(dvmResolveClass)    # v0<- resolved ClassObject ptr
14747                                                 # got null?
14748     beqz     v0, common_exceptionThrown         # yes, handle exception
14749     move     a1, v0                             # a1<- class resolved from AAAAAAAA
14750     LOAD_base_offObject_clazz(a0, rOBJ)   # a0<- obj->clazz
14751     b       .LOP_CHECK_CAST_JUMBO_resolved                # pick up where we left off
14752
14753
14754
14755 /* continuation for OP_INSTANCE_OF_JUMBO */
14756
14757      /*
14758      * Class resolved, determine type of check necessary.  This is common.
14759      *  r0 holds obj->clazz
14760      *  r1 holds class resolved from AAAAAAAA
14761      *  r9 holds BBBB
14762      */
14763
14764 .LOP_INSTANCE_OF_JUMBO_resolved:                   #  a0=obj->clazz, a1=resolved class
14765     # same class (trivial success)?
14766     beq       a0, a1, .LOP_INSTANCE_OF_JUMBO_trivial  #  yes, trivial finish
14767     # fall through to OP_INSTANCE_OF_JUMBO_fullcheck
14768
14769     /*
14770      * Trivial test failed, need to perform full check.  This is common.
14771      *  a0 holds obj->clazz
14772      *  a1 holds class resolved from AAAAAAAA
14773      *  rOBJ holds BBBB
14774      */
14775 .LOP_INSTANCE_OF_JUMBO_fullcheck:
14776     JAL(dvmInstanceofNonTrivial)           #  v0 <- boolean result
14777     move      a0, v0
14778     b         .LOP_INSTANCE_OF_JUMBO_store            #  go to OP_INSTANCE_OF_JUMBO_store
14779
14780 .LOP_INSTANCE_OF_JUMBO_trivial:
14781     li        a0, 1                        #  indicate success
14782     # fall thru
14783     /*
14784      * a0   holds boolean result
14785      * rOBJ holds BBBB
14786      */
14787 .LOP_INSTANCE_OF_JUMBO_store:
14788     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
14789     SET_VREG(a0, rOBJ)                     #  vBBBB <- a0
14790     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14791     GOTO_OPCODE(t0)                        #  jump to next instruction
14792
14793     /*
14794      * Resolution required.  This is the least-likely path.
14795      *
14796      *  a3   holds AAAAAAAA
14797      *  rOBJ holds BBBB
14798      */
14799 .LOP_INSTANCE_OF_JUMBO_resolve:
14800     EXPORT_PC()                            #  resolve() could throw
14801     LOAD_rSELF_method(a0)                  #  a0 <- self->method
14802     move      a1, a3                       #  a1 <- AAAAAAAA
14803     li        a2, 1                        #  a2 <- true
14804     LOAD_base_offMethod_clazz(a0, a0)      #  a0 <- method->clazz
14805     JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
14806     # got null?
14807     move      a1, v0                       #  a1 <- class resolved from BBB
14808     beqz      v0, common_exceptionThrown   #  yes, handle exception
14809     FETCH(ra, 4)                           #  a3<- vCCCC
14810     move       a1, a0                       #  a1<- class resolved from AAAAAAAA
14811
14812     GET_VREG(a0, a3)                       #  a0 <- vCCCC (object)
14813     LOAD_base_offObject_clazz(a0, a0)      #  a0 <- obj->clazz
14814     b         .LOP_INSTANCE_OF_JUMBO_resolved         #  pick up where we left off
14815
14816
14817 /* continuation for OP_NEW_INSTANCE_JUMBO */
14818
14819 .LOP_NEW_INSTANCE_JUMBO_continue:
14820     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
14821     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14822     SET_VREG(v0, a3)                       #  vBBBB <- v0
14823     GOTO_OPCODE(t0)                        #  jump to next instruction
14824
14825 #if defined(WITH_JIT)
14826     /*
14827      * Check to see if we need to stop the trace building early.
14828      * v0: new object
14829      * a3: vAA
14830      */
14831 .LOP_NEW_INSTANCE_JUMBO_jitCheck:
14832     lw        a1, 0(rBIX)                  #  reload resolved class
14833     # okay?
14834     bnez      a1, .LOP_NEW_INSTANCE_JUMBO_continue     #  yes, finish
14835     move      rOBJ, v0                     #  preserve new object
14836     move      rBIX, a3                     #  preserve vAA
14837     move      a0, rSELF
14838     move      a1, rPC
14839     JAL(dvmJitEndTraceSelect)              #  (self, pc)
14840     FETCH_ADVANCE_INST(2)                  #  advance rPC, load rINST
14841     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14842     SET_VREG(rOBJ, rBIX)                   #  vAA <- new object
14843     GOTO_OPCODE(t0)                        #  jump to next instruction
14844 #endif
14845
14846     /*
14847      * Class initialization required.
14848      *
14849      *  a0 holds class object
14850      */
14851 .LOP_NEW_INSTANCE_JUMBO_needinit:
14852     JAL(dvmInitClass)                      #  initialize class
14853     move      a0, rOBJ                     #  restore a0
14854     # check boolean result
14855     bnez      v0, .LOP_NEW_INSTANCE_JUMBO_initialized  #  success, continue
14856     b         common_exceptionThrown       #  failed, deal with init exception
14857
14858
14859     /*
14860      * Resolution required.  This is the least-likely path.
14861      *
14862      *  a1 holds AAAAAAAA
14863      */
14864 .LOP_NEW_INSTANCE_JUMBO_resolve:
14865     LOAD_rSELF_method(a3)                  #  a3 <- self->method
14866     li        a2, 0                        #  a2 <- false
14867     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
14868     JAL(dvmResolveClass)                   #  v0 <- resolved ClassObject ptr
14869     move      a0, v0
14870     # got null?
14871     bnez      v0, .LOP_NEW_INSTANCE_JUMBO_resolved     #  no, continue
14872     b         common_exceptionThrown       #  yes, handle exception
14873
14874 /* continuation for OP_NEW_ARRAY_JUMBO */
14875
14876     /*
14877      * Finish allocation.
14878      *
14879      *  a0 holds class
14880      *  a1 holds array length
14881      */
14882 .LOP_NEW_ARRAY_JUMBO_finish:
14883     li        a2, ALLOC_DONT_TRACK         #  don't track in local refs table
14884     JAL(dvmAllocArrayByClass)              #  v0 <- call(clazz, length, flags)
14885     FETCH(a2, 3)                           # r2<- vBBBB
14886     # failed?
14887     beqz      v0, common_exceptionThrown   #  yes, handle the exception
14888     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
14889     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
14890     SET_VREG(v0, a2)                       #  vBBBB <- v0
14891     GOTO_OPCODE(t0)                        #  jump to next instruction
14892 #%break
14893
14894
14895
14896     /*
14897      * Resolve class.  (This is an uncommon case.)
14898      *
14899      *  a1 holds array length
14900      *  a2 holds class ref AAAAAAAA
14901      */
14902 .LOP_NEW_ARRAY_JUMBO_resolve:
14903     LOAD_rSELF_method(a3)                  #  a3 <- self->method
14904     move      rOBJ, a1                     #  rOBJ <- length (save)
14905     move      a1, a2                       #  a1 <- AAAAAAAA
14906     li        a2, 0                        #  a2 <- false
14907     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
14908     JAL(dvmResolveClass)                   #  v0 <- call(clazz, ref)
14909     move      a1, rOBJ                     #  a1 <- length (restore)
14910     # got null?
14911     beqz      v0, common_exceptionThrown   #  yes, handle exception
14912     move      a0, v0
14913     b         .LOP_NEW_ARRAY_JUMBO_finish           #  continue with to OP_NEW_ARRAY_JUMBO_finish
14914
14915
14916
14917 /* continuation for OP_FILLED_NEW_ARRAY_JUMBO */
14918
14919     /*
14920      * On entry:
14921      *  a0 holds array class
14922      *  rOBJ holds AA or BA
14923      */
14924 .LOP_FILLED_NEW_ARRAY_JUMBO_continue:
14925     LOAD_base_offClassObject_descriptor(a3, a0) #  a3 <- arrayClass->descriptor
14926     li        a2, ALLOC_DONT_TRACK         #  a2 <- alloc flags
14927     lbu       rINST, 1(a3)                 #  rINST <- descriptor[1]
14928     FETCH(a1, 3)                           # a1<- BBBB (length)
14929     seq       t0, rINST, 'I'               #  array of ints?
14930     seq       t1, rINST, 'L'               #  array of objects?
14931     or        t0, t1
14932     seq       t1, rINST, '['               #  array of arrays?
14933     or        t0, t1
14934     move      rBIX, a1                     #  save length in rBIX
14935     beqz      t0, .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl      #  no, not handled yet
14936     JAL(dvmAllocArrayByClass)              #  v0 <- call(arClass, length, flags)
14937     # null return?
14938     beqz      v0, common_exceptionThrown   #  alloc failed, handle exception
14939
14940     FETCH(a1, 4)                           #  a1 CCCC
14941     sw        v0, offThread_retval(rSELF)  #  retval.l <- new array
14942     sw        rINST, (offThread_retval+4)(rSELF) #  retval.h <- type
14943     addu      a0, v0, offArrayObject_contents #  a0 <- newArray->contents
14944     subu      rBIX, rBIX, 1                #  length--, check for neg
14945     FETCH_ADVANCE_INST(5)                  #  advance to next instr, load rINST
14946     bltz      rBIX, 2f                     #  was zero, bail
14947
14948     # copy values from registers into the array
14949     # a0=array, a1=CCCC, t0=BBBB(length)
14950     move      t0, rBIX
14951     EAS2(a2, rFP, a1)                      #  a2 <- &fp[CCCC]
14952 1:
14953     lw        a3, 0(a2)                    #  a3 <- *a2++
14954     addu      a2, 4
14955     subu      t0, t0, 1                    #  count--
14956     sw        a3, (a0)                     #  *contents++ = vX
14957     addu      a0, 4
14958     bgez      t0, 1b
14959
14960 2:
14961     lw        a0, offThread_retval(rSELF)  #  a0 <- object
14962     lw        a1, (offThread_retval+4)(rSELF) #  a1 <- type
14963     seq       t1, a1, 'I'                  #  Is int array?
14964     bnez      t1, 3f
14965     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
14966     srl       t3, a0, GC_CARD_SHIFT
14967     addu      t2, a2, t3
14968     sb        a2, (t2)
14969 3:
14970     GET_INST_OPCODE(t0)                    #  ip <- opcode from rINST
14971     GOTO_OPCODE(t0)                        #  execute it
14972
14973
14974     /*
14975      * Throw an exception indicating that we have not implemented this
14976      * mode of filled-new-array.
14977      */
14978 .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl:
14979     la        a0, .LstrFilledNewArrayNotImpl
14980     JAL(dvmThrowInternalError)
14981     b         common_exceptionThrown
14982
14983 /* continuation for OP_IGET_JUMBO */
14984
14985 .LOP_IGET_JUMBO_resolved:
14986      # test results
14987     move      a0, v0
14988     beqz      a0,common_exceptionThrown
14989     /*
14990      * Currently:
14991      *  v0 holds resolved field
14992      *  rOBJ holds object (caller saved)
14993      */
14994 .LOP_IGET_JUMBO_finish:
14995     #BAL(common_squeak0)
14996     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
14997     # check object for null
14998     beqz      rOBJ, common_errNullObject   #  object was null
14999     addu      a3, a3, rOBJ                 #  form address
15000     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15001          # noop                               #  acquiring load
15002     FETCH(a2, 3)                           #  a2<- BBBB
15003     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15004     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15005     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15006     GOTO_OPCODE(t0)                        #  jump to next instruction
15007
15008
15009 /* continuation for OP_IGET_WIDE_JUMBO */
15010
15011 .LOP_IGET_WIDE_JUMBO_resolved:
15012     # test return code
15013     move      a0, v0
15014     bnez      v0, .LOP_IGET_WIDE_JUMBO_finish
15015     b         common_exceptionThrown
15016
15017     /*
15018      * Currently:
15019      *  a0   holds resolved field
15020      *  rOBJ holds object
15021      */
15022 .LOP_IGET_WIDE_JUMBO_finish:
15023     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15024     beqz      rOBJ, common_errNullObject   #  object was null
15025     GET_OPA4(a2)                           #  a2 <- A+
15026     addu      rOBJ, rOBJ, a3               #  form address
15027     .if 0
15028     vLOAD64(a0, a1, rOBJ)                  #  a0/a1 <- obj.field (64-bit align ok)
15029     .else
15030     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- obj.field (64-bit align ok)
15031     .endif
15032     FETCH(a2, 3)                           # r2<- BBBB
15033     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15034     EAS2(a3, rFP, a2)                      #  a3 <- &fp[BBBB]
15035     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15036     STORE64(a0, a1, a3)                    #  fp[BBBB] <- a0/a1
15037     GOTO_OPCODE(t0)                        #  jump to next instruction
15038
15039
15040 /* continuation for OP_IGET_OBJECT_JUMBO */
15041
15042 .LOP_IGET_OBJECT_JUMBO_resolved:
15043      # test results
15044     move      a0, v0
15045     beqz      a0,common_exceptionThrown
15046     /*
15047      * Currently:
15048      *  v0 holds resolved field
15049      *  rOBJ holds object (caller saved)
15050      */
15051 .LOP_IGET_OBJECT_JUMBO_finish:
15052     #BAL(common_squeak0)
15053     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15054     # check object for null
15055     beqz      rOBJ, common_errNullObject   #  object was null
15056     addu      a3, a3, rOBJ                 #  form address
15057     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15058          # noop                               #  acquiring load
15059     FETCH(a2, 3)                           #  a2<- BBBB
15060     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15061     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15062     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15063     GOTO_OPCODE(t0)                        #  jump to next instruction
15064
15065
15066 /* continuation for OP_IGET_BOOLEAN_JUMBO */
15067
15068 .LOP_IGET_BOOLEAN_JUMBO_resolved:
15069      # test results
15070     move      a0, v0
15071     beqz      a0,common_exceptionThrown
15072     /*
15073      * Currently:
15074      *  v0 holds resolved field
15075      *  rOBJ holds object (caller saved)
15076      */
15077 .LOP_IGET_BOOLEAN_JUMBO_finish:
15078     #BAL(common_squeak0)
15079     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15080     # check object for null
15081     beqz      rOBJ, common_errNullObject   #  object was null
15082     addu      a3, a3, rOBJ                 #  form address
15083     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15084          # noop                               #  acquiring load
15085     FETCH(a2, 3)                           #  a2<- BBBB
15086     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15087     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15088     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15089     GOTO_OPCODE(t0)                        #  jump to next instruction
15090
15091
15092 /* continuation for OP_IGET_BYTE_JUMBO */
15093
15094 .LOP_IGET_BYTE_JUMBO_resolved:
15095      # test results
15096     move      a0, v0
15097     beqz      a0,common_exceptionThrown
15098     /*
15099      * Currently:
15100      *  v0 holds resolved field
15101      *  rOBJ holds object (caller saved)
15102      */
15103 .LOP_IGET_BYTE_JUMBO_finish:
15104     #BAL(common_squeak0)
15105     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15106     # check object for null
15107     beqz      rOBJ, common_errNullObject   #  object was null
15108     addu      a3, a3, rOBJ                 #  form address
15109     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15110          # noop                               #  acquiring load
15111     FETCH(a2, 3)                           #  a2<- BBBB
15112     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15113     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15114     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15115     GOTO_OPCODE(t0)                        #  jump to next instruction
15116
15117
15118 /* continuation for OP_IGET_CHAR_JUMBO */
15119
15120 .LOP_IGET_CHAR_JUMBO_resolved:
15121      # test results
15122     move      a0, v0
15123     beqz      a0,common_exceptionThrown
15124     /*
15125      * Currently:
15126      *  v0 holds resolved field
15127      *  rOBJ holds object (caller saved)
15128      */
15129 .LOP_IGET_CHAR_JUMBO_finish:
15130     #BAL(common_squeak0)
15131     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15132     # check object for null
15133     beqz      rOBJ, common_errNullObject   #  object was null
15134     addu      a3, a3, rOBJ                 #  form address
15135     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15136          # noop                               #  acquiring load
15137     FETCH(a2, 3)                           #  a2<- BBBB
15138     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15139     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15140     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15141     GOTO_OPCODE(t0)                        #  jump to next instruction
15142
15143
15144 /* continuation for OP_IGET_SHORT_JUMBO */
15145
15146 .LOP_IGET_SHORT_JUMBO_resolved:
15147      # test results
15148     move      a0, v0
15149     beqz      a0,common_exceptionThrown
15150     /*
15151      * Currently:
15152      *  v0 holds resolved field
15153      *  rOBJ holds object (caller saved)
15154      */
15155 .LOP_IGET_SHORT_JUMBO_finish:
15156     #BAL(common_squeak0)
15157     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15158     # check object for null
15159     beqz      rOBJ, common_errNullObject   #  object was null
15160     addu      a3, a3, rOBJ                 #  form address
15161     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15162          # noop                               #  acquiring load
15163     FETCH(a2, 3)                           #  a2<- BBBB
15164     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15165     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15166     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15167     GOTO_OPCODE(t0)                        #  jump to next instruction
15168
15169
15170 /* continuation for OP_IPUT_JUMBO */
15171
15172 .LOP_IPUT_JUMBO_resolved:
15173     move      a0, v0
15174     beqz      a0, common_exceptionThrown
15175     # fall through to OP_IPUT_JUMBO_finish
15176
15177
15178     /*
15179      * Currently:
15180      *  a0 holds resolved field
15181      *  rOBJ holds object
15182      */
15183 .LOP_IPUT_JUMBO_finish:
15184     #BAL(common_squeak0)
15185     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15186     FETCH(a1, 3)                           # a1<- BBBB
15187     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15188     # check object for null
15189     beqz      rOBJ, common_errNullObject   #  object was null
15190     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15191     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15192     addu      rOBJ, rOBJ, a3               #  form address
15193         #  noop                            #  releasing store
15194     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
15195     # noop
15196     GOTO_OPCODE(t0)                        #  jump to next instruction
15197
15198
15199 /* continuation for OP_IPUT_WIDE_JUMBO */
15200
15201 .LOP_IPUT_WIDE_JUMBO_resolved:
15202     move      a0, v0
15203     beqz      a0, common_exceptionThrown
15204     # fall through to OP_IPUT_WIDE_JUMBO_finish
15205     /*
15206      * Currently:
15207      *  a0   holds resolved field
15208      *  rOBJ holds object
15209      */
15210 .LOP_IPUT_WIDE_JUMBO_finish:
15211     FETCH(a2, 3)                           # a1<- BBBB
15212     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15213     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BBBB]
15214     # check object for null
15215     beqz      rOBJ, common_errNullObject   #  object was null
15216     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15217     LOAD64(a0, a1, a2)                     #  a0/a1 <- fp[BBBB]
15218     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
15219     addu      a2, rOBJ, a3                 #  form address
15220     .if 0
15221     JAL(dvmQuasiAtomicSwap64Sync)          # stores r0/r1 into addr r2
15222 #    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
15223     .else
15224     STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
15225     .endif
15226     GOTO_OPCODE(rBIX)                      #  jump to next instruction
15227
15228
15229
15230 /* continuation for OP_IPUT_OBJECT_JUMBO */
15231
15232     /*
15233      * Currently:
15234      *  a0 holds resolved field
15235      *  rOBJ holds object
15236      */
15237 .LOP_IPUT_OBJECT_JUMBO_resolved:
15238     move      a0, v0
15239     beqz      a0, common_exceptionThrown
15240     # fall through to OP_IPUT_OBJECT_JUMBO_finish
15241
15242 .LOP_IPUT_OBJECT_JUMBO_finish:
15243     #BAL(common_squeak0)
15244     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15245     FETCH(a1, 3)                              # a1<- BBBB
15246     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15247     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
15248     # check object for null
15249     beqz      rOBJ, common_errNullObject   #  object was null
15250     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15251     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15252     addu      t2, rOBJ, a3                 #  form address
15253         #  noop                            #  releasing store
15254     sw a0, (t2)                        #  obj.field (32 bits) <- a0
15255         #  noop
15256     beqz      a0, 1f                       #  stored a null reference?
15257     srl       t1, rOBJ, GC_CARD_SHIFT
15258     addu      t2, a2, t1
15259     sb        a2, (t2)                     #  mark card if not
15260 1:
15261     GOTO_OPCODE(t0)                        #  jump to next instruction
15262
15263
15264 /* continuation for OP_IPUT_BOOLEAN_JUMBO */
15265
15266 .LOP_IPUT_BOOLEAN_JUMBO_resolved:
15267     move      a0, v0
15268     beqz      a0, common_exceptionThrown
15269     # fall through to OP_IPUT_BOOLEAN_JUMBO_finish
15270
15271
15272     /*
15273      * Currently:
15274      *  a0 holds resolved field
15275      *  rOBJ holds object
15276      */
15277 .LOP_IPUT_BOOLEAN_JUMBO_finish:
15278     #BAL(common_squeak0)
15279     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15280     FETCH(a1, 3)                           # a1<- BBBB
15281     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15282     # check object for null
15283     beqz      rOBJ, common_errNullObject   #  object was null
15284     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15285     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15286     addu      rOBJ, rOBJ, a3               #  form address
15287         #  noop                            #  releasing store
15288     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
15289     # noop
15290     GOTO_OPCODE(t0)                        #  jump to next instruction
15291
15292
15293 /* continuation for OP_IPUT_BYTE_JUMBO */
15294
15295 .LOP_IPUT_BYTE_JUMBO_resolved:
15296     move      a0, v0
15297     beqz      a0, common_exceptionThrown
15298     # fall through to OP_IPUT_BYTE_JUMBO_finish
15299
15300
15301     /*
15302      * Currently:
15303      *  a0 holds resolved field
15304      *  rOBJ holds object
15305      */
15306 .LOP_IPUT_BYTE_JUMBO_finish:
15307     #BAL(common_squeak0)
15308     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15309     FETCH(a1, 3)                           # a1<- BBBB
15310     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15311     # check object for null
15312     beqz      rOBJ, common_errNullObject   #  object was null
15313     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15314     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15315     addu      rOBJ, rOBJ, a3               #  form address
15316         #  noop                            #  releasing store
15317     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
15318     # noop
15319     GOTO_OPCODE(t0)                        #  jump to next instruction
15320
15321
15322 /* continuation for OP_IPUT_CHAR_JUMBO */
15323
15324 .LOP_IPUT_CHAR_JUMBO_resolved:
15325     move      a0, v0
15326     beqz      a0, common_exceptionThrown
15327     # fall through to OP_IPUT_CHAR_JUMBO_finish
15328
15329
15330     /*
15331      * Currently:
15332      *  a0 holds resolved field
15333      *  rOBJ holds object
15334      */
15335 .LOP_IPUT_CHAR_JUMBO_finish:
15336     #BAL(common_squeak0)
15337     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15338     FETCH(a1, 3)                           # a1<- BBBB
15339     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15340     # check object for null
15341     beqz      rOBJ, common_errNullObject   #  object was null
15342     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15343     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15344     addu      rOBJ, rOBJ, a3               #  form address
15345         #  noop                            #  releasing store
15346     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
15347     # noop
15348     GOTO_OPCODE(t0)                        #  jump to next instruction
15349
15350
15351 /* continuation for OP_IPUT_SHORT_JUMBO */
15352
15353 .LOP_IPUT_SHORT_JUMBO_resolved:
15354     move      a0, v0
15355     beqz      a0, common_exceptionThrown
15356     # fall through to OP_IPUT_SHORT_JUMBO_finish
15357
15358
15359     /*
15360      * Currently:
15361      *  a0 holds resolved field
15362      *  rOBJ holds object
15363      */
15364 .LOP_IPUT_SHORT_JUMBO_finish:
15365     #BAL(common_squeak0)
15366     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15367     FETCH(a1, 3)                           # a1<- BBBB
15368     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15369     # check object for null
15370     beqz      rOBJ, common_errNullObject   #  object was null
15371     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15372     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15373     addu      rOBJ, rOBJ, a3               #  form address
15374         #  noop                            #  releasing store
15375     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
15376     # noop
15377     GOTO_OPCODE(t0)                        #  jump to next instruction
15378
15379
15380 /* continuation for OP_SGET_JUMBO */
15381
15382 .LOP_SGET_JUMBO_finish:
15383     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15384                       #  no-op                                #  acquiring load
15385     FETCH(a2, 3)                           # r2<- BBBB
15386     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15387     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15388     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15389
15390 /* continuation for OP_SGET_WIDE_JUMBO */
15391
15392 .LOP_SGET_WIDE_JUMBO_finish:
15393     FETCH(a1, 3)                           # a1<- BBBB
15394     .if 0
15395     vLOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
15396     .else
15397     LOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
15398     .endif
15399     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15400     EAS2(a1, rFP, a1)                      #  a1 <- &fp[BBBB]
15401     STORE64(a2, a3, a1)                    #  vBBBB/vBBBB+1 <- a2/a3
15402     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15403     GOTO_OPCODE(t0)                        #  jump to next instruction
15404
15405 /* continuation for OP_SGET_OBJECT_JUMBO */
15406
15407 .LOP_SGET_OBJECT_JUMBO_finish:
15408     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15409                       #  no-op                                #  acquiring load
15410     FETCH(a2, 3)                           # r2<- BBBB
15411     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15412     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15413     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15414
15415 /* continuation for OP_SGET_BOOLEAN_JUMBO */
15416
15417 .LOP_SGET_BOOLEAN_JUMBO_finish:
15418     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15419                       #  no-op                                #  acquiring load
15420     FETCH(a2, 3)                           # r2<- BBBB
15421     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15422     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15423     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15424
15425 /* continuation for OP_SGET_BYTE_JUMBO */
15426
15427 .LOP_SGET_BYTE_JUMBO_finish:
15428     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15429                       #  no-op                                #  acquiring load
15430     FETCH(a2, 3)                           # r2<- BBBB
15431     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15432     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15433     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15434
15435 /* continuation for OP_SGET_CHAR_JUMBO */
15436
15437 .LOP_SGET_CHAR_JUMBO_finish:
15438     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15439                       #  no-op                                #  acquiring load
15440     FETCH(a2, 3)                           # r2<- BBBB
15441     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15442     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15443     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15444
15445 /* continuation for OP_SGET_SHORT_JUMBO */
15446
15447 .LOP_SGET_SHORT_JUMBO_finish:
15448     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15449                       #  no-op                                #  acquiring load
15450     FETCH(a2, 3)                           # r2<- BBBB
15451     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15452     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15453     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15454
15455 /* continuation for OP_SPUT_JUMBO */
15456
15457 .LOP_SPUT_JUMBO_finish:
15458     # field ptr in a0
15459     FETCH(a2, 3)                           # a2<- BBBB
15460     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15461     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15462     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15463           #  no-op                             #  releasing store
15464     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15465           #  no-op
15466     GOTO_OPCODE(t0)                        #  jump to next instruction
15467
15468 /* continuation for OP_SPUT_WIDE_JUMBO */
15469
15470     /*
15471      * Continuation if the field has not yet been resolved.
15472      *  a1:  AAAAAAAA field ref
15473      *  rOBJ:  &fp[BBBB]
15474      *  rBIX: dvmDex->pResFields
15475      *
15476      * Returns StaticField pointer in a2.
15477      */
15478 .LOP_SPUT_WIDE_JUMBO_resolve:
15479     LOAD_rSELF_method(a2)                  #  a2 <- current method
15480 #if defined(WITH_JIT)
15481     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
15482 #endif
15483     EXPORT_PC()                            #  resolve() could throw, so export now
15484     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
15485     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
15486     # success ?
15487     move      a0, v0
15488     beqz      v0, common_exceptionThrown   #  no, handle exception
15489 #if defined(WITH_JIT)
15490     /*
15491      * If the JIT is actively building a trace we need to make sure
15492      * that the field is fully resolved before including this instruction.
15493      */
15494     JAL(common_verifyField)
15495 #endif
15496     move      a2, v0
15497     b         .LOP_SPUT_WIDE_JUMBO_finish           # resume
15498
15499 /* continuation for OP_SPUT_OBJECT_JUMBO */
15500 .LOP_SPUT_OBJECT_JUMBO_finish:                     #  field ptr in a0
15501     FETCH(a2, 3)                        # a2<- BBBB
15502     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15503     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15504     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
15505     lw        t1, offField_clazz(a0)       #  t1 <- field->clazz
15506     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15507           #  no-op                             #  releasing store
15508     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15509           #  no-op
15510     beqz      a1, 1f
15511     srl       t2, t1, GC_CARD_SHIFT
15512     addu      t3, a2, t2
15513     sb        a2, (t3)
15514     1:
15515     GOTO_OPCODE(t0)                        #  jump to next instruction
15516
15517 /* continuation for OP_SPUT_BOOLEAN_JUMBO */
15518
15519 .LOP_SPUT_BOOLEAN_JUMBO_finish:
15520     # field ptr in a0
15521     FETCH(a2, 3)                           # a2<- BBBB
15522     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15523     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15524     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15525           #  no-op                             #  releasing store
15526     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15527           #  no-op
15528     GOTO_OPCODE(t0)                        #  jump to next instruction
15529
15530 /* continuation for OP_SPUT_BYTE_JUMBO */
15531
15532 .LOP_SPUT_BYTE_JUMBO_finish:
15533     # field ptr in a0
15534     FETCH(a2, 3)                           # a2<- BBBB
15535     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15536     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15537     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15538           #  no-op                             #  releasing store
15539     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15540           #  no-op
15541     GOTO_OPCODE(t0)                        #  jump to next instruction
15542
15543 /* continuation for OP_SPUT_CHAR_JUMBO */
15544
15545 .LOP_SPUT_CHAR_JUMBO_finish:
15546     # field ptr in a0
15547     FETCH(a2, 3)                           # a2<- BBBB
15548     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15549     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15550     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15551           #  no-op                             #  releasing store
15552     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15553           #  no-op
15554     GOTO_OPCODE(t0)                        #  jump to next instruction
15555
15556 /* continuation for OP_SPUT_SHORT_JUMBO */
15557
15558 .LOP_SPUT_SHORT_JUMBO_finish:
15559     # field ptr in a0
15560     FETCH(a2, 3)                           # a2<- BBBB
15561     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15562     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15563     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15564           #  no-op                             #  releasing store
15565     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15566           #  no-op
15567     GOTO_OPCODE(t0)                        #  jump to next instruction
15568
15569 /* continuation for OP_INVOKE_VIRTUAL_JUMBO */
15570
15571     /*
15572      * At this point:
15573      *  a0 = resolved base method
15574      *  rBIX= C or CCCC (index of first arg, which is the "this" ptr)
15575      */
15576 .LOP_INVOKE_VIRTUAL_JUMBO_continue:
15577     FETCH(rBIX,4)                          #  rBIX <- CCCC
15578     GET_VREG(rOBJ, rBIX)                   #  rOBJ <- "this" ptr
15579     LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
15580     # is "this" null?
15581     beqz      rOBJ, common_errNullObject   #  null "this", throw exception
15582     LOAD_base_offObject_clazz(a3, rOBJ)    #  a3 <- thisPtr->clazz
15583     LOAD_base_offClassObject_vtable(a3, a3) #  a3 <- thisPtr->clazz->vtable
15584     LOAD_eas2(a0, a3, a2)                  #  a0 <- vtable[methodIndex]
15585     b         common_invokeMethodJumbo     #  (a0=method, rOBJ="this")
15586
15587
15588 /* continuation for OP_INVOKE_SUPER_JUMBO */
15589
15590     /*
15591      * At this point:
15592      *  a0 = resolved base method
15593      *  rBIX = method->clazz
15594      */
15595 .LOP_INVOKE_SUPER_JUMBO_continue:
15596     LOAD_base_offClassObject_super(a1, rBIX) #  a1 <- method->clazz->super
15597     LOADu2_offMethod_methodIndex(a2, a0)   #  a2 <- baseMethod->methodIndex
15598     LOAD_base_offClassObject_vtableCount(a3, a1) #  a3 <- super->vtableCount
15599     EXPORT_PC()                            #  must export for invoke
15600     # compare (methodIndex, vtableCount)
15601     bgeu      a2, a3, .LOP_INVOKE_SUPER_JUMBO_nsm      #  method not present in superclass
15602     LOAD_base_offClassObject_vtable(a1, a1) #  a1 <- ...clazz->super->vtable
15603     LOAD_eas2(a0, a1, a2)                  #  a0 <- vtable[methodIndex]
15604     b         common_invokeMethodJumbo     #  a0=method rOBJ="this"
15605
15606     /*
15607      * Throw a NoSuchMethodError with the method name as the message.
15608      *  a0 = resolved base method
15609      */
15610 .LOP_INVOKE_SUPER_JUMBO_nsm:
15611     LOAD_base_offMethod_name(a1, a0)       #  a1 <- method name
15612     b         common_errNoSuchMethod
15613
15614
15615 /* continuation for OP_INVOKE_STATIC_JUMBO */
15616
15617 .LOP_INVOKE_STATIC_JUMBO_resolve:
15618     LOAD_rSELF_method(a3)                  #  a3 <- self->method
15619     LOAD_base_offMethod_clazz(a0, a3)      #  a0 <- method->clazz
15620     li        a2, METHOD_STATIC            #  resolver method type
15621     JAL(dvmResolveMethod)                  #  v0 <- call(clazz, ref, flags)
15622     move      a0, v0
15623 #if defined(WITH_JIT)
15624     /*
15625      * Check to see if we're actively building a trace.  If so,
15626      * we need to keep this instruction out of it.
15627      * rBIX: &resolved_methodToCall
15628      */
15629     lhu        a2, offThread_subMode(rSELF)
15630     beqz      v0, common_exceptionThrown   #  null, handle exception
15631     and       a2, kSubModeJitTraceBuild    #  trace under construction?
15632     beqz      a2, common_invokeMethodJumboNoThis #  no, (a0=method, rOBJ="this")
15633     lw        a1, 0(rBIX)                  #  reload resolved method
15634     # finished resloving?
15635     bnez      a1, common_invokeMethodJumboNoThis #  yes, (a0=method, rOBJ="this")
15636     move      rBIX, a0                     #  preserve method
15637     move      a0, rSELF
15638     move      a1, rPC
15639     JAL(dvmJitEndTraceSelect)              #  (self, pc)
15640     move      a0, rBIX
15641     b         common_invokeMethodJumboNoThis #  whew, finally!
15642 #else
15643     # got null?
15644     bnez      v0, common_invokeMethodJumboNoThis #  (a0=method, rOBJ="this")
15645     b         common_exceptionThrown       #  yes, handle exception
15646 #endif
15647
15648 /* continuation for OP_INVOKE_OBJECT_INIT_JUMBO */
15649     /*
15650      * A debugger is attached, so we need to go ahead and do
15651      * this.  For simplicity, we'll just jump directly to the
15652      * corresponding handler.  Note that we can't use
15653      * rIBASE here because it may be in single-step mode.
15654      * Load the primary table base directly.
15655      */
15656 .LOP_INVOKE_OBJECT_INIT_JUMBO_debugger:
15657     lw      a1, offThread_mainHandlerTable(rSELF)
15658     .if 1
15659     li      t0, OP_INVOKE_DIRECT_JUMBO
15660     .else
15661     li      t0, OP_INVOKE_DIRECT_RANGE
15662     .endif
15663     GOTO_OPCODE_BASE(a1, t0)            # execute it
15664
15665 /* continuation for OP_IGET_VOLATILE_JUMBO */
15666
15667 .LOP_IGET_VOLATILE_JUMBO_resolved:
15668      # test results
15669     move      a0, v0
15670     beqz      a0,common_exceptionThrown
15671     /*
15672      * Currently:
15673      *  v0 holds resolved field
15674      *  rOBJ holds object (caller saved)
15675      */
15676 .LOP_IGET_VOLATILE_JUMBO_finish:
15677     #BAL(common_squeak0)
15678     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15679     # check object for null
15680     beqz      rOBJ, common_errNullObject   #  object was null
15681     addu      a3, a3, rOBJ                 #  form address
15682     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15683     SMP_DMB                               #  acquiring load
15684     FETCH(a2, 3)                           #  a2<- BBBB
15685     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15686     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15687     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15688     GOTO_OPCODE(t0)                        #  jump to next instruction
15689
15690
15691 /* continuation for OP_IGET_WIDE_VOLATILE_JUMBO */
15692
15693 .LOP_IGET_WIDE_VOLATILE_JUMBO_resolved:
15694     # test return code
15695     move      a0, v0
15696     bnez      v0, .LOP_IGET_WIDE_VOLATILE_JUMBO_finish
15697     b         common_exceptionThrown
15698
15699     /*
15700      * Currently:
15701      *  a0   holds resolved field
15702      *  rOBJ holds object
15703      */
15704 .LOP_IGET_WIDE_VOLATILE_JUMBO_finish:
15705     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15706     beqz      rOBJ, common_errNullObject   #  object was null
15707     GET_OPA4(a2)                           #  a2 <- A+
15708     addu      rOBJ, rOBJ, a3               #  form address
15709     .if 1
15710     vLOAD64(a0, a1, rOBJ)                  #  a0/a1 <- obj.field (64-bit align ok)
15711     .else
15712     LOAD64(a0, a1, rOBJ)                   #  a0/a1 <- obj.field (64-bit align ok)
15713     .endif
15714     FETCH(a2, 3)                           # r2<- BBBB
15715     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15716     EAS2(a3, rFP, a2)                      #  a3 <- &fp[BBBB]
15717     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15718     STORE64(a0, a1, a3)                    #  fp[BBBB] <- a0/a1
15719     GOTO_OPCODE(t0)                        #  jump to next instruction
15720
15721
15722 /* continuation for OP_IGET_OBJECT_VOLATILE_JUMBO */
15723
15724 .LOP_IGET_OBJECT_VOLATILE_JUMBO_resolved:
15725      # test results
15726     move      a0, v0
15727     beqz      a0,common_exceptionThrown
15728     /*
15729      * Currently:
15730      *  v0 holds resolved field
15731      *  rOBJ holds object (caller saved)
15732      */
15733 .LOP_IGET_OBJECT_VOLATILE_JUMBO_finish:
15734     #BAL(common_squeak0)
15735     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15736     # check object for null
15737     beqz      rOBJ, common_errNullObject   #  object was null
15738     addu      a3, a3, rOBJ                 #  form address
15739     lw a0, (a3)                         #  a0 <- obj.field (8/16/32 bits)
15740     SMP_DMB                               #  acquiring load
15741     FETCH(a2, 3)                           #  a2<- BBBB
15742     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15743     SET_VREG(a0, a2)                       #  fp[BBBB]<- a0
15744     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15745     GOTO_OPCODE(t0)                        #  jump to next instruction
15746
15747
15748 /* continuation for OP_IPUT_VOLATILE_JUMBO */
15749
15750 .LOP_IPUT_VOLATILE_JUMBO_resolved:
15751     move      a0, v0
15752     beqz      a0, common_exceptionThrown
15753     # fall through to OP_IPUT_VOLATILE_JUMBO_finish
15754
15755
15756     /*
15757      * Currently:
15758      *  a0 holds resolved field
15759      *  rOBJ holds object
15760      */
15761 .LOP_IPUT_VOLATILE_JUMBO_finish:
15762     #BAL(common_squeak0)
15763     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15764     FETCH(a1, 3)                           # a1<- BBBB
15765     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15766     # check object for null
15767     beqz      rOBJ, common_errNullObject   #  object was null
15768     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15769     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15770     addu      rOBJ, rOBJ, a3               #  form address
15771     SMP_DMB_ST                            #  releasing store
15772     sw a0, (rOBJ)                      #  obj.field (8/16/32 bits) <- a0
15773     SMP_DMB
15774     GOTO_OPCODE(t0)                        #  jump to next instruction
15775
15776
15777 /* continuation for OP_IPUT_WIDE_VOLATILE_JUMBO */
15778
15779 .LOP_IPUT_WIDE_VOLATILE_JUMBO_resolved:
15780     move      a0, v0
15781     beqz      a0, common_exceptionThrown
15782     # fall through to OP_IPUT_WIDE_VOLATILE_JUMBO_finish
15783     /*
15784      * Currently:
15785      *  a0   holds resolved field
15786      *  rOBJ holds object
15787      */
15788 .LOP_IPUT_WIDE_VOLATILE_JUMBO_finish:
15789     FETCH(a2, 3)                           # a1<- BBBB
15790     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15791     EAS2(a2, rFP, a2)                      #  a2 <- &fp[BBBB]
15792     # check object for null
15793     beqz      rOBJ, common_errNullObject   #  object was null
15794     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15795     LOAD64(a0, a1, a2)                     #  a0/a1 <- fp[BBBB]
15796     GET_INST_OPCODE(rBIX)                  #  extract opcode from rINST
15797     addu      a2, rOBJ, a3                 #  form address
15798     .if 1
15799     JAL(dvmQuasiAtomicSwap64Sync)          # stores r0/r1 into addr r2
15800 #    STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
15801     .else
15802     STORE64(a0, a1, a2)                    #  obj.field (64 bits, aligned) <- a0 a1
15803     .endif
15804     GOTO_OPCODE(rBIX)                      #  jump to next instruction
15805
15806
15807
15808 /* continuation for OP_IPUT_OBJECT_VOLATILE_JUMBO */
15809
15810     /*
15811      * Currently:
15812      *  a0 holds resolved field
15813      *  rOBJ holds object
15814      */
15815 .LOP_IPUT_OBJECT_VOLATILE_JUMBO_resolved:
15816     move      a0, v0
15817     beqz      a0, common_exceptionThrown
15818     # fall through to OP_IPUT_OBJECT_VOLATILE_JUMBO_finish
15819
15820 .LOP_IPUT_OBJECT_VOLATILE_JUMBO_finish:
15821     #BAL(common_squeak0)
15822     LOAD_base_offInstField_byteOffset(a3, a0) #  a3 <- byte offset of field
15823     FETCH(a1, 3)                              # a1<- BBBB
15824     GET_VREG(a0, a1)                       #  a0 <- fp[BBBB]
15825     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
15826     # check object for null
15827     beqz      rOBJ, common_errNullObject   #  object was null
15828     FETCH_ADVANCE_INST(5)                  #  advance rPC, load rINST
15829     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15830     addu      t2, rOBJ, a3                 #  form address
15831     SMP_DMB_ST                            #  releasing store
15832     sw a0, (t2)                        #  obj.field (32 bits) <- a0
15833     SMP_DMB
15834     beqz      a0, 1f                       #  stored a null reference?
15835     srl       t1, rOBJ, GC_CARD_SHIFT
15836     addu      t2, a2, t1
15837     sb        a2, (t2)                     #  mark card if not
15838 1:
15839     GOTO_OPCODE(t0)                        #  jump to next instruction
15840
15841
15842 /* continuation for OP_SGET_VOLATILE_JUMBO */
15843
15844 .LOP_SGET_VOLATILE_JUMBO_finish:
15845     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15846     SMP_DMB                               #  acquiring load
15847     FETCH(a2, 3)                           # r2<- BBBB
15848     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15849     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15850     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15851
15852 /* continuation for OP_SGET_WIDE_VOLATILE_JUMBO */
15853
15854 .LOP_SGET_WIDE_VOLATILE_JUMBO_finish:
15855     FETCH(a1, 3)                           # a1<- BBBB
15856     .if 1
15857     vLOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
15858     .else
15859     LOAD64_off(a2, a3, a0, offStaticField_value) #  a2/a3 <- field value (aligned)
15860     .endif
15861     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15862     EAS2(a1, rFP, a1)                      #  a1 <- &fp[BBBB]
15863     STORE64(a2, a3, a1)                    #  vBBBB/vBBBB+1 <- a2/a3
15864     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15865     GOTO_OPCODE(t0)                        #  jump to next instruction
15866
15867 /* continuation for OP_SGET_OBJECT_VOLATILE_JUMBO */
15868
15869 .LOP_SGET_OBJECT_VOLATILE_JUMBO_finish:
15870     LOAD_base_offStaticField_value(a1, a0) #  a1 <- field value
15871     SMP_DMB                               #  acquiring load
15872     FETCH(a2, 3)                           # r2<- BBBB
15873     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15874     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15875     SET_VREG_GOTO(a1, a2, t0)              #  fp[BBBB] <- a1
15876
15877 /* continuation for OP_SPUT_VOLATILE_JUMBO */
15878
15879 .LOP_SPUT_VOLATILE_JUMBO_finish:
15880     # field ptr in a0
15881     FETCH(a2, 3)                           # a2<- BBBB
15882     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15883     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15884     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15885     SMP_DMB_ST                            #  releasing store
15886     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15887     SMP_DMB
15888     GOTO_OPCODE(t0)                        #  jump to next instruction
15889
15890 /* continuation for OP_SPUT_WIDE_VOLATILE_JUMBO */
15891
15892     /*
15893      * Continuation if the field has not yet been resolved.
15894      *  a1:  AAAAAAAA field ref
15895      *  rOBJ:  &fp[BBBB]
15896      *  rBIX: dvmDex->pResFields
15897      *
15898      * Returns StaticField pointer in a2.
15899      */
15900 .LOP_SPUT_WIDE_VOLATILE_JUMBO_resolve:
15901     LOAD_rSELF_method(a2)                  #  a2 <- current method
15902 #if defined(WITH_JIT)
15903     EAS2(rBIX, rBIX, a1)                   #  rBIX<- &dvmDex->pResFields[field]
15904 #endif
15905     EXPORT_PC()                            #  resolve() could throw, so export now
15906     LOAD_base_offMethod_clazz(a0, a2)      #  a0 <- method->clazz
15907     JAL(dvmResolveStaticField)             #  v0 <- resolved StaticField ptr
15908     # success ?
15909     move      a0, v0
15910     beqz      v0, common_exceptionThrown   #  no, handle exception
15911 #if defined(WITH_JIT)
15912     /*
15913      * If the JIT is actively building a trace we need to make sure
15914      * that the field is fully resolved before including this instruction.
15915      */
15916     JAL(common_verifyField)
15917 #endif
15918     move      a2, v0
15919     b         .LOP_SPUT_WIDE_VOLATILE_JUMBO_finish           # resume
15920
15921 /* continuation for OP_SPUT_OBJECT_VOLATILE_JUMBO */
15922 .LOP_SPUT_OBJECT_VOLATILE_JUMBO_finish:                     #  field ptr in a0
15923     FETCH(a2, 3)                        # a2<- BBBB
15924     FETCH_ADVANCE_INST(4)                  #  advance rPC, load rINST
15925     GET_VREG(a1, a2)                       #  a1 <- fp[BBBB]
15926     lw        a2, offThread_cardTable(rSELF) #  a2 <- card table base
15927     lw        t1, offField_clazz(a0)       #  t1 <- field->clazz
15928     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
15929     SMP_DMB_ST                            #  releasing store
15930     sw        a1, offStaticField_value(a0) #  field <- vBBBB
15931     SMP_DMB
15932     beqz      a1, 1f
15933     srl       t2, t1, GC_CARD_SHIFT
15934     addu      t3, a2, t2
15935     sb        a2, (t3)
15936     1:
15937     GOTO_OPCODE(t0)                        #  jump to next instruction
15938
15939     .size   dvmAsmSisterStart, .-dvmAsmSisterStart
15940     .global dvmAsmSisterEnd
15941 dvmAsmSisterEnd:
15942
15943 /* File: mips/footer.S */
15944 /*
15945  * ===========================================================================
15946  *  Common subroutines and data
15947  * ===========================================================================
15948  */
15949
15950     .text
15951     .align 2
15952
15953 #if defined(WITH_JIT)
15954 #if defined(WITH_SELF_VERIFICATION)
15955
15956 /*
15957  * "longjmp" to a translation after single-stepping.  Before returning
15958  * to translation, must save state for self-verification.
15959  */
15960     .global dvmJitResumeTranslation             # (Thread* self, u4* dFP)
15961 dvmJitResumeTranslation:
15962     move    rSELF, a0                           # restore self
15963     move    rPC, a1                             # restore Dalvik pc
15964     move    rFP, a2                             # restore Dalvik fp
15965     lw      rBIX, offThread_jitResumeNPC(rSELF)
15966     sw      zero, offThread_jitResumeNPC(rSELF) # reset resume address
15967     lw      sp, offThread_jitResumeNSP(rSELF)   # cut back native stack
15968     b       jitSVShadowRunStart                 # resume as if cache hit
15969                                                 # expects resume addr in rBIX
15970
15971     .global dvmJitToInterpPunt
15972 dvmJitToInterpPunt:
15973     li        a2, kSVSPunt                 #  a2 <- interpreter entry point
15974     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
15975     b         jitSVShadowRunEnd            #  doesn't return
15976
15977     .global dvmJitToInterpSingleStep
15978 dvmJitToInterpSingleStep:
15979     move      rPC, a0                      # set up dalvik pc
15980     EXPORT_PC()
15981     sw        ra, offThread_jitResumeNPC(rSELF)
15982     sw        a1, offThread_jitResumeDPC(rSELF)
15983     li        a2, kSVSSingleStep           #  a2 <- interpreter entry point
15984     b         jitSVShadowRunEnd            #  doesn't return
15985
15986     .global dvmJitToInterpNoChainNoProfile
15987 dvmJitToInterpNoChainNoProfile:
15988     move      a0, rPC                      #  pass our target PC
15989     li        a2, kSVSNoProfile            #  a2 <- interpreter entry point
15990     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
15991     b         jitSVShadowRunEnd            #  doesn't return
15992
15993     .global dvmJitToInterpTraceSelectNoChain
15994 dvmJitToInterpTraceSelectNoChain:
15995     move      a0, rPC                      #  pass our target PC
15996     li        a2, kSVSTraceSelect          #  a2 <- interpreter entry point
15997     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
15998     b         jitSVShadowRunEnd            #  doesn't return
15999
16000     .global dvmJitToInterpTraceSelect
16001 dvmJitToInterpTraceSelect:
16002     lw        a0, 0(ra)                   #  pass our target PC
16003     li        a2, kSVSTraceSelect          #  a2 <- interpreter entry point
16004     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
16005     b         jitSVShadowRunEnd            #  doesn't return
16006
16007     .global dvmJitToInterpBackwardBranch
16008 dvmJitToInterpBackwardBranch:
16009     lw        a0, 0(ra)                   #  pass our target PC
16010     li        a2, kSVSBackwardBranch       #  a2 <- interpreter entry point
16011     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
16012     b         jitSVShadowRunEnd            #  doesn't return
16013
16014     .global dvmJitToInterpNormal
16015 dvmJitToInterpNormal:
16016     lw        a0, 0(ra)                   #  pass our target PC
16017     li        a2, kSVSNormal               #  a2 <- interpreter entry point
16018     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
16019     b         jitSVShadowRunEnd            #  doesn't return
16020
16021     .global dvmJitToInterpNoChain
16022 dvmJitToInterpNoChain:
16023     move      a0, rPC                      #  pass our target PC
16024     li        a2, kSVSNoChain              #  a2 <- interpreter entry point
16025     sw        zero, offThread_inJitCodeCache(rSELF) #  Back to the interp land
16026     b         jitSVShadowRunEnd            #  doesn't return
16027 #else                                   /*  WITH_SELF_VERIFICATION */
16028
16029
16030 /*
16031  * "longjmp" to a translation after single-stepping.
16032  */
16033     .global dvmJitResumeTranslation             # (Thread* self, u4* dFP)
16034 dvmJitResumeTranslation:
16035     move    rSELF, a0                           # restore self
16036     move    rPC, a1                             # restore Dalvik pc
16037     move    rFP, a2                             # restore Dalvik fp
16038     lw      a0, offThread_jitResumeNPC(rSELF)
16039     sw      zero, offThread_jitResumeNPC(rSELF) # reset resume address
16040     lw      sp, offThread_jitResumeNSP(rSELF)   # cut back native stack
16041     jr      a0                                  # resume translation
16042
16043
16044 /*
16045  * Return from the translation cache to the interpreter when the compiler is
16046  * having issues translating/executing a Dalvik instruction. We have to skip
16047  * the code cache lookup otherwise it is possible to indefinitely bouce
16048  * between the interpreter and the code cache if the instruction that fails
16049  * to be compiled happens to be at a trace start.
16050  */
16051     .global dvmJitToInterpPunt
16052 dvmJitToInterpPunt:
16053     lw        gp, STACK_OFFSET_GP(sp)
16054     move      rPC, a0
16055 #if defined(WITH_JIT_TUNING)
16056     move      a0, ra
16057     JAL(dvmBumpPunt)
16058 #endif
16059     EXPORT_PC()
16060     sw        zero, offThread_inJitCodeCache(rSELF) # Back to the interp land
16061     lw        rIBASE, offThread_curHandlerTable(rSELF)
16062     FETCH_INST()
16063     GET_INST_OPCODE(t0)
16064     GOTO_OPCODE(t0)
16065
16066 /*
16067  * Return to the interpreter to handle a single instruction.
16068  * On entry:
16069  *    rPC <= Dalvik PC of instrucion to interpret
16070  *    a1 <= Dalvik PC of resume instruction
16071  *    ra <= resume point in translation
16072  */
16073
16074     .global dvmJitToInterpSingleStep
16075 dvmJitToInterpSingleStep:
16076     lw        gp, STACK_OFFSET_GP(sp)
16077     move      rPC, a0                       # set up dalvik pc
16078     EXPORT_PC()
16079     sw        ra, offThread_jitResumeNPC(rSELF)
16080     sw        sp, offThread_jitResumeNSP(rSELF)
16081     sw        a1, offThread_jitResumeDPC(rSELF)
16082     li        a1, 1
16083     sw        a1, offThread_singleStepCount(rSELF) # just step once
16084     move      a0, rSELF
16085     li        a1, kSubModeCountedStep
16086     JAL(dvmEnableSubMode)                   # (self, subMode)
16087     lw        rIBASE, offThread_curHandlerTable(rSELF)
16088     FETCH_INST()
16089     GET_INST_OPCODE(t0)
16090     GOTO_OPCODE(t0)
16091 /*
16092  * Return from the translation cache and immediately request
16093  * a translation for the exit target.  Commonly used for callees.
16094  */
16095     .global dvmJitToInterpTraceSelectNoChain
16096 dvmJitToInterpTraceSelectNoChain:
16097     lw        gp, STACK_OFFSET_GP(sp)
16098 #if defined(WITH_JIT_TUNING)
16099     JAL(dvmBumpNoChain)
16100 #endif
16101     move      a0, rPC
16102     move      a1, rSELF
16103     JAL(dvmJitGetTraceAddrThread)          # (pc, self)
16104     move      a0, v0
16105     sw        a0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag
16106     move      a1, rPC                      # arg1 of translation may need this
16107     move      ra, zero                     #  in case target is HANDLER_INTERPRET
16108     beqz      a0, 2f                       # 0 means translation does not exist
16109     jr        a0
16110
16111 /*
16112  * Return from the translation cache and immediately request
16113  * a translation for the exit target.  Commonly used following
16114  * invokes.
16115  */
16116     .global dvmJitToInterpTraceSelect
16117 dvmJitToInterpTraceSelect:
16118     lw        gp, STACK_OFFSET_GP(sp)
16119     lw        rPC, (ra)                    #  get our target PC
16120     subu      rINST, ra, 8                 #  save start of chain branch
16121     move      a0, rPC
16122     move      a1, rSELF
16123     JAL(dvmJitGetTraceAddrThread)          # @ (pc, self)
16124     sw        v0, offThread_inJitCodeCache(rSELF) # set the inJitCodeCache flag
16125     beqz      v0, 2f
16126     move      a0, v0
16127     move      a1, rINST
16128     JAL(dvmJitChain)                       #  v0 <- dvmJitChain(codeAddr, chainAddr)
16129     move      a1, rPC                      #  arg1 of translation may need this
16130     move      ra, zero                     #  in case target is HANDLER_INTERPRET
16131     move      a0, v0
16132     beqz      a0, toInterpreter            #  didn't chain - resume with interpreter
16133
16134     jr        a0                           #  continue native execution
16135
16136 /* No translation, so request one if profiling isn't disabled */
16137 2:
16138     lw        rIBASE, offThread_curHandlerTable(rSELF)
16139     lw        a0, offThread_pJitProfTable(rSELF)
16140     FETCH_INST()
16141     li        t0, kJitTSelectRequestHot
16142     movn      a2, t0, a0                   #  ask for trace selection
16143     bnez      a0, common_selectTrace
16144     GET_INST_OPCODE(t0)
16145     GOTO_OPCODE(t0)
16146
16147 /*
16148  * Return from the translation cache to the interpreter.
16149  * The return was done with a BLX from thumb mode, and
16150  * the following 32-bit word contains the target rPC value.
16151  * Note that lr (r14) will have its low-order bit set to denote
16152  * its thumb-mode origin.
16153  *
16154  * We'll need to stash our lr origin away, recover the new
16155  * target and then check to see if there is a translation available
16156  * for our new target.  If so, we do a translation chain and
16157  * go back to native execution.  Otherwise, it's back to the
16158  * interpreter (after treating this entry as a potential
16159  * trace start).
16160  */
16161     .global dvmJitToInterpNormal
16162 dvmJitToInterpNormal:
16163     lw        gp, STACK_OFFSET_GP(sp)
16164     lw        rPC, (ra)                    #  get our target PC
16165     subu      rINST, ra, 8                 #  save start of chain branch
16166 #if defined(WITH_JIT_TUNING)
16167     JAL(dvmBumpNormal)
16168 #endif
16169     move      a0, rPC
16170     move      a1, rSELF
16171     JAL(dvmJitGetTraceAddrThread)           # @ (pc, self)
16172     move      a0, v0
16173     sw        a0, offThread_inJitCodeCache(rSELF) #  set the inJitCodeCache flag
16174     beqz      a0, toInterpreter            #  go if not, otherwise do chain
16175     move      a1, rINST
16176     JAL(dvmJitChain)                       #  v0 <- dvmJitChain(codeAddr, chainAddr)
16177     move      a1, rPC                      #  arg1 of translation may need this
16178     move      ra, zero                     #  in case target is HANDLER_INTERPRET
16179     move      a0, v0
16180     beqz      a0, toInterpreter            #  didn't chain - resume with interpreter
16181
16182     jr        a0                           #  continue native execution
16183
16184 /*
16185  * Return from the translation cache to the interpreter to do method invocation.
16186  * Check if translation exists for the callee, but don't chain to it.
16187  */
16188     .global dvmJitToInterpNoChainNoProfile
16189 dvmJitToInterpNoChainNoProfile:
16190 #if defined(WITH_JIT_TUNING)
16191     JAL(dvmBumpNoChain)
16192 #endif
16193     move      a0, rPC
16194     move      a1, rSELF
16195     JAL(dvmJitGetTraceAddrThread)          # (pc, self)
16196     move      a0, v0
16197     sw        a0, offThread_inJitCodeCache(rSELF) #  set the inJitCodeCache flag
16198     move      a1, rPC                      #  arg1 of translation may need this
16199     move      ra, zero                     #  in case target is HANDLER_INTERPRET
16200     beqz      a0, footer235
16201
16202     jr        a0                           #  continue native execution if so
16203 footer235:
16204     EXPORT_PC()
16205     lw        rIBASE, offThread_curHandlerTable(rSELF)
16206     FETCH_INST()
16207     GET_INST_OPCODE(t0)                    #  extract opcode from rINST
16208     GOTO_OPCODE(t0)                        #  jump to next instruction
16209
16210 /*
16211  * Return from the translation cache to the interpreter to do method invocation.
16212  * Check if translation exists for the callee, but don't chain to it.
16213  */
16214
16215     .global dvmJitToInterpNoChain
16216 dvmJitToInterpNoChain:
16217     lw        gp, STACK_OFFSET_GP(sp)
16218 #if defined(WITH_JIT_TUNING)
16219     JAL(dvmBumpNoChain)
16220 #endif
16221     move      a0, rPC
16222     move      a1, rSELF
16223     JAL(dvmJitGetTraceAddrThread)          # (pc, self)
16224     move      a0, v0
16225     sw        a0, offThread_inJitCodeCache(rSELF) #  set the inJitCodeCache flag
16226     move      a1, rPC                      #  arg1 of translation may need this
16227     move      ra, zero                     #  in case target is HANDLER_INTERPRET
16228     beqz      a0, 1f
16229     jr        a0                           #  continue native execution if so
16230 1:
16231 #endif                                  /*  WITH_SELF_VERIFICATION */
16232
16233 /*
16234  * No translation, restore interpreter regs and start interpreting.
16235  * rSELF & rFP were preserved in the translated code, and rPC has
16236  * already been restored by the time we get here.  We'll need to set
16237  * up rIBASE & rINST, and load the address of the JitTable into r0.
16238  */
16239
16240 toInterpreter:
16241     EXPORT_PC()
16242     lw        rIBASE, offThread_curHandlerTable(rSELF)
16243     FETCH_INST()
16244     lw        a0, offThread_pJitProfTable(rSELF)
16245     lw        rIBASE, offThread_curHandlerTable(rSELF)
16246     # NOTE: intended fallthrough
16247
16248 /*
16249  * Similar to common_updateProfile, but tests for null pJitProfTable
16250  * r0 holds pJifProfTAble, rINST is loaded, rPC is current and
16251  * rIBASE has been recently refreshed.
16252  */
16253
16254 common_testUpdateProfile:
16255
16256     beqz      a0, 4f
16257
16258 /*
16259  * Common code to update potential trace start counter, and initiate
16260  * a trace-build if appropriate.
16261  * On entry here:
16262  *    r0    <= pJitProfTable (verified non-NULL)
16263  *    rPC   <= Dalvik PC
16264  *    rINST <= next instruction
16265  */
16266 common_updateProfile:
16267     srl       a3, rPC, 12                  #  cheap, but fast hash function
16268     xor       a3, a3, rPC
16269     andi      a3, a3, JIT_PROF_SIZE-1      #  eliminate excess bits
16270     addu      t1, a0, a3
16271     lbu       a1, (t1)                     #  get counter
16272     GET_INST_OPCODE(t0)
16273     subu      a1, a1, 1                    #  decrement counter
16274     sb        a1, (t1)                     #  and store it
16275     beqz      a1, 1f
16276     GOTO_OPCODE(t0)                        #  if not threshold, fallthrough otherwise
16277 1:
16278     /* Looks good, reset the counter */
16279     lw        a1, offThread_jitThreshold(rSELF)
16280     sb        a1, (t1)
16281     EXPORT_PC()
16282     move      a0, rPC
16283     move      a1, rSELF
16284     JAL(dvmJitGetTraceAddrThread)          # (pc, self)
16285     move      a0, v0
16286     sw        v0, offThread_inJitCodeCache(rSELF) #  set the inJitCodeCache flag
16287     move      a1, rPC                      #  arg1 of translation may need this
16288     move      ra, zero                     #  in case target is HANDLER_INTERPRET
16289
16290 #if !defined(WITH_SELF_VERIFICATION)
16291     li        t0, kJitTSelectRequest       #  ask for trace selection
16292     movz      a2, t0, a0
16293     beqz      a0, common_selectTrace
16294     jr        a0                           #  jump to the translation
16295 #else
16296
16297     bne       a0, zero, skip_ask_for_trace_selection
16298     li        a2, kJitTSelectRequest       #  ask for trace selection
16299     j         common_selectTrace
16300
16301 skip_ask_for_trace_selection:
16302     /*
16303      * At this point, we have a target translation.  However, if
16304      * that translation is actually the interpret-only pseudo-translation
16305      * we want to treat it the same as no translation.
16306      */
16307     move      rBIX, a0                     #  save target
16308     jal       dvmCompilerGetInterpretTemplate
16309     # special case?
16310     bne       v0, rBIX, jitSVShadowRunStart  #  set up self verification shadow space
16311     # Need to clear the inJitCodeCache flag
16312     sw        zero, offThread_inJitCodeCache(rSELF) #  back to the interp land
16313     GET_INST_OPCODE(t0)
16314     GOTO_OPCODE(t0)
16315     /* no return */
16316 #endif
16317
16318 /*
16319  * On entry:
16320  *  r2 is jit state.
16321  */
16322
16323 common_selectTrace:
16324     lhu        a0, offThread_subMode(rSELF)
16325     andi       a0, (kSubModeJitTraceBuild | kSubModeJitSV)
16326     bnez       a0, 3f                      # already doing JIT work, continue
16327     sw         a2, offThread_jitState(rSELF)
16328     move       a0, rSELF
16329
16330 /*
16331  * Call out to validate trace-building request.  If successful,
16332  * rIBASE will be swapped to to send us into single-stepping trace
16333  * building mode, so we need to refresh before we continue.
16334  */
16335
16336     EXPORT_PC()
16337     SAVE_PC_TO_SELF()
16338     SAVE_FP_TO_SELF()
16339     JAL(dvmJitCheckTraceRequest)
16340 3:
16341     FETCH_INST()
16342     lw        rIBASE, offThread_curHandlerTable(rSELF)
16343 4:
16344     GET_INST_OPCODE(t0)                    # extract opcode from rINST
16345     GOTO_OPCODE(t0)
16346     /* no return */
16347 #endif
16348
16349 #if defined(WITH_SELF_VERIFICATION)
16350
16351 /*
16352  * Save PC and registers to shadow memory for self verification mode
16353  * before jumping to native translation.
16354  * On entry:
16355  *    rPC, rFP, rSELF: the values that they should contain
16356  *    r10: the address of the target translation.
16357  */
16358 jitSVShadowRunStart:
16359     move      a0, rPC                      #  r0 <- program counter
16360     move      a1, rFP                      #  r1 <- frame pointer
16361     move      a2, rSELF                    #  r2 <- InterpState pointer
16362     move      a3, rBIX                     #  r3 <- target translation
16363     jal       dvmSelfVerificationSaveState #  save registers to shadow space
16364     lw        rFP, offShadowSpace_shadowFP(v0) #  rFP <- fp in shadow space
16365     jr        rBIX                         #  jump to the translation
16366
16367 /*
16368  * Restore PC, registers, and interpState to original values
16369  * before jumping back to the interpreter.
16370  */
16371 jitSVShadowRunEnd:
16372     move      a1, rFP                      #  pass ending fp
16373     move      a3, rSELF                    #  pass self ptr for convenience
16374     jal       dvmSelfVerificationRestoreState #  restore pc and fp values
16375     LOAD_PC_FP_FROM_SELF()                 #  restore pc, fp
16376     lw        a1, offShadowSpace_svState(a0) #  get self verification state
16377     beq       a1, zero, 1f                 #  check for punt condition
16378
16379     # Setup SV single-stepping
16380     move      a0, rSELF
16381     li        a1, kSubModeJitSV
16382     JAL(dvmEnableSubMode)                  # (self, subMode)
16383     li        a2, kJitSelfVerification     #  ask for self verification
16384     sw        a2, offThread_jitState(rSELF)
16385     # Intentional fallthrough
16386
16387 1:
16388     # exit to interpreter without check
16389     EXPORT_PC()
16390     lw        rIBASE, offThread_curHandlerTable(rSELF)
16391     FETCH_INST()
16392     GET_INST_OPCODE(t0)
16393     GOTO_OPCODE(t0)
16394 #endif
16395
16396 /*
16397  * The equivalent of "goto bail", this calls through the "bail handler".
16398  * It will end this interpreter activation, and return to the caller
16399  * of dvmMterpStdRun.
16400  *
16401  * State registers will be saved to the "thread" area before bailing
16402  * debugging purposes
16403  */
16404     .ent common_gotoBail
16405 common_gotoBail:
16406     SAVE_PC_FP_TO_SELF()                   # export state to "thread"
16407     move      a0, rSELF                    # a0 <- self ptr
16408     b         dvmMterpStdBail              # call(self, changeInterp)
16409     .end common_gotoBail
16410
16411 /*
16412  * The JIT's invoke method needs to remember the callsite class and
16413  * target pair.  Save them here so that they are available to
16414  * dvmCheckJit following the interpretation of this invoke.
16415  */
16416 #if defined(WITH_JIT)
16417 save_callsiteinfo:
16418     beqz    rOBJ, 1f
16419     lw      rOBJ, offObject_clazz(rOBJ)
16420 1:
16421     sw      a0, offThread_methodToCall(rSELF)
16422     sw      rOBJ, offThread_callsiteClass(rSELF)
16423     jr      ra
16424 #endif
16425
16426 /*
16427  * Common code for jumbo method invocation.
16428  * NOTE: this adjusts rPC to account for the difference in instruction width.
16429  * As a result, the savedPc in the stack frame will not be wholly accurate. So
16430  * long as that is only used for source file line number calculations, we're
16431  * okay.
16432  */
16433 common_invokeMethodJumboNoThis:
16434 #if defined(WITH_JIT)
16435  /* On entry: a0 is "Method* methodToCall */
16436     li       rOBJ, 0                     # clear "this"
16437 #endif
16438 common_invokeMethodJumbo:
16439  /* On entry: a0 is "Method* methodToCall, rOBJ is "this" */
16440 .LinvokeNewJumbo:
16441 #if defined(WITH_JIT)
16442     lhu      a1, offThread_subMode(rSELF)
16443     andi     a1, kSubModeJitTraceBuild
16444     beqz     a1, 1f
16445     JAL(save_callsiteinfo)
16446 #endif
16447 /* prepare to copy args to "outs" area of current frame */
16448 1:
16449     add      rPC, rPC, 4          # adjust pc to make return consistent
16450     FETCH(a2, 1)
16451     SAVEAREA_FROM_FP(rBIX, rFP)   # rBIX <- stack save area
16452     beqz     a2, .LinvokeArgsDone  # if no args, skip the rest
16453     FETCH(a1, 2)                  # a1 <- CCCC
16454     b         .LinvokeRangeArgs   # handle args like invoke range
16455
16456
16457 /*
16458  * Common code for method invocation with range.
16459  *
16460  * On entry:
16461  *  a0 is "Method* methodToCall", the method we're trying to call
16462  */
16463 common_invokeMethodRange:
16464 .LinvokeNewRange:
16465 #if defined(WITH_JIT)
16466     lhu      a1, offThread_subMode(rSELF)
16467     andi     a1, kSubModeJitTraceBuild
16468     beqz     a1, 1f
16469     JAL(save_callsiteinfo)
16470 #endif
16471     # prepare to copy args to "outs" area of current frame
16472 1:
16473     GET_OPA(a2)
16474     SAVEAREA_FROM_FP(rBIX, rFP)              #  rBIX <- stack save area
16475     beqz      a2, .LinvokeArgsDone
16476     FETCH(a1, 2)                           #  a1 <- CCCC
16477 .LinvokeRangeArgs:
16478     # a0=methodToCall, a1=CCCC, a2=count, rBIX=outs
16479     # (very few methods have > 10 args; could unroll for common cases)
16480     EAS2(a3, rFP, a1)
16481     sll       t0, a2, 2
16482     subu      rBIX, rBIX, t0
16483
16484 1:
16485     lw        a1, 0(a3)
16486     addu      a3, a3, 4
16487     subu      a2, a2, 1
16488     sw        a1, 0(rBIX)
16489     addu      rBIX, 4
16490     bnez      a2, 1b
16491     b         .LinvokeArgsDone
16492
16493 /*
16494  * Common code for method invocation without range.
16495  *
16496  * On entry:
16497  *  a0 is "Method* methodToCall", "rOBJ is this"
16498  */
16499 common_invokeMethodNoRange:
16500 .LinvokeNewNoRange:
16501 #if defined(WITH_JIT)
16502     lhu      a1, offThread_subMode(rSELF)
16503     andi     a1, kSubModeJitTraceBuild
16504     beqz     a1, 1f
16505     JAL(save_callsiteinfo)
16506 #endif
16507
16508     # prepare to copy args to "outs" area of current frame
16509 1:
16510     GET_OPB(a2)
16511     SAVEAREA_FROM_FP(rBIX, rFP)
16512     beqz      a2, .LinvokeArgsDone
16513     FETCH(a1, 2)
16514
16515     # a0=methodToCall, a1=GFED, a2=count,
16516 .LinvokeNonRange:
16517     beq       a2, 0, 0f
16518     beq       a2, 1, 1f
16519     beq       a2, 2, 2f
16520     beq       a2, 3, 3f
16521     beq       a2, 4, 4f
16522     beq       a2, 5, 5f
16523
16524 5:
16525     and       t0, rINST, 0x0f00
16526     ESRN(t2, rFP, t0, 6)
16527     lw        a3, (t2)
16528     subu      rBIX, 4
16529     sw        a3, 0(rBIX)
16530
16531 4:
16532     and       t0, a1, 0xf000
16533     ESRN(t2, rFP, t0, 10)
16534     lw        a3, (t2)
16535     subu      rBIX, 4
16536     sw        a3, 0(rBIX)
16537
16538 3:
16539     and       t0, a1, 0x0f00
16540     ESRN(t2, rFP, t0, 6)
16541     lw        a3, (t2)
16542     subu      rBIX, 4
16543     sw        a3, 0(rBIX)
16544
16545 2:
16546     and       t0, a1, 0x00f0
16547     ESRN(t2, rFP, t0, 2)
16548     lw        a3, (t2)
16549     subu      rBIX, 4
16550     sw        a3, 0(rBIX)
16551
16552 1:
16553     and       t0, a1, 0x000f
16554     EASN(t2, rFP, t0, 2)
16555     lw        a3, (t2)
16556     subu      rBIX, 4
16557     sw        a3, 0(rBIX)
16558
16559 0:
16560     #fall through .LinvokeArgsDone
16561
16562
16563 .LinvokeArgsDone:                          #  a0=methodToCall
16564     lhu       rOBJ, offMethod_registersSize(a0)
16565     lhu       a3, offMethod_outsSize(a0)
16566     lw        a2, offMethod_insns(a0)
16567     lw        rINST, offMethod_clazz(a0)
16568     # find space for the new stack frame, check for overflow
16569     SAVEAREA_FROM_FP(a1, rFP)              # a1 <- stack save area
16570     sll       t0, rOBJ, 2                    #  a1 <- newFp (old savearea - regsSize)
16571     subu      a1, a1, t0
16572     SAVEAREA_FROM_FP(rBIX, a1)
16573     lw        rOBJ, offThread_interpStackEnd(rSELF) #  t3 <- interpStackEnd
16574     sll       t2, a3, 2
16575     subu      t0, rBIX, t2
16576     lhu       ra, offThread_subMode(rSELF)
16577     lw        a3, offMethod_accessFlags(a0) #  a3 <- methodToCall->accessFlags
16578     bltu      t0, rOBJ, .LstackOverflow      #  yes, this frame will overflow stack
16579
16580
16581     # set up newSaveArea
16582 #ifdef EASY_GDB
16583     SAVEAREA_FROM_FP(t0, rFP)
16584     sw        t0, offStackSaveArea_prevSave(rBIX)
16585 #endif
16586     sw        rFP, (offStackSaveArea_prevFrame)(rBIX)
16587     sw        rPC, (offStackSaveArea_savedPc)(rBIX)
16588 #if defined(WITH_JIT)
16589     sw        zero, (offStackSaveArea_returnAddr)(rBIX)
16590 #endif
16591     sw        a0, (offStackSaveArea_method)(rBIX)
16592     # Profiling?
16593     bnez       ra, 2f
16594 1:
16595     and       t2, a3, ACC_NATIVE
16596     bnez      t2, .LinvokeNative
16597     lhu       rOBJ, (a2)           # rOBJ -< load Inst from New PC
16598     lw        a3, offClassObject_pDvmDex(rINST)
16599     move      rPC, a2              # Publish new rPC
16600     # Update state values for the new method
16601     # a0=methodToCall, a1=newFp, a3=newMethodClass, rOBJ=newINST
16602     sw        a0, offThread_method(rSELF)
16603     sw        a3, offThread_methodClassDex(rSELF)
16604     li        a2, 1
16605     sw        a2, offThread_debugIsMethodEntry(rSELF)
16606
16607 #if defined(WITH_JIT)
16608     lw        a0, offThread_pJitProfTable(rSELF)
16609     move      rFP, a1                    # fp = newFp
16610     GET_PREFETCHED_OPCODE(t0, rOBJ)      # extract prefetched opcode from rOBJ
16611     move      rINST, rOBJ                # publish new rINST
16612     sw        a1, offThread_curFrame(rSELF)
16613     bnez      a0, common_updateProfile
16614     GOTO_OPCODE(t0)
16615 #else
16616     move      rFP, a1
16617     GET_PREFETCHED_OPCODE(t0, rOBJ)
16618     move      rINST, rOBJ
16619     sw        a1, offThread_curFrame(rSELF)
16620     GOTO_OPCODE(t0)
16621 #endif
16622
16623 2:
16624     # Profiling - record method entry.  a0: methodToCall
16625     STACK_STORE(a0, 0)
16626     STACK_STORE(a1, 4)
16627     STACK_STORE(a2, 8)
16628     STACK_STORE(a3, 12)
16629     sw       rPC, offThread_pc(rSELF)          # update interpSave.pc
16630     move     a1, a0
16631     move     a0, rSELF
16632     JAL(dvmReportInvoke)
16633     STACK_LOAD(a3, 12)                         # restore a0-a3
16634     STACK_LOAD(a2, 8)
16635     STACK_LOAD(a1, 4)
16636     STACK_LOAD(a0, 0)
16637     b        1b
16638 .LinvokeNative:
16639     # Prep for the native call
16640     # a0=methodToCall, a1=newFp, rBIX=newSaveArea
16641     lhu       ra, offThread_subMode(rSELF)
16642     lw        t3, offThread_jniLocal_topCookie(rSELF)
16643     sw        a1, offThread_curFrame(rSELF)
16644     sw        t3, offStackSaveArea_localRefCookie(rBIX) # newFp->localRefCookie=top
16645     move      a2, a0
16646     move      a0, a1
16647     addu      a1, rSELF, offThread_retval
16648     move      a3, rSELF
16649 #ifdef ASSIST_DEBUGGER
16650     /* insert fake function header to help gdb find the stack frame */
16651     b         .Lskip
16652     .ent dalvik_mterp
16653 dalvik_mterp:
16654     STACK_STORE_FULL()
16655 .Lskip:
16656 #endif
16657     bnez      ra, 11f                          # Any special SubModes active?
16658     lw        t9, offMethod_nativeFunc(a2)
16659     jalr      t9
16660     lw        gp, STACK_OFFSET_GP(sp)
16661 7:
16662     # native return; rBIX=newSaveArea
16663     # equivalent to dvmPopJniLocals
16664     lw        a0, offStackSaveArea_localRefCookie(rBIX)
16665     lw        a1, offThread_exception(rSELF)
16666     sw        rFP, offThread_curFrame(rSELF)
16667     sw        a0, offThread_jniLocal_topCookie(rSELF)    # new top <- old top
16668     bnez      a1, common_exceptionThrown
16669
16670     FETCH_ADVANCE_INST(3)
16671     GET_INST_OPCODE(t0)
16672     GOTO_OPCODE(t0)
16673 11:
16674     # a0=newFp, a1=&retval, a2=methodToCall, a3=self, ra=subModes
16675     SCRATCH_STORE(a0, 0)
16676     SCRATCH_STORE(a1, 4)
16677     SCRATCH_STORE(a2, 8)
16678     SCRATCH_STORE(a3, 12)
16679     move      a0, a2                    # a0 <- methodToCall
16680     move      a1, rSELF
16681     move      a2, rFP
16682     JAL(dvmReportPreNativeInvoke)       # (methodToCall, self, fp)
16683     SCRATCH_LOAD(a3, 12)                         # restore a0-a3
16684     SCRATCH_LOAD(a2, 8)
16685     SCRATCH_LOAD(a1, 4)
16686     SCRATCH_LOAD(a0, 0)
16687
16688     # Call the native method
16689     lw       t9, offMethod_nativeFunc(a2)      # t9<-methodToCall->nativeFunc
16690     jalr     t9
16691     lw       gp, STACK_OFFSET_GP(sp)
16692
16693     # Restore the pre-call arguments
16694     SCRATCH_LOAD(a3, 12)                         # restore a0-a3
16695     SCRATCH_LOAD(a2, 8)
16696     SCRATCH_LOAD(a1, 4)
16697     SCRATCH_LOAD(a0, 0)
16698
16699     # Finish up any post-invoke subMode requirements
16700     move      a0, a2
16701     move      a1, rSELF
16702     move      a2, rFP
16703     JAL(dvmReportPostNativeInvoke)      # (methodToCall, self, fp)
16704     b         7b
16705
16706
16707 .LstackOverflow:       # a0=methodToCall
16708     move      a1, a0                    #  a1 <- methodToCall
16709     move      a0, rSELF                 # a0 <- self
16710     JAL(dvmHandleStackOverflow)         #  dvmHandleStackOverflow(self, methodToCall)
16711     b         common_exceptionThrown
16712 #ifdef ASSIST_DEBUGGER
16713     .end dalvik_mterp
16714 #endif
16715
16716     /*
16717      * Common code for method invocation, calling through "glue code".
16718      *
16719      * TODO: now that we have range and non-range invoke handlers, this
16720      *       needs to be split into two.  Maybe just create entry points
16721      *       that set r9 and jump here?
16722      *
16723      * On entry:
16724      *  r0 is "Method* methodToCall", the method we're trying to call
16725      *  r9 is "bool methodCallRange", indicating if this is a /range variant
16726      */
16727
16728 /*
16729  * Common code for handling a return instruction.
16730  *
16731  * This does not return.
16732  */
16733 common_returnFromMethod:
16734 .LreturnNew:
16735     lhu       t0, offThread_subMode(rSELF)
16736     SAVEAREA_FROM_FP(a0, rFP)
16737     lw        rOBJ, offStackSaveArea_savedPc(a0) # rOBJ = saveArea->savedPc
16738     bnez      t0, 19f
16739 14:
16740     lw        rFP, offStackSaveArea_prevFrame(a0) # fp = saveArea->prevFrame
16741     lw        a2, (offStackSaveArea_method - sizeofStackSaveArea)(rFP)
16742                                                # a2<- method we're returning to
16743     # is this a break frame?
16744     beqz      a2, common_gotoBail              # break frame, bail out completely
16745
16746     lw        rBIX, offMethod_clazz(a2)        # rBIX<- method->clazz
16747     lw        rIBASE, offThread_curHandlerTable(rSELF) # refresh rIBASE
16748     PREFETCH_ADVANCE_INST(rINST, rOBJ, 3)      # advance rOBJ, update new rINST
16749     sw        a2, offThread_method(rSELF)      # self->method = newSave->method
16750     lw        a1, offClassObject_pDvmDex(rBIX) # r1<- method->clazz->pDvmDex
16751     sw        rFP, offThread_curFrame(rSELF)   # curFrame = fp
16752 #if defined(WITH_JIT)
16753     lw         rBIX, offStackSaveArea_returnAddr(a0)
16754     move       rPC, rOBJ                       # publish new rPC
16755     sw         a1, offThread_methodClassDex(rSELF)
16756     sw         rBIX, offThread_inJitCodeCache(rSELF) # may return to JIT'ed land
16757     beqz       rBIX, 15f                       # caller is compiled code
16758     move       t9, rBIX
16759     jalr       t9
16760     lw         gp, STACK_OFFSET_GP(sp)
16761 15:
16762     GET_INST_OPCODE(t0)                        # extract opcode from rINST
16763     GOTO_OPCODE(t0)                            # jump to next instruction
16764 #else
16765     GET_INST_OPCODE(t0)                        # extract opcode from rINST
16766     move       rPC, rOBJ                       # publish new rPC
16767     sw         a1, offThread_methodClassDex(rSELF)
16768     GOTO_OPCODE(t0)
16769 #endif
16770
16771 19:
16772     # Handle special actions
16773     # On entry, a0: StackSaveArea
16774     lw         a1, offStackSaveArea_prevFrame(a0) # a1<- prevFP
16775     sw         rPC, offThread_pc(rSELF)        # update interpSave.pc
16776     sw         a1, offThread_curFrame(rSELF)   # update interpSave.curFrame
16777     move       a0, rSELF
16778     JAL(dvmReportReturn)
16779     SAVEAREA_FROM_FP(a0, rFP)                  # restore StackSaveArea
16780     b          14b
16781
16782     .if 0
16783     /*
16784      * Return handling, calls through "glue code".
16785      */
16786 .LreturnOld:
16787     SAVE_PC_FP_TO_SELF()                       # export state
16788     move       a0, rSELF                       # arg to function
16789     JAL(dvmMterp_returnFromMethod)
16790     b          common_resumeAfterGlueCall
16791     .endif
16792
16793 /*
16794  * Somebody has thrown an exception.  Handle it.
16795  *
16796  * If the exception processing code returns to us (instead of falling
16797  * out of the interpreter), continue with whatever the next instruction
16798  * now happens to be.
16799  *
16800  * This does not return.
16801  */
16802     .global dvmMterpCommonExceptionThrown
16803 dvmMterpCommonExceptionThrown:
16804 common_exceptionThrown:
16805 .LexceptionNew:
16806
16807     EXPORT_PC()
16808     move     a0, rSELF
16809     JAL(dvmCheckSuspendPending)
16810     lw       rOBJ, offThread_exception(rSELF)
16811     move     a1, rSELF
16812     move     a0, rOBJ
16813     JAL(dvmAddTrackedAlloc)
16814     lhu      a2, offThread_subMode(rSELF)
16815     sw       zero, offThread_exception(rSELF)
16816
16817     # Special subMode?
16818     bnez     a2, 7f                     # any special subMode handling needed?
16819 8:
16820     /* set up args and a local for "&fp" */
16821     sw       rFP, 20(sp)                 #  store rFP => tmp
16822     addu     t0, sp, 20                  #  compute &tmp
16823     sw       t0, STACK_OFFSET_ARG04(sp)  #  save it in arg4 as per ABI
16824     li       a3, 0                       #  a3 <- false
16825     lw       a1, offThread_method(rSELF)
16826     move     a0, rSELF
16827     lw       a1, offMethod_insns(a1)
16828     lhu      ra, offThread_subMode(rSELF)
16829     move     a2, rOBJ
16830     subu     a1, rPC, a1
16831     sra      a1, a1, 1
16832
16833     /* call, r0 gets catchRelPc (a code-unit offset) */
16834     JAL(dvmFindCatchBlock)           # call(self, relPc, exc, scan?, &fp)
16835     lw        rFP, 20(sp)            # retrieve the updated rFP
16836
16837     /* update frame pointer and check result from dvmFindCatchBlock */
16838     move      a0, v0
16839     bltz      v0, .LnotCaughtLocally
16840
16841     /* fix earlier stack overflow if necessary; Preserve a0 */
16842     lbu       a1, offThread_stackOverflowed(rSELF)
16843     beqz      a1, 1f
16844     move      rBIX, a0
16845     move      a0, rSELF
16846     move      a1, rOBJ
16847     JAL(dvmCleanupStackOverflow)
16848     move      a0, rBIX
16849
16850 1:
16851
16852 /* adjust locals to match self->interpSave.curFrame and updated PC */
16853     SAVEAREA_FROM_FP(a1, rFP)           # a1<- new save area
16854     lw        a1, offStackSaveArea_method(a1)
16855     sw        a1, offThread_method(rSELF)
16856     lw        a2, offMethod_clazz(a1)
16857     lw        a3, offMethod_insns(a1)
16858     lw        a2, offClassObject_pDvmDex(a2)
16859     EAS1(rPC, a3, a0)
16860     sw        a2, offThread_methodClassDex(rSELF)
16861
16862     /* release the tracked alloc on the exception */
16863     move      a0, rOBJ
16864     move      a1, rSELF
16865     JAL(dvmReleaseTrackedAlloc)
16866
16867     /* restore the exception if the handler wants it */
16868     lw        rIBASE, offThread_curHandlerTable(rSELF)
16869     FETCH_INST()
16870     GET_INST_OPCODE(t0)
16871     bne       t0, OP_MOVE_EXCEPTION, 2f
16872     sw        rOBJ, offThread_exception(rSELF)
16873 2:
16874     GOTO_OPCODE(t0)
16875
16876     # Manage debugger bookkeeping
16877 7:
16878     sw        rPC, offThread_pc(rSELF)
16879     sw        rFP, offThread_curFrame(rSELF)
16880     move      a0, rSELF
16881     move      a1, rOBJ
16882     JAL(dvmReportExceptionThrow)
16883     b         8b
16884
16885 .LnotCaughtLocally:                     #  rOBJ = exception
16886     /* fix stack overflow if necessary */
16887     lbu       a1, offThread_stackOverflowed(rSELF)
16888     beqz      a1, 3f
16889     move      a0, rSELF
16890     move      a1, rOBJ
16891     JAL(dvmCleanupStackOverflow)           #  dvmCleanupStackOverflow(self, exception)
16892
16893 3:
16894     # may want to show "not caught locally" debug messages here
16895 #if DVM_SHOW_EXCEPTION >= 2
16896     /* call __android_log_print(prio, tag, format, ...) */
16897     /* "Exception %s from %s:%d not caught locally" */
16898     lw        a0, offThread_method(rSELF)
16899     lw        a1, offMethod_insns(a0)
16900     subu      a1, rPC, a1
16901     sra       a1, a1, 1
16902     JAL(dvmLineNumFromPC)
16903     sw        v0, 20(sp)
16904     # dvmGetMethodSourceFile(method)
16905     lw        a0, offThread_method(rSELF)
16906     JAL(dvmGetMethodSourceFile)
16907     sw        v0, 16(sp)
16908     # exception->clazz->descriptor
16909     lw        a3, offObject_clazz(rOBJ)
16910     lw        a3, offClassObject_descriptor(a3)
16911     la        a2, .LstrExceptionNotCaughtLocally
16912     la        a1, .LstrLogTag
16913     li        a0, 3
16914     JAL(__android_log_print)
16915 #endif
16916     sw        rOBJ, offThread_exception(rSELF)
16917     move      a0, rOBJ
16918     move      a1, rSELF
16919     JAL(dvmReleaseTrackedAlloc)
16920     b         common_gotoBail
16921
16922     /*
16923      * Exception handling, calls through "glue code".
16924      */
16925     .if     0
16926 .LexceptionOld:
16927     SAVE_PC_TO_SELF()                # export state
16928     SAVE_FP_TO_SELF()
16929     move     a0, rSELF               # arg to function
16930     JAL(dvmMterp_exceptionThrown)
16931     b       common_resumeAfterGlueCall
16932     .endif
16933
16934 #if defined(WITH_JIT)
16935     /*
16936      * If the JIT is actively building a trace we need to make sure
16937      * that the field is fully resolved before including the current
16938      * instruction.
16939      *
16940      * On entry:
16941      *     rBIX: &dvmDex->pResFields[field]
16942      *     a0:  field pointer (must preserve)
16943      */
16944 common_verifyField:
16945      lhu     a3, offThread_subMode(rSELF)
16946      andi    a3, kSubModeJitTraceBuild
16947      bnez    a3, 1f                 # Not building trace, continue
16948      jr      ra
16949 1:
16950      lw      a1, (rBIX)
16951      beqz    a1, 2f                 # resolution complete ?
16952      jr      ra
16953 2:
16954     SCRATCH_STORE(a0, 0)
16955     SCRATCH_STORE(a1, 4)
16956     SCRATCH_STORE(a2, 8)
16957     SCRATCH_STORE(a3, 12)
16958     SCRATCH_STORE(ra, 16)
16959     move    a0, rSELF
16960     move    a1, rPC
16961     JAL(dvmJitEndTraceSelect)        #(self,pc) end trace before this inst)
16962     SCRATCH_LOAD(a0, 0)
16963     SCRATCH_LOAD(a1, 4)
16964     SCRATCH_LOAD(a2, 8)
16965     SCRATCH_LOAD(a3, 12)
16966     SCRATCH_LOAD(ra, 16)
16967     jr      ra                       # return
16968 #endif
16969
16970 /*
16971  * After returning from a "glued" function, pull out the updated
16972  * values and start executing at the next instruction.
16973  */
16974 common_resumeAfterGlueCall:
16975     LOAD_PC_FP_FROM_SELF()           #  pull rPC and rFP out of thread
16976     lw      rIBASE, offThread_curHandlerTable(rSELF) # refresh
16977     FETCH_INST()                     #  load rINST from rPC
16978     GET_INST_OPCODE(t0)              #  extract opcode from rINST
16979     GOTO_OPCODE(t0)                  #  jump to next instruction
16980
16981 /*
16982  * Invalid array index. Note that our calling convention is strange; we use a1
16983  * and a3 because those just happen to be the registers all our callers are
16984  * using. We move a3 before calling the C function, but a1 happens to match.
16985  * a1: index
16986  * a3: size
16987  */
16988 common_errArrayIndex:
16989     EXPORT_PC()
16990     move      a0, a3
16991     JAL(dvmThrowArrayIndexOutOfBoundsException)
16992     b         common_exceptionThrown
16993
16994 /*
16995  * Integer divide or mod by zero.
16996  */
16997 common_errDivideByZero:
16998     EXPORT_PC()
16999     la     a0, .LstrDivideByZero
17000     JAL(dvmThrowArithmeticException)
17001     b       common_exceptionThrown
17002
17003 /*
17004  * Attempt to allocate an array with a negative size.
17005  * On entry: length in a1
17006  */
17007 common_errNegativeArraySize:
17008     EXPORT_PC()
17009     move    a0, a1                                # arg0 <- len
17010     JAL(dvmThrowNegativeArraySizeException)    # (len)
17011     b       common_exceptionThrown
17012
17013 /*
17014  * Invocation of a non-existent method.
17015  * On entry: method name in a1
17016  */
17017 common_errNoSuchMethod:
17018     EXPORT_PC()
17019     move     a0, a1
17020     JAL(dvmThrowNoSuchMethodError)
17021     b       common_exceptionThrown
17022
17023 /*
17024  * We encountered a null object when we weren't expecting one.  We
17025  * export the PC, throw a NullPointerException, and goto the exception
17026  * processing code.
17027  */
17028 common_errNullObject:
17029     EXPORT_PC()
17030     li      a0, 0
17031     JAL(dvmThrowNullPointerException)
17032     b       common_exceptionThrown
17033
17034 /*
17035  * For debugging, cause an immediate fault. The source address will be in ra. Use a jal to jump here.
17036  */
17037 common_abort:
17038     lw      zero,-4(zero)            #  generate SIGSEGV
17039
17040 /*
17041  * Spit out a "we were here", preserving all registers.
17042  */
17043     .macro SQUEAK num
17044 common_squeak\num:
17045     STACK_STORE_RA();
17046     la        a0, .LstrSqueak
17047     LOAD_IMM(a1, \num);
17048     JAL(printf);
17049     STACK_LOAD_RA();
17050     RETURN;
17051     .endm
17052
17053     SQUEAK 0
17054     SQUEAK 1
17055     SQUEAK 2
17056     SQUEAK 3
17057     SQUEAK 4
17058     SQUEAK 5
17059
17060 /*
17061  * Spit out the number in a0, preserving registers.
17062  */
17063 common_printNum:
17064     STACK_STORE_RA()
17065     MOVE_REG(a1, a0)
17066     la        a0, .LstrSqueak
17067     JAL(printf)
17068     STACK_LOAD_RA()
17069     RETURN
17070
17071 /*
17072  * Print a newline, preserving registers.
17073  */
17074 common_printNewline:
17075     STACK_STORE_RA()
17076     la        a0, .LstrNewline
17077     JAL(printf)
17078     STACK_LOAD_RA()
17079     RETURN
17080
17081     /*
17082      * Print the 32-bit quantity in a0 as a hex value, preserving registers.
17083      */
17084 common_printHex:
17085     STACK_STORE_RA()
17086     MOVE_REG(a1, a0)
17087     la        a0, .LstrPrintHex
17088     JAL(printf)
17089     STACK_LOAD_RA()
17090 RETURN;
17091
17092 /*
17093  * Print the 64-bit quantity in a0-a1, preserving registers.
17094  */
17095 common_printLong:
17096     STACK_STORE_RA()
17097     MOVE_REG(a3, a1)
17098     MOVE_REG(a2, a0)
17099     la        a0, .LstrPrintLong
17100     JAL(printf)
17101     STACK_LOAD_RA()
17102     RETURN;
17103
17104 /*
17105  * Print full method info.  Pass the Method* in a0.  Preserves regs.
17106  */
17107 common_printMethod:
17108     STACK_STORE_RA()
17109     JAL(dvmMterpPrintMethod)
17110     STACK_LOAD_RA()
17111     RETURN
17112
17113 /*
17114  * Call a C helper function that dumps regs and possibly some
17115  * additional info.  Requires the C function to be compiled in.
17116  */
17117     .if 0
17118 common_dumpRegs:
17119     STACK_STORE_RA()
17120     JAL(dvmMterpDumpMipsRegs)
17121     STACK_LOAD_RA()
17122     RETURN
17123     .endif
17124
17125 /*
17126  * Zero-terminated ASCII string data.
17127  */
17128     .data
17129
17130 .LstrBadEntryPoint:
17131     .asciiz "Bad entry point %d\n"
17132 .LstrDivideByZero:
17133     .asciiz "divide by zero"
17134 .LstrFilledNewArrayNotImpl:
17135     .asciiz "filled-new-array only implemented for 'int'"
17136 .LstrLogTag:
17137     .asciiz  "mterp"
17138 .LstrExceptionNotCaughtLocally:
17139     .asciiz  "Exception %s from %s:%d not caught locally\n"
17140
17141 .LstrNewline:
17142     .asciiz "\n"
17143 .LstrSqueak:
17144     .asciiz "<%d>"
17145 .LstrPrintHex:
17146     .asciiz "<0x%x>"
17147 .LstrPrintLong:
17148     .asciiz "<%lld>"
17149
17150
17151     .global dvmAsmAltInstructionStart
17152     .type   dvmAsmAltInstructionStart, %function
17153     .text
17154
17155 dvmAsmAltInstructionStart = .L_ALT_OP_NOP
17156 /* ------------------------------ */
17157     .balign 128
17158 .L_ALT_OP_NOP: /* 0x00 */
17159 /* File: mips/alt_stub.S */
17160 /*
17161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17162  * any interesting requests and then jump to the real instruction
17163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17166  * bail to the real handler if breakFlags==0.
17167  */
17168     lbu    a3, offThread_breakFlags(rSELF)
17169     la     rBIX, dvmAsmInstructionStart + (0 * 128)
17170     lw     rIBASE, offThread_curHandlerTable(rSELF)
17171     bnez   a3, 1f
17172     jr     rBIX            # nothing to do - jump to real handler
17173 1:
17174     EXPORT_PC()
17175     move   a0, rPC         # arg0
17176     move   a1, rFP         # arg1
17177     move   a2, rSELF       # arg2
17178     JAL(dvmCheckBefore)
17179     jr     rBIX
17180
17181 /* ------------------------------ */
17182     .balign 128
17183 .L_ALT_OP_MOVE: /* 0x01 */
17184 /* File: mips/alt_stub.S */
17185 /*
17186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17187  * any interesting requests and then jump to the real instruction
17188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17191  * bail to the real handler if breakFlags==0.
17192  */
17193     lbu    a3, offThread_breakFlags(rSELF)
17194     la     rBIX, dvmAsmInstructionStart + (1 * 128)
17195     lw     rIBASE, offThread_curHandlerTable(rSELF)
17196     bnez   a3, 1f
17197     jr     rBIX            # nothing to do - jump to real handler
17198 1:
17199     EXPORT_PC()
17200     move   a0, rPC         # arg0
17201     move   a1, rFP         # arg1
17202     move   a2, rSELF       # arg2
17203     JAL(dvmCheckBefore)
17204     jr     rBIX
17205
17206 /* ------------------------------ */
17207     .balign 128
17208 .L_ALT_OP_MOVE_FROM16: /* 0x02 */
17209 /* File: mips/alt_stub.S */
17210 /*
17211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17212  * any interesting requests and then jump to the real instruction
17213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17216  * bail to the real handler if breakFlags==0.
17217  */
17218     lbu    a3, offThread_breakFlags(rSELF)
17219     la     rBIX, dvmAsmInstructionStart + (2 * 128)
17220     lw     rIBASE, offThread_curHandlerTable(rSELF)
17221     bnez   a3, 1f
17222     jr     rBIX            # nothing to do - jump to real handler
17223 1:
17224     EXPORT_PC()
17225     move   a0, rPC         # arg0
17226     move   a1, rFP         # arg1
17227     move   a2, rSELF       # arg2
17228     JAL(dvmCheckBefore)
17229     jr     rBIX
17230
17231 /* ------------------------------ */
17232     .balign 128
17233 .L_ALT_OP_MOVE_16: /* 0x03 */
17234 /* File: mips/alt_stub.S */
17235 /*
17236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17237  * any interesting requests and then jump to the real instruction
17238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17241  * bail to the real handler if breakFlags==0.
17242  */
17243     lbu    a3, offThread_breakFlags(rSELF)
17244     la     rBIX, dvmAsmInstructionStart + (3 * 128)
17245     lw     rIBASE, offThread_curHandlerTable(rSELF)
17246     bnez   a3, 1f
17247     jr     rBIX            # nothing to do - jump to real handler
17248 1:
17249     EXPORT_PC()
17250     move   a0, rPC         # arg0
17251     move   a1, rFP         # arg1
17252     move   a2, rSELF       # arg2
17253     JAL(dvmCheckBefore)
17254     jr     rBIX
17255
17256 /* ------------------------------ */
17257     .balign 128
17258 .L_ALT_OP_MOVE_WIDE: /* 0x04 */
17259 /* File: mips/alt_stub.S */
17260 /*
17261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17262  * any interesting requests and then jump to the real instruction
17263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17266  * bail to the real handler if breakFlags==0.
17267  */
17268     lbu    a3, offThread_breakFlags(rSELF)
17269     la     rBIX, dvmAsmInstructionStart + (4 * 128)
17270     lw     rIBASE, offThread_curHandlerTable(rSELF)
17271     bnez   a3, 1f
17272     jr     rBIX            # nothing to do - jump to real handler
17273 1:
17274     EXPORT_PC()
17275     move   a0, rPC         # arg0
17276     move   a1, rFP         # arg1
17277     move   a2, rSELF       # arg2
17278     JAL(dvmCheckBefore)
17279     jr     rBIX
17280
17281 /* ------------------------------ */
17282     .balign 128
17283 .L_ALT_OP_MOVE_WIDE_FROM16: /* 0x05 */
17284 /* File: mips/alt_stub.S */
17285 /*
17286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17287  * any interesting requests and then jump to the real instruction
17288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17291  * bail to the real handler if breakFlags==0.
17292  */
17293     lbu    a3, offThread_breakFlags(rSELF)
17294     la     rBIX, dvmAsmInstructionStart + (5 * 128)
17295     lw     rIBASE, offThread_curHandlerTable(rSELF)
17296     bnez   a3, 1f
17297     jr     rBIX            # nothing to do - jump to real handler
17298 1:
17299     EXPORT_PC()
17300     move   a0, rPC         # arg0
17301     move   a1, rFP         # arg1
17302     move   a2, rSELF       # arg2
17303     JAL(dvmCheckBefore)
17304     jr     rBIX
17305
17306 /* ------------------------------ */
17307     .balign 128
17308 .L_ALT_OP_MOVE_WIDE_16: /* 0x06 */
17309 /* File: mips/alt_stub.S */
17310 /*
17311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17312  * any interesting requests and then jump to the real instruction
17313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17316  * bail to the real handler if breakFlags==0.
17317  */
17318     lbu    a3, offThread_breakFlags(rSELF)
17319     la     rBIX, dvmAsmInstructionStart + (6 * 128)
17320     lw     rIBASE, offThread_curHandlerTable(rSELF)
17321     bnez   a3, 1f
17322     jr     rBIX            # nothing to do - jump to real handler
17323 1:
17324     EXPORT_PC()
17325     move   a0, rPC         # arg0
17326     move   a1, rFP         # arg1
17327     move   a2, rSELF       # arg2
17328     JAL(dvmCheckBefore)
17329     jr     rBIX
17330
17331 /* ------------------------------ */
17332     .balign 128
17333 .L_ALT_OP_MOVE_OBJECT: /* 0x07 */
17334 /* File: mips/alt_stub.S */
17335 /*
17336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17337  * any interesting requests and then jump to the real instruction
17338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17341  * bail to the real handler if breakFlags==0.
17342  */
17343     lbu    a3, offThread_breakFlags(rSELF)
17344     la     rBIX, dvmAsmInstructionStart + (7 * 128)
17345     lw     rIBASE, offThread_curHandlerTable(rSELF)
17346     bnez   a3, 1f
17347     jr     rBIX            # nothing to do - jump to real handler
17348 1:
17349     EXPORT_PC()
17350     move   a0, rPC         # arg0
17351     move   a1, rFP         # arg1
17352     move   a2, rSELF       # arg2
17353     JAL(dvmCheckBefore)
17354     jr     rBIX
17355
17356 /* ------------------------------ */
17357     .balign 128
17358 .L_ALT_OP_MOVE_OBJECT_FROM16: /* 0x08 */
17359 /* File: mips/alt_stub.S */
17360 /*
17361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17362  * any interesting requests and then jump to the real instruction
17363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17366  * bail to the real handler if breakFlags==0.
17367  */
17368     lbu    a3, offThread_breakFlags(rSELF)
17369     la     rBIX, dvmAsmInstructionStart + (8 * 128)
17370     lw     rIBASE, offThread_curHandlerTable(rSELF)
17371     bnez   a3, 1f
17372     jr     rBIX            # nothing to do - jump to real handler
17373 1:
17374     EXPORT_PC()
17375     move   a0, rPC         # arg0
17376     move   a1, rFP         # arg1
17377     move   a2, rSELF       # arg2
17378     JAL(dvmCheckBefore)
17379     jr     rBIX
17380
17381 /* ------------------------------ */
17382     .balign 128
17383 .L_ALT_OP_MOVE_OBJECT_16: /* 0x09 */
17384 /* File: mips/alt_stub.S */
17385 /*
17386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17387  * any interesting requests and then jump to the real instruction
17388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17391  * bail to the real handler if breakFlags==0.
17392  */
17393     lbu    a3, offThread_breakFlags(rSELF)
17394     la     rBIX, dvmAsmInstructionStart + (9 * 128)
17395     lw     rIBASE, offThread_curHandlerTable(rSELF)
17396     bnez   a3, 1f
17397     jr     rBIX            # nothing to do - jump to real handler
17398 1:
17399     EXPORT_PC()
17400     move   a0, rPC         # arg0
17401     move   a1, rFP         # arg1
17402     move   a2, rSELF       # arg2
17403     JAL(dvmCheckBefore)
17404     jr     rBIX
17405
17406 /* ------------------------------ */
17407     .balign 128
17408 .L_ALT_OP_MOVE_RESULT: /* 0x0a */
17409 /* File: mips/alt_stub.S */
17410 /*
17411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17412  * any interesting requests and then jump to the real instruction
17413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17416  * bail to the real handler if breakFlags==0.
17417  */
17418     lbu    a3, offThread_breakFlags(rSELF)
17419     la     rBIX, dvmAsmInstructionStart + (10 * 128)
17420     lw     rIBASE, offThread_curHandlerTable(rSELF)
17421     bnez   a3, 1f
17422     jr     rBIX            # nothing to do - jump to real handler
17423 1:
17424     EXPORT_PC()
17425     move   a0, rPC         # arg0
17426     move   a1, rFP         # arg1
17427     move   a2, rSELF       # arg2
17428     JAL(dvmCheckBefore)
17429     jr     rBIX
17430
17431 /* ------------------------------ */
17432     .balign 128
17433 .L_ALT_OP_MOVE_RESULT_WIDE: /* 0x0b */
17434 /* File: mips/alt_stub.S */
17435 /*
17436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17437  * any interesting requests and then jump to the real instruction
17438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17441  * bail to the real handler if breakFlags==0.
17442  */
17443     lbu    a3, offThread_breakFlags(rSELF)
17444     la     rBIX, dvmAsmInstructionStart + (11 * 128)
17445     lw     rIBASE, offThread_curHandlerTable(rSELF)
17446     bnez   a3, 1f
17447     jr     rBIX            # nothing to do - jump to real handler
17448 1:
17449     EXPORT_PC()
17450     move   a0, rPC         # arg0
17451     move   a1, rFP         # arg1
17452     move   a2, rSELF       # arg2
17453     JAL(dvmCheckBefore)
17454     jr     rBIX
17455
17456 /* ------------------------------ */
17457     .balign 128
17458 .L_ALT_OP_MOVE_RESULT_OBJECT: /* 0x0c */
17459 /* File: mips/alt_stub.S */
17460 /*
17461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17462  * any interesting requests and then jump to the real instruction
17463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17466  * bail to the real handler if breakFlags==0.
17467  */
17468     lbu    a3, offThread_breakFlags(rSELF)
17469     la     rBIX, dvmAsmInstructionStart + (12 * 128)
17470     lw     rIBASE, offThread_curHandlerTable(rSELF)
17471     bnez   a3, 1f
17472     jr     rBIX            # nothing to do - jump to real handler
17473 1:
17474     EXPORT_PC()
17475     move   a0, rPC         # arg0
17476     move   a1, rFP         # arg1
17477     move   a2, rSELF       # arg2
17478     JAL(dvmCheckBefore)
17479     jr     rBIX
17480
17481 /* ------------------------------ */
17482     .balign 128
17483 .L_ALT_OP_MOVE_EXCEPTION: /* 0x0d */
17484 /* File: mips/alt_stub.S */
17485 /*
17486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17487  * any interesting requests and then jump to the real instruction
17488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17491  * bail to the real handler if breakFlags==0.
17492  */
17493     lbu    a3, offThread_breakFlags(rSELF)
17494     la     rBIX, dvmAsmInstructionStart + (13 * 128)
17495     lw     rIBASE, offThread_curHandlerTable(rSELF)
17496     bnez   a3, 1f
17497     jr     rBIX            # nothing to do - jump to real handler
17498 1:
17499     EXPORT_PC()
17500     move   a0, rPC         # arg0
17501     move   a1, rFP         # arg1
17502     move   a2, rSELF       # arg2
17503     JAL(dvmCheckBefore)
17504     jr     rBIX
17505
17506 /* ------------------------------ */
17507     .balign 128
17508 .L_ALT_OP_RETURN_VOID: /* 0x0e */
17509 /* File: mips/alt_stub.S */
17510 /*
17511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17512  * any interesting requests and then jump to the real instruction
17513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17516  * bail to the real handler if breakFlags==0.
17517  */
17518     lbu    a3, offThread_breakFlags(rSELF)
17519     la     rBIX, dvmAsmInstructionStart + (14 * 128)
17520     lw     rIBASE, offThread_curHandlerTable(rSELF)
17521     bnez   a3, 1f
17522     jr     rBIX            # nothing to do - jump to real handler
17523 1:
17524     EXPORT_PC()
17525     move   a0, rPC         # arg0
17526     move   a1, rFP         # arg1
17527     move   a2, rSELF       # arg2
17528     JAL(dvmCheckBefore)
17529     jr     rBIX
17530
17531 /* ------------------------------ */
17532     .balign 128
17533 .L_ALT_OP_RETURN: /* 0x0f */
17534 /* File: mips/alt_stub.S */
17535 /*
17536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17537  * any interesting requests and then jump to the real instruction
17538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17541  * bail to the real handler if breakFlags==0.
17542  */
17543     lbu    a3, offThread_breakFlags(rSELF)
17544     la     rBIX, dvmAsmInstructionStart + (15 * 128)
17545     lw     rIBASE, offThread_curHandlerTable(rSELF)
17546     bnez   a3, 1f
17547     jr     rBIX            # nothing to do - jump to real handler
17548 1:
17549     EXPORT_PC()
17550     move   a0, rPC         # arg0
17551     move   a1, rFP         # arg1
17552     move   a2, rSELF       # arg2
17553     JAL(dvmCheckBefore)
17554     jr     rBIX
17555
17556 /* ------------------------------ */
17557     .balign 128
17558 .L_ALT_OP_RETURN_WIDE: /* 0x10 */
17559 /* File: mips/alt_stub.S */
17560 /*
17561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17562  * any interesting requests and then jump to the real instruction
17563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17566  * bail to the real handler if breakFlags==0.
17567  */
17568     lbu    a3, offThread_breakFlags(rSELF)
17569     la     rBIX, dvmAsmInstructionStart + (16 * 128)
17570     lw     rIBASE, offThread_curHandlerTable(rSELF)
17571     bnez   a3, 1f
17572     jr     rBIX            # nothing to do - jump to real handler
17573 1:
17574     EXPORT_PC()
17575     move   a0, rPC         # arg0
17576     move   a1, rFP         # arg1
17577     move   a2, rSELF       # arg2
17578     JAL(dvmCheckBefore)
17579     jr     rBIX
17580
17581 /* ------------------------------ */
17582     .balign 128
17583 .L_ALT_OP_RETURN_OBJECT: /* 0x11 */
17584 /* File: mips/alt_stub.S */
17585 /*
17586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17587  * any interesting requests and then jump to the real instruction
17588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17591  * bail to the real handler if breakFlags==0.
17592  */
17593     lbu    a3, offThread_breakFlags(rSELF)
17594     la     rBIX, dvmAsmInstructionStart + (17 * 128)
17595     lw     rIBASE, offThread_curHandlerTable(rSELF)
17596     bnez   a3, 1f
17597     jr     rBIX            # nothing to do - jump to real handler
17598 1:
17599     EXPORT_PC()
17600     move   a0, rPC         # arg0
17601     move   a1, rFP         # arg1
17602     move   a2, rSELF       # arg2
17603     JAL(dvmCheckBefore)
17604     jr     rBIX
17605
17606 /* ------------------------------ */
17607     .balign 128
17608 .L_ALT_OP_CONST_4: /* 0x12 */
17609 /* File: mips/alt_stub.S */
17610 /*
17611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17612  * any interesting requests and then jump to the real instruction
17613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17616  * bail to the real handler if breakFlags==0.
17617  */
17618     lbu    a3, offThread_breakFlags(rSELF)
17619     la     rBIX, dvmAsmInstructionStart + (18 * 128)
17620     lw     rIBASE, offThread_curHandlerTable(rSELF)
17621     bnez   a3, 1f
17622     jr     rBIX            # nothing to do - jump to real handler
17623 1:
17624     EXPORT_PC()
17625     move   a0, rPC         # arg0
17626     move   a1, rFP         # arg1
17627     move   a2, rSELF       # arg2
17628     JAL(dvmCheckBefore)
17629     jr     rBIX
17630
17631 /* ------------------------------ */
17632     .balign 128
17633 .L_ALT_OP_CONST_16: /* 0x13 */
17634 /* File: mips/alt_stub.S */
17635 /*
17636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17637  * any interesting requests and then jump to the real instruction
17638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17641  * bail to the real handler if breakFlags==0.
17642  */
17643     lbu    a3, offThread_breakFlags(rSELF)
17644     la     rBIX, dvmAsmInstructionStart + (19 * 128)
17645     lw     rIBASE, offThread_curHandlerTable(rSELF)
17646     bnez   a3, 1f
17647     jr     rBIX            # nothing to do - jump to real handler
17648 1:
17649     EXPORT_PC()
17650     move   a0, rPC         # arg0
17651     move   a1, rFP         # arg1
17652     move   a2, rSELF       # arg2
17653     JAL(dvmCheckBefore)
17654     jr     rBIX
17655
17656 /* ------------------------------ */
17657     .balign 128
17658 .L_ALT_OP_CONST: /* 0x14 */
17659 /* File: mips/alt_stub.S */
17660 /*
17661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17662  * any interesting requests and then jump to the real instruction
17663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17666  * bail to the real handler if breakFlags==0.
17667  */
17668     lbu    a3, offThread_breakFlags(rSELF)
17669     la     rBIX, dvmAsmInstructionStart + (20 * 128)
17670     lw     rIBASE, offThread_curHandlerTable(rSELF)
17671     bnez   a3, 1f
17672     jr     rBIX            # nothing to do - jump to real handler
17673 1:
17674     EXPORT_PC()
17675     move   a0, rPC         # arg0
17676     move   a1, rFP         # arg1
17677     move   a2, rSELF       # arg2
17678     JAL(dvmCheckBefore)
17679     jr     rBIX
17680
17681 /* ------------------------------ */
17682     .balign 128
17683 .L_ALT_OP_CONST_HIGH16: /* 0x15 */
17684 /* File: mips/alt_stub.S */
17685 /*
17686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17687  * any interesting requests and then jump to the real instruction
17688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17691  * bail to the real handler if breakFlags==0.
17692  */
17693     lbu    a3, offThread_breakFlags(rSELF)
17694     la     rBIX, dvmAsmInstructionStart + (21 * 128)
17695     lw     rIBASE, offThread_curHandlerTable(rSELF)
17696     bnez   a3, 1f
17697     jr     rBIX            # nothing to do - jump to real handler
17698 1:
17699     EXPORT_PC()
17700     move   a0, rPC         # arg0
17701     move   a1, rFP         # arg1
17702     move   a2, rSELF       # arg2
17703     JAL(dvmCheckBefore)
17704     jr     rBIX
17705
17706 /* ------------------------------ */
17707     .balign 128
17708 .L_ALT_OP_CONST_WIDE_16: /* 0x16 */
17709 /* File: mips/alt_stub.S */
17710 /*
17711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17712  * any interesting requests and then jump to the real instruction
17713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17716  * bail to the real handler if breakFlags==0.
17717  */
17718     lbu    a3, offThread_breakFlags(rSELF)
17719     la     rBIX, dvmAsmInstructionStart + (22 * 128)
17720     lw     rIBASE, offThread_curHandlerTable(rSELF)
17721     bnez   a3, 1f
17722     jr     rBIX            # nothing to do - jump to real handler
17723 1:
17724     EXPORT_PC()
17725     move   a0, rPC         # arg0
17726     move   a1, rFP         # arg1
17727     move   a2, rSELF       # arg2
17728     JAL(dvmCheckBefore)
17729     jr     rBIX
17730
17731 /* ------------------------------ */
17732     .balign 128
17733 .L_ALT_OP_CONST_WIDE_32: /* 0x17 */
17734 /* File: mips/alt_stub.S */
17735 /*
17736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17737  * any interesting requests and then jump to the real instruction
17738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17741  * bail to the real handler if breakFlags==0.
17742  */
17743     lbu    a3, offThread_breakFlags(rSELF)
17744     la     rBIX, dvmAsmInstructionStart + (23 * 128)
17745     lw     rIBASE, offThread_curHandlerTable(rSELF)
17746     bnez   a3, 1f
17747     jr     rBIX            # nothing to do - jump to real handler
17748 1:
17749     EXPORT_PC()
17750     move   a0, rPC         # arg0
17751     move   a1, rFP         # arg1
17752     move   a2, rSELF       # arg2
17753     JAL(dvmCheckBefore)
17754     jr     rBIX
17755
17756 /* ------------------------------ */
17757     .balign 128
17758 .L_ALT_OP_CONST_WIDE: /* 0x18 */
17759 /* File: mips/alt_stub.S */
17760 /*
17761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17762  * any interesting requests and then jump to the real instruction
17763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17766  * bail to the real handler if breakFlags==0.
17767  */
17768     lbu    a3, offThread_breakFlags(rSELF)
17769     la     rBIX, dvmAsmInstructionStart + (24 * 128)
17770     lw     rIBASE, offThread_curHandlerTable(rSELF)
17771     bnez   a3, 1f
17772     jr     rBIX            # nothing to do - jump to real handler
17773 1:
17774     EXPORT_PC()
17775     move   a0, rPC         # arg0
17776     move   a1, rFP         # arg1
17777     move   a2, rSELF       # arg2
17778     JAL(dvmCheckBefore)
17779     jr     rBIX
17780
17781 /* ------------------------------ */
17782     .balign 128
17783 .L_ALT_OP_CONST_WIDE_HIGH16: /* 0x19 */
17784 /* File: mips/alt_stub.S */
17785 /*
17786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17787  * any interesting requests and then jump to the real instruction
17788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17791  * bail to the real handler if breakFlags==0.
17792  */
17793     lbu    a3, offThread_breakFlags(rSELF)
17794     la     rBIX, dvmAsmInstructionStart + (25 * 128)
17795     lw     rIBASE, offThread_curHandlerTable(rSELF)
17796     bnez   a3, 1f
17797     jr     rBIX            # nothing to do - jump to real handler
17798 1:
17799     EXPORT_PC()
17800     move   a0, rPC         # arg0
17801     move   a1, rFP         # arg1
17802     move   a2, rSELF       # arg2
17803     JAL(dvmCheckBefore)
17804     jr     rBIX
17805
17806 /* ------------------------------ */
17807     .balign 128
17808 .L_ALT_OP_CONST_STRING: /* 0x1a */
17809 /* File: mips/alt_stub.S */
17810 /*
17811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17812  * any interesting requests and then jump to the real instruction
17813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17816  * bail to the real handler if breakFlags==0.
17817  */
17818     lbu    a3, offThread_breakFlags(rSELF)
17819     la     rBIX, dvmAsmInstructionStart + (26 * 128)
17820     lw     rIBASE, offThread_curHandlerTable(rSELF)
17821     bnez   a3, 1f
17822     jr     rBIX            # nothing to do - jump to real handler
17823 1:
17824     EXPORT_PC()
17825     move   a0, rPC         # arg0
17826     move   a1, rFP         # arg1
17827     move   a2, rSELF       # arg2
17828     JAL(dvmCheckBefore)
17829     jr     rBIX
17830
17831 /* ------------------------------ */
17832     .balign 128
17833 .L_ALT_OP_CONST_STRING_JUMBO: /* 0x1b */
17834 /* File: mips/alt_stub.S */
17835 /*
17836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17837  * any interesting requests and then jump to the real instruction
17838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17841  * bail to the real handler if breakFlags==0.
17842  */
17843     lbu    a3, offThread_breakFlags(rSELF)
17844     la     rBIX, dvmAsmInstructionStart + (27 * 128)
17845     lw     rIBASE, offThread_curHandlerTable(rSELF)
17846     bnez   a3, 1f
17847     jr     rBIX            # nothing to do - jump to real handler
17848 1:
17849     EXPORT_PC()
17850     move   a0, rPC         # arg0
17851     move   a1, rFP         # arg1
17852     move   a2, rSELF       # arg2
17853     JAL(dvmCheckBefore)
17854     jr     rBIX
17855
17856 /* ------------------------------ */
17857     .balign 128
17858 .L_ALT_OP_CONST_CLASS: /* 0x1c */
17859 /* File: mips/alt_stub.S */
17860 /*
17861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17862  * any interesting requests and then jump to the real instruction
17863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17866  * bail to the real handler if breakFlags==0.
17867  */
17868     lbu    a3, offThread_breakFlags(rSELF)
17869     la     rBIX, dvmAsmInstructionStart + (28 * 128)
17870     lw     rIBASE, offThread_curHandlerTable(rSELF)
17871     bnez   a3, 1f
17872     jr     rBIX            # nothing to do - jump to real handler
17873 1:
17874     EXPORT_PC()
17875     move   a0, rPC         # arg0
17876     move   a1, rFP         # arg1
17877     move   a2, rSELF       # arg2
17878     JAL(dvmCheckBefore)
17879     jr     rBIX
17880
17881 /* ------------------------------ */
17882     .balign 128
17883 .L_ALT_OP_MONITOR_ENTER: /* 0x1d */
17884 /* File: mips/alt_stub.S */
17885 /*
17886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17887  * any interesting requests and then jump to the real instruction
17888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17891  * bail to the real handler if breakFlags==0.
17892  */
17893     lbu    a3, offThread_breakFlags(rSELF)
17894     la     rBIX, dvmAsmInstructionStart + (29 * 128)
17895     lw     rIBASE, offThread_curHandlerTable(rSELF)
17896     bnez   a3, 1f
17897     jr     rBIX            # nothing to do - jump to real handler
17898 1:
17899     EXPORT_PC()
17900     move   a0, rPC         # arg0
17901     move   a1, rFP         # arg1
17902     move   a2, rSELF       # arg2
17903     JAL(dvmCheckBefore)
17904     jr     rBIX
17905
17906 /* ------------------------------ */
17907     .balign 128
17908 .L_ALT_OP_MONITOR_EXIT: /* 0x1e */
17909 /* File: mips/alt_stub.S */
17910 /*
17911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17912  * any interesting requests and then jump to the real instruction
17913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17916  * bail to the real handler if breakFlags==0.
17917  */
17918     lbu    a3, offThread_breakFlags(rSELF)
17919     la     rBIX, dvmAsmInstructionStart + (30 * 128)
17920     lw     rIBASE, offThread_curHandlerTable(rSELF)
17921     bnez   a3, 1f
17922     jr     rBIX            # nothing to do - jump to real handler
17923 1:
17924     EXPORT_PC()
17925     move   a0, rPC         # arg0
17926     move   a1, rFP         # arg1
17927     move   a2, rSELF       # arg2
17928     JAL(dvmCheckBefore)
17929     jr     rBIX
17930
17931 /* ------------------------------ */
17932     .balign 128
17933 .L_ALT_OP_CHECK_CAST: /* 0x1f */
17934 /* File: mips/alt_stub.S */
17935 /*
17936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17937  * any interesting requests and then jump to the real instruction
17938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17941  * bail to the real handler if breakFlags==0.
17942  */
17943     lbu    a3, offThread_breakFlags(rSELF)
17944     la     rBIX, dvmAsmInstructionStart + (31 * 128)
17945     lw     rIBASE, offThread_curHandlerTable(rSELF)
17946     bnez   a3, 1f
17947     jr     rBIX            # nothing to do - jump to real handler
17948 1:
17949     EXPORT_PC()
17950     move   a0, rPC         # arg0
17951     move   a1, rFP         # arg1
17952     move   a2, rSELF       # arg2
17953     JAL(dvmCheckBefore)
17954     jr     rBIX
17955
17956 /* ------------------------------ */
17957     .balign 128
17958 .L_ALT_OP_INSTANCE_OF: /* 0x20 */
17959 /* File: mips/alt_stub.S */
17960 /*
17961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17962  * any interesting requests and then jump to the real instruction
17963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17966  * bail to the real handler if breakFlags==0.
17967  */
17968     lbu    a3, offThread_breakFlags(rSELF)
17969     la     rBIX, dvmAsmInstructionStart + (32 * 128)
17970     lw     rIBASE, offThread_curHandlerTable(rSELF)
17971     bnez   a3, 1f
17972     jr     rBIX            # nothing to do - jump to real handler
17973 1:
17974     EXPORT_PC()
17975     move   a0, rPC         # arg0
17976     move   a1, rFP         # arg1
17977     move   a2, rSELF       # arg2
17978     JAL(dvmCheckBefore)
17979     jr     rBIX
17980
17981 /* ------------------------------ */
17982     .balign 128
17983 .L_ALT_OP_ARRAY_LENGTH: /* 0x21 */
17984 /* File: mips/alt_stub.S */
17985 /*
17986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
17987  * any interesting requests and then jump to the real instruction
17988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
17989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
17990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
17991  * bail to the real handler if breakFlags==0.
17992  */
17993     lbu    a3, offThread_breakFlags(rSELF)
17994     la     rBIX, dvmAsmInstructionStart + (33 * 128)
17995     lw     rIBASE, offThread_curHandlerTable(rSELF)
17996     bnez   a3, 1f
17997     jr     rBIX            # nothing to do - jump to real handler
17998 1:
17999     EXPORT_PC()
18000     move   a0, rPC         # arg0
18001     move   a1, rFP         # arg1
18002     move   a2, rSELF       # arg2
18003     JAL(dvmCheckBefore)
18004     jr     rBIX
18005
18006 /* ------------------------------ */
18007     .balign 128
18008 .L_ALT_OP_NEW_INSTANCE: /* 0x22 */
18009 /* File: mips/alt_stub.S */
18010 /*
18011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18012  * any interesting requests and then jump to the real instruction
18013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18016  * bail to the real handler if breakFlags==0.
18017  */
18018     lbu    a3, offThread_breakFlags(rSELF)
18019     la     rBIX, dvmAsmInstructionStart + (34 * 128)
18020     lw     rIBASE, offThread_curHandlerTable(rSELF)
18021     bnez   a3, 1f
18022     jr     rBIX            # nothing to do - jump to real handler
18023 1:
18024     EXPORT_PC()
18025     move   a0, rPC         # arg0
18026     move   a1, rFP         # arg1
18027     move   a2, rSELF       # arg2
18028     JAL(dvmCheckBefore)
18029     jr     rBIX
18030
18031 /* ------------------------------ */
18032     .balign 128
18033 .L_ALT_OP_NEW_ARRAY: /* 0x23 */
18034 /* File: mips/alt_stub.S */
18035 /*
18036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18037  * any interesting requests and then jump to the real instruction
18038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18041  * bail to the real handler if breakFlags==0.
18042  */
18043     lbu    a3, offThread_breakFlags(rSELF)
18044     la     rBIX, dvmAsmInstructionStart + (35 * 128)
18045     lw     rIBASE, offThread_curHandlerTable(rSELF)
18046     bnez   a3, 1f
18047     jr     rBIX            # nothing to do - jump to real handler
18048 1:
18049     EXPORT_PC()
18050     move   a0, rPC         # arg0
18051     move   a1, rFP         # arg1
18052     move   a2, rSELF       # arg2
18053     JAL(dvmCheckBefore)
18054     jr     rBIX
18055
18056 /* ------------------------------ */
18057     .balign 128
18058 .L_ALT_OP_FILLED_NEW_ARRAY: /* 0x24 */
18059 /* File: mips/alt_stub.S */
18060 /*
18061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18062  * any interesting requests and then jump to the real instruction
18063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18066  * bail to the real handler if breakFlags==0.
18067  */
18068     lbu    a3, offThread_breakFlags(rSELF)
18069     la     rBIX, dvmAsmInstructionStart + (36 * 128)
18070     lw     rIBASE, offThread_curHandlerTable(rSELF)
18071     bnez   a3, 1f
18072     jr     rBIX            # nothing to do - jump to real handler
18073 1:
18074     EXPORT_PC()
18075     move   a0, rPC         # arg0
18076     move   a1, rFP         # arg1
18077     move   a2, rSELF       # arg2
18078     JAL(dvmCheckBefore)
18079     jr     rBIX
18080
18081 /* ------------------------------ */
18082     .balign 128
18083 .L_ALT_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */
18084 /* File: mips/alt_stub.S */
18085 /*
18086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18087  * any interesting requests and then jump to the real instruction
18088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18091  * bail to the real handler if breakFlags==0.
18092  */
18093     lbu    a3, offThread_breakFlags(rSELF)
18094     la     rBIX, dvmAsmInstructionStart + (37 * 128)
18095     lw     rIBASE, offThread_curHandlerTable(rSELF)
18096     bnez   a3, 1f
18097     jr     rBIX            # nothing to do - jump to real handler
18098 1:
18099     EXPORT_PC()
18100     move   a0, rPC         # arg0
18101     move   a1, rFP         # arg1
18102     move   a2, rSELF       # arg2
18103     JAL(dvmCheckBefore)
18104     jr     rBIX
18105
18106 /* ------------------------------ */
18107     .balign 128
18108 .L_ALT_OP_FILL_ARRAY_DATA: /* 0x26 */
18109 /* File: mips/alt_stub.S */
18110 /*
18111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18112  * any interesting requests and then jump to the real instruction
18113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18116  * bail to the real handler if breakFlags==0.
18117  */
18118     lbu    a3, offThread_breakFlags(rSELF)
18119     la     rBIX, dvmAsmInstructionStart + (38 * 128)
18120     lw     rIBASE, offThread_curHandlerTable(rSELF)
18121     bnez   a3, 1f
18122     jr     rBIX            # nothing to do - jump to real handler
18123 1:
18124     EXPORT_PC()
18125     move   a0, rPC         # arg0
18126     move   a1, rFP         # arg1
18127     move   a2, rSELF       # arg2
18128     JAL(dvmCheckBefore)
18129     jr     rBIX
18130
18131 /* ------------------------------ */
18132     .balign 128
18133 .L_ALT_OP_THROW: /* 0x27 */
18134 /* File: mips/alt_stub.S */
18135 /*
18136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18137  * any interesting requests and then jump to the real instruction
18138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18141  * bail to the real handler if breakFlags==0.
18142  */
18143     lbu    a3, offThread_breakFlags(rSELF)
18144     la     rBIX, dvmAsmInstructionStart + (39 * 128)
18145     lw     rIBASE, offThread_curHandlerTable(rSELF)
18146     bnez   a3, 1f
18147     jr     rBIX            # nothing to do - jump to real handler
18148 1:
18149     EXPORT_PC()
18150     move   a0, rPC         # arg0
18151     move   a1, rFP         # arg1
18152     move   a2, rSELF       # arg2
18153     JAL(dvmCheckBefore)
18154     jr     rBIX
18155
18156 /* ------------------------------ */
18157     .balign 128
18158 .L_ALT_OP_GOTO: /* 0x28 */
18159 /* File: mips/alt_stub.S */
18160 /*
18161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18162  * any interesting requests and then jump to the real instruction
18163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18166  * bail to the real handler if breakFlags==0.
18167  */
18168     lbu    a3, offThread_breakFlags(rSELF)
18169     la     rBIX, dvmAsmInstructionStart + (40 * 128)
18170     lw     rIBASE, offThread_curHandlerTable(rSELF)
18171     bnez   a3, 1f
18172     jr     rBIX            # nothing to do - jump to real handler
18173 1:
18174     EXPORT_PC()
18175     move   a0, rPC         # arg0
18176     move   a1, rFP         # arg1
18177     move   a2, rSELF       # arg2
18178     JAL(dvmCheckBefore)
18179     jr     rBIX
18180
18181 /* ------------------------------ */
18182     .balign 128
18183 .L_ALT_OP_GOTO_16: /* 0x29 */
18184 /* File: mips/alt_stub.S */
18185 /*
18186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18187  * any interesting requests and then jump to the real instruction
18188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18191  * bail to the real handler if breakFlags==0.
18192  */
18193     lbu    a3, offThread_breakFlags(rSELF)
18194     la     rBIX, dvmAsmInstructionStart + (41 * 128)
18195     lw     rIBASE, offThread_curHandlerTable(rSELF)
18196     bnez   a3, 1f
18197     jr     rBIX            # nothing to do - jump to real handler
18198 1:
18199     EXPORT_PC()
18200     move   a0, rPC         # arg0
18201     move   a1, rFP         # arg1
18202     move   a2, rSELF       # arg2
18203     JAL(dvmCheckBefore)
18204     jr     rBIX
18205
18206 /* ------------------------------ */
18207     .balign 128
18208 .L_ALT_OP_GOTO_32: /* 0x2a */
18209 /* File: mips/alt_stub.S */
18210 /*
18211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18212  * any interesting requests and then jump to the real instruction
18213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18216  * bail to the real handler if breakFlags==0.
18217  */
18218     lbu    a3, offThread_breakFlags(rSELF)
18219     la     rBIX, dvmAsmInstructionStart + (42 * 128)
18220     lw     rIBASE, offThread_curHandlerTable(rSELF)
18221     bnez   a3, 1f
18222     jr     rBIX            # nothing to do - jump to real handler
18223 1:
18224     EXPORT_PC()
18225     move   a0, rPC         # arg0
18226     move   a1, rFP         # arg1
18227     move   a2, rSELF       # arg2
18228     JAL(dvmCheckBefore)
18229     jr     rBIX
18230
18231 /* ------------------------------ */
18232     .balign 128
18233 .L_ALT_OP_PACKED_SWITCH: /* 0x2b */
18234 /* File: mips/alt_stub.S */
18235 /*
18236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18237  * any interesting requests and then jump to the real instruction
18238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18241  * bail to the real handler if breakFlags==0.
18242  */
18243     lbu    a3, offThread_breakFlags(rSELF)
18244     la     rBIX, dvmAsmInstructionStart + (43 * 128)
18245     lw     rIBASE, offThread_curHandlerTable(rSELF)
18246     bnez   a3, 1f
18247     jr     rBIX            # nothing to do - jump to real handler
18248 1:
18249     EXPORT_PC()
18250     move   a0, rPC         # arg0
18251     move   a1, rFP         # arg1
18252     move   a2, rSELF       # arg2
18253     JAL(dvmCheckBefore)
18254     jr     rBIX
18255
18256 /* ------------------------------ */
18257     .balign 128
18258 .L_ALT_OP_SPARSE_SWITCH: /* 0x2c */
18259 /* File: mips/alt_stub.S */
18260 /*
18261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18262  * any interesting requests and then jump to the real instruction
18263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18266  * bail to the real handler if breakFlags==0.
18267  */
18268     lbu    a3, offThread_breakFlags(rSELF)
18269     la     rBIX, dvmAsmInstructionStart + (44 * 128)
18270     lw     rIBASE, offThread_curHandlerTable(rSELF)
18271     bnez   a3, 1f
18272     jr     rBIX            # nothing to do - jump to real handler
18273 1:
18274     EXPORT_PC()
18275     move   a0, rPC         # arg0
18276     move   a1, rFP         # arg1
18277     move   a2, rSELF       # arg2
18278     JAL(dvmCheckBefore)
18279     jr     rBIX
18280
18281 /* ------------------------------ */
18282     .balign 128
18283 .L_ALT_OP_CMPL_FLOAT: /* 0x2d */
18284 /* File: mips/alt_stub.S */
18285 /*
18286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18287  * any interesting requests and then jump to the real instruction
18288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18291  * bail to the real handler if breakFlags==0.
18292  */
18293     lbu    a3, offThread_breakFlags(rSELF)
18294     la     rBIX, dvmAsmInstructionStart + (45 * 128)
18295     lw     rIBASE, offThread_curHandlerTable(rSELF)
18296     bnez   a3, 1f
18297     jr     rBIX            # nothing to do - jump to real handler
18298 1:
18299     EXPORT_PC()
18300     move   a0, rPC         # arg0
18301     move   a1, rFP         # arg1
18302     move   a2, rSELF       # arg2
18303     JAL(dvmCheckBefore)
18304     jr     rBIX
18305
18306 /* ------------------------------ */
18307     .balign 128
18308 .L_ALT_OP_CMPG_FLOAT: /* 0x2e */
18309 /* File: mips/alt_stub.S */
18310 /*
18311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18312  * any interesting requests and then jump to the real instruction
18313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18316  * bail to the real handler if breakFlags==0.
18317  */
18318     lbu    a3, offThread_breakFlags(rSELF)
18319     la     rBIX, dvmAsmInstructionStart + (46 * 128)
18320     lw     rIBASE, offThread_curHandlerTable(rSELF)
18321     bnez   a3, 1f
18322     jr     rBIX            # nothing to do - jump to real handler
18323 1:
18324     EXPORT_PC()
18325     move   a0, rPC         # arg0
18326     move   a1, rFP         # arg1
18327     move   a2, rSELF       # arg2
18328     JAL(dvmCheckBefore)
18329     jr     rBIX
18330
18331 /* ------------------------------ */
18332     .balign 128
18333 .L_ALT_OP_CMPL_DOUBLE: /* 0x2f */
18334 /* File: mips/alt_stub.S */
18335 /*
18336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18337  * any interesting requests and then jump to the real instruction
18338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18341  * bail to the real handler if breakFlags==0.
18342  */
18343     lbu    a3, offThread_breakFlags(rSELF)
18344     la     rBIX, dvmAsmInstructionStart + (47 * 128)
18345     lw     rIBASE, offThread_curHandlerTable(rSELF)
18346     bnez   a3, 1f
18347     jr     rBIX            # nothing to do - jump to real handler
18348 1:
18349     EXPORT_PC()
18350     move   a0, rPC         # arg0
18351     move   a1, rFP         # arg1
18352     move   a2, rSELF       # arg2
18353     JAL(dvmCheckBefore)
18354     jr     rBIX
18355
18356 /* ------------------------------ */
18357     .balign 128
18358 .L_ALT_OP_CMPG_DOUBLE: /* 0x30 */
18359 /* File: mips/alt_stub.S */
18360 /*
18361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18362  * any interesting requests and then jump to the real instruction
18363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18366  * bail to the real handler if breakFlags==0.
18367  */
18368     lbu    a3, offThread_breakFlags(rSELF)
18369     la     rBIX, dvmAsmInstructionStart + (48 * 128)
18370     lw     rIBASE, offThread_curHandlerTable(rSELF)
18371     bnez   a3, 1f
18372     jr     rBIX            # nothing to do - jump to real handler
18373 1:
18374     EXPORT_PC()
18375     move   a0, rPC         # arg0
18376     move   a1, rFP         # arg1
18377     move   a2, rSELF       # arg2
18378     JAL(dvmCheckBefore)
18379     jr     rBIX
18380
18381 /* ------------------------------ */
18382     .balign 128
18383 .L_ALT_OP_CMP_LONG: /* 0x31 */
18384 /* File: mips/alt_stub.S */
18385 /*
18386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18387  * any interesting requests and then jump to the real instruction
18388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18391  * bail to the real handler if breakFlags==0.
18392  */
18393     lbu    a3, offThread_breakFlags(rSELF)
18394     la     rBIX, dvmAsmInstructionStart + (49 * 128)
18395     lw     rIBASE, offThread_curHandlerTable(rSELF)
18396     bnez   a3, 1f
18397     jr     rBIX            # nothing to do - jump to real handler
18398 1:
18399     EXPORT_PC()
18400     move   a0, rPC         # arg0
18401     move   a1, rFP         # arg1
18402     move   a2, rSELF       # arg2
18403     JAL(dvmCheckBefore)
18404     jr     rBIX
18405
18406 /* ------------------------------ */
18407     .balign 128
18408 .L_ALT_OP_IF_EQ: /* 0x32 */
18409 /* File: mips/alt_stub.S */
18410 /*
18411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18412  * any interesting requests and then jump to the real instruction
18413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18416  * bail to the real handler if breakFlags==0.
18417  */
18418     lbu    a3, offThread_breakFlags(rSELF)
18419     la     rBIX, dvmAsmInstructionStart + (50 * 128)
18420     lw     rIBASE, offThread_curHandlerTable(rSELF)
18421     bnez   a3, 1f
18422     jr     rBIX            # nothing to do - jump to real handler
18423 1:
18424     EXPORT_PC()
18425     move   a0, rPC         # arg0
18426     move   a1, rFP         # arg1
18427     move   a2, rSELF       # arg2
18428     JAL(dvmCheckBefore)
18429     jr     rBIX
18430
18431 /* ------------------------------ */
18432     .balign 128
18433 .L_ALT_OP_IF_NE: /* 0x33 */
18434 /* File: mips/alt_stub.S */
18435 /*
18436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18437  * any interesting requests and then jump to the real instruction
18438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18441  * bail to the real handler if breakFlags==0.
18442  */
18443     lbu    a3, offThread_breakFlags(rSELF)
18444     la     rBIX, dvmAsmInstructionStart + (51 * 128)
18445     lw     rIBASE, offThread_curHandlerTable(rSELF)
18446     bnez   a3, 1f
18447     jr     rBIX            # nothing to do - jump to real handler
18448 1:
18449     EXPORT_PC()
18450     move   a0, rPC         # arg0
18451     move   a1, rFP         # arg1
18452     move   a2, rSELF       # arg2
18453     JAL(dvmCheckBefore)
18454     jr     rBIX
18455
18456 /* ------------------------------ */
18457     .balign 128
18458 .L_ALT_OP_IF_LT: /* 0x34 */
18459 /* File: mips/alt_stub.S */
18460 /*
18461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18462  * any interesting requests and then jump to the real instruction
18463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18466  * bail to the real handler if breakFlags==0.
18467  */
18468     lbu    a3, offThread_breakFlags(rSELF)
18469     la     rBIX, dvmAsmInstructionStart + (52 * 128)
18470     lw     rIBASE, offThread_curHandlerTable(rSELF)
18471     bnez   a3, 1f
18472     jr     rBIX            # nothing to do - jump to real handler
18473 1:
18474     EXPORT_PC()
18475     move   a0, rPC         # arg0
18476     move   a1, rFP         # arg1
18477     move   a2, rSELF       # arg2
18478     JAL(dvmCheckBefore)
18479     jr     rBIX
18480
18481 /* ------------------------------ */
18482     .balign 128
18483 .L_ALT_OP_IF_GE: /* 0x35 */
18484 /* File: mips/alt_stub.S */
18485 /*
18486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18487  * any interesting requests and then jump to the real instruction
18488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18491  * bail to the real handler if breakFlags==0.
18492  */
18493     lbu    a3, offThread_breakFlags(rSELF)
18494     la     rBIX, dvmAsmInstructionStart + (53 * 128)
18495     lw     rIBASE, offThread_curHandlerTable(rSELF)
18496     bnez   a3, 1f
18497     jr     rBIX            # nothing to do - jump to real handler
18498 1:
18499     EXPORT_PC()
18500     move   a0, rPC         # arg0
18501     move   a1, rFP         # arg1
18502     move   a2, rSELF       # arg2
18503     JAL(dvmCheckBefore)
18504     jr     rBIX
18505
18506 /* ------------------------------ */
18507     .balign 128
18508 .L_ALT_OP_IF_GT: /* 0x36 */
18509 /* File: mips/alt_stub.S */
18510 /*
18511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18512  * any interesting requests and then jump to the real instruction
18513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18516  * bail to the real handler if breakFlags==0.
18517  */
18518     lbu    a3, offThread_breakFlags(rSELF)
18519     la     rBIX, dvmAsmInstructionStart + (54 * 128)
18520     lw     rIBASE, offThread_curHandlerTable(rSELF)
18521     bnez   a3, 1f
18522     jr     rBIX            # nothing to do - jump to real handler
18523 1:
18524     EXPORT_PC()
18525     move   a0, rPC         # arg0
18526     move   a1, rFP         # arg1
18527     move   a2, rSELF       # arg2
18528     JAL(dvmCheckBefore)
18529     jr     rBIX
18530
18531 /* ------------------------------ */
18532     .balign 128
18533 .L_ALT_OP_IF_LE: /* 0x37 */
18534 /* File: mips/alt_stub.S */
18535 /*
18536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18537  * any interesting requests and then jump to the real instruction
18538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18541  * bail to the real handler if breakFlags==0.
18542  */
18543     lbu    a3, offThread_breakFlags(rSELF)
18544     la     rBIX, dvmAsmInstructionStart + (55 * 128)
18545     lw     rIBASE, offThread_curHandlerTable(rSELF)
18546     bnez   a3, 1f
18547     jr     rBIX            # nothing to do - jump to real handler
18548 1:
18549     EXPORT_PC()
18550     move   a0, rPC         # arg0
18551     move   a1, rFP         # arg1
18552     move   a2, rSELF       # arg2
18553     JAL(dvmCheckBefore)
18554     jr     rBIX
18555
18556 /* ------------------------------ */
18557     .balign 128
18558 .L_ALT_OP_IF_EQZ: /* 0x38 */
18559 /* File: mips/alt_stub.S */
18560 /*
18561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18562  * any interesting requests and then jump to the real instruction
18563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18566  * bail to the real handler if breakFlags==0.
18567  */
18568     lbu    a3, offThread_breakFlags(rSELF)
18569     la     rBIX, dvmAsmInstructionStart + (56 * 128)
18570     lw     rIBASE, offThread_curHandlerTable(rSELF)
18571     bnez   a3, 1f
18572     jr     rBIX            # nothing to do - jump to real handler
18573 1:
18574     EXPORT_PC()
18575     move   a0, rPC         # arg0
18576     move   a1, rFP         # arg1
18577     move   a2, rSELF       # arg2
18578     JAL(dvmCheckBefore)
18579     jr     rBIX
18580
18581 /* ------------------------------ */
18582     .balign 128
18583 .L_ALT_OP_IF_NEZ: /* 0x39 */
18584 /* File: mips/alt_stub.S */
18585 /*
18586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18587  * any interesting requests and then jump to the real instruction
18588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18591  * bail to the real handler if breakFlags==0.
18592  */
18593     lbu    a3, offThread_breakFlags(rSELF)
18594     la     rBIX, dvmAsmInstructionStart + (57 * 128)
18595     lw     rIBASE, offThread_curHandlerTable(rSELF)
18596     bnez   a3, 1f
18597     jr     rBIX            # nothing to do - jump to real handler
18598 1:
18599     EXPORT_PC()
18600     move   a0, rPC         # arg0
18601     move   a1, rFP         # arg1
18602     move   a2, rSELF       # arg2
18603     JAL(dvmCheckBefore)
18604     jr     rBIX
18605
18606 /* ------------------------------ */
18607     .balign 128
18608 .L_ALT_OP_IF_LTZ: /* 0x3a */
18609 /* File: mips/alt_stub.S */
18610 /*
18611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18612  * any interesting requests and then jump to the real instruction
18613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18616  * bail to the real handler if breakFlags==0.
18617  */
18618     lbu    a3, offThread_breakFlags(rSELF)
18619     la     rBIX, dvmAsmInstructionStart + (58 * 128)
18620     lw     rIBASE, offThread_curHandlerTable(rSELF)
18621     bnez   a3, 1f
18622     jr     rBIX            # nothing to do - jump to real handler
18623 1:
18624     EXPORT_PC()
18625     move   a0, rPC         # arg0
18626     move   a1, rFP         # arg1
18627     move   a2, rSELF       # arg2
18628     JAL(dvmCheckBefore)
18629     jr     rBIX
18630
18631 /* ------------------------------ */
18632     .balign 128
18633 .L_ALT_OP_IF_GEZ: /* 0x3b */
18634 /* File: mips/alt_stub.S */
18635 /*
18636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18637  * any interesting requests and then jump to the real instruction
18638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18641  * bail to the real handler if breakFlags==0.
18642  */
18643     lbu    a3, offThread_breakFlags(rSELF)
18644     la     rBIX, dvmAsmInstructionStart + (59 * 128)
18645     lw     rIBASE, offThread_curHandlerTable(rSELF)
18646     bnez   a3, 1f
18647     jr     rBIX            # nothing to do - jump to real handler
18648 1:
18649     EXPORT_PC()
18650     move   a0, rPC         # arg0
18651     move   a1, rFP         # arg1
18652     move   a2, rSELF       # arg2
18653     JAL(dvmCheckBefore)
18654     jr     rBIX
18655
18656 /* ------------------------------ */
18657     .balign 128
18658 .L_ALT_OP_IF_GTZ: /* 0x3c */
18659 /* File: mips/alt_stub.S */
18660 /*
18661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18662  * any interesting requests and then jump to the real instruction
18663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18666  * bail to the real handler if breakFlags==0.
18667  */
18668     lbu    a3, offThread_breakFlags(rSELF)
18669     la     rBIX, dvmAsmInstructionStart + (60 * 128)
18670     lw     rIBASE, offThread_curHandlerTable(rSELF)
18671     bnez   a3, 1f
18672     jr     rBIX            # nothing to do - jump to real handler
18673 1:
18674     EXPORT_PC()
18675     move   a0, rPC         # arg0
18676     move   a1, rFP         # arg1
18677     move   a2, rSELF       # arg2
18678     JAL(dvmCheckBefore)
18679     jr     rBIX
18680
18681 /* ------------------------------ */
18682     .balign 128
18683 .L_ALT_OP_IF_LEZ: /* 0x3d */
18684 /* File: mips/alt_stub.S */
18685 /*
18686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18687  * any interesting requests and then jump to the real instruction
18688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18691  * bail to the real handler if breakFlags==0.
18692  */
18693     lbu    a3, offThread_breakFlags(rSELF)
18694     la     rBIX, dvmAsmInstructionStart + (61 * 128)
18695     lw     rIBASE, offThread_curHandlerTable(rSELF)
18696     bnez   a3, 1f
18697     jr     rBIX            # nothing to do - jump to real handler
18698 1:
18699     EXPORT_PC()
18700     move   a0, rPC         # arg0
18701     move   a1, rFP         # arg1
18702     move   a2, rSELF       # arg2
18703     JAL(dvmCheckBefore)
18704     jr     rBIX
18705
18706 /* ------------------------------ */
18707     .balign 128
18708 .L_ALT_OP_UNUSED_3E: /* 0x3e */
18709 /* File: mips/alt_stub.S */
18710 /*
18711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18712  * any interesting requests and then jump to the real instruction
18713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18716  * bail to the real handler if breakFlags==0.
18717  */
18718     lbu    a3, offThread_breakFlags(rSELF)
18719     la     rBIX, dvmAsmInstructionStart + (62 * 128)
18720     lw     rIBASE, offThread_curHandlerTable(rSELF)
18721     bnez   a3, 1f
18722     jr     rBIX            # nothing to do - jump to real handler
18723 1:
18724     EXPORT_PC()
18725     move   a0, rPC         # arg0
18726     move   a1, rFP         # arg1
18727     move   a2, rSELF       # arg2
18728     JAL(dvmCheckBefore)
18729     jr     rBIX
18730
18731 /* ------------------------------ */
18732     .balign 128
18733 .L_ALT_OP_UNUSED_3F: /* 0x3f */
18734 /* File: mips/alt_stub.S */
18735 /*
18736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18737  * any interesting requests and then jump to the real instruction
18738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18741  * bail to the real handler if breakFlags==0.
18742  */
18743     lbu    a3, offThread_breakFlags(rSELF)
18744     la     rBIX, dvmAsmInstructionStart + (63 * 128)
18745     lw     rIBASE, offThread_curHandlerTable(rSELF)
18746     bnez   a3, 1f
18747     jr     rBIX            # nothing to do - jump to real handler
18748 1:
18749     EXPORT_PC()
18750     move   a0, rPC         # arg0
18751     move   a1, rFP         # arg1
18752     move   a2, rSELF       # arg2
18753     JAL(dvmCheckBefore)
18754     jr     rBIX
18755
18756 /* ------------------------------ */
18757     .balign 128
18758 .L_ALT_OP_UNUSED_40: /* 0x40 */
18759 /* File: mips/alt_stub.S */
18760 /*
18761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18762  * any interesting requests and then jump to the real instruction
18763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18766  * bail to the real handler if breakFlags==0.
18767  */
18768     lbu    a3, offThread_breakFlags(rSELF)
18769     la     rBIX, dvmAsmInstructionStart + (64 * 128)
18770     lw     rIBASE, offThread_curHandlerTable(rSELF)
18771     bnez   a3, 1f
18772     jr     rBIX            # nothing to do - jump to real handler
18773 1:
18774     EXPORT_PC()
18775     move   a0, rPC         # arg0
18776     move   a1, rFP         # arg1
18777     move   a2, rSELF       # arg2
18778     JAL(dvmCheckBefore)
18779     jr     rBIX
18780
18781 /* ------------------------------ */
18782     .balign 128
18783 .L_ALT_OP_UNUSED_41: /* 0x41 */
18784 /* File: mips/alt_stub.S */
18785 /*
18786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18787  * any interesting requests and then jump to the real instruction
18788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18791  * bail to the real handler if breakFlags==0.
18792  */
18793     lbu    a3, offThread_breakFlags(rSELF)
18794     la     rBIX, dvmAsmInstructionStart + (65 * 128)
18795     lw     rIBASE, offThread_curHandlerTable(rSELF)
18796     bnez   a3, 1f
18797     jr     rBIX            # nothing to do - jump to real handler
18798 1:
18799     EXPORT_PC()
18800     move   a0, rPC         # arg0
18801     move   a1, rFP         # arg1
18802     move   a2, rSELF       # arg2
18803     JAL(dvmCheckBefore)
18804     jr     rBIX
18805
18806 /* ------------------------------ */
18807     .balign 128
18808 .L_ALT_OP_UNUSED_42: /* 0x42 */
18809 /* File: mips/alt_stub.S */
18810 /*
18811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18812  * any interesting requests and then jump to the real instruction
18813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18816  * bail to the real handler if breakFlags==0.
18817  */
18818     lbu    a3, offThread_breakFlags(rSELF)
18819     la     rBIX, dvmAsmInstructionStart + (66 * 128)
18820     lw     rIBASE, offThread_curHandlerTable(rSELF)
18821     bnez   a3, 1f
18822     jr     rBIX            # nothing to do - jump to real handler
18823 1:
18824     EXPORT_PC()
18825     move   a0, rPC         # arg0
18826     move   a1, rFP         # arg1
18827     move   a2, rSELF       # arg2
18828     JAL(dvmCheckBefore)
18829     jr     rBIX
18830
18831 /* ------------------------------ */
18832     .balign 128
18833 .L_ALT_OP_UNUSED_43: /* 0x43 */
18834 /* File: mips/alt_stub.S */
18835 /*
18836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18837  * any interesting requests and then jump to the real instruction
18838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18841  * bail to the real handler if breakFlags==0.
18842  */
18843     lbu    a3, offThread_breakFlags(rSELF)
18844     la     rBIX, dvmAsmInstructionStart + (67 * 128)
18845     lw     rIBASE, offThread_curHandlerTable(rSELF)
18846     bnez   a3, 1f
18847     jr     rBIX            # nothing to do - jump to real handler
18848 1:
18849     EXPORT_PC()
18850     move   a0, rPC         # arg0
18851     move   a1, rFP         # arg1
18852     move   a2, rSELF       # arg2
18853     JAL(dvmCheckBefore)
18854     jr     rBIX
18855
18856 /* ------------------------------ */
18857     .balign 128
18858 .L_ALT_OP_AGET: /* 0x44 */
18859 /* File: mips/alt_stub.S */
18860 /*
18861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18862  * any interesting requests and then jump to the real instruction
18863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18866  * bail to the real handler if breakFlags==0.
18867  */
18868     lbu    a3, offThread_breakFlags(rSELF)
18869     la     rBIX, dvmAsmInstructionStart + (68 * 128)
18870     lw     rIBASE, offThread_curHandlerTable(rSELF)
18871     bnez   a3, 1f
18872     jr     rBIX            # nothing to do - jump to real handler
18873 1:
18874     EXPORT_PC()
18875     move   a0, rPC         # arg0
18876     move   a1, rFP         # arg1
18877     move   a2, rSELF       # arg2
18878     JAL(dvmCheckBefore)
18879     jr     rBIX
18880
18881 /* ------------------------------ */
18882     .balign 128
18883 .L_ALT_OP_AGET_WIDE: /* 0x45 */
18884 /* File: mips/alt_stub.S */
18885 /*
18886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18887  * any interesting requests and then jump to the real instruction
18888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18891  * bail to the real handler if breakFlags==0.
18892  */
18893     lbu    a3, offThread_breakFlags(rSELF)
18894     la     rBIX, dvmAsmInstructionStart + (69 * 128)
18895     lw     rIBASE, offThread_curHandlerTable(rSELF)
18896     bnez   a3, 1f
18897     jr     rBIX            # nothing to do - jump to real handler
18898 1:
18899     EXPORT_PC()
18900     move   a0, rPC         # arg0
18901     move   a1, rFP         # arg1
18902     move   a2, rSELF       # arg2
18903     JAL(dvmCheckBefore)
18904     jr     rBIX
18905
18906 /* ------------------------------ */
18907     .balign 128
18908 .L_ALT_OP_AGET_OBJECT: /* 0x46 */
18909 /* File: mips/alt_stub.S */
18910 /*
18911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18912  * any interesting requests and then jump to the real instruction
18913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18916  * bail to the real handler if breakFlags==0.
18917  */
18918     lbu    a3, offThread_breakFlags(rSELF)
18919     la     rBIX, dvmAsmInstructionStart + (70 * 128)
18920     lw     rIBASE, offThread_curHandlerTable(rSELF)
18921     bnez   a3, 1f
18922     jr     rBIX            # nothing to do - jump to real handler
18923 1:
18924     EXPORT_PC()
18925     move   a0, rPC         # arg0
18926     move   a1, rFP         # arg1
18927     move   a2, rSELF       # arg2
18928     JAL(dvmCheckBefore)
18929     jr     rBIX
18930
18931 /* ------------------------------ */
18932     .balign 128
18933 .L_ALT_OP_AGET_BOOLEAN: /* 0x47 */
18934 /* File: mips/alt_stub.S */
18935 /*
18936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18937  * any interesting requests and then jump to the real instruction
18938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18941  * bail to the real handler if breakFlags==0.
18942  */
18943     lbu    a3, offThread_breakFlags(rSELF)
18944     la     rBIX, dvmAsmInstructionStart + (71 * 128)
18945     lw     rIBASE, offThread_curHandlerTable(rSELF)
18946     bnez   a3, 1f
18947     jr     rBIX            # nothing to do - jump to real handler
18948 1:
18949     EXPORT_PC()
18950     move   a0, rPC         # arg0
18951     move   a1, rFP         # arg1
18952     move   a2, rSELF       # arg2
18953     JAL(dvmCheckBefore)
18954     jr     rBIX
18955
18956 /* ------------------------------ */
18957     .balign 128
18958 .L_ALT_OP_AGET_BYTE: /* 0x48 */
18959 /* File: mips/alt_stub.S */
18960 /*
18961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18962  * any interesting requests and then jump to the real instruction
18963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18966  * bail to the real handler if breakFlags==0.
18967  */
18968     lbu    a3, offThread_breakFlags(rSELF)
18969     la     rBIX, dvmAsmInstructionStart + (72 * 128)
18970     lw     rIBASE, offThread_curHandlerTable(rSELF)
18971     bnez   a3, 1f
18972     jr     rBIX            # nothing to do - jump to real handler
18973 1:
18974     EXPORT_PC()
18975     move   a0, rPC         # arg0
18976     move   a1, rFP         # arg1
18977     move   a2, rSELF       # arg2
18978     JAL(dvmCheckBefore)
18979     jr     rBIX
18980
18981 /* ------------------------------ */
18982     .balign 128
18983 .L_ALT_OP_AGET_CHAR: /* 0x49 */
18984 /* File: mips/alt_stub.S */
18985 /*
18986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
18987  * any interesting requests and then jump to the real instruction
18988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
18989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
18990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
18991  * bail to the real handler if breakFlags==0.
18992  */
18993     lbu    a3, offThread_breakFlags(rSELF)
18994     la     rBIX, dvmAsmInstructionStart + (73 * 128)
18995     lw     rIBASE, offThread_curHandlerTable(rSELF)
18996     bnez   a3, 1f
18997     jr     rBIX            # nothing to do - jump to real handler
18998 1:
18999     EXPORT_PC()
19000     move   a0, rPC         # arg0
19001     move   a1, rFP         # arg1
19002     move   a2, rSELF       # arg2
19003     JAL(dvmCheckBefore)
19004     jr     rBIX
19005
19006 /* ------------------------------ */
19007     .balign 128
19008 .L_ALT_OP_AGET_SHORT: /* 0x4a */
19009 /* File: mips/alt_stub.S */
19010 /*
19011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19012  * any interesting requests and then jump to the real instruction
19013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19016  * bail to the real handler if breakFlags==0.
19017  */
19018     lbu    a3, offThread_breakFlags(rSELF)
19019     la     rBIX, dvmAsmInstructionStart + (74 * 128)
19020     lw     rIBASE, offThread_curHandlerTable(rSELF)
19021     bnez   a3, 1f
19022     jr     rBIX            # nothing to do - jump to real handler
19023 1:
19024     EXPORT_PC()
19025     move   a0, rPC         # arg0
19026     move   a1, rFP         # arg1
19027     move   a2, rSELF       # arg2
19028     JAL(dvmCheckBefore)
19029     jr     rBIX
19030
19031 /* ------------------------------ */
19032     .balign 128
19033 .L_ALT_OP_APUT: /* 0x4b */
19034 /* File: mips/alt_stub.S */
19035 /*
19036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19037  * any interesting requests and then jump to the real instruction
19038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19041  * bail to the real handler if breakFlags==0.
19042  */
19043     lbu    a3, offThread_breakFlags(rSELF)
19044     la     rBIX, dvmAsmInstructionStart + (75 * 128)
19045     lw     rIBASE, offThread_curHandlerTable(rSELF)
19046     bnez   a3, 1f
19047     jr     rBIX            # nothing to do - jump to real handler
19048 1:
19049     EXPORT_PC()
19050     move   a0, rPC         # arg0
19051     move   a1, rFP         # arg1
19052     move   a2, rSELF       # arg2
19053     JAL(dvmCheckBefore)
19054     jr     rBIX
19055
19056 /* ------------------------------ */
19057     .balign 128
19058 .L_ALT_OP_APUT_WIDE: /* 0x4c */
19059 /* File: mips/alt_stub.S */
19060 /*
19061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19062  * any interesting requests and then jump to the real instruction
19063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19066  * bail to the real handler if breakFlags==0.
19067  */
19068     lbu    a3, offThread_breakFlags(rSELF)
19069     la     rBIX, dvmAsmInstructionStart + (76 * 128)
19070     lw     rIBASE, offThread_curHandlerTable(rSELF)
19071     bnez   a3, 1f
19072     jr     rBIX            # nothing to do - jump to real handler
19073 1:
19074     EXPORT_PC()
19075     move   a0, rPC         # arg0
19076     move   a1, rFP         # arg1
19077     move   a2, rSELF       # arg2
19078     JAL(dvmCheckBefore)
19079     jr     rBIX
19080
19081 /* ------------------------------ */
19082     .balign 128
19083 .L_ALT_OP_APUT_OBJECT: /* 0x4d */
19084 /* File: mips/alt_stub.S */
19085 /*
19086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19087  * any interesting requests and then jump to the real instruction
19088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19091  * bail to the real handler if breakFlags==0.
19092  */
19093     lbu    a3, offThread_breakFlags(rSELF)
19094     la     rBIX, dvmAsmInstructionStart + (77 * 128)
19095     lw     rIBASE, offThread_curHandlerTable(rSELF)
19096     bnez   a3, 1f
19097     jr     rBIX            # nothing to do - jump to real handler
19098 1:
19099     EXPORT_PC()
19100     move   a0, rPC         # arg0
19101     move   a1, rFP         # arg1
19102     move   a2, rSELF       # arg2
19103     JAL(dvmCheckBefore)
19104     jr     rBIX
19105
19106 /* ------------------------------ */
19107     .balign 128
19108 .L_ALT_OP_APUT_BOOLEAN: /* 0x4e */
19109 /* File: mips/alt_stub.S */
19110 /*
19111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19112  * any interesting requests and then jump to the real instruction
19113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19116  * bail to the real handler if breakFlags==0.
19117  */
19118     lbu    a3, offThread_breakFlags(rSELF)
19119     la     rBIX, dvmAsmInstructionStart + (78 * 128)
19120     lw     rIBASE, offThread_curHandlerTable(rSELF)
19121     bnez   a3, 1f
19122     jr     rBIX            # nothing to do - jump to real handler
19123 1:
19124     EXPORT_PC()
19125     move   a0, rPC         # arg0
19126     move   a1, rFP         # arg1
19127     move   a2, rSELF       # arg2
19128     JAL(dvmCheckBefore)
19129     jr     rBIX
19130
19131 /* ------------------------------ */
19132     .balign 128
19133 .L_ALT_OP_APUT_BYTE: /* 0x4f */
19134 /* File: mips/alt_stub.S */
19135 /*
19136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19137  * any interesting requests and then jump to the real instruction
19138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19141  * bail to the real handler if breakFlags==0.
19142  */
19143     lbu    a3, offThread_breakFlags(rSELF)
19144     la     rBIX, dvmAsmInstructionStart + (79 * 128)
19145     lw     rIBASE, offThread_curHandlerTable(rSELF)
19146     bnez   a3, 1f
19147     jr     rBIX            # nothing to do - jump to real handler
19148 1:
19149     EXPORT_PC()
19150     move   a0, rPC         # arg0
19151     move   a1, rFP         # arg1
19152     move   a2, rSELF       # arg2
19153     JAL(dvmCheckBefore)
19154     jr     rBIX
19155
19156 /* ------------------------------ */
19157     .balign 128
19158 .L_ALT_OP_APUT_CHAR: /* 0x50 */
19159 /* File: mips/alt_stub.S */
19160 /*
19161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19162  * any interesting requests and then jump to the real instruction
19163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19166  * bail to the real handler if breakFlags==0.
19167  */
19168     lbu    a3, offThread_breakFlags(rSELF)
19169     la     rBIX, dvmAsmInstructionStart + (80 * 128)
19170     lw     rIBASE, offThread_curHandlerTable(rSELF)
19171     bnez   a3, 1f
19172     jr     rBIX            # nothing to do - jump to real handler
19173 1:
19174     EXPORT_PC()
19175     move   a0, rPC         # arg0
19176     move   a1, rFP         # arg1
19177     move   a2, rSELF       # arg2
19178     JAL(dvmCheckBefore)
19179     jr     rBIX
19180
19181 /* ------------------------------ */
19182     .balign 128
19183 .L_ALT_OP_APUT_SHORT: /* 0x51 */
19184 /* File: mips/alt_stub.S */
19185 /*
19186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19187  * any interesting requests and then jump to the real instruction
19188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19191  * bail to the real handler if breakFlags==0.
19192  */
19193     lbu    a3, offThread_breakFlags(rSELF)
19194     la     rBIX, dvmAsmInstructionStart + (81 * 128)
19195     lw     rIBASE, offThread_curHandlerTable(rSELF)
19196     bnez   a3, 1f
19197     jr     rBIX            # nothing to do - jump to real handler
19198 1:
19199     EXPORT_PC()
19200     move   a0, rPC         # arg0
19201     move   a1, rFP         # arg1
19202     move   a2, rSELF       # arg2
19203     JAL(dvmCheckBefore)
19204     jr     rBIX
19205
19206 /* ------------------------------ */
19207     .balign 128
19208 .L_ALT_OP_IGET: /* 0x52 */
19209 /* File: mips/alt_stub.S */
19210 /*
19211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19212  * any interesting requests and then jump to the real instruction
19213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19216  * bail to the real handler if breakFlags==0.
19217  */
19218     lbu    a3, offThread_breakFlags(rSELF)
19219     la     rBIX, dvmAsmInstructionStart + (82 * 128)
19220     lw     rIBASE, offThread_curHandlerTable(rSELF)
19221     bnez   a3, 1f
19222     jr     rBIX            # nothing to do - jump to real handler
19223 1:
19224     EXPORT_PC()
19225     move   a0, rPC         # arg0
19226     move   a1, rFP         # arg1
19227     move   a2, rSELF       # arg2
19228     JAL(dvmCheckBefore)
19229     jr     rBIX
19230
19231 /* ------------------------------ */
19232     .balign 128
19233 .L_ALT_OP_IGET_WIDE: /* 0x53 */
19234 /* File: mips/alt_stub.S */
19235 /*
19236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19237  * any interesting requests and then jump to the real instruction
19238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19241  * bail to the real handler if breakFlags==0.
19242  */
19243     lbu    a3, offThread_breakFlags(rSELF)
19244     la     rBIX, dvmAsmInstructionStart + (83 * 128)
19245     lw     rIBASE, offThread_curHandlerTable(rSELF)
19246     bnez   a3, 1f
19247     jr     rBIX            # nothing to do - jump to real handler
19248 1:
19249     EXPORT_PC()
19250     move   a0, rPC         # arg0
19251     move   a1, rFP         # arg1
19252     move   a2, rSELF       # arg2
19253     JAL(dvmCheckBefore)
19254     jr     rBIX
19255
19256 /* ------------------------------ */
19257     .balign 128
19258 .L_ALT_OP_IGET_OBJECT: /* 0x54 */
19259 /* File: mips/alt_stub.S */
19260 /*
19261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19262  * any interesting requests and then jump to the real instruction
19263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19266  * bail to the real handler if breakFlags==0.
19267  */
19268     lbu    a3, offThread_breakFlags(rSELF)
19269     la     rBIX, dvmAsmInstructionStart + (84 * 128)
19270     lw     rIBASE, offThread_curHandlerTable(rSELF)
19271     bnez   a3, 1f
19272     jr     rBIX            # nothing to do - jump to real handler
19273 1:
19274     EXPORT_PC()
19275     move   a0, rPC         # arg0
19276     move   a1, rFP         # arg1
19277     move   a2, rSELF       # arg2
19278     JAL(dvmCheckBefore)
19279     jr     rBIX
19280
19281 /* ------------------------------ */
19282     .balign 128
19283 .L_ALT_OP_IGET_BOOLEAN: /* 0x55 */
19284 /* File: mips/alt_stub.S */
19285 /*
19286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19287  * any interesting requests and then jump to the real instruction
19288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19291  * bail to the real handler if breakFlags==0.
19292  */
19293     lbu    a3, offThread_breakFlags(rSELF)
19294     la     rBIX, dvmAsmInstructionStart + (85 * 128)
19295     lw     rIBASE, offThread_curHandlerTable(rSELF)
19296     bnez   a3, 1f
19297     jr     rBIX            # nothing to do - jump to real handler
19298 1:
19299     EXPORT_PC()
19300     move   a0, rPC         # arg0
19301     move   a1, rFP         # arg1
19302     move   a2, rSELF       # arg2
19303     JAL(dvmCheckBefore)
19304     jr     rBIX
19305
19306 /* ------------------------------ */
19307     .balign 128
19308 .L_ALT_OP_IGET_BYTE: /* 0x56 */
19309 /* File: mips/alt_stub.S */
19310 /*
19311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19312  * any interesting requests and then jump to the real instruction
19313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19316  * bail to the real handler if breakFlags==0.
19317  */
19318     lbu    a3, offThread_breakFlags(rSELF)
19319     la     rBIX, dvmAsmInstructionStart + (86 * 128)
19320     lw     rIBASE, offThread_curHandlerTable(rSELF)
19321     bnez   a3, 1f
19322     jr     rBIX            # nothing to do - jump to real handler
19323 1:
19324     EXPORT_PC()
19325     move   a0, rPC         # arg0
19326     move   a1, rFP         # arg1
19327     move   a2, rSELF       # arg2
19328     JAL(dvmCheckBefore)
19329     jr     rBIX
19330
19331 /* ------------------------------ */
19332     .balign 128
19333 .L_ALT_OP_IGET_CHAR: /* 0x57 */
19334 /* File: mips/alt_stub.S */
19335 /*
19336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19337  * any interesting requests and then jump to the real instruction
19338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19341  * bail to the real handler if breakFlags==0.
19342  */
19343     lbu    a3, offThread_breakFlags(rSELF)
19344     la     rBIX, dvmAsmInstructionStart + (87 * 128)
19345     lw     rIBASE, offThread_curHandlerTable(rSELF)
19346     bnez   a3, 1f
19347     jr     rBIX            # nothing to do - jump to real handler
19348 1:
19349     EXPORT_PC()
19350     move   a0, rPC         # arg0
19351     move   a1, rFP         # arg1
19352     move   a2, rSELF       # arg2
19353     JAL(dvmCheckBefore)
19354     jr     rBIX
19355
19356 /* ------------------------------ */
19357     .balign 128
19358 .L_ALT_OP_IGET_SHORT: /* 0x58 */
19359 /* File: mips/alt_stub.S */
19360 /*
19361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19362  * any interesting requests and then jump to the real instruction
19363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19366  * bail to the real handler if breakFlags==0.
19367  */
19368     lbu    a3, offThread_breakFlags(rSELF)
19369     la     rBIX, dvmAsmInstructionStart + (88 * 128)
19370     lw     rIBASE, offThread_curHandlerTable(rSELF)
19371     bnez   a3, 1f
19372     jr     rBIX            # nothing to do - jump to real handler
19373 1:
19374     EXPORT_PC()
19375     move   a0, rPC         # arg0
19376     move   a1, rFP         # arg1
19377     move   a2, rSELF       # arg2
19378     JAL(dvmCheckBefore)
19379     jr     rBIX
19380
19381 /* ------------------------------ */
19382     .balign 128
19383 .L_ALT_OP_IPUT: /* 0x59 */
19384 /* File: mips/alt_stub.S */
19385 /*
19386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19387  * any interesting requests and then jump to the real instruction
19388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19391  * bail to the real handler if breakFlags==0.
19392  */
19393     lbu    a3, offThread_breakFlags(rSELF)
19394     la     rBIX, dvmAsmInstructionStart + (89 * 128)
19395     lw     rIBASE, offThread_curHandlerTable(rSELF)
19396     bnez   a3, 1f
19397     jr     rBIX            # nothing to do - jump to real handler
19398 1:
19399     EXPORT_PC()
19400     move   a0, rPC         # arg0
19401     move   a1, rFP         # arg1
19402     move   a2, rSELF       # arg2
19403     JAL(dvmCheckBefore)
19404     jr     rBIX
19405
19406 /* ------------------------------ */
19407     .balign 128
19408 .L_ALT_OP_IPUT_WIDE: /* 0x5a */
19409 /* File: mips/alt_stub.S */
19410 /*
19411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19412  * any interesting requests and then jump to the real instruction
19413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19416  * bail to the real handler if breakFlags==0.
19417  */
19418     lbu    a3, offThread_breakFlags(rSELF)
19419     la     rBIX, dvmAsmInstructionStart + (90 * 128)
19420     lw     rIBASE, offThread_curHandlerTable(rSELF)
19421     bnez   a3, 1f
19422     jr     rBIX            # nothing to do - jump to real handler
19423 1:
19424     EXPORT_PC()
19425     move   a0, rPC         # arg0
19426     move   a1, rFP         # arg1
19427     move   a2, rSELF       # arg2
19428     JAL(dvmCheckBefore)
19429     jr     rBIX
19430
19431 /* ------------------------------ */
19432     .balign 128
19433 .L_ALT_OP_IPUT_OBJECT: /* 0x5b */
19434 /* File: mips/alt_stub.S */
19435 /*
19436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19437  * any interesting requests and then jump to the real instruction
19438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19441  * bail to the real handler if breakFlags==0.
19442  */
19443     lbu    a3, offThread_breakFlags(rSELF)
19444     la     rBIX, dvmAsmInstructionStart + (91 * 128)
19445     lw     rIBASE, offThread_curHandlerTable(rSELF)
19446     bnez   a3, 1f
19447     jr     rBIX            # nothing to do - jump to real handler
19448 1:
19449     EXPORT_PC()
19450     move   a0, rPC         # arg0
19451     move   a1, rFP         # arg1
19452     move   a2, rSELF       # arg2
19453     JAL(dvmCheckBefore)
19454     jr     rBIX
19455
19456 /* ------------------------------ */
19457     .balign 128
19458 .L_ALT_OP_IPUT_BOOLEAN: /* 0x5c */
19459 /* File: mips/alt_stub.S */
19460 /*
19461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19462  * any interesting requests and then jump to the real instruction
19463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19466  * bail to the real handler if breakFlags==0.
19467  */
19468     lbu    a3, offThread_breakFlags(rSELF)
19469     la     rBIX, dvmAsmInstructionStart + (92 * 128)
19470     lw     rIBASE, offThread_curHandlerTable(rSELF)
19471     bnez   a3, 1f
19472     jr     rBIX            # nothing to do - jump to real handler
19473 1:
19474     EXPORT_PC()
19475     move   a0, rPC         # arg0
19476     move   a1, rFP         # arg1
19477     move   a2, rSELF       # arg2
19478     JAL(dvmCheckBefore)
19479     jr     rBIX
19480
19481 /* ------------------------------ */
19482     .balign 128
19483 .L_ALT_OP_IPUT_BYTE: /* 0x5d */
19484 /* File: mips/alt_stub.S */
19485 /*
19486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19487  * any interesting requests and then jump to the real instruction
19488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19491  * bail to the real handler if breakFlags==0.
19492  */
19493     lbu    a3, offThread_breakFlags(rSELF)
19494     la     rBIX, dvmAsmInstructionStart + (93 * 128)
19495     lw     rIBASE, offThread_curHandlerTable(rSELF)
19496     bnez   a3, 1f
19497     jr     rBIX            # nothing to do - jump to real handler
19498 1:
19499     EXPORT_PC()
19500     move   a0, rPC         # arg0
19501     move   a1, rFP         # arg1
19502     move   a2, rSELF       # arg2
19503     JAL(dvmCheckBefore)
19504     jr     rBIX
19505
19506 /* ------------------------------ */
19507     .balign 128
19508 .L_ALT_OP_IPUT_CHAR: /* 0x5e */
19509 /* File: mips/alt_stub.S */
19510 /*
19511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19512  * any interesting requests and then jump to the real instruction
19513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19516  * bail to the real handler if breakFlags==0.
19517  */
19518     lbu    a3, offThread_breakFlags(rSELF)
19519     la     rBIX, dvmAsmInstructionStart + (94 * 128)
19520     lw     rIBASE, offThread_curHandlerTable(rSELF)
19521     bnez   a3, 1f
19522     jr     rBIX            # nothing to do - jump to real handler
19523 1:
19524     EXPORT_PC()
19525     move   a0, rPC         # arg0
19526     move   a1, rFP         # arg1
19527     move   a2, rSELF       # arg2
19528     JAL(dvmCheckBefore)
19529     jr     rBIX
19530
19531 /* ------------------------------ */
19532     .balign 128
19533 .L_ALT_OP_IPUT_SHORT: /* 0x5f */
19534 /* File: mips/alt_stub.S */
19535 /*
19536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19537  * any interesting requests and then jump to the real instruction
19538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19541  * bail to the real handler if breakFlags==0.
19542  */
19543     lbu    a3, offThread_breakFlags(rSELF)
19544     la     rBIX, dvmAsmInstructionStart + (95 * 128)
19545     lw     rIBASE, offThread_curHandlerTable(rSELF)
19546     bnez   a3, 1f
19547     jr     rBIX            # nothing to do - jump to real handler
19548 1:
19549     EXPORT_PC()
19550     move   a0, rPC         # arg0
19551     move   a1, rFP         # arg1
19552     move   a2, rSELF       # arg2
19553     JAL(dvmCheckBefore)
19554     jr     rBIX
19555
19556 /* ------------------------------ */
19557     .balign 128
19558 .L_ALT_OP_SGET: /* 0x60 */
19559 /* File: mips/alt_stub.S */
19560 /*
19561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19562  * any interesting requests and then jump to the real instruction
19563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19566  * bail to the real handler if breakFlags==0.
19567  */
19568     lbu    a3, offThread_breakFlags(rSELF)
19569     la     rBIX, dvmAsmInstructionStart + (96 * 128)
19570     lw     rIBASE, offThread_curHandlerTable(rSELF)
19571     bnez   a3, 1f
19572     jr     rBIX            # nothing to do - jump to real handler
19573 1:
19574     EXPORT_PC()
19575     move   a0, rPC         # arg0
19576     move   a1, rFP         # arg1
19577     move   a2, rSELF       # arg2
19578     JAL(dvmCheckBefore)
19579     jr     rBIX
19580
19581 /* ------------------------------ */
19582     .balign 128
19583 .L_ALT_OP_SGET_WIDE: /* 0x61 */
19584 /* File: mips/alt_stub.S */
19585 /*
19586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19587  * any interesting requests and then jump to the real instruction
19588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19591  * bail to the real handler if breakFlags==0.
19592  */
19593     lbu    a3, offThread_breakFlags(rSELF)
19594     la     rBIX, dvmAsmInstructionStart + (97 * 128)
19595     lw     rIBASE, offThread_curHandlerTable(rSELF)
19596     bnez   a3, 1f
19597     jr     rBIX            # nothing to do - jump to real handler
19598 1:
19599     EXPORT_PC()
19600     move   a0, rPC         # arg0
19601     move   a1, rFP         # arg1
19602     move   a2, rSELF       # arg2
19603     JAL(dvmCheckBefore)
19604     jr     rBIX
19605
19606 /* ------------------------------ */
19607     .balign 128
19608 .L_ALT_OP_SGET_OBJECT: /* 0x62 */
19609 /* File: mips/alt_stub.S */
19610 /*
19611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19612  * any interesting requests and then jump to the real instruction
19613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19616  * bail to the real handler if breakFlags==0.
19617  */
19618     lbu    a3, offThread_breakFlags(rSELF)
19619     la     rBIX, dvmAsmInstructionStart + (98 * 128)
19620     lw     rIBASE, offThread_curHandlerTable(rSELF)
19621     bnez   a3, 1f
19622     jr     rBIX            # nothing to do - jump to real handler
19623 1:
19624     EXPORT_PC()
19625     move   a0, rPC         # arg0
19626     move   a1, rFP         # arg1
19627     move   a2, rSELF       # arg2
19628     JAL(dvmCheckBefore)
19629     jr     rBIX
19630
19631 /* ------------------------------ */
19632     .balign 128
19633 .L_ALT_OP_SGET_BOOLEAN: /* 0x63 */
19634 /* File: mips/alt_stub.S */
19635 /*
19636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19637  * any interesting requests and then jump to the real instruction
19638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19641  * bail to the real handler if breakFlags==0.
19642  */
19643     lbu    a3, offThread_breakFlags(rSELF)
19644     la     rBIX, dvmAsmInstructionStart + (99 * 128)
19645     lw     rIBASE, offThread_curHandlerTable(rSELF)
19646     bnez   a3, 1f
19647     jr     rBIX            # nothing to do - jump to real handler
19648 1:
19649     EXPORT_PC()
19650     move   a0, rPC         # arg0
19651     move   a1, rFP         # arg1
19652     move   a2, rSELF       # arg2
19653     JAL(dvmCheckBefore)
19654     jr     rBIX
19655
19656 /* ------------------------------ */
19657     .balign 128
19658 .L_ALT_OP_SGET_BYTE: /* 0x64 */
19659 /* File: mips/alt_stub.S */
19660 /*
19661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19662  * any interesting requests and then jump to the real instruction
19663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19666  * bail to the real handler if breakFlags==0.
19667  */
19668     lbu    a3, offThread_breakFlags(rSELF)
19669     la     rBIX, dvmAsmInstructionStart + (100 * 128)
19670     lw     rIBASE, offThread_curHandlerTable(rSELF)
19671     bnez   a3, 1f
19672     jr     rBIX            # nothing to do - jump to real handler
19673 1:
19674     EXPORT_PC()
19675     move   a0, rPC         # arg0
19676     move   a1, rFP         # arg1
19677     move   a2, rSELF       # arg2
19678     JAL(dvmCheckBefore)
19679     jr     rBIX
19680
19681 /* ------------------------------ */
19682     .balign 128
19683 .L_ALT_OP_SGET_CHAR: /* 0x65 */
19684 /* File: mips/alt_stub.S */
19685 /*
19686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19687  * any interesting requests and then jump to the real instruction
19688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19691  * bail to the real handler if breakFlags==0.
19692  */
19693     lbu    a3, offThread_breakFlags(rSELF)
19694     la     rBIX, dvmAsmInstructionStart + (101 * 128)
19695     lw     rIBASE, offThread_curHandlerTable(rSELF)
19696     bnez   a3, 1f
19697     jr     rBIX            # nothing to do - jump to real handler
19698 1:
19699     EXPORT_PC()
19700     move   a0, rPC         # arg0
19701     move   a1, rFP         # arg1
19702     move   a2, rSELF       # arg2
19703     JAL(dvmCheckBefore)
19704     jr     rBIX
19705
19706 /* ------------------------------ */
19707     .balign 128
19708 .L_ALT_OP_SGET_SHORT: /* 0x66 */
19709 /* File: mips/alt_stub.S */
19710 /*
19711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19712  * any interesting requests and then jump to the real instruction
19713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19716  * bail to the real handler if breakFlags==0.
19717  */
19718     lbu    a3, offThread_breakFlags(rSELF)
19719     la     rBIX, dvmAsmInstructionStart + (102 * 128)
19720     lw     rIBASE, offThread_curHandlerTable(rSELF)
19721     bnez   a3, 1f
19722     jr     rBIX            # nothing to do - jump to real handler
19723 1:
19724     EXPORT_PC()
19725     move   a0, rPC         # arg0
19726     move   a1, rFP         # arg1
19727     move   a2, rSELF       # arg2
19728     JAL(dvmCheckBefore)
19729     jr     rBIX
19730
19731 /* ------------------------------ */
19732     .balign 128
19733 .L_ALT_OP_SPUT: /* 0x67 */
19734 /* File: mips/alt_stub.S */
19735 /*
19736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19737  * any interesting requests and then jump to the real instruction
19738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19741  * bail to the real handler if breakFlags==0.
19742  */
19743     lbu    a3, offThread_breakFlags(rSELF)
19744     la     rBIX, dvmAsmInstructionStart + (103 * 128)
19745     lw     rIBASE, offThread_curHandlerTable(rSELF)
19746     bnez   a3, 1f
19747     jr     rBIX            # nothing to do - jump to real handler
19748 1:
19749     EXPORT_PC()
19750     move   a0, rPC         # arg0
19751     move   a1, rFP         # arg1
19752     move   a2, rSELF       # arg2
19753     JAL(dvmCheckBefore)
19754     jr     rBIX
19755
19756 /* ------------------------------ */
19757     .balign 128
19758 .L_ALT_OP_SPUT_WIDE: /* 0x68 */
19759 /* File: mips/alt_stub.S */
19760 /*
19761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19762  * any interesting requests and then jump to the real instruction
19763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19766  * bail to the real handler if breakFlags==0.
19767  */
19768     lbu    a3, offThread_breakFlags(rSELF)
19769     la     rBIX, dvmAsmInstructionStart + (104 * 128)
19770     lw     rIBASE, offThread_curHandlerTable(rSELF)
19771     bnez   a3, 1f
19772     jr     rBIX            # nothing to do - jump to real handler
19773 1:
19774     EXPORT_PC()
19775     move   a0, rPC         # arg0
19776     move   a1, rFP         # arg1
19777     move   a2, rSELF       # arg2
19778     JAL(dvmCheckBefore)
19779     jr     rBIX
19780
19781 /* ------------------------------ */
19782     .balign 128
19783 .L_ALT_OP_SPUT_OBJECT: /* 0x69 */
19784 /* File: mips/alt_stub.S */
19785 /*
19786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19787  * any interesting requests and then jump to the real instruction
19788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19791  * bail to the real handler if breakFlags==0.
19792  */
19793     lbu    a3, offThread_breakFlags(rSELF)
19794     la     rBIX, dvmAsmInstructionStart + (105 * 128)
19795     lw     rIBASE, offThread_curHandlerTable(rSELF)
19796     bnez   a3, 1f
19797     jr     rBIX            # nothing to do - jump to real handler
19798 1:
19799     EXPORT_PC()
19800     move   a0, rPC         # arg0
19801     move   a1, rFP         # arg1
19802     move   a2, rSELF       # arg2
19803     JAL(dvmCheckBefore)
19804     jr     rBIX
19805
19806 /* ------------------------------ */
19807     .balign 128
19808 .L_ALT_OP_SPUT_BOOLEAN: /* 0x6a */
19809 /* File: mips/alt_stub.S */
19810 /*
19811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19812  * any interesting requests and then jump to the real instruction
19813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19816  * bail to the real handler if breakFlags==0.
19817  */
19818     lbu    a3, offThread_breakFlags(rSELF)
19819     la     rBIX, dvmAsmInstructionStart + (106 * 128)
19820     lw     rIBASE, offThread_curHandlerTable(rSELF)
19821     bnez   a3, 1f
19822     jr     rBIX            # nothing to do - jump to real handler
19823 1:
19824     EXPORT_PC()
19825     move   a0, rPC         # arg0
19826     move   a1, rFP         # arg1
19827     move   a2, rSELF       # arg2
19828     JAL(dvmCheckBefore)
19829     jr     rBIX
19830
19831 /* ------------------------------ */
19832     .balign 128
19833 .L_ALT_OP_SPUT_BYTE: /* 0x6b */
19834 /* File: mips/alt_stub.S */
19835 /*
19836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19837  * any interesting requests and then jump to the real instruction
19838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19841  * bail to the real handler if breakFlags==0.
19842  */
19843     lbu    a3, offThread_breakFlags(rSELF)
19844     la     rBIX, dvmAsmInstructionStart + (107 * 128)
19845     lw     rIBASE, offThread_curHandlerTable(rSELF)
19846     bnez   a3, 1f
19847     jr     rBIX            # nothing to do - jump to real handler
19848 1:
19849     EXPORT_PC()
19850     move   a0, rPC         # arg0
19851     move   a1, rFP         # arg1
19852     move   a2, rSELF       # arg2
19853     JAL(dvmCheckBefore)
19854     jr     rBIX
19855
19856 /* ------------------------------ */
19857     .balign 128
19858 .L_ALT_OP_SPUT_CHAR: /* 0x6c */
19859 /* File: mips/alt_stub.S */
19860 /*
19861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19862  * any interesting requests and then jump to the real instruction
19863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19866  * bail to the real handler if breakFlags==0.
19867  */
19868     lbu    a3, offThread_breakFlags(rSELF)
19869     la     rBIX, dvmAsmInstructionStart + (108 * 128)
19870     lw     rIBASE, offThread_curHandlerTable(rSELF)
19871     bnez   a3, 1f
19872     jr     rBIX            # nothing to do - jump to real handler
19873 1:
19874     EXPORT_PC()
19875     move   a0, rPC         # arg0
19876     move   a1, rFP         # arg1
19877     move   a2, rSELF       # arg2
19878     JAL(dvmCheckBefore)
19879     jr     rBIX
19880
19881 /* ------------------------------ */
19882     .balign 128
19883 .L_ALT_OP_SPUT_SHORT: /* 0x6d */
19884 /* File: mips/alt_stub.S */
19885 /*
19886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19887  * any interesting requests and then jump to the real instruction
19888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19891  * bail to the real handler if breakFlags==0.
19892  */
19893     lbu    a3, offThread_breakFlags(rSELF)
19894     la     rBIX, dvmAsmInstructionStart + (109 * 128)
19895     lw     rIBASE, offThread_curHandlerTable(rSELF)
19896     bnez   a3, 1f
19897     jr     rBIX            # nothing to do - jump to real handler
19898 1:
19899     EXPORT_PC()
19900     move   a0, rPC         # arg0
19901     move   a1, rFP         # arg1
19902     move   a2, rSELF       # arg2
19903     JAL(dvmCheckBefore)
19904     jr     rBIX
19905
19906 /* ------------------------------ */
19907     .balign 128
19908 .L_ALT_OP_INVOKE_VIRTUAL: /* 0x6e */
19909 /* File: mips/alt_stub.S */
19910 /*
19911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19912  * any interesting requests and then jump to the real instruction
19913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19916  * bail to the real handler if breakFlags==0.
19917  */
19918     lbu    a3, offThread_breakFlags(rSELF)
19919     la     rBIX, dvmAsmInstructionStart + (110 * 128)
19920     lw     rIBASE, offThread_curHandlerTable(rSELF)
19921     bnez   a3, 1f
19922     jr     rBIX            # nothing to do - jump to real handler
19923 1:
19924     EXPORT_PC()
19925     move   a0, rPC         # arg0
19926     move   a1, rFP         # arg1
19927     move   a2, rSELF       # arg2
19928     JAL(dvmCheckBefore)
19929     jr     rBIX
19930
19931 /* ------------------------------ */
19932     .balign 128
19933 .L_ALT_OP_INVOKE_SUPER: /* 0x6f */
19934 /* File: mips/alt_stub.S */
19935 /*
19936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19937  * any interesting requests and then jump to the real instruction
19938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19941  * bail to the real handler if breakFlags==0.
19942  */
19943     lbu    a3, offThread_breakFlags(rSELF)
19944     la     rBIX, dvmAsmInstructionStart + (111 * 128)
19945     lw     rIBASE, offThread_curHandlerTable(rSELF)
19946     bnez   a3, 1f
19947     jr     rBIX            # nothing to do - jump to real handler
19948 1:
19949     EXPORT_PC()
19950     move   a0, rPC         # arg0
19951     move   a1, rFP         # arg1
19952     move   a2, rSELF       # arg2
19953     JAL(dvmCheckBefore)
19954     jr     rBIX
19955
19956 /* ------------------------------ */
19957     .balign 128
19958 .L_ALT_OP_INVOKE_DIRECT: /* 0x70 */
19959 /* File: mips/alt_stub.S */
19960 /*
19961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19962  * any interesting requests and then jump to the real instruction
19963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19966  * bail to the real handler if breakFlags==0.
19967  */
19968     lbu    a3, offThread_breakFlags(rSELF)
19969     la     rBIX, dvmAsmInstructionStart + (112 * 128)
19970     lw     rIBASE, offThread_curHandlerTable(rSELF)
19971     bnez   a3, 1f
19972     jr     rBIX            # nothing to do - jump to real handler
19973 1:
19974     EXPORT_PC()
19975     move   a0, rPC         # arg0
19976     move   a1, rFP         # arg1
19977     move   a2, rSELF       # arg2
19978     JAL(dvmCheckBefore)
19979     jr     rBIX
19980
19981 /* ------------------------------ */
19982     .balign 128
19983 .L_ALT_OP_INVOKE_STATIC: /* 0x71 */
19984 /* File: mips/alt_stub.S */
19985 /*
19986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
19987  * any interesting requests and then jump to the real instruction
19988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
19989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
19990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
19991  * bail to the real handler if breakFlags==0.
19992  */
19993     lbu    a3, offThread_breakFlags(rSELF)
19994     la     rBIX, dvmAsmInstructionStart + (113 * 128)
19995     lw     rIBASE, offThread_curHandlerTable(rSELF)
19996     bnez   a3, 1f
19997     jr     rBIX            # nothing to do - jump to real handler
19998 1:
19999     EXPORT_PC()
20000     move   a0, rPC         # arg0
20001     move   a1, rFP         # arg1
20002     move   a2, rSELF       # arg2
20003     JAL(dvmCheckBefore)
20004     jr     rBIX
20005
20006 /* ------------------------------ */
20007     .balign 128
20008 .L_ALT_OP_INVOKE_INTERFACE: /* 0x72 */
20009 /* File: mips/alt_stub.S */
20010 /*
20011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20012  * any interesting requests and then jump to the real instruction
20013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20016  * bail to the real handler if breakFlags==0.
20017  */
20018     lbu    a3, offThread_breakFlags(rSELF)
20019     la     rBIX, dvmAsmInstructionStart + (114 * 128)
20020     lw     rIBASE, offThread_curHandlerTable(rSELF)
20021     bnez   a3, 1f
20022     jr     rBIX            # nothing to do - jump to real handler
20023 1:
20024     EXPORT_PC()
20025     move   a0, rPC         # arg0
20026     move   a1, rFP         # arg1
20027     move   a2, rSELF       # arg2
20028     JAL(dvmCheckBefore)
20029     jr     rBIX
20030
20031 /* ------------------------------ */
20032     .balign 128
20033 .L_ALT_OP_UNUSED_73: /* 0x73 */
20034 /* File: mips/alt_stub.S */
20035 /*
20036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20037  * any interesting requests and then jump to the real instruction
20038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20041  * bail to the real handler if breakFlags==0.
20042  */
20043     lbu    a3, offThread_breakFlags(rSELF)
20044     la     rBIX, dvmAsmInstructionStart + (115 * 128)
20045     lw     rIBASE, offThread_curHandlerTable(rSELF)
20046     bnez   a3, 1f
20047     jr     rBIX            # nothing to do - jump to real handler
20048 1:
20049     EXPORT_PC()
20050     move   a0, rPC         # arg0
20051     move   a1, rFP         # arg1
20052     move   a2, rSELF       # arg2
20053     JAL(dvmCheckBefore)
20054     jr     rBIX
20055
20056 /* ------------------------------ */
20057     .balign 128
20058 .L_ALT_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */
20059 /* File: mips/alt_stub.S */
20060 /*
20061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20062  * any interesting requests and then jump to the real instruction
20063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20066  * bail to the real handler if breakFlags==0.
20067  */
20068     lbu    a3, offThread_breakFlags(rSELF)
20069     la     rBIX, dvmAsmInstructionStart + (116 * 128)
20070     lw     rIBASE, offThread_curHandlerTable(rSELF)
20071     bnez   a3, 1f
20072     jr     rBIX            # nothing to do - jump to real handler
20073 1:
20074     EXPORT_PC()
20075     move   a0, rPC         # arg0
20076     move   a1, rFP         # arg1
20077     move   a2, rSELF       # arg2
20078     JAL(dvmCheckBefore)
20079     jr     rBIX
20080
20081 /* ------------------------------ */
20082     .balign 128
20083 .L_ALT_OP_INVOKE_SUPER_RANGE: /* 0x75 */
20084 /* File: mips/alt_stub.S */
20085 /*
20086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20087  * any interesting requests and then jump to the real instruction
20088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20091  * bail to the real handler if breakFlags==0.
20092  */
20093     lbu    a3, offThread_breakFlags(rSELF)
20094     la     rBIX, dvmAsmInstructionStart + (117 * 128)
20095     lw     rIBASE, offThread_curHandlerTable(rSELF)
20096     bnez   a3, 1f
20097     jr     rBIX            # nothing to do - jump to real handler
20098 1:
20099     EXPORT_PC()
20100     move   a0, rPC         # arg0
20101     move   a1, rFP         # arg1
20102     move   a2, rSELF       # arg2
20103     JAL(dvmCheckBefore)
20104     jr     rBIX
20105
20106 /* ------------------------------ */
20107     .balign 128
20108 .L_ALT_OP_INVOKE_DIRECT_RANGE: /* 0x76 */
20109 /* File: mips/alt_stub.S */
20110 /*
20111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20112  * any interesting requests and then jump to the real instruction
20113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20116  * bail to the real handler if breakFlags==0.
20117  */
20118     lbu    a3, offThread_breakFlags(rSELF)
20119     la     rBIX, dvmAsmInstructionStart + (118 * 128)
20120     lw     rIBASE, offThread_curHandlerTable(rSELF)
20121     bnez   a3, 1f
20122     jr     rBIX            # nothing to do - jump to real handler
20123 1:
20124     EXPORT_PC()
20125     move   a0, rPC         # arg0
20126     move   a1, rFP         # arg1
20127     move   a2, rSELF       # arg2
20128     JAL(dvmCheckBefore)
20129     jr     rBIX
20130
20131 /* ------------------------------ */
20132     .balign 128
20133 .L_ALT_OP_INVOKE_STATIC_RANGE: /* 0x77 */
20134 /* File: mips/alt_stub.S */
20135 /*
20136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20137  * any interesting requests and then jump to the real instruction
20138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20141  * bail to the real handler if breakFlags==0.
20142  */
20143     lbu    a3, offThread_breakFlags(rSELF)
20144     la     rBIX, dvmAsmInstructionStart + (119 * 128)
20145     lw     rIBASE, offThread_curHandlerTable(rSELF)
20146     bnez   a3, 1f
20147     jr     rBIX            # nothing to do - jump to real handler
20148 1:
20149     EXPORT_PC()
20150     move   a0, rPC         # arg0
20151     move   a1, rFP         # arg1
20152     move   a2, rSELF       # arg2
20153     JAL(dvmCheckBefore)
20154     jr     rBIX
20155
20156 /* ------------------------------ */
20157     .balign 128
20158 .L_ALT_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */
20159 /* File: mips/alt_stub.S */
20160 /*
20161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20162  * any interesting requests and then jump to the real instruction
20163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20166  * bail to the real handler if breakFlags==0.
20167  */
20168     lbu    a3, offThread_breakFlags(rSELF)
20169     la     rBIX, dvmAsmInstructionStart + (120 * 128)
20170     lw     rIBASE, offThread_curHandlerTable(rSELF)
20171     bnez   a3, 1f
20172     jr     rBIX            # nothing to do - jump to real handler
20173 1:
20174     EXPORT_PC()
20175     move   a0, rPC         # arg0
20176     move   a1, rFP         # arg1
20177     move   a2, rSELF       # arg2
20178     JAL(dvmCheckBefore)
20179     jr     rBIX
20180
20181 /* ------------------------------ */
20182     .balign 128
20183 .L_ALT_OP_UNUSED_79: /* 0x79 */
20184 /* File: mips/alt_stub.S */
20185 /*
20186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20187  * any interesting requests and then jump to the real instruction
20188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20191  * bail to the real handler if breakFlags==0.
20192  */
20193     lbu    a3, offThread_breakFlags(rSELF)
20194     la     rBIX, dvmAsmInstructionStart + (121 * 128)
20195     lw     rIBASE, offThread_curHandlerTable(rSELF)
20196     bnez   a3, 1f
20197     jr     rBIX            # nothing to do - jump to real handler
20198 1:
20199     EXPORT_PC()
20200     move   a0, rPC         # arg0
20201     move   a1, rFP         # arg1
20202     move   a2, rSELF       # arg2
20203     JAL(dvmCheckBefore)
20204     jr     rBIX
20205
20206 /* ------------------------------ */
20207     .balign 128
20208 .L_ALT_OP_UNUSED_7A: /* 0x7a */
20209 /* File: mips/alt_stub.S */
20210 /*
20211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20212  * any interesting requests and then jump to the real instruction
20213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20216  * bail to the real handler if breakFlags==0.
20217  */
20218     lbu    a3, offThread_breakFlags(rSELF)
20219     la     rBIX, dvmAsmInstructionStart + (122 * 128)
20220     lw     rIBASE, offThread_curHandlerTable(rSELF)
20221     bnez   a3, 1f
20222     jr     rBIX            # nothing to do - jump to real handler
20223 1:
20224     EXPORT_PC()
20225     move   a0, rPC         # arg0
20226     move   a1, rFP         # arg1
20227     move   a2, rSELF       # arg2
20228     JAL(dvmCheckBefore)
20229     jr     rBIX
20230
20231 /* ------------------------------ */
20232     .balign 128
20233 .L_ALT_OP_NEG_INT: /* 0x7b */
20234 /* File: mips/alt_stub.S */
20235 /*
20236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20237  * any interesting requests and then jump to the real instruction
20238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20241  * bail to the real handler if breakFlags==0.
20242  */
20243     lbu    a3, offThread_breakFlags(rSELF)
20244     la     rBIX, dvmAsmInstructionStart + (123 * 128)
20245     lw     rIBASE, offThread_curHandlerTable(rSELF)
20246     bnez   a3, 1f
20247     jr     rBIX            # nothing to do - jump to real handler
20248 1:
20249     EXPORT_PC()
20250     move   a0, rPC         # arg0
20251     move   a1, rFP         # arg1
20252     move   a2, rSELF       # arg2
20253     JAL(dvmCheckBefore)
20254     jr     rBIX
20255
20256 /* ------------------------------ */
20257     .balign 128
20258 .L_ALT_OP_NOT_INT: /* 0x7c */
20259 /* File: mips/alt_stub.S */
20260 /*
20261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20262  * any interesting requests and then jump to the real instruction
20263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20266  * bail to the real handler if breakFlags==0.
20267  */
20268     lbu    a3, offThread_breakFlags(rSELF)
20269     la     rBIX, dvmAsmInstructionStart + (124 * 128)
20270     lw     rIBASE, offThread_curHandlerTable(rSELF)
20271     bnez   a3, 1f
20272     jr     rBIX            # nothing to do - jump to real handler
20273 1:
20274     EXPORT_PC()
20275     move   a0, rPC         # arg0
20276     move   a1, rFP         # arg1
20277     move   a2, rSELF       # arg2
20278     JAL(dvmCheckBefore)
20279     jr     rBIX
20280
20281 /* ------------------------------ */
20282     .balign 128
20283 .L_ALT_OP_NEG_LONG: /* 0x7d */
20284 /* File: mips/alt_stub.S */
20285 /*
20286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20287  * any interesting requests and then jump to the real instruction
20288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20291  * bail to the real handler if breakFlags==0.
20292  */
20293     lbu    a3, offThread_breakFlags(rSELF)
20294     la     rBIX, dvmAsmInstructionStart + (125 * 128)
20295     lw     rIBASE, offThread_curHandlerTable(rSELF)
20296     bnez   a3, 1f
20297     jr     rBIX            # nothing to do - jump to real handler
20298 1:
20299     EXPORT_PC()
20300     move   a0, rPC         # arg0
20301     move   a1, rFP         # arg1
20302     move   a2, rSELF       # arg2
20303     JAL(dvmCheckBefore)
20304     jr     rBIX
20305
20306 /* ------------------------------ */
20307     .balign 128
20308 .L_ALT_OP_NOT_LONG: /* 0x7e */
20309 /* File: mips/alt_stub.S */
20310 /*
20311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20312  * any interesting requests and then jump to the real instruction
20313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20316  * bail to the real handler if breakFlags==0.
20317  */
20318     lbu    a3, offThread_breakFlags(rSELF)
20319     la     rBIX, dvmAsmInstructionStart + (126 * 128)
20320     lw     rIBASE, offThread_curHandlerTable(rSELF)
20321     bnez   a3, 1f
20322     jr     rBIX            # nothing to do - jump to real handler
20323 1:
20324     EXPORT_PC()
20325     move   a0, rPC         # arg0
20326     move   a1, rFP         # arg1
20327     move   a2, rSELF       # arg2
20328     JAL(dvmCheckBefore)
20329     jr     rBIX
20330
20331 /* ------------------------------ */
20332     .balign 128
20333 .L_ALT_OP_NEG_FLOAT: /* 0x7f */
20334 /* File: mips/alt_stub.S */
20335 /*
20336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20337  * any interesting requests and then jump to the real instruction
20338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20341  * bail to the real handler if breakFlags==0.
20342  */
20343     lbu    a3, offThread_breakFlags(rSELF)
20344     la     rBIX, dvmAsmInstructionStart + (127 * 128)
20345     lw     rIBASE, offThread_curHandlerTable(rSELF)
20346     bnez   a3, 1f
20347     jr     rBIX            # nothing to do - jump to real handler
20348 1:
20349     EXPORT_PC()
20350     move   a0, rPC         # arg0
20351     move   a1, rFP         # arg1
20352     move   a2, rSELF       # arg2
20353     JAL(dvmCheckBefore)
20354     jr     rBIX
20355
20356 /* ------------------------------ */
20357     .balign 128
20358 .L_ALT_OP_NEG_DOUBLE: /* 0x80 */
20359 /* File: mips/alt_stub.S */
20360 /*
20361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20362  * any interesting requests and then jump to the real instruction
20363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20366  * bail to the real handler if breakFlags==0.
20367  */
20368     lbu    a3, offThread_breakFlags(rSELF)
20369     la     rBIX, dvmAsmInstructionStart + (128 * 128)
20370     lw     rIBASE, offThread_curHandlerTable(rSELF)
20371     bnez   a3, 1f
20372     jr     rBIX            # nothing to do - jump to real handler
20373 1:
20374     EXPORT_PC()
20375     move   a0, rPC         # arg0
20376     move   a1, rFP         # arg1
20377     move   a2, rSELF       # arg2
20378     JAL(dvmCheckBefore)
20379     jr     rBIX
20380
20381 /* ------------------------------ */
20382     .balign 128
20383 .L_ALT_OP_INT_TO_LONG: /* 0x81 */
20384 /* File: mips/alt_stub.S */
20385 /*
20386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20387  * any interesting requests and then jump to the real instruction
20388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20391  * bail to the real handler if breakFlags==0.
20392  */
20393     lbu    a3, offThread_breakFlags(rSELF)
20394     la     rBIX, dvmAsmInstructionStart + (129 * 128)
20395     lw     rIBASE, offThread_curHandlerTable(rSELF)
20396     bnez   a3, 1f
20397     jr     rBIX            # nothing to do - jump to real handler
20398 1:
20399     EXPORT_PC()
20400     move   a0, rPC         # arg0
20401     move   a1, rFP         # arg1
20402     move   a2, rSELF       # arg2
20403     JAL(dvmCheckBefore)
20404     jr     rBIX
20405
20406 /* ------------------------------ */
20407     .balign 128
20408 .L_ALT_OP_INT_TO_FLOAT: /* 0x82 */
20409 /* File: mips/alt_stub.S */
20410 /*
20411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20412  * any interesting requests and then jump to the real instruction
20413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20416  * bail to the real handler if breakFlags==0.
20417  */
20418     lbu    a3, offThread_breakFlags(rSELF)
20419     la     rBIX, dvmAsmInstructionStart + (130 * 128)
20420     lw     rIBASE, offThread_curHandlerTable(rSELF)
20421     bnez   a3, 1f
20422     jr     rBIX            # nothing to do - jump to real handler
20423 1:
20424     EXPORT_PC()
20425     move   a0, rPC         # arg0
20426     move   a1, rFP         # arg1
20427     move   a2, rSELF       # arg2
20428     JAL(dvmCheckBefore)
20429     jr     rBIX
20430
20431 /* ------------------------------ */
20432     .balign 128
20433 .L_ALT_OP_INT_TO_DOUBLE: /* 0x83 */
20434 /* File: mips/alt_stub.S */
20435 /*
20436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20437  * any interesting requests and then jump to the real instruction
20438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20441  * bail to the real handler if breakFlags==0.
20442  */
20443     lbu    a3, offThread_breakFlags(rSELF)
20444     la     rBIX, dvmAsmInstructionStart + (131 * 128)
20445     lw     rIBASE, offThread_curHandlerTable(rSELF)
20446     bnez   a3, 1f
20447     jr     rBIX            # nothing to do - jump to real handler
20448 1:
20449     EXPORT_PC()
20450     move   a0, rPC         # arg0
20451     move   a1, rFP         # arg1
20452     move   a2, rSELF       # arg2
20453     JAL(dvmCheckBefore)
20454     jr     rBIX
20455
20456 /* ------------------------------ */
20457     .balign 128
20458 .L_ALT_OP_LONG_TO_INT: /* 0x84 */
20459 /* File: mips/alt_stub.S */
20460 /*
20461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20462  * any interesting requests and then jump to the real instruction
20463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20466  * bail to the real handler if breakFlags==0.
20467  */
20468     lbu    a3, offThread_breakFlags(rSELF)
20469     la     rBIX, dvmAsmInstructionStart + (132 * 128)
20470     lw     rIBASE, offThread_curHandlerTable(rSELF)
20471     bnez   a3, 1f
20472     jr     rBIX            # nothing to do - jump to real handler
20473 1:
20474     EXPORT_PC()
20475     move   a0, rPC         # arg0
20476     move   a1, rFP         # arg1
20477     move   a2, rSELF       # arg2
20478     JAL(dvmCheckBefore)
20479     jr     rBIX
20480
20481 /* ------------------------------ */
20482     .balign 128
20483 .L_ALT_OP_LONG_TO_FLOAT: /* 0x85 */
20484 /* File: mips/alt_stub.S */
20485 /*
20486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20487  * any interesting requests and then jump to the real instruction
20488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20491  * bail to the real handler if breakFlags==0.
20492  */
20493     lbu    a3, offThread_breakFlags(rSELF)
20494     la     rBIX, dvmAsmInstructionStart + (133 * 128)
20495     lw     rIBASE, offThread_curHandlerTable(rSELF)
20496     bnez   a3, 1f
20497     jr     rBIX            # nothing to do - jump to real handler
20498 1:
20499     EXPORT_PC()
20500     move   a0, rPC         # arg0
20501     move   a1, rFP         # arg1
20502     move   a2, rSELF       # arg2
20503     JAL(dvmCheckBefore)
20504     jr     rBIX
20505
20506 /* ------------------------------ */
20507     .balign 128
20508 .L_ALT_OP_LONG_TO_DOUBLE: /* 0x86 */
20509 /* File: mips/alt_stub.S */
20510 /*
20511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20512  * any interesting requests and then jump to the real instruction
20513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20516  * bail to the real handler if breakFlags==0.
20517  */
20518     lbu    a3, offThread_breakFlags(rSELF)
20519     la     rBIX, dvmAsmInstructionStart + (134 * 128)
20520     lw     rIBASE, offThread_curHandlerTable(rSELF)
20521     bnez   a3, 1f
20522     jr     rBIX            # nothing to do - jump to real handler
20523 1:
20524     EXPORT_PC()
20525     move   a0, rPC         # arg0
20526     move   a1, rFP         # arg1
20527     move   a2, rSELF       # arg2
20528     JAL(dvmCheckBefore)
20529     jr     rBIX
20530
20531 /* ------------------------------ */
20532     .balign 128
20533 .L_ALT_OP_FLOAT_TO_INT: /* 0x87 */
20534 /* File: mips/alt_stub.S */
20535 /*
20536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20537  * any interesting requests and then jump to the real instruction
20538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20541  * bail to the real handler if breakFlags==0.
20542  */
20543     lbu    a3, offThread_breakFlags(rSELF)
20544     la     rBIX, dvmAsmInstructionStart + (135 * 128)
20545     lw     rIBASE, offThread_curHandlerTable(rSELF)
20546     bnez   a3, 1f
20547     jr     rBIX            # nothing to do - jump to real handler
20548 1:
20549     EXPORT_PC()
20550     move   a0, rPC         # arg0
20551     move   a1, rFP         # arg1
20552     move   a2, rSELF       # arg2
20553     JAL(dvmCheckBefore)
20554     jr     rBIX
20555
20556 /* ------------------------------ */
20557     .balign 128
20558 .L_ALT_OP_FLOAT_TO_LONG: /* 0x88 */
20559 /* File: mips/alt_stub.S */
20560 /*
20561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20562  * any interesting requests and then jump to the real instruction
20563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20566  * bail to the real handler if breakFlags==0.
20567  */
20568     lbu    a3, offThread_breakFlags(rSELF)
20569     la     rBIX, dvmAsmInstructionStart + (136 * 128)
20570     lw     rIBASE, offThread_curHandlerTable(rSELF)
20571     bnez   a3, 1f
20572     jr     rBIX            # nothing to do - jump to real handler
20573 1:
20574     EXPORT_PC()
20575     move   a0, rPC         # arg0
20576     move   a1, rFP         # arg1
20577     move   a2, rSELF       # arg2
20578     JAL(dvmCheckBefore)
20579     jr     rBIX
20580
20581 /* ------------------------------ */
20582     .balign 128
20583 .L_ALT_OP_FLOAT_TO_DOUBLE: /* 0x89 */
20584 /* File: mips/alt_stub.S */
20585 /*
20586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20587  * any interesting requests and then jump to the real instruction
20588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20591  * bail to the real handler if breakFlags==0.
20592  */
20593     lbu    a3, offThread_breakFlags(rSELF)
20594     la     rBIX, dvmAsmInstructionStart + (137 * 128)
20595     lw     rIBASE, offThread_curHandlerTable(rSELF)
20596     bnez   a3, 1f
20597     jr     rBIX            # nothing to do - jump to real handler
20598 1:
20599     EXPORT_PC()
20600     move   a0, rPC         # arg0
20601     move   a1, rFP         # arg1
20602     move   a2, rSELF       # arg2
20603     JAL(dvmCheckBefore)
20604     jr     rBIX
20605
20606 /* ------------------------------ */
20607     .balign 128
20608 .L_ALT_OP_DOUBLE_TO_INT: /* 0x8a */
20609 /* File: mips/alt_stub.S */
20610 /*
20611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20612  * any interesting requests and then jump to the real instruction
20613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20616  * bail to the real handler if breakFlags==0.
20617  */
20618     lbu    a3, offThread_breakFlags(rSELF)
20619     la     rBIX, dvmAsmInstructionStart + (138 * 128)
20620     lw     rIBASE, offThread_curHandlerTable(rSELF)
20621     bnez   a3, 1f
20622     jr     rBIX            # nothing to do - jump to real handler
20623 1:
20624     EXPORT_PC()
20625     move   a0, rPC         # arg0
20626     move   a1, rFP         # arg1
20627     move   a2, rSELF       # arg2
20628     JAL(dvmCheckBefore)
20629     jr     rBIX
20630
20631 /* ------------------------------ */
20632     .balign 128
20633 .L_ALT_OP_DOUBLE_TO_LONG: /* 0x8b */
20634 /* File: mips/alt_stub.S */
20635 /*
20636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20637  * any interesting requests and then jump to the real instruction
20638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20641  * bail to the real handler if breakFlags==0.
20642  */
20643     lbu    a3, offThread_breakFlags(rSELF)
20644     la     rBIX, dvmAsmInstructionStart + (139 * 128)
20645     lw     rIBASE, offThread_curHandlerTable(rSELF)
20646     bnez   a3, 1f
20647     jr     rBIX            # nothing to do - jump to real handler
20648 1:
20649     EXPORT_PC()
20650     move   a0, rPC         # arg0
20651     move   a1, rFP         # arg1
20652     move   a2, rSELF       # arg2
20653     JAL(dvmCheckBefore)
20654     jr     rBIX
20655
20656 /* ------------------------------ */
20657     .balign 128
20658 .L_ALT_OP_DOUBLE_TO_FLOAT: /* 0x8c */
20659 /* File: mips/alt_stub.S */
20660 /*
20661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20662  * any interesting requests and then jump to the real instruction
20663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20666  * bail to the real handler if breakFlags==0.
20667  */
20668     lbu    a3, offThread_breakFlags(rSELF)
20669     la     rBIX, dvmAsmInstructionStart + (140 * 128)
20670     lw     rIBASE, offThread_curHandlerTable(rSELF)
20671     bnez   a3, 1f
20672     jr     rBIX            # nothing to do - jump to real handler
20673 1:
20674     EXPORT_PC()
20675     move   a0, rPC         # arg0
20676     move   a1, rFP         # arg1
20677     move   a2, rSELF       # arg2
20678     JAL(dvmCheckBefore)
20679     jr     rBIX
20680
20681 /* ------------------------------ */
20682     .balign 128
20683 .L_ALT_OP_INT_TO_BYTE: /* 0x8d */
20684 /* File: mips/alt_stub.S */
20685 /*
20686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20687  * any interesting requests and then jump to the real instruction
20688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20691  * bail to the real handler if breakFlags==0.
20692  */
20693     lbu    a3, offThread_breakFlags(rSELF)
20694     la     rBIX, dvmAsmInstructionStart + (141 * 128)
20695     lw     rIBASE, offThread_curHandlerTable(rSELF)
20696     bnez   a3, 1f
20697     jr     rBIX            # nothing to do - jump to real handler
20698 1:
20699     EXPORT_PC()
20700     move   a0, rPC         # arg0
20701     move   a1, rFP         # arg1
20702     move   a2, rSELF       # arg2
20703     JAL(dvmCheckBefore)
20704     jr     rBIX
20705
20706 /* ------------------------------ */
20707     .balign 128
20708 .L_ALT_OP_INT_TO_CHAR: /* 0x8e */
20709 /* File: mips/alt_stub.S */
20710 /*
20711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20712  * any interesting requests and then jump to the real instruction
20713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20716  * bail to the real handler if breakFlags==0.
20717  */
20718     lbu    a3, offThread_breakFlags(rSELF)
20719     la     rBIX, dvmAsmInstructionStart + (142 * 128)
20720     lw     rIBASE, offThread_curHandlerTable(rSELF)
20721     bnez   a3, 1f
20722     jr     rBIX            # nothing to do - jump to real handler
20723 1:
20724     EXPORT_PC()
20725     move   a0, rPC         # arg0
20726     move   a1, rFP         # arg1
20727     move   a2, rSELF       # arg2
20728     JAL(dvmCheckBefore)
20729     jr     rBIX
20730
20731 /* ------------------------------ */
20732     .balign 128
20733 .L_ALT_OP_INT_TO_SHORT: /* 0x8f */
20734 /* File: mips/alt_stub.S */
20735 /*
20736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20737  * any interesting requests and then jump to the real instruction
20738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20741  * bail to the real handler if breakFlags==0.
20742  */
20743     lbu    a3, offThread_breakFlags(rSELF)
20744     la     rBIX, dvmAsmInstructionStart + (143 * 128)
20745     lw     rIBASE, offThread_curHandlerTable(rSELF)
20746     bnez   a3, 1f
20747     jr     rBIX            # nothing to do - jump to real handler
20748 1:
20749     EXPORT_PC()
20750     move   a0, rPC         # arg0
20751     move   a1, rFP         # arg1
20752     move   a2, rSELF       # arg2
20753     JAL(dvmCheckBefore)
20754     jr     rBIX
20755
20756 /* ------------------------------ */
20757     .balign 128
20758 .L_ALT_OP_ADD_INT: /* 0x90 */
20759 /* File: mips/alt_stub.S */
20760 /*
20761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20762  * any interesting requests and then jump to the real instruction
20763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20766  * bail to the real handler if breakFlags==0.
20767  */
20768     lbu    a3, offThread_breakFlags(rSELF)
20769     la     rBIX, dvmAsmInstructionStart + (144 * 128)
20770     lw     rIBASE, offThread_curHandlerTable(rSELF)
20771     bnez   a3, 1f
20772     jr     rBIX            # nothing to do - jump to real handler
20773 1:
20774     EXPORT_PC()
20775     move   a0, rPC         # arg0
20776     move   a1, rFP         # arg1
20777     move   a2, rSELF       # arg2
20778     JAL(dvmCheckBefore)
20779     jr     rBIX
20780
20781 /* ------------------------------ */
20782     .balign 128
20783 .L_ALT_OP_SUB_INT: /* 0x91 */
20784 /* File: mips/alt_stub.S */
20785 /*
20786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20787  * any interesting requests and then jump to the real instruction
20788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20791  * bail to the real handler if breakFlags==0.
20792  */
20793     lbu    a3, offThread_breakFlags(rSELF)
20794     la     rBIX, dvmAsmInstructionStart + (145 * 128)
20795     lw     rIBASE, offThread_curHandlerTable(rSELF)
20796     bnez   a3, 1f
20797     jr     rBIX            # nothing to do - jump to real handler
20798 1:
20799     EXPORT_PC()
20800     move   a0, rPC         # arg0
20801     move   a1, rFP         # arg1
20802     move   a2, rSELF       # arg2
20803     JAL(dvmCheckBefore)
20804     jr     rBIX
20805
20806 /* ------------------------------ */
20807     .balign 128
20808 .L_ALT_OP_MUL_INT: /* 0x92 */
20809 /* File: mips/alt_stub.S */
20810 /*
20811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20812  * any interesting requests and then jump to the real instruction
20813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20816  * bail to the real handler if breakFlags==0.
20817  */
20818     lbu    a3, offThread_breakFlags(rSELF)
20819     la     rBIX, dvmAsmInstructionStart + (146 * 128)
20820     lw     rIBASE, offThread_curHandlerTable(rSELF)
20821     bnez   a3, 1f
20822     jr     rBIX            # nothing to do - jump to real handler
20823 1:
20824     EXPORT_PC()
20825     move   a0, rPC         # arg0
20826     move   a1, rFP         # arg1
20827     move   a2, rSELF       # arg2
20828     JAL(dvmCheckBefore)
20829     jr     rBIX
20830
20831 /* ------------------------------ */
20832     .balign 128
20833 .L_ALT_OP_DIV_INT: /* 0x93 */
20834 /* File: mips/alt_stub.S */
20835 /*
20836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20837  * any interesting requests and then jump to the real instruction
20838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20841  * bail to the real handler if breakFlags==0.
20842  */
20843     lbu    a3, offThread_breakFlags(rSELF)
20844     la     rBIX, dvmAsmInstructionStart + (147 * 128)
20845     lw     rIBASE, offThread_curHandlerTable(rSELF)
20846     bnez   a3, 1f
20847     jr     rBIX            # nothing to do - jump to real handler
20848 1:
20849     EXPORT_PC()
20850     move   a0, rPC         # arg0
20851     move   a1, rFP         # arg1
20852     move   a2, rSELF       # arg2
20853     JAL(dvmCheckBefore)
20854     jr     rBIX
20855
20856 /* ------------------------------ */
20857     .balign 128
20858 .L_ALT_OP_REM_INT: /* 0x94 */
20859 /* File: mips/alt_stub.S */
20860 /*
20861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20862  * any interesting requests and then jump to the real instruction
20863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20866  * bail to the real handler if breakFlags==0.
20867  */
20868     lbu    a3, offThread_breakFlags(rSELF)
20869     la     rBIX, dvmAsmInstructionStart + (148 * 128)
20870     lw     rIBASE, offThread_curHandlerTable(rSELF)
20871     bnez   a3, 1f
20872     jr     rBIX            # nothing to do - jump to real handler
20873 1:
20874     EXPORT_PC()
20875     move   a0, rPC         # arg0
20876     move   a1, rFP         # arg1
20877     move   a2, rSELF       # arg2
20878     JAL(dvmCheckBefore)
20879     jr     rBIX
20880
20881 /* ------------------------------ */
20882     .balign 128
20883 .L_ALT_OP_AND_INT: /* 0x95 */
20884 /* File: mips/alt_stub.S */
20885 /*
20886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20887  * any interesting requests and then jump to the real instruction
20888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20891  * bail to the real handler if breakFlags==0.
20892  */
20893     lbu    a3, offThread_breakFlags(rSELF)
20894     la     rBIX, dvmAsmInstructionStart + (149 * 128)
20895     lw     rIBASE, offThread_curHandlerTable(rSELF)
20896     bnez   a3, 1f
20897     jr     rBIX            # nothing to do - jump to real handler
20898 1:
20899     EXPORT_PC()
20900     move   a0, rPC         # arg0
20901     move   a1, rFP         # arg1
20902     move   a2, rSELF       # arg2
20903     JAL(dvmCheckBefore)
20904     jr     rBIX
20905
20906 /* ------------------------------ */
20907     .balign 128
20908 .L_ALT_OP_OR_INT: /* 0x96 */
20909 /* File: mips/alt_stub.S */
20910 /*
20911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20912  * any interesting requests and then jump to the real instruction
20913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20916  * bail to the real handler if breakFlags==0.
20917  */
20918     lbu    a3, offThread_breakFlags(rSELF)
20919     la     rBIX, dvmAsmInstructionStart + (150 * 128)
20920     lw     rIBASE, offThread_curHandlerTable(rSELF)
20921     bnez   a3, 1f
20922     jr     rBIX            # nothing to do - jump to real handler
20923 1:
20924     EXPORT_PC()
20925     move   a0, rPC         # arg0
20926     move   a1, rFP         # arg1
20927     move   a2, rSELF       # arg2
20928     JAL(dvmCheckBefore)
20929     jr     rBIX
20930
20931 /* ------------------------------ */
20932     .balign 128
20933 .L_ALT_OP_XOR_INT: /* 0x97 */
20934 /* File: mips/alt_stub.S */
20935 /*
20936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20937  * any interesting requests and then jump to the real instruction
20938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20941  * bail to the real handler if breakFlags==0.
20942  */
20943     lbu    a3, offThread_breakFlags(rSELF)
20944     la     rBIX, dvmAsmInstructionStart + (151 * 128)
20945     lw     rIBASE, offThread_curHandlerTable(rSELF)
20946     bnez   a3, 1f
20947     jr     rBIX            # nothing to do - jump to real handler
20948 1:
20949     EXPORT_PC()
20950     move   a0, rPC         # arg0
20951     move   a1, rFP         # arg1
20952     move   a2, rSELF       # arg2
20953     JAL(dvmCheckBefore)
20954     jr     rBIX
20955
20956 /* ------------------------------ */
20957     .balign 128
20958 .L_ALT_OP_SHL_INT: /* 0x98 */
20959 /* File: mips/alt_stub.S */
20960 /*
20961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20962  * any interesting requests and then jump to the real instruction
20963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20966  * bail to the real handler if breakFlags==0.
20967  */
20968     lbu    a3, offThread_breakFlags(rSELF)
20969     la     rBIX, dvmAsmInstructionStart + (152 * 128)
20970     lw     rIBASE, offThread_curHandlerTable(rSELF)
20971     bnez   a3, 1f
20972     jr     rBIX            # nothing to do - jump to real handler
20973 1:
20974     EXPORT_PC()
20975     move   a0, rPC         # arg0
20976     move   a1, rFP         # arg1
20977     move   a2, rSELF       # arg2
20978     JAL(dvmCheckBefore)
20979     jr     rBIX
20980
20981 /* ------------------------------ */
20982     .balign 128
20983 .L_ALT_OP_SHR_INT: /* 0x99 */
20984 /* File: mips/alt_stub.S */
20985 /*
20986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
20987  * any interesting requests and then jump to the real instruction
20988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
20989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
20990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
20991  * bail to the real handler if breakFlags==0.
20992  */
20993     lbu    a3, offThread_breakFlags(rSELF)
20994     la     rBIX, dvmAsmInstructionStart + (153 * 128)
20995     lw     rIBASE, offThread_curHandlerTable(rSELF)
20996     bnez   a3, 1f
20997     jr     rBIX            # nothing to do - jump to real handler
20998 1:
20999     EXPORT_PC()
21000     move   a0, rPC         # arg0
21001     move   a1, rFP         # arg1
21002     move   a2, rSELF       # arg2
21003     JAL(dvmCheckBefore)
21004     jr     rBIX
21005
21006 /* ------------------------------ */
21007     .balign 128
21008 .L_ALT_OP_USHR_INT: /* 0x9a */
21009 /* File: mips/alt_stub.S */
21010 /*
21011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21012  * any interesting requests and then jump to the real instruction
21013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21016  * bail to the real handler if breakFlags==0.
21017  */
21018     lbu    a3, offThread_breakFlags(rSELF)
21019     la     rBIX, dvmAsmInstructionStart + (154 * 128)
21020     lw     rIBASE, offThread_curHandlerTable(rSELF)
21021     bnez   a3, 1f
21022     jr     rBIX            # nothing to do - jump to real handler
21023 1:
21024     EXPORT_PC()
21025     move   a0, rPC         # arg0
21026     move   a1, rFP         # arg1
21027     move   a2, rSELF       # arg2
21028     JAL(dvmCheckBefore)
21029     jr     rBIX
21030
21031 /* ------------------------------ */
21032     .balign 128
21033 .L_ALT_OP_ADD_LONG: /* 0x9b */
21034 /* File: mips/alt_stub.S */
21035 /*
21036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21037  * any interesting requests and then jump to the real instruction
21038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21041  * bail to the real handler if breakFlags==0.
21042  */
21043     lbu    a3, offThread_breakFlags(rSELF)
21044     la     rBIX, dvmAsmInstructionStart + (155 * 128)
21045     lw     rIBASE, offThread_curHandlerTable(rSELF)
21046     bnez   a3, 1f
21047     jr     rBIX            # nothing to do - jump to real handler
21048 1:
21049     EXPORT_PC()
21050     move   a0, rPC         # arg0
21051     move   a1, rFP         # arg1
21052     move   a2, rSELF       # arg2
21053     JAL(dvmCheckBefore)
21054     jr     rBIX
21055
21056 /* ------------------------------ */
21057     .balign 128
21058 .L_ALT_OP_SUB_LONG: /* 0x9c */
21059 /* File: mips/alt_stub.S */
21060 /*
21061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21062  * any interesting requests and then jump to the real instruction
21063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21066  * bail to the real handler if breakFlags==0.
21067  */
21068     lbu    a3, offThread_breakFlags(rSELF)
21069     la     rBIX, dvmAsmInstructionStart + (156 * 128)
21070     lw     rIBASE, offThread_curHandlerTable(rSELF)
21071     bnez   a3, 1f
21072     jr     rBIX            # nothing to do - jump to real handler
21073 1:
21074     EXPORT_PC()
21075     move   a0, rPC         # arg0
21076     move   a1, rFP         # arg1
21077     move   a2, rSELF       # arg2
21078     JAL(dvmCheckBefore)
21079     jr     rBIX
21080
21081 /* ------------------------------ */
21082     .balign 128
21083 .L_ALT_OP_MUL_LONG: /* 0x9d */
21084 /* File: mips/alt_stub.S */
21085 /*
21086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21087  * any interesting requests and then jump to the real instruction
21088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21091  * bail to the real handler if breakFlags==0.
21092  */
21093     lbu    a3, offThread_breakFlags(rSELF)
21094     la     rBIX, dvmAsmInstructionStart + (157 * 128)
21095     lw     rIBASE, offThread_curHandlerTable(rSELF)
21096     bnez   a3, 1f
21097     jr     rBIX            # nothing to do - jump to real handler
21098 1:
21099     EXPORT_PC()
21100     move   a0, rPC         # arg0
21101     move   a1, rFP         # arg1
21102     move   a2, rSELF       # arg2
21103     JAL(dvmCheckBefore)
21104     jr     rBIX
21105
21106 /* ------------------------------ */
21107     .balign 128
21108 .L_ALT_OP_DIV_LONG: /* 0x9e */
21109 /* File: mips/alt_stub.S */
21110 /*
21111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21112  * any interesting requests and then jump to the real instruction
21113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21116  * bail to the real handler if breakFlags==0.
21117  */
21118     lbu    a3, offThread_breakFlags(rSELF)
21119     la     rBIX, dvmAsmInstructionStart + (158 * 128)
21120     lw     rIBASE, offThread_curHandlerTable(rSELF)
21121     bnez   a3, 1f
21122     jr     rBIX            # nothing to do - jump to real handler
21123 1:
21124     EXPORT_PC()
21125     move   a0, rPC         # arg0
21126     move   a1, rFP         # arg1
21127     move   a2, rSELF       # arg2
21128     JAL(dvmCheckBefore)
21129     jr     rBIX
21130
21131 /* ------------------------------ */
21132     .balign 128
21133 .L_ALT_OP_REM_LONG: /* 0x9f */
21134 /* File: mips/alt_stub.S */
21135 /*
21136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21137  * any interesting requests and then jump to the real instruction
21138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21141  * bail to the real handler if breakFlags==0.
21142  */
21143     lbu    a3, offThread_breakFlags(rSELF)
21144     la     rBIX, dvmAsmInstructionStart + (159 * 128)
21145     lw     rIBASE, offThread_curHandlerTable(rSELF)
21146     bnez   a3, 1f
21147     jr     rBIX            # nothing to do - jump to real handler
21148 1:
21149     EXPORT_PC()
21150     move   a0, rPC         # arg0
21151     move   a1, rFP         # arg1
21152     move   a2, rSELF       # arg2
21153     JAL(dvmCheckBefore)
21154     jr     rBIX
21155
21156 /* ------------------------------ */
21157     .balign 128
21158 .L_ALT_OP_AND_LONG: /* 0xa0 */
21159 /* File: mips/alt_stub.S */
21160 /*
21161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21162  * any interesting requests and then jump to the real instruction
21163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21166  * bail to the real handler if breakFlags==0.
21167  */
21168     lbu    a3, offThread_breakFlags(rSELF)
21169     la     rBIX, dvmAsmInstructionStart + (160 * 128)
21170     lw     rIBASE, offThread_curHandlerTable(rSELF)
21171     bnez   a3, 1f
21172     jr     rBIX            # nothing to do - jump to real handler
21173 1:
21174     EXPORT_PC()
21175     move   a0, rPC         # arg0
21176     move   a1, rFP         # arg1
21177     move   a2, rSELF       # arg2
21178     JAL(dvmCheckBefore)
21179     jr     rBIX
21180
21181 /* ------------------------------ */
21182     .balign 128
21183 .L_ALT_OP_OR_LONG: /* 0xa1 */
21184 /* File: mips/alt_stub.S */
21185 /*
21186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21187  * any interesting requests and then jump to the real instruction
21188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21191  * bail to the real handler if breakFlags==0.
21192  */
21193     lbu    a3, offThread_breakFlags(rSELF)
21194     la     rBIX, dvmAsmInstructionStart + (161 * 128)
21195     lw     rIBASE, offThread_curHandlerTable(rSELF)
21196     bnez   a3, 1f
21197     jr     rBIX            # nothing to do - jump to real handler
21198 1:
21199     EXPORT_PC()
21200     move   a0, rPC         # arg0
21201     move   a1, rFP         # arg1
21202     move   a2, rSELF       # arg2
21203     JAL(dvmCheckBefore)
21204     jr     rBIX
21205
21206 /* ------------------------------ */
21207     .balign 128
21208 .L_ALT_OP_XOR_LONG: /* 0xa2 */
21209 /* File: mips/alt_stub.S */
21210 /*
21211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21212  * any interesting requests and then jump to the real instruction
21213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21216  * bail to the real handler if breakFlags==0.
21217  */
21218     lbu    a3, offThread_breakFlags(rSELF)
21219     la     rBIX, dvmAsmInstructionStart + (162 * 128)
21220     lw     rIBASE, offThread_curHandlerTable(rSELF)
21221     bnez   a3, 1f
21222     jr     rBIX            # nothing to do - jump to real handler
21223 1:
21224     EXPORT_PC()
21225     move   a0, rPC         # arg0
21226     move   a1, rFP         # arg1
21227     move   a2, rSELF       # arg2
21228     JAL(dvmCheckBefore)
21229     jr     rBIX
21230
21231 /* ------------------------------ */
21232     .balign 128
21233 .L_ALT_OP_SHL_LONG: /* 0xa3 */
21234 /* File: mips/alt_stub.S */
21235 /*
21236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21237  * any interesting requests and then jump to the real instruction
21238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21241  * bail to the real handler if breakFlags==0.
21242  */
21243     lbu    a3, offThread_breakFlags(rSELF)
21244     la     rBIX, dvmAsmInstructionStart + (163 * 128)
21245     lw     rIBASE, offThread_curHandlerTable(rSELF)
21246     bnez   a3, 1f
21247     jr     rBIX            # nothing to do - jump to real handler
21248 1:
21249     EXPORT_PC()
21250     move   a0, rPC         # arg0
21251     move   a1, rFP         # arg1
21252     move   a2, rSELF       # arg2
21253     JAL(dvmCheckBefore)
21254     jr     rBIX
21255
21256 /* ------------------------------ */
21257     .balign 128
21258 .L_ALT_OP_SHR_LONG: /* 0xa4 */
21259 /* File: mips/alt_stub.S */
21260 /*
21261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21262  * any interesting requests and then jump to the real instruction
21263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21266  * bail to the real handler if breakFlags==0.
21267  */
21268     lbu    a3, offThread_breakFlags(rSELF)
21269     la     rBIX, dvmAsmInstructionStart + (164 * 128)
21270     lw     rIBASE, offThread_curHandlerTable(rSELF)
21271     bnez   a3, 1f
21272     jr     rBIX            # nothing to do - jump to real handler
21273 1:
21274     EXPORT_PC()
21275     move   a0, rPC         # arg0
21276     move   a1, rFP         # arg1
21277     move   a2, rSELF       # arg2
21278     JAL(dvmCheckBefore)
21279     jr     rBIX
21280
21281 /* ------------------------------ */
21282     .balign 128
21283 .L_ALT_OP_USHR_LONG: /* 0xa5 */
21284 /* File: mips/alt_stub.S */
21285 /*
21286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21287  * any interesting requests and then jump to the real instruction
21288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21291  * bail to the real handler if breakFlags==0.
21292  */
21293     lbu    a3, offThread_breakFlags(rSELF)
21294     la     rBIX, dvmAsmInstructionStart + (165 * 128)
21295     lw     rIBASE, offThread_curHandlerTable(rSELF)
21296     bnez   a3, 1f
21297     jr     rBIX            # nothing to do - jump to real handler
21298 1:
21299     EXPORT_PC()
21300     move   a0, rPC         # arg0
21301     move   a1, rFP         # arg1
21302     move   a2, rSELF       # arg2
21303     JAL(dvmCheckBefore)
21304     jr     rBIX
21305
21306 /* ------------------------------ */
21307     .balign 128
21308 .L_ALT_OP_ADD_FLOAT: /* 0xa6 */
21309 /* File: mips/alt_stub.S */
21310 /*
21311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21312  * any interesting requests and then jump to the real instruction
21313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21316  * bail to the real handler if breakFlags==0.
21317  */
21318     lbu    a3, offThread_breakFlags(rSELF)
21319     la     rBIX, dvmAsmInstructionStart + (166 * 128)
21320     lw     rIBASE, offThread_curHandlerTable(rSELF)
21321     bnez   a3, 1f
21322     jr     rBIX            # nothing to do - jump to real handler
21323 1:
21324     EXPORT_PC()
21325     move   a0, rPC         # arg0
21326     move   a1, rFP         # arg1
21327     move   a2, rSELF       # arg2
21328     JAL(dvmCheckBefore)
21329     jr     rBIX
21330
21331 /* ------------------------------ */
21332     .balign 128
21333 .L_ALT_OP_SUB_FLOAT: /* 0xa7 */
21334 /* File: mips/alt_stub.S */
21335 /*
21336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21337  * any interesting requests and then jump to the real instruction
21338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21341  * bail to the real handler if breakFlags==0.
21342  */
21343     lbu    a3, offThread_breakFlags(rSELF)
21344     la     rBIX, dvmAsmInstructionStart + (167 * 128)
21345     lw     rIBASE, offThread_curHandlerTable(rSELF)
21346     bnez   a3, 1f
21347     jr     rBIX            # nothing to do - jump to real handler
21348 1:
21349     EXPORT_PC()
21350     move   a0, rPC         # arg0
21351     move   a1, rFP         # arg1
21352     move   a2, rSELF       # arg2
21353     JAL(dvmCheckBefore)
21354     jr     rBIX
21355
21356 /* ------------------------------ */
21357     .balign 128
21358 .L_ALT_OP_MUL_FLOAT: /* 0xa8 */
21359 /* File: mips/alt_stub.S */
21360 /*
21361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21362  * any interesting requests and then jump to the real instruction
21363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21366  * bail to the real handler if breakFlags==0.
21367  */
21368     lbu    a3, offThread_breakFlags(rSELF)
21369     la     rBIX, dvmAsmInstructionStart + (168 * 128)
21370     lw     rIBASE, offThread_curHandlerTable(rSELF)
21371     bnez   a3, 1f
21372     jr     rBIX            # nothing to do - jump to real handler
21373 1:
21374     EXPORT_PC()
21375     move   a0, rPC         # arg0
21376     move   a1, rFP         # arg1
21377     move   a2, rSELF       # arg2
21378     JAL(dvmCheckBefore)
21379     jr     rBIX
21380
21381 /* ------------------------------ */
21382     .balign 128
21383 .L_ALT_OP_DIV_FLOAT: /* 0xa9 */
21384 /* File: mips/alt_stub.S */
21385 /*
21386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21387  * any interesting requests and then jump to the real instruction
21388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21391  * bail to the real handler if breakFlags==0.
21392  */
21393     lbu    a3, offThread_breakFlags(rSELF)
21394     la     rBIX, dvmAsmInstructionStart + (169 * 128)
21395     lw     rIBASE, offThread_curHandlerTable(rSELF)
21396     bnez   a3, 1f
21397     jr     rBIX            # nothing to do - jump to real handler
21398 1:
21399     EXPORT_PC()
21400     move   a0, rPC         # arg0
21401     move   a1, rFP         # arg1
21402     move   a2, rSELF       # arg2
21403     JAL(dvmCheckBefore)
21404     jr     rBIX
21405
21406 /* ------------------------------ */
21407     .balign 128
21408 .L_ALT_OP_REM_FLOAT: /* 0xaa */
21409 /* File: mips/alt_stub.S */
21410 /*
21411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21412  * any interesting requests and then jump to the real instruction
21413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21416  * bail to the real handler if breakFlags==0.
21417  */
21418     lbu    a3, offThread_breakFlags(rSELF)
21419     la     rBIX, dvmAsmInstructionStart + (170 * 128)
21420     lw     rIBASE, offThread_curHandlerTable(rSELF)
21421     bnez   a3, 1f
21422     jr     rBIX            # nothing to do - jump to real handler
21423 1:
21424     EXPORT_PC()
21425     move   a0, rPC         # arg0
21426     move   a1, rFP         # arg1
21427     move   a2, rSELF       # arg2
21428     JAL(dvmCheckBefore)
21429     jr     rBIX
21430
21431 /* ------------------------------ */
21432     .balign 128
21433 .L_ALT_OP_ADD_DOUBLE: /* 0xab */
21434 /* File: mips/alt_stub.S */
21435 /*
21436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21437  * any interesting requests and then jump to the real instruction
21438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21441  * bail to the real handler if breakFlags==0.
21442  */
21443     lbu    a3, offThread_breakFlags(rSELF)
21444     la     rBIX, dvmAsmInstructionStart + (171 * 128)
21445     lw     rIBASE, offThread_curHandlerTable(rSELF)
21446     bnez   a3, 1f
21447     jr     rBIX            # nothing to do - jump to real handler
21448 1:
21449     EXPORT_PC()
21450     move   a0, rPC         # arg0
21451     move   a1, rFP         # arg1
21452     move   a2, rSELF       # arg2
21453     JAL(dvmCheckBefore)
21454     jr     rBIX
21455
21456 /* ------------------------------ */
21457     .balign 128
21458 .L_ALT_OP_SUB_DOUBLE: /* 0xac */
21459 /* File: mips/alt_stub.S */
21460 /*
21461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21462  * any interesting requests and then jump to the real instruction
21463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21466  * bail to the real handler if breakFlags==0.
21467  */
21468     lbu    a3, offThread_breakFlags(rSELF)
21469     la     rBIX, dvmAsmInstructionStart + (172 * 128)
21470     lw     rIBASE, offThread_curHandlerTable(rSELF)
21471     bnez   a3, 1f
21472     jr     rBIX            # nothing to do - jump to real handler
21473 1:
21474     EXPORT_PC()
21475     move   a0, rPC         # arg0
21476     move   a1, rFP         # arg1
21477     move   a2, rSELF       # arg2
21478     JAL(dvmCheckBefore)
21479     jr     rBIX
21480
21481 /* ------------------------------ */
21482     .balign 128
21483 .L_ALT_OP_MUL_DOUBLE: /* 0xad */
21484 /* File: mips/alt_stub.S */
21485 /*
21486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21487  * any interesting requests and then jump to the real instruction
21488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21491  * bail to the real handler if breakFlags==0.
21492  */
21493     lbu    a3, offThread_breakFlags(rSELF)
21494     la     rBIX, dvmAsmInstructionStart + (173 * 128)
21495     lw     rIBASE, offThread_curHandlerTable(rSELF)
21496     bnez   a3, 1f
21497     jr     rBIX            # nothing to do - jump to real handler
21498 1:
21499     EXPORT_PC()
21500     move   a0, rPC         # arg0
21501     move   a1, rFP         # arg1
21502     move   a2, rSELF       # arg2
21503     JAL(dvmCheckBefore)
21504     jr     rBIX
21505
21506 /* ------------------------------ */
21507     .balign 128
21508 .L_ALT_OP_DIV_DOUBLE: /* 0xae */
21509 /* File: mips/alt_stub.S */
21510 /*
21511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21512  * any interesting requests and then jump to the real instruction
21513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21516  * bail to the real handler if breakFlags==0.
21517  */
21518     lbu    a3, offThread_breakFlags(rSELF)
21519     la     rBIX, dvmAsmInstructionStart + (174 * 128)
21520     lw     rIBASE, offThread_curHandlerTable(rSELF)
21521     bnez   a3, 1f
21522     jr     rBIX            # nothing to do - jump to real handler
21523 1:
21524     EXPORT_PC()
21525     move   a0, rPC         # arg0
21526     move   a1, rFP         # arg1
21527     move   a2, rSELF       # arg2
21528     JAL(dvmCheckBefore)
21529     jr     rBIX
21530
21531 /* ------------------------------ */
21532     .balign 128
21533 .L_ALT_OP_REM_DOUBLE: /* 0xaf */
21534 /* File: mips/alt_stub.S */
21535 /*
21536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21537  * any interesting requests and then jump to the real instruction
21538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21541  * bail to the real handler if breakFlags==0.
21542  */
21543     lbu    a3, offThread_breakFlags(rSELF)
21544     la     rBIX, dvmAsmInstructionStart + (175 * 128)
21545     lw     rIBASE, offThread_curHandlerTable(rSELF)
21546     bnez   a3, 1f
21547     jr     rBIX            # nothing to do - jump to real handler
21548 1:
21549     EXPORT_PC()
21550     move   a0, rPC         # arg0
21551     move   a1, rFP         # arg1
21552     move   a2, rSELF       # arg2
21553     JAL(dvmCheckBefore)
21554     jr     rBIX
21555
21556 /* ------------------------------ */
21557     .balign 128
21558 .L_ALT_OP_ADD_INT_2ADDR: /* 0xb0 */
21559 /* File: mips/alt_stub.S */
21560 /*
21561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21562  * any interesting requests and then jump to the real instruction
21563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21566  * bail to the real handler if breakFlags==0.
21567  */
21568     lbu    a3, offThread_breakFlags(rSELF)
21569     la     rBIX, dvmAsmInstructionStart + (176 * 128)
21570     lw     rIBASE, offThread_curHandlerTable(rSELF)
21571     bnez   a3, 1f
21572     jr     rBIX            # nothing to do - jump to real handler
21573 1:
21574     EXPORT_PC()
21575     move   a0, rPC         # arg0
21576     move   a1, rFP         # arg1
21577     move   a2, rSELF       # arg2
21578     JAL(dvmCheckBefore)
21579     jr     rBIX
21580
21581 /* ------------------------------ */
21582     .balign 128
21583 .L_ALT_OP_SUB_INT_2ADDR: /* 0xb1 */
21584 /* File: mips/alt_stub.S */
21585 /*
21586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21587  * any interesting requests and then jump to the real instruction
21588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21591  * bail to the real handler if breakFlags==0.
21592  */
21593     lbu    a3, offThread_breakFlags(rSELF)
21594     la     rBIX, dvmAsmInstructionStart + (177 * 128)
21595     lw     rIBASE, offThread_curHandlerTable(rSELF)
21596     bnez   a3, 1f
21597     jr     rBIX            # nothing to do - jump to real handler
21598 1:
21599     EXPORT_PC()
21600     move   a0, rPC         # arg0
21601     move   a1, rFP         # arg1
21602     move   a2, rSELF       # arg2
21603     JAL(dvmCheckBefore)
21604     jr     rBIX
21605
21606 /* ------------------------------ */
21607     .balign 128
21608 .L_ALT_OP_MUL_INT_2ADDR: /* 0xb2 */
21609 /* File: mips/alt_stub.S */
21610 /*
21611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21612  * any interesting requests and then jump to the real instruction
21613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21616  * bail to the real handler if breakFlags==0.
21617  */
21618     lbu    a3, offThread_breakFlags(rSELF)
21619     la     rBIX, dvmAsmInstructionStart + (178 * 128)
21620     lw     rIBASE, offThread_curHandlerTable(rSELF)
21621     bnez   a3, 1f
21622     jr     rBIX            # nothing to do - jump to real handler
21623 1:
21624     EXPORT_PC()
21625     move   a0, rPC         # arg0
21626     move   a1, rFP         # arg1
21627     move   a2, rSELF       # arg2
21628     JAL(dvmCheckBefore)
21629     jr     rBIX
21630
21631 /* ------------------------------ */
21632     .balign 128
21633 .L_ALT_OP_DIV_INT_2ADDR: /* 0xb3 */
21634 /* File: mips/alt_stub.S */
21635 /*
21636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21637  * any interesting requests and then jump to the real instruction
21638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21641  * bail to the real handler if breakFlags==0.
21642  */
21643     lbu    a3, offThread_breakFlags(rSELF)
21644     la     rBIX, dvmAsmInstructionStart + (179 * 128)
21645     lw     rIBASE, offThread_curHandlerTable(rSELF)
21646     bnez   a3, 1f
21647     jr     rBIX            # nothing to do - jump to real handler
21648 1:
21649     EXPORT_PC()
21650     move   a0, rPC         # arg0
21651     move   a1, rFP         # arg1
21652     move   a2, rSELF       # arg2
21653     JAL(dvmCheckBefore)
21654     jr     rBIX
21655
21656 /* ------------------------------ */
21657     .balign 128
21658 .L_ALT_OP_REM_INT_2ADDR: /* 0xb4 */
21659 /* File: mips/alt_stub.S */
21660 /*
21661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21662  * any interesting requests and then jump to the real instruction
21663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21666  * bail to the real handler if breakFlags==0.
21667  */
21668     lbu    a3, offThread_breakFlags(rSELF)
21669     la     rBIX, dvmAsmInstructionStart + (180 * 128)
21670     lw     rIBASE, offThread_curHandlerTable(rSELF)
21671     bnez   a3, 1f
21672     jr     rBIX            # nothing to do - jump to real handler
21673 1:
21674     EXPORT_PC()
21675     move   a0, rPC         # arg0
21676     move   a1, rFP         # arg1
21677     move   a2, rSELF       # arg2
21678     JAL(dvmCheckBefore)
21679     jr     rBIX
21680
21681 /* ------------------------------ */
21682     .balign 128
21683 .L_ALT_OP_AND_INT_2ADDR: /* 0xb5 */
21684 /* File: mips/alt_stub.S */
21685 /*
21686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21687  * any interesting requests and then jump to the real instruction
21688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21691  * bail to the real handler if breakFlags==0.
21692  */
21693     lbu    a3, offThread_breakFlags(rSELF)
21694     la     rBIX, dvmAsmInstructionStart + (181 * 128)
21695     lw     rIBASE, offThread_curHandlerTable(rSELF)
21696     bnez   a3, 1f
21697     jr     rBIX            # nothing to do - jump to real handler
21698 1:
21699     EXPORT_PC()
21700     move   a0, rPC         # arg0
21701     move   a1, rFP         # arg1
21702     move   a2, rSELF       # arg2
21703     JAL(dvmCheckBefore)
21704     jr     rBIX
21705
21706 /* ------------------------------ */
21707     .balign 128
21708 .L_ALT_OP_OR_INT_2ADDR: /* 0xb6 */
21709 /* File: mips/alt_stub.S */
21710 /*
21711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21712  * any interesting requests and then jump to the real instruction
21713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21716  * bail to the real handler if breakFlags==0.
21717  */
21718     lbu    a3, offThread_breakFlags(rSELF)
21719     la     rBIX, dvmAsmInstructionStart + (182 * 128)
21720     lw     rIBASE, offThread_curHandlerTable(rSELF)
21721     bnez   a3, 1f
21722     jr     rBIX            # nothing to do - jump to real handler
21723 1:
21724     EXPORT_PC()
21725     move   a0, rPC         # arg0
21726     move   a1, rFP         # arg1
21727     move   a2, rSELF       # arg2
21728     JAL(dvmCheckBefore)
21729     jr     rBIX
21730
21731 /* ------------------------------ */
21732     .balign 128
21733 .L_ALT_OP_XOR_INT_2ADDR: /* 0xb7 */
21734 /* File: mips/alt_stub.S */
21735 /*
21736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21737  * any interesting requests and then jump to the real instruction
21738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21741  * bail to the real handler if breakFlags==0.
21742  */
21743     lbu    a3, offThread_breakFlags(rSELF)
21744     la     rBIX, dvmAsmInstructionStart + (183 * 128)
21745     lw     rIBASE, offThread_curHandlerTable(rSELF)
21746     bnez   a3, 1f
21747     jr     rBIX            # nothing to do - jump to real handler
21748 1:
21749     EXPORT_PC()
21750     move   a0, rPC         # arg0
21751     move   a1, rFP         # arg1
21752     move   a2, rSELF       # arg2
21753     JAL(dvmCheckBefore)
21754     jr     rBIX
21755
21756 /* ------------------------------ */
21757     .balign 128
21758 .L_ALT_OP_SHL_INT_2ADDR: /* 0xb8 */
21759 /* File: mips/alt_stub.S */
21760 /*
21761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21762  * any interesting requests and then jump to the real instruction
21763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21766  * bail to the real handler if breakFlags==0.
21767  */
21768     lbu    a3, offThread_breakFlags(rSELF)
21769     la     rBIX, dvmAsmInstructionStart + (184 * 128)
21770     lw     rIBASE, offThread_curHandlerTable(rSELF)
21771     bnez   a3, 1f
21772     jr     rBIX            # nothing to do - jump to real handler
21773 1:
21774     EXPORT_PC()
21775     move   a0, rPC         # arg0
21776     move   a1, rFP         # arg1
21777     move   a2, rSELF       # arg2
21778     JAL(dvmCheckBefore)
21779     jr     rBIX
21780
21781 /* ------------------------------ */
21782     .balign 128
21783 .L_ALT_OP_SHR_INT_2ADDR: /* 0xb9 */
21784 /* File: mips/alt_stub.S */
21785 /*
21786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21787  * any interesting requests and then jump to the real instruction
21788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21791  * bail to the real handler if breakFlags==0.
21792  */
21793     lbu    a3, offThread_breakFlags(rSELF)
21794     la     rBIX, dvmAsmInstructionStart + (185 * 128)
21795     lw     rIBASE, offThread_curHandlerTable(rSELF)
21796     bnez   a3, 1f
21797     jr     rBIX            # nothing to do - jump to real handler
21798 1:
21799     EXPORT_PC()
21800     move   a0, rPC         # arg0
21801     move   a1, rFP         # arg1
21802     move   a2, rSELF       # arg2
21803     JAL(dvmCheckBefore)
21804     jr     rBIX
21805
21806 /* ------------------------------ */
21807     .balign 128
21808 .L_ALT_OP_USHR_INT_2ADDR: /* 0xba */
21809 /* File: mips/alt_stub.S */
21810 /*
21811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21812  * any interesting requests and then jump to the real instruction
21813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21816  * bail to the real handler if breakFlags==0.
21817  */
21818     lbu    a3, offThread_breakFlags(rSELF)
21819     la     rBIX, dvmAsmInstructionStart + (186 * 128)
21820     lw     rIBASE, offThread_curHandlerTable(rSELF)
21821     bnez   a3, 1f
21822     jr     rBIX            # nothing to do - jump to real handler
21823 1:
21824     EXPORT_PC()
21825     move   a0, rPC         # arg0
21826     move   a1, rFP         # arg1
21827     move   a2, rSELF       # arg2
21828     JAL(dvmCheckBefore)
21829     jr     rBIX
21830
21831 /* ------------------------------ */
21832     .balign 128
21833 .L_ALT_OP_ADD_LONG_2ADDR: /* 0xbb */
21834 /* File: mips/alt_stub.S */
21835 /*
21836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21837  * any interesting requests and then jump to the real instruction
21838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21841  * bail to the real handler if breakFlags==0.
21842  */
21843     lbu    a3, offThread_breakFlags(rSELF)
21844     la     rBIX, dvmAsmInstructionStart + (187 * 128)
21845     lw     rIBASE, offThread_curHandlerTable(rSELF)
21846     bnez   a3, 1f
21847     jr     rBIX            # nothing to do - jump to real handler
21848 1:
21849     EXPORT_PC()
21850     move   a0, rPC         # arg0
21851     move   a1, rFP         # arg1
21852     move   a2, rSELF       # arg2
21853     JAL(dvmCheckBefore)
21854     jr     rBIX
21855
21856 /* ------------------------------ */
21857     .balign 128
21858 .L_ALT_OP_SUB_LONG_2ADDR: /* 0xbc */
21859 /* File: mips/alt_stub.S */
21860 /*
21861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21862  * any interesting requests and then jump to the real instruction
21863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21866  * bail to the real handler if breakFlags==0.
21867  */
21868     lbu    a3, offThread_breakFlags(rSELF)
21869     la     rBIX, dvmAsmInstructionStart + (188 * 128)
21870     lw     rIBASE, offThread_curHandlerTable(rSELF)
21871     bnez   a3, 1f
21872     jr     rBIX            # nothing to do - jump to real handler
21873 1:
21874     EXPORT_PC()
21875     move   a0, rPC         # arg0
21876     move   a1, rFP         # arg1
21877     move   a2, rSELF       # arg2
21878     JAL(dvmCheckBefore)
21879     jr     rBIX
21880
21881 /* ------------------------------ */
21882     .balign 128
21883 .L_ALT_OP_MUL_LONG_2ADDR: /* 0xbd */
21884 /* File: mips/alt_stub.S */
21885 /*
21886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21887  * any interesting requests and then jump to the real instruction
21888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21891  * bail to the real handler if breakFlags==0.
21892  */
21893     lbu    a3, offThread_breakFlags(rSELF)
21894     la     rBIX, dvmAsmInstructionStart + (189 * 128)
21895     lw     rIBASE, offThread_curHandlerTable(rSELF)
21896     bnez   a3, 1f
21897     jr     rBIX            # nothing to do - jump to real handler
21898 1:
21899     EXPORT_PC()
21900     move   a0, rPC         # arg0
21901     move   a1, rFP         # arg1
21902     move   a2, rSELF       # arg2
21903     JAL(dvmCheckBefore)
21904     jr     rBIX
21905
21906 /* ------------------------------ */
21907     .balign 128
21908 .L_ALT_OP_DIV_LONG_2ADDR: /* 0xbe */
21909 /* File: mips/alt_stub.S */
21910 /*
21911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21912  * any interesting requests and then jump to the real instruction
21913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21916  * bail to the real handler if breakFlags==0.
21917  */
21918     lbu    a3, offThread_breakFlags(rSELF)
21919     la     rBIX, dvmAsmInstructionStart + (190 * 128)
21920     lw     rIBASE, offThread_curHandlerTable(rSELF)
21921     bnez   a3, 1f
21922     jr     rBIX            # nothing to do - jump to real handler
21923 1:
21924     EXPORT_PC()
21925     move   a0, rPC         # arg0
21926     move   a1, rFP         # arg1
21927     move   a2, rSELF       # arg2
21928     JAL(dvmCheckBefore)
21929     jr     rBIX
21930
21931 /* ------------------------------ */
21932     .balign 128
21933 .L_ALT_OP_REM_LONG_2ADDR: /* 0xbf */
21934 /* File: mips/alt_stub.S */
21935 /*
21936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21937  * any interesting requests and then jump to the real instruction
21938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21941  * bail to the real handler if breakFlags==0.
21942  */
21943     lbu    a3, offThread_breakFlags(rSELF)
21944     la     rBIX, dvmAsmInstructionStart + (191 * 128)
21945     lw     rIBASE, offThread_curHandlerTable(rSELF)
21946     bnez   a3, 1f
21947     jr     rBIX            # nothing to do - jump to real handler
21948 1:
21949     EXPORT_PC()
21950     move   a0, rPC         # arg0
21951     move   a1, rFP         # arg1
21952     move   a2, rSELF       # arg2
21953     JAL(dvmCheckBefore)
21954     jr     rBIX
21955
21956 /* ------------------------------ */
21957     .balign 128
21958 .L_ALT_OP_AND_LONG_2ADDR: /* 0xc0 */
21959 /* File: mips/alt_stub.S */
21960 /*
21961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21962  * any interesting requests and then jump to the real instruction
21963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21966  * bail to the real handler if breakFlags==0.
21967  */
21968     lbu    a3, offThread_breakFlags(rSELF)
21969     la     rBIX, dvmAsmInstructionStart + (192 * 128)
21970     lw     rIBASE, offThread_curHandlerTable(rSELF)
21971     bnez   a3, 1f
21972     jr     rBIX            # nothing to do - jump to real handler
21973 1:
21974     EXPORT_PC()
21975     move   a0, rPC         # arg0
21976     move   a1, rFP         # arg1
21977     move   a2, rSELF       # arg2
21978     JAL(dvmCheckBefore)
21979     jr     rBIX
21980
21981 /* ------------------------------ */
21982     .balign 128
21983 .L_ALT_OP_OR_LONG_2ADDR: /* 0xc1 */
21984 /* File: mips/alt_stub.S */
21985 /*
21986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
21987  * any interesting requests and then jump to the real instruction
21988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
21989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
21990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
21991  * bail to the real handler if breakFlags==0.
21992  */
21993     lbu    a3, offThread_breakFlags(rSELF)
21994     la     rBIX, dvmAsmInstructionStart + (193 * 128)
21995     lw     rIBASE, offThread_curHandlerTable(rSELF)
21996     bnez   a3, 1f
21997     jr     rBIX            # nothing to do - jump to real handler
21998 1:
21999     EXPORT_PC()
22000     move   a0, rPC         # arg0
22001     move   a1, rFP         # arg1
22002     move   a2, rSELF       # arg2
22003     JAL(dvmCheckBefore)
22004     jr     rBIX
22005
22006 /* ------------------------------ */
22007     .balign 128
22008 .L_ALT_OP_XOR_LONG_2ADDR: /* 0xc2 */
22009 /* File: mips/alt_stub.S */
22010 /*
22011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22012  * any interesting requests and then jump to the real instruction
22013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22016  * bail to the real handler if breakFlags==0.
22017  */
22018     lbu    a3, offThread_breakFlags(rSELF)
22019     la     rBIX, dvmAsmInstructionStart + (194 * 128)
22020     lw     rIBASE, offThread_curHandlerTable(rSELF)
22021     bnez   a3, 1f
22022     jr     rBIX            # nothing to do - jump to real handler
22023 1:
22024     EXPORT_PC()
22025     move   a0, rPC         # arg0
22026     move   a1, rFP         # arg1
22027     move   a2, rSELF       # arg2
22028     JAL(dvmCheckBefore)
22029     jr     rBIX
22030
22031 /* ------------------------------ */
22032     .balign 128
22033 .L_ALT_OP_SHL_LONG_2ADDR: /* 0xc3 */
22034 /* File: mips/alt_stub.S */
22035 /*
22036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22037  * any interesting requests and then jump to the real instruction
22038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22041  * bail to the real handler if breakFlags==0.
22042  */
22043     lbu    a3, offThread_breakFlags(rSELF)
22044     la     rBIX, dvmAsmInstructionStart + (195 * 128)
22045     lw     rIBASE, offThread_curHandlerTable(rSELF)
22046     bnez   a3, 1f
22047     jr     rBIX            # nothing to do - jump to real handler
22048 1:
22049     EXPORT_PC()
22050     move   a0, rPC         # arg0
22051     move   a1, rFP         # arg1
22052     move   a2, rSELF       # arg2
22053     JAL(dvmCheckBefore)
22054     jr     rBIX
22055
22056 /* ------------------------------ */
22057     .balign 128
22058 .L_ALT_OP_SHR_LONG_2ADDR: /* 0xc4 */
22059 /* File: mips/alt_stub.S */
22060 /*
22061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22062  * any interesting requests and then jump to the real instruction
22063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22066  * bail to the real handler if breakFlags==0.
22067  */
22068     lbu    a3, offThread_breakFlags(rSELF)
22069     la     rBIX, dvmAsmInstructionStart + (196 * 128)
22070     lw     rIBASE, offThread_curHandlerTable(rSELF)
22071     bnez   a3, 1f
22072     jr     rBIX            # nothing to do - jump to real handler
22073 1:
22074     EXPORT_PC()
22075     move   a0, rPC         # arg0
22076     move   a1, rFP         # arg1
22077     move   a2, rSELF       # arg2
22078     JAL(dvmCheckBefore)
22079     jr     rBIX
22080
22081 /* ------------------------------ */
22082     .balign 128
22083 .L_ALT_OP_USHR_LONG_2ADDR: /* 0xc5 */
22084 /* File: mips/alt_stub.S */
22085 /*
22086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22087  * any interesting requests and then jump to the real instruction
22088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22091  * bail to the real handler if breakFlags==0.
22092  */
22093     lbu    a3, offThread_breakFlags(rSELF)
22094     la     rBIX, dvmAsmInstructionStart + (197 * 128)
22095     lw     rIBASE, offThread_curHandlerTable(rSELF)
22096     bnez   a3, 1f
22097     jr     rBIX            # nothing to do - jump to real handler
22098 1:
22099     EXPORT_PC()
22100     move   a0, rPC         # arg0
22101     move   a1, rFP         # arg1
22102     move   a2, rSELF       # arg2
22103     JAL(dvmCheckBefore)
22104     jr     rBIX
22105
22106 /* ------------------------------ */
22107     .balign 128
22108 .L_ALT_OP_ADD_FLOAT_2ADDR: /* 0xc6 */
22109 /* File: mips/alt_stub.S */
22110 /*
22111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22112  * any interesting requests and then jump to the real instruction
22113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22116  * bail to the real handler if breakFlags==0.
22117  */
22118     lbu    a3, offThread_breakFlags(rSELF)
22119     la     rBIX, dvmAsmInstructionStart + (198 * 128)
22120     lw     rIBASE, offThread_curHandlerTable(rSELF)
22121     bnez   a3, 1f
22122     jr     rBIX            # nothing to do - jump to real handler
22123 1:
22124     EXPORT_PC()
22125     move   a0, rPC         # arg0
22126     move   a1, rFP         # arg1
22127     move   a2, rSELF       # arg2
22128     JAL(dvmCheckBefore)
22129     jr     rBIX
22130
22131 /* ------------------------------ */
22132     .balign 128
22133 .L_ALT_OP_SUB_FLOAT_2ADDR: /* 0xc7 */
22134 /* File: mips/alt_stub.S */
22135 /*
22136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22137  * any interesting requests and then jump to the real instruction
22138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22141  * bail to the real handler if breakFlags==0.
22142  */
22143     lbu    a3, offThread_breakFlags(rSELF)
22144     la     rBIX, dvmAsmInstructionStart + (199 * 128)
22145     lw     rIBASE, offThread_curHandlerTable(rSELF)
22146     bnez   a3, 1f
22147     jr     rBIX            # nothing to do - jump to real handler
22148 1:
22149     EXPORT_PC()
22150     move   a0, rPC         # arg0
22151     move   a1, rFP         # arg1
22152     move   a2, rSELF       # arg2
22153     JAL(dvmCheckBefore)
22154     jr     rBIX
22155
22156 /* ------------------------------ */
22157     .balign 128
22158 .L_ALT_OP_MUL_FLOAT_2ADDR: /* 0xc8 */
22159 /* File: mips/alt_stub.S */
22160 /*
22161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22162  * any interesting requests and then jump to the real instruction
22163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22166  * bail to the real handler if breakFlags==0.
22167  */
22168     lbu    a3, offThread_breakFlags(rSELF)
22169     la     rBIX, dvmAsmInstructionStart + (200 * 128)
22170     lw     rIBASE, offThread_curHandlerTable(rSELF)
22171     bnez   a3, 1f
22172     jr     rBIX            # nothing to do - jump to real handler
22173 1:
22174     EXPORT_PC()
22175     move   a0, rPC         # arg0
22176     move   a1, rFP         # arg1
22177     move   a2, rSELF       # arg2
22178     JAL(dvmCheckBefore)
22179     jr     rBIX
22180
22181 /* ------------------------------ */
22182     .balign 128
22183 .L_ALT_OP_DIV_FLOAT_2ADDR: /* 0xc9 */
22184 /* File: mips/alt_stub.S */
22185 /*
22186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22187  * any interesting requests and then jump to the real instruction
22188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22191  * bail to the real handler if breakFlags==0.
22192  */
22193     lbu    a3, offThread_breakFlags(rSELF)
22194     la     rBIX, dvmAsmInstructionStart + (201 * 128)
22195     lw     rIBASE, offThread_curHandlerTable(rSELF)
22196     bnez   a3, 1f
22197     jr     rBIX            # nothing to do - jump to real handler
22198 1:
22199     EXPORT_PC()
22200     move   a0, rPC         # arg0
22201     move   a1, rFP         # arg1
22202     move   a2, rSELF       # arg2
22203     JAL(dvmCheckBefore)
22204     jr     rBIX
22205
22206 /* ------------------------------ */
22207     .balign 128
22208 .L_ALT_OP_REM_FLOAT_2ADDR: /* 0xca */
22209 /* File: mips/alt_stub.S */
22210 /*
22211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22212  * any interesting requests and then jump to the real instruction
22213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22216  * bail to the real handler if breakFlags==0.
22217  */
22218     lbu    a3, offThread_breakFlags(rSELF)
22219     la     rBIX, dvmAsmInstructionStart + (202 * 128)
22220     lw     rIBASE, offThread_curHandlerTable(rSELF)
22221     bnez   a3, 1f
22222     jr     rBIX            # nothing to do - jump to real handler
22223 1:
22224     EXPORT_PC()
22225     move   a0, rPC         # arg0
22226     move   a1, rFP         # arg1
22227     move   a2, rSELF       # arg2
22228     JAL(dvmCheckBefore)
22229     jr     rBIX
22230
22231 /* ------------------------------ */
22232     .balign 128
22233 .L_ALT_OP_ADD_DOUBLE_2ADDR: /* 0xcb */
22234 /* File: mips/alt_stub.S */
22235 /*
22236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22237  * any interesting requests and then jump to the real instruction
22238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22241  * bail to the real handler if breakFlags==0.
22242  */
22243     lbu    a3, offThread_breakFlags(rSELF)
22244     la     rBIX, dvmAsmInstructionStart + (203 * 128)
22245     lw     rIBASE, offThread_curHandlerTable(rSELF)
22246     bnez   a3, 1f
22247     jr     rBIX            # nothing to do - jump to real handler
22248 1:
22249     EXPORT_PC()
22250     move   a0, rPC         # arg0
22251     move   a1, rFP         # arg1
22252     move   a2, rSELF       # arg2
22253     JAL(dvmCheckBefore)
22254     jr     rBIX
22255
22256 /* ------------------------------ */
22257     .balign 128
22258 .L_ALT_OP_SUB_DOUBLE_2ADDR: /* 0xcc */
22259 /* File: mips/alt_stub.S */
22260 /*
22261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22262  * any interesting requests and then jump to the real instruction
22263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22266  * bail to the real handler if breakFlags==0.
22267  */
22268     lbu    a3, offThread_breakFlags(rSELF)
22269     la     rBIX, dvmAsmInstructionStart + (204 * 128)
22270     lw     rIBASE, offThread_curHandlerTable(rSELF)
22271     bnez   a3, 1f
22272     jr     rBIX            # nothing to do - jump to real handler
22273 1:
22274     EXPORT_PC()
22275     move   a0, rPC         # arg0
22276     move   a1, rFP         # arg1
22277     move   a2, rSELF       # arg2
22278     JAL(dvmCheckBefore)
22279     jr     rBIX
22280
22281 /* ------------------------------ */
22282     .balign 128
22283 .L_ALT_OP_MUL_DOUBLE_2ADDR: /* 0xcd */
22284 /* File: mips/alt_stub.S */
22285 /*
22286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22287  * any interesting requests and then jump to the real instruction
22288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22291  * bail to the real handler if breakFlags==0.
22292  */
22293     lbu    a3, offThread_breakFlags(rSELF)
22294     la     rBIX, dvmAsmInstructionStart + (205 * 128)
22295     lw     rIBASE, offThread_curHandlerTable(rSELF)
22296     bnez   a3, 1f
22297     jr     rBIX            # nothing to do - jump to real handler
22298 1:
22299     EXPORT_PC()
22300     move   a0, rPC         # arg0
22301     move   a1, rFP         # arg1
22302     move   a2, rSELF       # arg2
22303     JAL(dvmCheckBefore)
22304     jr     rBIX
22305
22306 /* ------------------------------ */
22307     .balign 128
22308 .L_ALT_OP_DIV_DOUBLE_2ADDR: /* 0xce */
22309 /* File: mips/alt_stub.S */
22310 /*
22311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22312  * any interesting requests and then jump to the real instruction
22313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22316  * bail to the real handler if breakFlags==0.
22317  */
22318     lbu    a3, offThread_breakFlags(rSELF)
22319     la     rBIX, dvmAsmInstructionStart + (206 * 128)
22320     lw     rIBASE, offThread_curHandlerTable(rSELF)
22321     bnez   a3, 1f
22322     jr     rBIX            # nothing to do - jump to real handler
22323 1:
22324     EXPORT_PC()
22325     move   a0, rPC         # arg0
22326     move   a1, rFP         # arg1
22327     move   a2, rSELF       # arg2
22328     JAL(dvmCheckBefore)
22329     jr     rBIX
22330
22331 /* ------------------------------ */
22332     .balign 128
22333 .L_ALT_OP_REM_DOUBLE_2ADDR: /* 0xcf */
22334 /* File: mips/alt_stub.S */
22335 /*
22336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22337  * any interesting requests and then jump to the real instruction
22338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22341  * bail to the real handler if breakFlags==0.
22342  */
22343     lbu    a3, offThread_breakFlags(rSELF)
22344     la     rBIX, dvmAsmInstructionStart + (207 * 128)
22345     lw     rIBASE, offThread_curHandlerTable(rSELF)
22346     bnez   a3, 1f
22347     jr     rBIX            # nothing to do - jump to real handler
22348 1:
22349     EXPORT_PC()
22350     move   a0, rPC         # arg0
22351     move   a1, rFP         # arg1
22352     move   a2, rSELF       # arg2
22353     JAL(dvmCheckBefore)
22354     jr     rBIX
22355
22356 /* ------------------------------ */
22357     .balign 128
22358 .L_ALT_OP_ADD_INT_LIT16: /* 0xd0 */
22359 /* File: mips/alt_stub.S */
22360 /*
22361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22362  * any interesting requests and then jump to the real instruction
22363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22366  * bail to the real handler if breakFlags==0.
22367  */
22368     lbu    a3, offThread_breakFlags(rSELF)
22369     la     rBIX, dvmAsmInstructionStart + (208 * 128)
22370     lw     rIBASE, offThread_curHandlerTable(rSELF)
22371     bnez   a3, 1f
22372     jr     rBIX            # nothing to do - jump to real handler
22373 1:
22374     EXPORT_PC()
22375     move   a0, rPC         # arg0
22376     move   a1, rFP         # arg1
22377     move   a2, rSELF       # arg2
22378     JAL(dvmCheckBefore)
22379     jr     rBIX
22380
22381 /* ------------------------------ */
22382     .balign 128
22383 .L_ALT_OP_RSUB_INT: /* 0xd1 */
22384 /* File: mips/alt_stub.S */
22385 /*
22386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22387  * any interesting requests and then jump to the real instruction
22388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22391  * bail to the real handler if breakFlags==0.
22392  */
22393     lbu    a3, offThread_breakFlags(rSELF)
22394     la     rBIX, dvmAsmInstructionStart + (209 * 128)
22395     lw     rIBASE, offThread_curHandlerTable(rSELF)
22396     bnez   a3, 1f
22397     jr     rBIX            # nothing to do - jump to real handler
22398 1:
22399     EXPORT_PC()
22400     move   a0, rPC         # arg0
22401     move   a1, rFP         # arg1
22402     move   a2, rSELF       # arg2
22403     JAL(dvmCheckBefore)
22404     jr     rBIX
22405
22406 /* ------------------------------ */
22407     .balign 128
22408 .L_ALT_OP_MUL_INT_LIT16: /* 0xd2 */
22409 /* File: mips/alt_stub.S */
22410 /*
22411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22412  * any interesting requests and then jump to the real instruction
22413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22416  * bail to the real handler if breakFlags==0.
22417  */
22418     lbu    a3, offThread_breakFlags(rSELF)
22419     la     rBIX, dvmAsmInstructionStart + (210 * 128)
22420     lw     rIBASE, offThread_curHandlerTable(rSELF)
22421     bnez   a3, 1f
22422     jr     rBIX            # nothing to do - jump to real handler
22423 1:
22424     EXPORT_PC()
22425     move   a0, rPC         # arg0
22426     move   a1, rFP         # arg1
22427     move   a2, rSELF       # arg2
22428     JAL(dvmCheckBefore)
22429     jr     rBIX
22430
22431 /* ------------------------------ */
22432     .balign 128
22433 .L_ALT_OP_DIV_INT_LIT16: /* 0xd3 */
22434 /* File: mips/alt_stub.S */
22435 /*
22436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22437  * any interesting requests and then jump to the real instruction
22438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22441  * bail to the real handler if breakFlags==0.
22442  */
22443     lbu    a3, offThread_breakFlags(rSELF)
22444     la     rBIX, dvmAsmInstructionStart + (211 * 128)
22445     lw     rIBASE, offThread_curHandlerTable(rSELF)
22446     bnez   a3, 1f
22447     jr     rBIX            # nothing to do - jump to real handler
22448 1:
22449     EXPORT_PC()
22450     move   a0, rPC         # arg0
22451     move   a1, rFP         # arg1
22452     move   a2, rSELF       # arg2
22453     JAL(dvmCheckBefore)
22454     jr     rBIX
22455
22456 /* ------------------------------ */
22457     .balign 128
22458 .L_ALT_OP_REM_INT_LIT16: /* 0xd4 */
22459 /* File: mips/alt_stub.S */
22460 /*
22461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22462  * any interesting requests and then jump to the real instruction
22463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22466  * bail to the real handler if breakFlags==0.
22467  */
22468     lbu    a3, offThread_breakFlags(rSELF)
22469     la     rBIX, dvmAsmInstructionStart + (212 * 128)
22470     lw     rIBASE, offThread_curHandlerTable(rSELF)
22471     bnez   a3, 1f
22472     jr     rBIX            # nothing to do - jump to real handler
22473 1:
22474     EXPORT_PC()
22475     move   a0, rPC         # arg0
22476     move   a1, rFP         # arg1
22477     move   a2, rSELF       # arg2
22478     JAL(dvmCheckBefore)
22479     jr     rBIX
22480
22481 /* ------------------------------ */
22482     .balign 128
22483 .L_ALT_OP_AND_INT_LIT16: /* 0xd5 */
22484 /* File: mips/alt_stub.S */
22485 /*
22486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22487  * any interesting requests and then jump to the real instruction
22488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22491  * bail to the real handler if breakFlags==0.
22492  */
22493     lbu    a3, offThread_breakFlags(rSELF)
22494     la     rBIX, dvmAsmInstructionStart + (213 * 128)
22495     lw     rIBASE, offThread_curHandlerTable(rSELF)
22496     bnez   a3, 1f
22497     jr     rBIX            # nothing to do - jump to real handler
22498 1:
22499     EXPORT_PC()
22500     move   a0, rPC         # arg0
22501     move   a1, rFP         # arg1
22502     move   a2, rSELF       # arg2
22503     JAL(dvmCheckBefore)
22504     jr     rBIX
22505
22506 /* ------------------------------ */
22507     .balign 128
22508 .L_ALT_OP_OR_INT_LIT16: /* 0xd6 */
22509 /* File: mips/alt_stub.S */
22510 /*
22511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22512  * any interesting requests and then jump to the real instruction
22513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22516  * bail to the real handler if breakFlags==0.
22517  */
22518     lbu    a3, offThread_breakFlags(rSELF)
22519     la     rBIX, dvmAsmInstructionStart + (214 * 128)
22520     lw     rIBASE, offThread_curHandlerTable(rSELF)
22521     bnez   a3, 1f
22522     jr     rBIX            # nothing to do - jump to real handler
22523 1:
22524     EXPORT_PC()
22525     move   a0, rPC         # arg0
22526     move   a1, rFP         # arg1
22527     move   a2, rSELF       # arg2
22528     JAL(dvmCheckBefore)
22529     jr     rBIX
22530
22531 /* ------------------------------ */
22532     .balign 128
22533 .L_ALT_OP_XOR_INT_LIT16: /* 0xd7 */
22534 /* File: mips/alt_stub.S */
22535 /*
22536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22537  * any interesting requests and then jump to the real instruction
22538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22541  * bail to the real handler if breakFlags==0.
22542  */
22543     lbu    a3, offThread_breakFlags(rSELF)
22544     la     rBIX, dvmAsmInstructionStart + (215 * 128)
22545     lw     rIBASE, offThread_curHandlerTable(rSELF)
22546     bnez   a3, 1f
22547     jr     rBIX            # nothing to do - jump to real handler
22548 1:
22549     EXPORT_PC()
22550     move   a0, rPC         # arg0
22551     move   a1, rFP         # arg1
22552     move   a2, rSELF       # arg2
22553     JAL(dvmCheckBefore)
22554     jr     rBIX
22555
22556 /* ------------------------------ */
22557     .balign 128
22558 .L_ALT_OP_ADD_INT_LIT8: /* 0xd8 */
22559 /* File: mips/alt_stub.S */
22560 /*
22561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22562  * any interesting requests and then jump to the real instruction
22563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22566  * bail to the real handler if breakFlags==0.
22567  */
22568     lbu    a3, offThread_breakFlags(rSELF)
22569     la     rBIX, dvmAsmInstructionStart + (216 * 128)
22570     lw     rIBASE, offThread_curHandlerTable(rSELF)
22571     bnez   a3, 1f
22572     jr     rBIX            # nothing to do - jump to real handler
22573 1:
22574     EXPORT_PC()
22575     move   a0, rPC         # arg0
22576     move   a1, rFP         # arg1
22577     move   a2, rSELF       # arg2
22578     JAL(dvmCheckBefore)
22579     jr     rBIX
22580
22581 /* ------------------------------ */
22582     .balign 128
22583 .L_ALT_OP_RSUB_INT_LIT8: /* 0xd9 */
22584 /* File: mips/alt_stub.S */
22585 /*
22586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22587  * any interesting requests and then jump to the real instruction
22588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22591  * bail to the real handler if breakFlags==0.
22592  */
22593     lbu    a3, offThread_breakFlags(rSELF)
22594     la     rBIX, dvmAsmInstructionStart + (217 * 128)
22595     lw     rIBASE, offThread_curHandlerTable(rSELF)
22596     bnez   a3, 1f
22597     jr     rBIX            # nothing to do - jump to real handler
22598 1:
22599     EXPORT_PC()
22600     move   a0, rPC         # arg0
22601     move   a1, rFP         # arg1
22602     move   a2, rSELF       # arg2
22603     JAL(dvmCheckBefore)
22604     jr     rBIX
22605
22606 /* ------------------------------ */
22607     .balign 128
22608 .L_ALT_OP_MUL_INT_LIT8: /* 0xda */
22609 /* File: mips/alt_stub.S */
22610 /*
22611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22612  * any interesting requests and then jump to the real instruction
22613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22616  * bail to the real handler if breakFlags==0.
22617  */
22618     lbu    a3, offThread_breakFlags(rSELF)
22619     la     rBIX, dvmAsmInstructionStart + (218 * 128)
22620     lw     rIBASE, offThread_curHandlerTable(rSELF)
22621     bnez   a3, 1f
22622     jr     rBIX            # nothing to do - jump to real handler
22623 1:
22624     EXPORT_PC()
22625     move   a0, rPC         # arg0
22626     move   a1, rFP         # arg1
22627     move   a2, rSELF       # arg2
22628     JAL(dvmCheckBefore)
22629     jr     rBIX
22630
22631 /* ------------------------------ */
22632     .balign 128
22633 .L_ALT_OP_DIV_INT_LIT8: /* 0xdb */
22634 /* File: mips/alt_stub.S */
22635 /*
22636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22637  * any interesting requests and then jump to the real instruction
22638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22641  * bail to the real handler if breakFlags==0.
22642  */
22643     lbu    a3, offThread_breakFlags(rSELF)
22644     la     rBIX, dvmAsmInstructionStart + (219 * 128)
22645     lw     rIBASE, offThread_curHandlerTable(rSELF)
22646     bnez   a3, 1f
22647     jr     rBIX            # nothing to do - jump to real handler
22648 1:
22649     EXPORT_PC()
22650     move   a0, rPC         # arg0
22651     move   a1, rFP         # arg1
22652     move   a2, rSELF       # arg2
22653     JAL(dvmCheckBefore)
22654     jr     rBIX
22655
22656 /* ------------------------------ */
22657     .balign 128
22658 .L_ALT_OP_REM_INT_LIT8: /* 0xdc */
22659 /* File: mips/alt_stub.S */
22660 /*
22661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22662  * any interesting requests and then jump to the real instruction
22663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22666  * bail to the real handler if breakFlags==0.
22667  */
22668     lbu    a3, offThread_breakFlags(rSELF)
22669     la     rBIX, dvmAsmInstructionStart + (220 * 128)
22670     lw     rIBASE, offThread_curHandlerTable(rSELF)
22671     bnez   a3, 1f
22672     jr     rBIX            # nothing to do - jump to real handler
22673 1:
22674     EXPORT_PC()
22675     move   a0, rPC         # arg0
22676     move   a1, rFP         # arg1
22677     move   a2, rSELF       # arg2
22678     JAL(dvmCheckBefore)
22679     jr     rBIX
22680
22681 /* ------------------------------ */
22682     .balign 128
22683 .L_ALT_OP_AND_INT_LIT8: /* 0xdd */
22684 /* File: mips/alt_stub.S */
22685 /*
22686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22687  * any interesting requests and then jump to the real instruction
22688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22691  * bail to the real handler if breakFlags==0.
22692  */
22693     lbu    a3, offThread_breakFlags(rSELF)
22694     la     rBIX, dvmAsmInstructionStart + (221 * 128)
22695     lw     rIBASE, offThread_curHandlerTable(rSELF)
22696     bnez   a3, 1f
22697     jr     rBIX            # nothing to do - jump to real handler
22698 1:
22699     EXPORT_PC()
22700     move   a0, rPC         # arg0
22701     move   a1, rFP         # arg1
22702     move   a2, rSELF       # arg2
22703     JAL(dvmCheckBefore)
22704     jr     rBIX
22705
22706 /* ------------------------------ */
22707     .balign 128
22708 .L_ALT_OP_OR_INT_LIT8: /* 0xde */
22709 /* File: mips/alt_stub.S */
22710 /*
22711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22712  * any interesting requests and then jump to the real instruction
22713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22716  * bail to the real handler if breakFlags==0.
22717  */
22718     lbu    a3, offThread_breakFlags(rSELF)
22719     la     rBIX, dvmAsmInstructionStart + (222 * 128)
22720     lw     rIBASE, offThread_curHandlerTable(rSELF)
22721     bnez   a3, 1f
22722     jr     rBIX            # nothing to do - jump to real handler
22723 1:
22724     EXPORT_PC()
22725     move   a0, rPC         # arg0
22726     move   a1, rFP         # arg1
22727     move   a2, rSELF       # arg2
22728     JAL(dvmCheckBefore)
22729     jr     rBIX
22730
22731 /* ------------------------------ */
22732     .balign 128
22733 .L_ALT_OP_XOR_INT_LIT8: /* 0xdf */
22734 /* File: mips/alt_stub.S */
22735 /*
22736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22737  * any interesting requests and then jump to the real instruction
22738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22741  * bail to the real handler if breakFlags==0.
22742  */
22743     lbu    a3, offThread_breakFlags(rSELF)
22744     la     rBIX, dvmAsmInstructionStart + (223 * 128)
22745     lw     rIBASE, offThread_curHandlerTable(rSELF)
22746     bnez   a3, 1f
22747     jr     rBIX            # nothing to do - jump to real handler
22748 1:
22749     EXPORT_PC()
22750     move   a0, rPC         # arg0
22751     move   a1, rFP         # arg1
22752     move   a2, rSELF       # arg2
22753     JAL(dvmCheckBefore)
22754     jr     rBIX
22755
22756 /* ------------------------------ */
22757     .balign 128
22758 .L_ALT_OP_SHL_INT_LIT8: /* 0xe0 */
22759 /* File: mips/alt_stub.S */
22760 /*
22761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22762  * any interesting requests and then jump to the real instruction
22763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22766  * bail to the real handler if breakFlags==0.
22767  */
22768     lbu    a3, offThread_breakFlags(rSELF)
22769     la     rBIX, dvmAsmInstructionStart + (224 * 128)
22770     lw     rIBASE, offThread_curHandlerTable(rSELF)
22771     bnez   a3, 1f
22772     jr     rBIX            # nothing to do - jump to real handler
22773 1:
22774     EXPORT_PC()
22775     move   a0, rPC         # arg0
22776     move   a1, rFP         # arg1
22777     move   a2, rSELF       # arg2
22778     JAL(dvmCheckBefore)
22779     jr     rBIX
22780
22781 /* ------------------------------ */
22782     .balign 128
22783 .L_ALT_OP_SHR_INT_LIT8: /* 0xe1 */
22784 /* File: mips/alt_stub.S */
22785 /*
22786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22787  * any interesting requests and then jump to the real instruction
22788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22791  * bail to the real handler if breakFlags==0.
22792  */
22793     lbu    a3, offThread_breakFlags(rSELF)
22794     la     rBIX, dvmAsmInstructionStart + (225 * 128)
22795     lw     rIBASE, offThread_curHandlerTable(rSELF)
22796     bnez   a3, 1f
22797     jr     rBIX            # nothing to do - jump to real handler
22798 1:
22799     EXPORT_PC()
22800     move   a0, rPC         # arg0
22801     move   a1, rFP         # arg1
22802     move   a2, rSELF       # arg2
22803     JAL(dvmCheckBefore)
22804     jr     rBIX
22805
22806 /* ------------------------------ */
22807     .balign 128
22808 .L_ALT_OP_USHR_INT_LIT8: /* 0xe2 */
22809 /* File: mips/alt_stub.S */
22810 /*
22811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22812  * any interesting requests and then jump to the real instruction
22813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22816  * bail to the real handler if breakFlags==0.
22817  */
22818     lbu    a3, offThread_breakFlags(rSELF)
22819     la     rBIX, dvmAsmInstructionStart + (226 * 128)
22820     lw     rIBASE, offThread_curHandlerTable(rSELF)
22821     bnez   a3, 1f
22822     jr     rBIX            # nothing to do - jump to real handler
22823 1:
22824     EXPORT_PC()
22825     move   a0, rPC         # arg0
22826     move   a1, rFP         # arg1
22827     move   a2, rSELF       # arg2
22828     JAL(dvmCheckBefore)
22829     jr     rBIX
22830
22831 /* ------------------------------ */
22832     .balign 128
22833 .L_ALT_OP_IGET_VOLATILE: /* 0xe3 */
22834 /* File: mips/alt_stub.S */
22835 /*
22836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22837  * any interesting requests and then jump to the real instruction
22838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22841  * bail to the real handler if breakFlags==0.
22842  */
22843     lbu    a3, offThread_breakFlags(rSELF)
22844     la     rBIX, dvmAsmInstructionStart + (227 * 128)
22845     lw     rIBASE, offThread_curHandlerTable(rSELF)
22846     bnez   a3, 1f
22847     jr     rBIX            # nothing to do - jump to real handler
22848 1:
22849     EXPORT_PC()
22850     move   a0, rPC         # arg0
22851     move   a1, rFP         # arg1
22852     move   a2, rSELF       # arg2
22853     JAL(dvmCheckBefore)
22854     jr     rBIX
22855
22856 /* ------------------------------ */
22857     .balign 128
22858 .L_ALT_OP_IPUT_VOLATILE: /* 0xe4 */
22859 /* File: mips/alt_stub.S */
22860 /*
22861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22862  * any interesting requests and then jump to the real instruction
22863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22866  * bail to the real handler if breakFlags==0.
22867  */
22868     lbu    a3, offThread_breakFlags(rSELF)
22869     la     rBIX, dvmAsmInstructionStart + (228 * 128)
22870     lw     rIBASE, offThread_curHandlerTable(rSELF)
22871     bnez   a3, 1f
22872     jr     rBIX            # nothing to do - jump to real handler
22873 1:
22874     EXPORT_PC()
22875     move   a0, rPC         # arg0
22876     move   a1, rFP         # arg1
22877     move   a2, rSELF       # arg2
22878     JAL(dvmCheckBefore)
22879     jr     rBIX
22880
22881 /* ------------------------------ */
22882     .balign 128
22883 .L_ALT_OP_SGET_VOLATILE: /* 0xe5 */
22884 /* File: mips/alt_stub.S */
22885 /*
22886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22887  * any interesting requests and then jump to the real instruction
22888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22891  * bail to the real handler if breakFlags==0.
22892  */
22893     lbu    a3, offThread_breakFlags(rSELF)
22894     la     rBIX, dvmAsmInstructionStart + (229 * 128)
22895     lw     rIBASE, offThread_curHandlerTable(rSELF)
22896     bnez   a3, 1f
22897     jr     rBIX            # nothing to do - jump to real handler
22898 1:
22899     EXPORT_PC()
22900     move   a0, rPC         # arg0
22901     move   a1, rFP         # arg1
22902     move   a2, rSELF       # arg2
22903     JAL(dvmCheckBefore)
22904     jr     rBIX
22905
22906 /* ------------------------------ */
22907     .balign 128
22908 .L_ALT_OP_SPUT_VOLATILE: /* 0xe6 */
22909 /* File: mips/alt_stub.S */
22910 /*
22911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22912  * any interesting requests and then jump to the real instruction
22913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22916  * bail to the real handler if breakFlags==0.
22917  */
22918     lbu    a3, offThread_breakFlags(rSELF)
22919     la     rBIX, dvmAsmInstructionStart + (230 * 128)
22920     lw     rIBASE, offThread_curHandlerTable(rSELF)
22921     bnez   a3, 1f
22922     jr     rBIX            # nothing to do - jump to real handler
22923 1:
22924     EXPORT_PC()
22925     move   a0, rPC         # arg0
22926     move   a1, rFP         # arg1
22927     move   a2, rSELF       # arg2
22928     JAL(dvmCheckBefore)
22929     jr     rBIX
22930
22931 /* ------------------------------ */
22932     .balign 128
22933 .L_ALT_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */
22934 /* File: mips/alt_stub.S */
22935 /*
22936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22937  * any interesting requests and then jump to the real instruction
22938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22941  * bail to the real handler if breakFlags==0.
22942  */
22943     lbu    a3, offThread_breakFlags(rSELF)
22944     la     rBIX, dvmAsmInstructionStart + (231 * 128)
22945     lw     rIBASE, offThread_curHandlerTable(rSELF)
22946     bnez   a3, 1f
22947     jr     rBIX            # nothing to do - jump to real handler
22948 1:
22949     EXPORT_PC()
22950     move   a0, rPC         # arg0
22951     move   a1, rFP         # arg1
22952     move   a2, rSELF       # arg2
22953     JAL(dvmCheckBefore)
22954     jr     rBIX
22955
22956 /* ------------------------------ */
22957     .balign 128
22958 .L_ALT_OP_IGET_WIDE_VOLATILE: /* 0xe8 */
22959 /* File: mips/alt_stub.S */
22960 /*
22961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22962  * any interesting requests and then jump to the real instruction
22963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22966  * bail to the real handler if breakFlags==0.
22967  */
22968     lbu    a3, offThread_breakFlags(rSELF)
22969     la     rBIX, dvmAsmInstructionStart + (232 * 128)
22970     lw     rIBASE, offThread_curHandlerTable(rSELF)
22971     bnez   a3, 1f
22972     jr     rBIX            # nothing to do - jump to real handler
22973 1:
22974     EXPORT_PC()
22975     move   a0, rPC         # arg0
22976     move   a1, rFP         # arg1
22977     move   a2, rSELF       # arg2
22978     JAL(dvmCheckBefore)
22979     jr     rBIX
22980
22981 /* ------------------------------ */
22982     .balign 128
22983 .L_ALT_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */
22984 /* File: mips/alt_stub.S */
22985 /*
22986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
22987  * any interesting requests and then jump to the real instruction
22988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
22989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
22990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
22991  * bail to the real handler if breakFlags==0.
22992  */
22993     lbu    a3, offThread_breakFlags(rSELF)
22994     la     rBIX, dvmAsmInstructionStart + (233 * 128)
22995     lw     rIBASE, offThread_curHandlerTable(rSELF)
22996     bnez   a3, 1f
22997     jr     rBIX            # nothing to do - jump to real handler
22998 1:
22999     EXPORT_PC()
23000     move   a0, rPC         # arg0
23001     move   a1, rFP         # arg1
23002     move   a2, rSELF       # arg2
23003     JAL(dvmCheckBefore)
23004     jr     rBIX
23005
23006 /* ------------------------------ */
23007     .balign 128
23008 .L_ALT_OP_SGET_WIDE_VOLATILE: /* 0xea */
23009 /* File: mips/alt_stub.S */
23010 /*
23011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23012  * any interesting requests and then jump to the real instruction
23013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23016  * bail to the real handler if breakFlags==0.
23017  */
23018     lbu    a3, offThread_breakFlags(rSELF)
23019     la     rBIX, dvmAsmInstructionStart + (234 * 128)
23020     lw     rIBASE, offThread_curHandlerTable(rSELF)
23021     bnez   a3, 1f
23022     jr     rBIX            # nothing to do - jump to real handler
23023 1:
23024     EXPORT_PC()
23025     move   a0, rPC         # arg0
23026     move   a1, rFP         # arg1
23027     move   a2, rSELF       # arg2
23028     JAL(dvmCheckBefore)
23029     jr     rBIX
23030
23031 /* ------------------------------ */
23032     .balign 128
23033 .L_ALT_OP_SPUT_WIDE_VOLATILE: /* 0xeb */
23034 /* File: mips/alt_stub.S */
23035 /*
23036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23037  * any interesting requests and then jump to the real instruction
23038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23041  * bail to the real handler if breakFlags==0.
23042  */
23043     lbu    a3, offThread_breakFlags(rSELF)
23044     la     rBIX, dvmAsmInstructionStart + (235 * 128)
23045     lw     rIBASE, offThread_curHandlerTable(rSELF)
23046     bnez   a3, 1f
23047     jr     rBIX            # nothing to do - jump to real handler
23048 1:
23049     EXPORT_PC()
23050     move   a0, rPC         # arg0
23051     move   a1, rFP         # arg1
23052     move   a2, rSELF       # arg2
23053     JAL(dvmCheckBefore)
23054     jr     rBIX
23055
23056 /* ------------------------------ */
23057     .balign 128
23058 .L_ALT_OP_BREAKPOINT: /* 0xec */
23059 /* File: mips/alt_stub.S */
23060 /*
23061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23062  * any interesting requests and then jump to the real instruction
23063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23066  * bail to the real handler if breakFlags==0.
23067  */
23068     lbu    a3, offThread_breakFlags(rSELF)
23069     la     rBIX, dvmAsmInstructionStart + (236 * 128)
23070     lw     rIBASE, offThread_curHandlerTable(rSELF)
23071     bnez   a3, 1f
23072     jr     rBIX            # nothing to do - jump to real handler
23073 1:
23074     EXPORT_PC()
23075     move   a0, rPC         # arg0
23076     move   a1, rFP         # arg1
23077     move   a2, rSELF       # arg2
23078     JAL(dvmCheckBefore)
23079     jr     rBIX
23080
23081 /* ------------------------------ */
23082     .balign 128
23083 .L_ALT_OP_THROW_VERIFICATION_ERROR: /* 0xed */
23084 /* File: mips/alt_stub.S */
23085 /*
23086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23087  * any interesting requests and then jump to the real instruction
23088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23091  * bail to the real handler if breakFlags==0.
23092  */
23093     lbu    a3, offThread_breakFlags(rSELF)
23094     la     rBIX, dvmAsmInstructionStart + (237 * 128)
23095     lw     rIBASE, offThread_curHandlerTable(rSELF)
23096     bnez   a3, 1f
23097     jr     rBIX            # nothing to do - jump to real handler
23098 1:
23099     EXPORT_PC()
23100     move   a0, rPC         # arg0
23101     move   a1, rFP         # arg1
23102     move   a2, rSELF       # arg2
23103     JAL(dvmCheckBefore)
23104     jr     rBIX
23105
23106 /* ------------------------------ */
23107     .balign 128
23108 .L_ALT_OP_EXECUTE_INLINE: /* 0xee */
23109 /* File: mips/alt_stub.S */
23110 /*
23111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23112  * any interesting requests and then jump to the real instruction
23113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23116  * bail to the real handler if breakFlags==0.
23117  */
23118     lbu    a3, offThread_breakFlags(rSELF)
23119     la     rBIX, dvmAsmInstructionStart + (238 * 128)
23120     lw     rIBASE, offThread_curHandlerTable(rSELF)
23121     bnez   a3, 1f
23122     jr     rBIX            # nothing to do - jump to real handler
23123 1:
23124     EXPORT_PC()
23125     move   a0, rPC         # arg0
23126     move   a1, rFP         # arg1
23127     move   a2, rSELF       # arg2
23128     JAL(dvmCheckBefore)
23129     jr     rBIX
23130
23131 /* ------------------------------ */
23132     .balign 128
23133 .L_ALT_OP_EXECUTE_INLINE_RANGE: /* 0xef */
23134 /* File: mips/alt_stub.S */
23135 /*
23136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23137  * any interesting requests and then jump to the real instruction
23138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23141  * bail to the real handler if breakFlags==0.
23142  */
23143     lbu    a3, offThread_breakFlags(rSELF)
23144     la     rBIX, dvmAsmInstructionStart + (239 * 128)
23145     lw     rIBASE, offThread_curHandlerTable(rSELF)
23146     bnez   a3, 1f
23147     jr     rBIX            # nothing to do - jump to real handler
23148 1:
23149     EXPORT_PC()
23150     move   a0, rPC         # arg0
23151     move   a1, rFP         # arg1
23152     move   a2, rSELF       # arg2
23153     JAL(dvmCheckBefore)
23154     jr     rBIX
23155
23156 /* ------------------------------ */
23157     .balign 128
23158 .L_ALT_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */
23159 /* File: mips/alt_stub.S */
23160 /*
23161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23162  * any interesting requests and then jump to the real instruction
23163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23166  * bail to the real handler if breakFlags==0.
23167  */
23168     lbu    a3, offThread_breakFlags(rSELF)
23169     la     rBIX, dvmAsmInstructionStart + (240 * 128)
23170     lw     rIBASE, offThread_curHandlerTable(rSELF)
23171     bnez   a3, 1f
23172     jr     rBIX            # nothing to do - jump to real handler
23173 1:
23174     EXPORT_PC()
23175     move   a0, rPC         # arg0
23176     move   a1, rFP         # arg1
23177     move   a2, rSELF       # arg2
23178     JAL(dvmCheckBefore)
23179     jr     rBIX
23180
23181 /* ------------------------------ */
23182     .balign 128
23183 .L_ALT_OP_RETURN_VOID_BARRIER: /* 0xf1 */
23184 /* File: mips/alt_stub.S */
23185 /*
23186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23187  * any interesting requests and then jump to the real instruction
23188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23191  * bail to the real handler if breakFlags==0.
23192  */
23193     lbu    a3, offThread_breakFlags(rSELF)
23194     la     rBIX, dvmAsmInstructionStart + (241 * 128)
23195     lw     rIBASE, offThread_curHandlerTable(rSELF)
23196     bnez   a3, 1f
23197     jr     rBIX            # nothing to do - jump to real handler
23198 1:
23199     EXPORT_PC()
23200     move   a0, rPC         # arg0
23201     move   a1, rFP         # arg1
23202     move   a2, rSELF       # arg2
23203     JAL(dvmCheckBefore)
23204     jr     rBIX
23205
23206 /* ------------------------------ */
23207     .balign 128
23208 .L_ALT_OP_IGET_QUICK: /* 0xf2 */
23209 /* File: mips/alt_stub.S */
23210 /*
23211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23212  * any interesting requests and then jump to the real instruction
23213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23216  * bail to the real handler if breakFlags==0.
23217  */
23218     lbu    a3, offThread_breakFlags(rSELF)
23219     la     rBIX, dvmAsmInstructionStart + (242 * 128)
23220     lw     rIBASE, offThread_curHandlerTable(rSELF)
23221     bnez   a3, 1f
23222     jr     rBIX            # nothing to do - jump to real handler
23223 1:
23224     EXPORT_PC()
23225     move   a0, rPC         # arg0
23226     move   a1, rFP         # arg1
23227     move   a2, rSELF       # arg2
23228     JAL(dvmCheckBefore)
23229     jr     rBIX
23230
23231 /* ------------------------------ */
23232     .balign 128
23233 .L_ALT_OP_IGET_WIDE_QUICK: /* 0xf3 */
23234 /* File: mips/alt_stub.S */
23235 /*
23236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23237  * any interesting requests and then jump to the real instruction
23238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23241  * bail to the real handler if breakFlags==0.
23242  */
23243     lbu    a3, offThread_breakFlags(rSELF)
23244     la     rBIX, dvmAsmInstructionStart + (243 * 128)
23245     lw     rIBASE, offThread_curHandlerTable(rSELF)
23246     bnez   a3, 1f
23247     jr     rBIX            # nothing to do - jump to real handler
23248 1:
23249     EXPORT_PC()
23250     move   a0, rPC         # arg0
23251     move   a1, rFP         # arg1
23252     move   a2, rSELF       # arg2
23253     JAL(dvmCheckBefore)
23254     jr     rBIX
23255
23256 /* ------------------------------ */
23257     .balign 128
23258 .L_ALT_OP_IGET_OBJECT_QUICK: /* 0xf4 */
23259 /* File: mips/alt_stub.S */
23260 /*
23261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23262  * any interesting requests and then jump to the real instruction
23263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23266  * bail to the real handler if breakFlags==0.
23267  */
23268     lbu    a3, offThread_breakFlags(rSELF)
23269     la     rBIX, dvmAsmInstructionStart + (244 * 128)
23270     lw     rIBASE, offThread_curHandlerTable(rSELF)
23271     bnez   a3, 1f
23272     jr     rBIX            # nothing to do - jump to real handler
23273 1:
23274     EXPORT_PC()
23275     move   a0, rPC         # arg0
23276     move   a1, rFP         # arg1
23277     move   a2, rSELF       # arg2
23278     JAL(dvmCheckBefore)
23279     jr     rBIX
23280
23281 /* ------------------------------ */
23282     .balign 128
23283 .L_ALT_OP_IPUT_QUICK: /* 0xf5 */
23284 /* File: mips/alt_stub.S */
23285 /*
23286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23287  * any interesting requests and then jump to the real instruction
23288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23291  * bail to the real handler if breakFlags==0.
23292  */
23293     lbu    a3, offThread_breakFlags(rSELF)
23294     la     rBIX, dvmAsmInstructionStart + (245 * 128)
23295     lw     rIBASE, offThread_curHandlerTable(rSELF)
23296     bnez   a3, 1f
23297     jr     rBIX            # nothing to do - jump to real handler
23298 1:
23299     EXPORT_PC()
23300     move   a0, rPC         # arg0
23301     move   a1, rFP         # arg1
23302     move   a2, rSELF       # arg2
23303     JAL(dvmCheckBefore)
23304     jr     rBIX
23305
23306 /* ------------------------------ */
23307     .balign 128
23308 .L_ALT_OP_IPUT_WIDE_QUICK: /* 0xf6 */
23309 /* File: mips/alt_stub.S */
23310 /*
23311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23312  * any interesting requests and then jump to the real instruction
23313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23316  * bail to the real handler if breakFlags==0.
23317  */
23318     lbu    a3, offThread_breakFlags(rSELF)
23319     la     rBIX, dvmAsmInstructionStart + (246 * 128)
23320     lw     rIBASE, offThread_curHandlerTable(rSELF)
23321     bnez   a3, 1f
23322     jr     rBIX            # nothing to do - jump to real handler
23323 1:
23324     EXPORT_PC()
23325     move   a0, rPC         # arg0
23326     move   a1, rFP         # arg1
23327     move   a2, rSELF       # arg2
23328     JAL(dvmCheckBefore)
23329     jr     rBIX
23330
23331 /* ------------------------------ */
23332     .balign 128
23333 .L_ALT_OP_IPUT_OBJECT_QUICK: /* 0xf7 */
23334 /* File: mips/alt_stub.S */
23335 /*
23336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23337  * any interesting requests and then jump to the real instruction
23338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23341  * bail to the real handler if breakFlags==0.
23342  */
23343     lbu    a3, offThread_breakFlags(rSELF)
23344     la     rBIX, dvmAsmInstructionStart + (247 * 128)
23345     lw     rIBASE, offThread_curHandlerTable(rSELF)
23346     bnez   a3, 1f
23347     jr     rBIX            # nothing to do - jump to real handler
23348 1:
23349     EXPORT_PC()
23350     move   a0, rPC         # arg0
23351     move   a1, rFP         # arg1
23352     move   a2, rSELF       # arg2
23353     JAL(dvmCheckBefore)
23354     jr     rBIX
23355
23356 /* ------------------------------ */
23357     .balign 128
23358 .L_ALT_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */
23359 /* File: mips/alt_stub.S */
23360 /*
23361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23362  * any interesting requests and then jump to the real instruction
23363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23366  * bail to the real handler if breakFlags==0.
23367  */
23368     lbu    a3, offThread_breakFlags(rSELF)
23369     la     rBIX, dvmAsmInstructionStart + (248 * 128)
23370     lw     rIBASE, offThread_curHandlerTable(rSELF)
23371     bnez   a3, 1f
23372     jr     rBIX            # nothing to do - jump to real handler
23373 1:
23374     EXPORT_PC()
23375     move   a0, rPC         # arg0
23376     move   a1, rFP         # arg1
23377     move   a2, rSELF       # arg2
23378     JAL(dvmCheckBefore)
23379     jr     rBIX
23380
23381 /* ------------------------------ */
23382     .balign 128
23383 .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */
23384 /* File: mips/alt_stub.S */
23385 /*
23386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23387  * any interesting requests and then jump to the real instruction
23388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23391  * bail to the real handler if breakFlags==0.
23392  */
23393     lbu    a3, offThread_breakFlags(rSELF)
23394     la     rBIX, dvmAsmInstructionStart + (249 * 128)
23395     lw     rIBASE, offThread_curHandlerTable(rSELF)
23396     bnez   a3, 1f
23397     jr     rBIX            # nothing to do - jump to real handler
23398 1:
23399     EXPORT_PC()
23400     move   a0, rPC         # arg0
23401     move   a1, rFP         # arg1
23402     move   a2, rSELF       # arg2
23403     JAL(dvmCheckBefore)
23404     jr     rBIX
23405
23406 /* ------------------------------ */
23407     .balign 128
23408 .L_ALT_OP_INVOKE_SUPER_QUICK: /* 0xfa */
23409 /* File: mips/alt_stub.S */
23410 /*
23411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23412  * any interesting requests and then jump to the real instruction
23413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23416  * bail to the real handler if breakFlags==0.
23417  */
23418     lbu    a3, offThread_breakFlags(rSELF)
23419     la     rBIX, dvmAsmInstructionStart + (250 * 128)
23420     lw     rIBASE, offThread_curHandlerTable(rSELF)
23421     bnez   a3, 1f
23422     jr     rBIX            # nothing to do - jump to real handler
23423 1:
23424     EXPORT_PC()
23425     move   a0, rPC         # arg0
23426     move   a1, rFP         # arg1
23427     move   a2, rSELF       # arg2
23428     JAL(dvmCheckBefore)
23429     jr     rBIX
23430
23431 /* ------------------------------ */
23432     .balign 128
23433 .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */
23434 /* File: mips/alt_stub.S */
23435 /*
23436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23437  * any interesting requests and then jump to the real instruction
23438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23441  * bail to the real handler if breakFlags==0.
23442  */
23443     lbu    a3, offThread_breakFlags(rSELF)
23444     la     rBIX, dvmAsmInstructionStart + (251 * 128)
23445     lw     rIBASE, offThread_curHandlerTable(rSELF)
23446     bnez   a3, 1f
23447     jr     rBIX            # nothing to do - jump to real handler
23448 1:
23449     EXPORT_PC()
23450     move   a0, rPC         # arg0
23451     move   a1, rFP         # arg1
23452     move   a2, rSELF       # arg2
23453     JAL(dvmCheckBefore)
23454     jr     rBIX
23455
23456 /* ------------------------------ */
23457     .balign 128
23458 .L_ALT_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */
23459 /* File: mips/alt_stub.S */
23460 /*
23461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23462  * any interesting requests and then jump to the real instruction
23463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23466  * bail to the real handler if breakFlags==0.
23467  */
23468     lbu    a3, offThread_breakFlags(rSELF)
23469     la     rBIX, dvmAsmInstructionStart + (252 * 128)
23470     lw     rIBASE, offThread_curHandlerTable(rSELF)
23471     bnez   a3, 1f
23472     jr     rBIX            # nothing to do - jump to real handler
23473 1:
23474     EXPORT_PC()
23475     move   a0, rPC         # arg0
23476     move   a1, rFP         # arg1
23477     move   a2, rSELF       # arg2
23478     JAL(dvmCheckBefore)
23479     jr     rBIX
23480
23481 /* ------------------------------ */
23482     .balign 128
23483 .L_ALT_OP_SGET_OBJECT_VOLATILE: /* 0xfd */
23484 /* File: mips/alt_stub.S */
23485 /*
23486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23487  * any interesting requests and then jump to the real instruction
23488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23491  * bail to the real handler if breakFlags==0.
23492  */
23493     lbu    a3, offThread_breakFlags(rSELF)
23494     la     rBIX, dvmAsmInstructionStart + (253 * 128)
23495     lw     rIBASE, offThread_curHandlerTable(rSELF)
23496     bnez   a3, 1f
23497     jr     rBIX            # nothing to do - jump to real handler
23498 1:
23499     EXPORT_PC()
23500     move   a0, rPC         # arg0
23501     move   a1, rFP         # arg1
23502     move   a2, rSELF       # arg2
23503     JAL(dvmCheckBefore)
23504     jr     rBIX
23505
23506 /* ------------------------------ */
23507     .balign 128
23508 .L_ALT_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */
23509 /* File: mips/alt_stub.S */
23510 /*
23511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23512  * any interesting requests and then jump to the real instruction
23513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23516  * bail to the real handler if breakFlags==0.
23517  */
23518     lbu    a3, offThread_breakFlags(rSELF)
23519     la     rBIX, dvmAsmInstructionStart + (254 * 128)
23520     lw     rIBASE, offThread_curHandlerTable(rSELF)
23521     bnez   a3, 1f
23522     jr     rBIX            # nothing to do - jump to real handler
23523 1:
23524     EXPORT_PC()
23525     move   a0, rPC         # arg0
23526     move   a1, rFP         # arg1
23527     move   a2, rSELF       # arg2
23528     JAL(dvmCheckBefore)
23529     jr     rBIX
23530
23531 /* ------------------------------ */
23532     .balign 128
23533 .L_ALT_OP_DISPATCH_FF: /* 0xff */
23534 /* File: mips/alt_stub.S */
23535 /*
23536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23537  * any interesting requests and then jump to the real instruction
23538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23541  * bail to the real handler if breakFlags==0.
23542  */
23543     lbu    a3, offThread_breakFlags(rSELF)
23544     la     rBIX, dvmAsmInstructionStart + (255 * 128)
23545     lw     rIBASE, offThread_curHandlerTable(rSELF)
23546     bnez   a3, 1f
23547     jr     rBIX            # nothing to do - jump to real handler
23548 1:
23549     EXPORT_PC()
23550     move   a0, rPC         # arg0
23551     move   a1, rFP         # arg1
23552     move   a2, rSELF       # arg2
23553     JAL(dvmCheckBefore)
23554     jr     rBIX
23555
23556 /* ------------------------------ */
23557     .balign 128
23558 .L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */
23559 /* File: mips/alt_stub.S */
23560 /*
23561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23562  * any interesting requests and then jump to the real instruction
23563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23566  * bail to the real handler if breakFlags==0.
23567  */
23568     lbu    a3, offThread_breakFlags(rSELF)
23569     la     rBIX, dvmAsmInstructionStart + (256 * 128)
23570     lw     rIBASE, offThread_curHandlerTable(rSELF)
23571     bnez   a3, 1f
23572     jr     rBIX            # nothing to do - jump to real handler
23573 1:
23574     EXPORT_PC()
23575     move   a0, rPC         # arg0
23576     move   a1, rFP         # arg1
23577     move   a2, rSELF       # arg2
23578     JAL(dvmCheckBefore)
23579     jr     rBIX
23580
23581 /* ------------------------------ */
23582     .balign 128
23583 .L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */
23584 /* File: mips/alt_stub.S */
23585 /*
23586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23587  * any interesting requests and then jump to the real instruction
23588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23591  * bail to the real handler if breakFlags==0.
23592  */
23593     lbu    a3, offThread_breakFlags(rSELF)
23594     la     rBIX, dvmAsmInstructionStart + (257 * 128)
23595     lw     rIBASE, offThread_curHandlerTable(rSELF)
23596     bnez   a3, 1f
23597     jr     rBIX            # nothing to do - jump to real handler
23598 1:
23599     EXPORT_PC()
23600     move   a0, rPC         # arg0
23601     move   a1, rFP         # arg1
23602     move   a2, rSELF       # arg2
23603     JAL(dvmCheckBefore)
23604     jr     rBIX
23605
23606 /* ------------------------------ */
23607     .balign 128
23608 .L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */
23609 /* File: mips/alt_stub.S */
23610 /*
23611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23612  * any interesting requests and then jump to the real instruction
23613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23616  * bail to the real handler if breakFlags==0.
23617  */
23618     lbu    a3, offThread_breakFlags(rSELF)
23619     la     rBIX, dvmAsmInstructionStart + (258 * 128)
23620     lw     rIBASE, offThread_curHandlerTable(rSELF)
23621     bnez   a3, 1f
23622     jr     rBIX            # nothing to do - jump to real handler
23623 1:
23624     EXPORT_PC()
23625     move   a0, rPC         # arg0
23626     move   a1, rFP         # arg1
23627     move   a2, rSELF       # arg2
23628     JAL(dvmCheckBefore)
23629     jr     rBIX
23630
23631 /* ------------------------------ */
23632     .balign 128
23633 .L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */
23634 /* File: mips/alt_stub.S */
23635 /*
23636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23637  * any interesting requests and then jump to the real instruction
23638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23641  * bail to the real handler if breakFlags==0.
23642  */
23643     lbu    a3, offThread_breakFlags(rSELF)
23644     la     rBIX, dvmAsmInstructionStart + (259 * 128)
23645     lw     rIBASE, offThread_curHandlerTable(rSELF)
23646     bnez   a3, 1f
23647     jr     rBIX            # nothing to do - jump to real handler
23648 1:
23649     EXPORT_PC()
23650     move   a0, rPC         # arg0
23651     move   a1, rFP         # arg1
23652     move   a2, rSELF       # arg2
23653     JAL(dvmCheckBefore)
23654     jr     rBIX
23655
23656 /* ------------------------------ */
23657     .balign 128
23658 .L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */
23659 /* File: mips/alt_stub.S */
23660 /*
23661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23662  * any interesting requests and then jump to the real instruction
23663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23666  * bail to the real handler if breakFlags==0.
23667  */
23668     lbu    a3, offThread_breakFlags(rSELF)
23669     la     rBIX, dvmAsmInstructionStart + (260 * 128)
23670     lw     rIBASE, offThread_curHandlerTable(rSELF)
23671     bnez   a3, 1f
23672     jr     rBIX            # nothing to do - jump to real handler
23673 1:
23674     EXPORT_PC()
23675     move   a0, rPC         # arg0
23676     move   a1, rFP         # arg1
23677     move   a2, rSELF       # arg2
23678     JAL(dvmCheckBefore)
23679     jr     rBIX
23680
23681 /* ------------------------------ */
23682     .balign 128
23683 .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */
23684 /* File: mips/alt_stub.S */
23685 /*
23686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23687  * any interesting requests and then jump to the real instruction
23688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23691  * bail to the real handler if breakFlags==0.
23692  */
23693     lbu    a3, offThread_breakFlags(rSELF)
23694     la     rBIX, dvmAsmInstructionStart + (261 * 128)
23695     lw     rIBASE, offThread_curHandlerTable(rSELF)
23696     bnez   a3, 1f
23697     jr     rBIX            # nothing to do - jump to real handler
23698 1:
23699     EXPORT_PC()
23700     move   a0, rPC         # arg0
23701     move   a1, rFP         # arg1
23702     move   a2, rSELF       # arg2
23703     JAL(dvmCheckBefore)
23704     jr     rBIX
23705
23706 /* ------------------------------ */
23707     .balign 128
23708 .L_ALT_OP_IGET_JUMBO: /* 0x106 */
23709 /* File: mips/alt_stub.S */
23710 /*
23711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23712  * any interesting requests and then jump to the real instruction
23713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23716  * bail to the real handler if breakFlags==0.
23717  */
23718     lbu    a3, offThread_breakFlags(rSELF)
23719     la     rBIX, dvmAsmInstructionStart + (262 * 128)
23720     lw     rIBASE, offThread_curHandlerTable(rSELF)
23721     bnez   a3, 1f
23722     jr     rBIX            # nothing to do - jump to real handler
23723 1:
23724     EXPORT_PC()
23725     move   a0, rPC         # arg0
23726     move   a1, rFP         # arg1
23727     move   a2, rSELF       # arg2
23728     JAL(dvmCheckBefore)
23729     jr     rBIX
23730
23731 /* ------------------------------ */
23732     .balign 128
23733 .L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */
23734 /* File: mips/alt_stub.S */
23735 /*
23736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23737  * any interesting requests and then jump to the real instruction
23738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23741  * bail to the real handler if breakFlags==0.
23742  */
23743     lbu    a3, offThread_breakFlags(rSELF)
23744     la     rBIX, dvmAsmInstructionStart + (263 * 128)
23745     lw     rIBASE, offThread_curHandlerTable(rSELF)
23746     bnez   a3, 1f
23747     jr     rBIX            # nothing to do - jump to real handler
23748 1:
23749     EXPORT_PC()
23750     move   a0, rPC         # arg0
23751     move   a1, rFP         # arg1
23752     move   a2, rSELF       # arg2
23753     JAL(dvmCheckBefore)
23754     jr     rBIX
23755
23756 /* ------------------------------ */
23757     .balign 128
23758 .L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */
23759 /* File: mips/alt_stub.S */
23760 /*
23761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23762  * any interesting requests and then jump to the real instruction
23763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23766  * bail to the real handler if breakFlags==0.
23767  */
23768     lbu    a3, offThread_breakFlags(rSELF)
23769     la     rBIX, dvmAsmInstructionStart + (264 * 128)
23770     lw     rIBASE, offThread_curHandlerTable(rSELF)
23771     bnez   a3, 1f
23772     jr     rBIX            # nothing to do - jump to real handler
23773 1:
23774     EXPORT_PC()
23775     move   a0, rPC         # arg0
23776     move   a1, rFP         # arg1
23777     move   a2, rSELF       # arg2
23778     JAL(dvmCheckBefore)
23779     jr     rBIX
23780
23781 /* ------------------------------ */
23782     .balign 128
23783 .L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */
23784 /* File: mips/alt_stub.S */
23785 /*
23786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23787  * any interesting requests and then jump to the real instruction
23788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23791  * bail to the real handler if breakFlags==0.
23792  */
23793     lbu    a3, offThread_breakFlags(rSELF)
23794     la     rBIX, dvmAsmInstructionStart + (265 * 128)
23795     lw     rIBASE, offThread_curHandlerTable(rSELF)
23796     bnez   a3, 1f
23797     jr     rBIX            # nothing to do - jump to real handler
23798 1:
23799     EXPORT_PC()
23800     move   a0, rPC         # arg0
23801     move   a1, rFP         # arg1
23802     move   a2, rSELF       # arg2
23803     JAL(dvmCheckBefore)
23804     jr     rBIX
23805
23806 /* ------------------------------ */
23807     .balign 128
23808 .L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */
23809 /* File: mips/alt_stub.S */
23810 /*
23811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23812  * any interesting requests and then jump to the real instruction
23813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23816  * bail to the real handler if breakFlags==0.
23817  */
23818     lbu    a3, offThread_breakFlags(rSELF)
23819     la     rBIX, dvmAsmInstructionStart + (266 * 128)
23820     lw     rIBASE, offThread_curHandlerTable(rSELF)
23821     bnez   a3, 1f
23822     jr     rBIX            # nothing to do - jump to real handler
23823 1:
23824     EXPORT_PC()
23825     move   a0, rPC         # arg0
23826     move   a1, rFP         # arg1
23827     move   a2, rSELF       # arg2
23828     JAL(dvmCheckBefore)
23829     jr     rBIX
23830
23831 /* ------------------------------ */
23832     .balign 128
23833 .L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */
23834 /* File: mips/alt_stub.S */
23835 /*
23836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23837  * any interesting requests and then jump to the real instruction
23838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23841  * bail to the real handler if breakFlags==0.
23842  */
23843     lbu    a3, offThread_breakFlags(rSELF)
23844     la     rBIX, dvmAsmInstructionStart + (267 * 128)
23845     lw     rIBASE, offThread_curHandlerTable(rSELF)
23846     bnez   a3, 1f
23847     jr     rBIX            # nothing to do - jump to real handler
23848 1:
23849     EXPORT_PC()
23850     move   a0, rPC         # arg0
23851     move   a1, rFP         # arg1
23852     move   a2, rSELF       # arg2
23853     JAL(dvmCheckBefore)
23854     jr     rBIX
23855
23856 /* ------------------------------ */
23857     .balign 128
23858 .L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */
23859 /* File: mips/alt_stub.S */
23860 /*
23861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23862  * any interesting requests and then jump to the real instruction
23863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23866  * bail to the real handler if breakFlags==0.
23867  */
23868     lbu    a3, offThread_breakFlags(rSELF)
23869     la     rBIX, dvmAsmInstructionStart + (268 * 128)
23870     lw     rIBASE, offThread_curHandlerTable(rSELF)
23871     bnez   a3, 1f
23872     jr     rBIX            # nothing to do - jump to real handler
23873 1:
23874     EXPORT_PC()
23875     move   a0, rPC         # arg0
23876     move   a1, rFP         # arg1
23877     move   a2, rSELF       # arg2
23878     JAL(dvmCheckBefore)
23879     jr     rBIX
23880
23881 /* ------------------------------ */
23882     .balign 128
23883 .L_ALT_OP_IPUT_JUMBO: /* 0x10d */
23884 /* File: mips/alt_stub.S */
23885 /*
23886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23887  * any interesting requests and then jump to the real instruction
23888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23891  * bail to the real handler if breakFlags==0.
23892  */
23893     lbu    a3, offThread_breakFlags(rSELF)
23894     la     rBIX, dvmAsmInstructionStart + (269 * 128)
23895     lw     rIBASE, offThread_curHandlerTable(rSELF)
23896     bnez   a3, 1f
23897     jr     rBIX            # nothing to do - jump to real handler
23898 1:
23899     EXPORT_PC()
23900     move   a0, rPC         # arg0
23901     move   a1, rFP         # arg1
23902     move   a2, rSELF       # arg2
23903     JAL(dvmCheckBefore)
23904     jr     rBIX
23905
23906 /* ------------------------------ */
23907     .balign 128
23908 .L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */
23909 /* File: mips/alt_stub.S */
23910 /*
23911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23912  * any interesting requests and then jump to the real instruction
23913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23916  * bail to the real handler if breakFlags==0.
23917  */
23918     lbu    a3, offThread_breakFlags(rSELF)
23919     la     rBIX, dvmAsmInstructionStart + (270 * 128)
23920     lw     rIBASE, offThread_curHandlerTable(rSELF)
23921     bnez   a3, 1f
23922     jr     rBIX            # nothing to do - jump to real handler
23923 1:
23924     EXPORT_PC()
23925     move   a0, rPC         # arg0
23926     move   a1, rFP         # arg1
23927     move   a2, rSELF       # arg2
23928     JAL(dvmCheckBefore)
23929     jr     rBIX
23930
23931 /* ------------------------------ */
23932     .balign 128
23933 .L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */
23934 /* File: mips/alt_stub.S */
23935 /*
23936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23937  * any interesting requests and then jump to the real instruction
23938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23941  * bail to the real handler if breakFlags==0.
23942  */
23943     lbu    a3, offThread_breakFlags(rSELF)
23944     la     rBIX, dvmAsmInstructionStart + (271 * 128)
23945     lw     rIBASE, offThread_curHandlerTable(rSELF)
23946     bnez   a3, 1f
23947     jr     rBIX            # nothing to do - jump to real handler
23948 1:
23949     EXPORT_PC()
23950     move   a0, rPC         # arg0
23951     move   a1, rFP         # arg1
23952     move   a2, rSELF       # arg2
23953     JAL(dvmCheckBefore)
23954     jr     rBIX
23955
23956 /* ------------------------------ */
23957     .balign 128
23958 .L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */
23959 /* File: mips/alt_stub.S */
23960 /*
23961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23962  * any interesting requests and then jump to the real instruction
23963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23966  * bail to the real handler if breakFlags==0.
23967  */
23968     lbu    a3, offThread_breakFlags(rSELF)
23969     la     rBIX, dvmAsmInstructionStart + (272 * 128)
23970     lw     rIBASE, offThread_curHandlerTable(rSELF)
23971     bnez   a3, 1f
23972     jr     rBIX            # nothing to do - jump to real handler
23973 1:
23974     EXPORT_PC()
23975     move   a0, rPC         # arg0
23976     move   a1, rFP         # arg1
23977     move   a2, rSELF       # arg2
23978     JAL(dvmCheckBefore)
23979     jr     rBIX
23980
23981 /* ------------------------------ */
23982     .balign 128
23983 .L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */
23984 /* File: mips/alt_stub.S */
23985 /*
23986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
23987  * any interesting requests and then jump to the real instruction
23988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
23989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
23990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
23991  * bail to the real handler if breakFlags==0.
23992  */
23993     lbu    a3, offThread_breakFlags(rSELF)
23994     la     rBIX, dvmAsmInstructionStart + (273 * 128)
23995     lw     rIBASE, offThread_curHandlerTable(rSELF)
23996     bnez   a3, 1f
23997     jr     rBIX            # nothing to do - jump to real handler
23998 1:
23999     EXPORT_PC()
24000     move   a0, rPC         # arg0
24001     move   a1, rFP         # arg1
24002     move   a2, rSELF       # arg2
24003     JAL(dvmCheckBefore)
24004     jr     rBIX
24005
24006 /* ------------------------------ */
24007     .balign 128
24008 .L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */
24009 /* File: mips/alt_stub.S */
24010 /*
24011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24012  * any interesting requests and then jump to the real instruction
24013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24016  * bail to the real handler if breakFlags==0.
24017  */
24018     lbu    a3, offThread_breakFlags(rSELF)
24019     la     rBIX, dvmAsmInstructionStart + (274 * 128)
24020     lw     rIBASE, offThread_curHandlerTable(rSELF)
24021     bnez   a3, 1f
24022     jr     rBIX            # nothing to do - jump to real handler
24023 1:
24024     EXPORT_PC()
24025     move   a0, rPC         # arg0
24026     move   a1, rFP         # arg1
24027     move   a2, rSELF       # arg2
24028     JAL(dvmCheckBefore)
24029     jr     rBIX
24030
24031 /* ------------------------------ */
24032     .balign 128
24033 .L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */
24034 /* File: mips/alt_stub.S */
24035 /*
24036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24037  * any interesting requests and then jump to the real instruction
24038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24041  * bail to the real handler if breakFlags==0.
24042  */
24043     lbu    a3, offThread_breakFlags(rSELF)
24044     la     rBIX, dvmAsmInstructionStart + (275 * 128)
24045     lw     rIBASE, offThread_curHandlerTable(rSELF)
24046     bnez   a3, 1f
24047     jr     rBIX            # nothing to do - jump to real handler
24048 1:
24049     EXPORT_PC()
24050     move   a0, rPC         # arg0
24051     move   a1, rFP         # arg1
24052     move   a2, rSELF       # arg2
24053     JAL(dvmCheckBefore)
24054     jr     rBIX
24055
24056 /* ------------------------------ */
24057     .balign 128
24058 .L_ALT_OP_SGET_JUMBO: /* 0x114 */
24059 /* File: mips/alt_stub.S */
24060 /*
24061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24062  * any interesting requests and then jump to the real instruction
24063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24066  * bail to the real handler if breakFlags==0.
24067  */
24068     lbu    a3, offThread_breakFlags(rSELF)
24069     la     rBIX, dvmAsmInstructionStart + (276 * 128)
24070     lw     rIBASE, offThread_curHandlerTable(rSELF)
24071     bnez   a3, 1f
24072     jr     rBIX            # nothing to do - jump to real handler
24073 1:
24074     EXPORT_PC()
24075     move   a0, rPC         # arg0
24076     move   a1, rFP         # arg1
24077     move   a2, rSELF       # arg2
24078     JAL(dvmCheckBefore)
24079     jr     rBIX
24080
24081 /* ------------------------------ */
24082     .balign 128
24083 .L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */
24084 /* File: mips/alt_stub.S */
24085 /*
24086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24087  * any interesting requests and then jump to the real instruction
24088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24091  * bail to the real handler if breakFlags==0.
24092  */
24093     lbu    a3, offThread_breakFlags(rSELF)
24094     la     rBIX, dvmAsmInstructionStart + (277 * 128)
24095     lw     rIBASE, offThread_curHandlerTable(rSELF)
24096     bnez   a3, 1f
24097     jr     rBIX            # nothing to do - jump to real handler
24098 1:
24099     EXPORT_PC()
24100     move   a0, rPC         # arg0
24101     move   a1, rFP         # arg1
24102     move   a2, rSELF       # arg2
24103     JAL(dvmCheckBefore)
24104     jr     rBIX
24105
24106 /* ------------------------------ */
24107     .balign 128
24108 .L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */
24109 /* File: mips/alt_stub.S */
24110 /*
24111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24112  * any interesting requests and then jump to the real instruction
24113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24116  * bail to the real handler if breakFlags==0.
24117  */
24118     lbu    a3, offThread_breakFlags(rSELF)
24119     la     rBIX, dvmAsmInstructionStart + (278 * 128)
24120     lw     rIBASE, offThread_curHandlerTable(rSELF)
24121     bnez   a3, 1f
24122     jr     rBIX            # nothing to do - jump to real handler
24123 1:
24124     EXPORT_PC()
24125     move   a0, rPC         # arg0
24126     move   a1, rFP         # arg1
24127     move   a2, rSELF       # arg2
24128     JAL(dvmCheckBefore)
24129     jr     rBIX
24130
24131 /* ------------------------------ */
24132     .balign 128
24133 .L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */
24134 /* File: mips/alt_stub.S */
24135 /*
24136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24137  * any interesting requests and then jump to the real instruction
24138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24141  * bail to the real handler if breakFlags==0.
24142  */
24143     lbu    a3, offThread_breakFlags(rSELF)
24144     la     rBIX, dvmAsmInstructionStart + (279 * 128)
24145     lw     rIBASE, offThread_curHandlerTable(rSELF)
24146     bnez   a3, 1f
24147     jr     rBIX            # nothing to do - jump to real handler
24148 1:
24149     EXPORT_PC()
24150     move   a0, rPC         # arg0
24151     move   a1, rFP         # arg1
24152     move   a2, rSELF       # arg2
24153     JAL(dvmCheckBefore)
24154     jr     rBIX
24155
24156 /* ------------------------------ */
24157     .balign 128
24158 .L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */
24159 /* File: mips/alt_stub.S */
24160 /*
24161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24162  * any interesting requests and then jump to the real instruction
24163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24166  * bail to the real handler if breakFlags==0.
24167  */
24168     lbu    a3, offThread_breakFlags(rSELF)
24169     la     rBIX, dvmAsmInstructionStart + (280 * 128)
24170     lw     rIBASE, offThread_curHandlerTable(rSELF)
24171     bnez   a3, 1f
24172     jr     rBIX            # nothing to do - jump to real handler
24173 1:
24174     EXPORT_PC()
24175     move   a0, rPC         # arg0
24176     move   a1, rFP         # arg1
24177     move   a2, rSELF       # arg2
24178     JAL(dvmCheckBefore)
24179     jr     rBIX
24180
24181 /* ------------------------------ */
24182     .balign 128
24183 .L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */
24184 /* File: mips/alt_stub.S */
24185 /*
24186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24187  * any interesting requests and then jump to the real instruction
24188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24191  * bail to the real handler if breakFlags==0.
24192  */
24193     lbu    a3, offThread_breakFlags(rSELF)
24194     la     rBIX, dvmAsmInstructionStart + (281 * 128)
24195     lw     rIBASE, offThread_curHandlerTable(rSELF)
24196     bnez   a3, 1f
24197     jr     rBIX            # nothing to do - jump to real handler
24198 1:
24199     EXPORT_PC()
24200     move   a0, rPC         # arg0
24201     move   a1, rFP         # arg1
24202     move   a2, rSELF       # arg2
24203     JAL(dvmCheckBefore)
24204     jr     rBIX
24205
24206 /* ------------------------------ */
24207     .balign 128
24208 .L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */
24209 /* File: mips/alt_stub.S */
24210 /*
24211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24212  * any interesting requests and then jump to the real instruction
24213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24216  * bail to the real handler if breakFlags==0.
24217  */
24218     lbu    a3, offThread_breakFlags(rSELF)
24219     la     rBIX, dvmAsmInstructionStart + (282 * 128)
24220     lw     rIBASE, offThread_curHandlerTable(rSELF)
24221     bnez   a3, 1f
24222     jr     rBIX            # nothing to do - jump to real handler
24223 1:
24224     EXPORT_PC()
24225     move   a0, rPC         # arg0
24226     move   a1, rFP         # arg1
24227     move   a2, rSELF       # arg2
24228     JAL(dvmCheckBefore)
24229     jr     rBIX
24230
24231 /* ------------------------------ */
24232     .balign 128
24233 .L_ALT_OP_SPUT_JUMBO: /* 0x11b */
24234 /* File: mips/alt_stub.S */
24235 /*
24236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24237  * any interesting requests and then jump to the real instruction
24238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24241  * bail to the real handler if breakFlags==0.
24242  */
24243     lbu    a3, offThread_breakFlags(rSELF)
24244     la     rBIX, dvmAsmInstructionStart + (283 * 128)
24245     lw     rIBASE, offThread_curHandlerTable(rSELF)
24246     bnez   a3, 1f
24247     jr     rBIX            # nothing to do - jump to real handler
24248 1:
24249     EXPORT_PC()
24250     move   a0, rPC         # arg0
24251     move   a1, rFP         # arg1
24252     move   a2, rSELF       # arg2
24253     JAL(dvmCheckBefore)
24254     jr     rBIX
24255
24256 /* ------------------------------ */
24257     .balign 128
24258 .L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */
24259 /* File: mips/alt_stub.S */
24260 /*
24261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24262  * any interesting requests and then jump to the real instruction
24263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24266  * bail to the real handler if breakFlags==0.
24267  */
24268     lbu    a3, offThread_breakFlags(rSELF)
24269     la     rBIX, dvmAsmInstructionStart + (284 * 128)
24270     lw     rIBASE, offThread_curHandlerTable(rSELF)
24271     bnez   a3, 1f
24272     jr     rBIX            # nothing to do - jump to real handler
24273 1:
24274     EXPORT_PC()
24275     move   a0, rPC         # arg0
24276     move   a1, rFP         # arg1
24277     move   a2, rSELF       # arg2
24278     JAL(dvmCheckBefore)
24279     jr     rBIX
24280
24281 /* ------------------------------ */
24282     .balign 128
24283 .L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */
24284 /* File: mips/alt_stub.S */
24285 /*
24286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24287  * any interesting requests and then jump to the real instruction
24288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24291  * bail to the real handler if breakFlags==0.
24292  */
24293     lbu    a3, offThread_breakFlags(rSELF)
24294     la     rBIX, dvmAsmInstructionStart + (285 * 128)
24295     lw     rIBASE, offThread_curHandlerTable(rSELF)
24296     bnez   a3, 1f
24297     jr     rBIX            # nothing to do - jump to real handler
24298 1:
24299     EXPORT_PC()
24300     move   a0, rPC         # arg0
24301     move   a1, rFP         # arg1
24302     move   a2, rSELF       # arg2
24303     JAL(dvmCheckBefore)
24304     jr     rBIX
24305
24306 /* ------------------------------ */
24307     .balign 128
24308 .L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */
24309 /* File: mips/alt_stub.S */
24310 /*
24311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24312  * any interesting requests and then jump to the real instruction
24313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24316  * bail to the real handler if breakFlags==0.
24317  */
24318     lbu    a3, offThread_breakFlags(rSELF)
24319     la     rBIX, dvmAsmInstructionStart + (286 * 128)
24320     lw     rIBASE, offThread_curHandlerTable(rSELF)
24321     bnez   a3, 1f
24322     jr     rBIX            # nothing to do - jump to real handler
24323 1:
24324     EXPORT_PC()
24325     move   a0, rPC         # arg0
24326     move   a1, rFP         # arg1
24327     move   a2, rSELF       # arg2
24328     JAL(dvmCheckBefore)
24329     jr     rBIX
24330
24331 /* ------------------------------ */
24332     .balign 128
24333 .L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */
24334 /* File: mips/alt_stub.S */
24335 /*
24336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24337  * any interesting requests and then jump to the real instruction
24338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24341  * bail to the real handler if breakFlags==0.
24342  */
24343     lbu    a3, offThread_breakFlags(rSELF)
24344     la     rBIX, dvmAsmInstructionStart + (287 * 128)
24345     lw     rIBASE, offThread_curHandlerTable(rSELF)
24346     bnez   a3, 1f
24347     jr     rBIX            # nothing to do - jump to real handler
24348 1:
24349     EXPORT_PC()
24350     move   a0, rPC         # arg0
24351     move   a1, rFP         # arg1
24352     move   a2, rSELF       # arg2
24353     JAL(dvmCheckBefore)
24354     jr     rBIX
24355
24356 /* ------------------------------ */
24357     .balign 128
24358 .L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */
24359 /* File: mips/alt_stub.S */
24360 /*
24361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24362  * any interesting requests and then jump to the real instruction
24363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24366  * bail to the real handler if breakFlags==0.
24367  */
24368     lbu    a3, offThread_breakFlags(rSELF)
24369     la     rBIX, dvmAsmInstructionStart + (288 * 128)
24370     lw     rIBASE, offThread_curHandlerTable(rSELF)
24371     bnez   a3, 1f
24372     jr     rBIX            # nothing to do - jump to real handler
24373 1:
24374     EXPORT_PC()
24375     move   a0, rPC         # arg0
24376     move   a1, rFP         # arg1
24377     move   a2, rSELF       # arg2
24378     JAL(dvmCheckBefore)
24379     jr     rBIX
24380
24381 /* ------------------------------ */
24382     .balign 128
24383 .L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */
24384 /* File: mips/alt_stub.S */
24385 /*
24386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24387  * any interesting requests and then jump to the real instruction
24388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24391  * bail to the real handler if breakFlags==0.
24392  */
24393     lbu    a3, offThread_breakFlags(rSELF)
24394     la     rBIX, dvmAsmInstructionStart + (289 * 128)
24395     lw     rIBASE, offThread_curHandlerTable(rSELF)
24396     bnez   a3, 1f
24397     jr     rBIX            # nothing to do - jump to real handler
24398 1:
24399     EXPORT_PC()
24400     move   a0, rPC         # arg0
24401     move   a1, rFP         # arg1
24402     move   a2, rSELF       # arg2
24403     JAL(dvmCheckBefore)
24404     jr     rBIX
24405
24406 /* ------------------------------ */
24407     .balign 128
24408 .L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */
24409 /* File: mips/alt_stub.S */
24410 /*
24411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24412  * any interesting requests and then jump to the real instruction
24413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24416  * bail to the real handler if breakFlags==0.
24417  */
24418     lbu    a3, offThread_breakFlags(rSELF)
24419     la     rBIX, dvmAsmInstructionStart + (290 * 128)
24420     lw     rIBASE, offThread_curHandlerTable(rSELF)
24421     bnez   a3, 1f
24422     jr     rBIX            # nothing to do - jump to real handler
24423 1:
24424     EXPORT_PC()
24425     move   a0, rPC         # arg0
24426     move   a1, rFP         # arg1
24427     move   a2, rSELF       # arg2
24428     JAL(dvmCheckBefore)
24429     jr     rBIX
24430
24431 /* ------------------------------ */
24432     .balign 128
24433 .L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */
24434 /* File: mips/alt_stub.S */
24435 /*
24436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24437  * any interesting requests and then jump to the real instruction
24438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24441  * bail to the real handler if breakFlags==0.
24442  */
24443     lbu    a3, offThread_breakFlags(rSELF)
24444     la     rBIX, dvmAsmInstructionStart + (291 * 128)
24445     lw     rIBASE, offThread_curHandlerTable(rSELF)
24446     bnez   a3, 1f
24447     jr     rBIX            # nothing to do - jump to real handler
24448 1:
24449     EXPORT_PC()
24450     move   a0, rPC         # arg0
24451     move   a1, rFP         # arg1
24452     move   a2, rSELF       # arg2
24453     JAL(dvmCheckBefore)
24454     jr     rBIX
24455
24456 /* ------------------------------ */
24457     .balign 128
24458 .L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */
24459 /* File: mips/alt_stub.S */
24460 /*
24461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24462  * any interesting requests and then jump to the real instruction
24463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24466  * bail to the real handler if breakFlags==0.
24467  */
24468     lbu    a3, offThread_breakFlags(rSELF)
24469     la     rBIX, dvmAsmInstructionStart + (292 * 128)
24470     lw     rIBASE, offThread_curHandlerTable(rSELF)
24471     bnez   a3, 1f
24472     jr     rBIX            # nothing to do - jump to real handler
24473 1:
24474     EXPORT_PC()
24475     move   a0, rPC         # arg0
24476     move   a1, rFP         # arg1
24477     move   a2, rSELF       # arg2
24478     JAL(dvmCheckBefore)
24479     jr     rBIX
24480
24481 /* ------------------------------ */
24482     .balign 128
24483 .L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */
24484 /* File: mips/alt_stub.S */
24485 /*
24486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24487  * any interesting requests and then jump to the real instruction
24488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24491  * bail to the real handler if breakFlags==0.
24492  */
24493     lbu    a3, offThread_breakFlags(rSELF)
24494     la     rBIX, dvmAsmInstructionStart + (293 * 128)
24495     lw     rIBASE, offThread_curHandlerTable(rSELF)
24496     bnez   a3, 1f
24497     jr     rBIX            # nothing to do - jump to real handler
24498 1:
24499     EXPORT_PC()
24500     move   a0, rPC         # arg0
24501     move   a1, rFP         # arg1
24502     move   a2, rSELF       # arg2
24503     JAL(dvmCheckBefore)
24504     jr     rBIX
24505
24506 /* ------------------------------ */
24507     .balign 128
24508 .L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */
24509 /* File: mips/alt_stub.S */
24510 /*
24511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24512  * any interesting requests and then jump to the real instruction
24513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24516  * bail to the real handler if breakFlags==0.
24517  */
24518     lbu    a3, offThread_breakFlags(rSELF)
24519     la     rBIX, dvmAsmInstructionStart + (294 * 128)
24520     lw     rIBASE, offThread_curHandlerTable(rSELF)
24521     bnez   a3, 1f
24522     jr     rBIX            # nothing to do - jump to real handler
24523 1:
24524     EXPORT_PC()
24525     move   a0, rPC         # arg0
24526     move   a1, rFP         # arg1
24527     move   a2, rSELF       # arg2
24528     JAL(dvmCheckBefore)
24529     jr     rBIX
24530
24531 /* ------------------------------ */
24532     .balign 128
24533 .L_ALT_OP_UNUSED_27FF: /* 0x127 */
24534 /* File: mips/alt_stub.S */
24535 /*
24536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24537  * any interesting requests and then jump to the real instruction
24538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24541  * bail to the real handler if breakFlags==0.
24542  */
24543     lbu    a3, offThread_breakFlags(rSELF)
24544     la     rBIX, dvmAsmInstructionStart + (295 * 128)
24545     lw     rIBASE, offThread_curHandlerTable(rSELF)
24546     bnez   a3, 1f
24547     jr     rBIX            # nothing to do - jump to real handler
24548 1:
24549     EXPORT_PC()
24550     move   a0, rPC         # arg0
24551     move   a1, rFP         # arg1
24552     move   a2, rSELF       # arg2
24553     JAL(dvmCheckBefore)
24554     jr     rBIX
24555
24556 /* ------------------------------ */
24557     .balign 128
24558 .L_ALT_OP_UNUSED_28FF: /* 0x128 */
24559 /* File: mips/alt_stub.S */
24560 /*
24561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24562  * any interesting requests and then jump to the real instruction
24563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24566  * bail to the real handler if breakFlags==0.
24567  */
24568     lbu    a3, offThread_breakFlags(rSELF)
24569     la     rBIX, dvmAsmInstructionStart + (296 * 128)
24570     lw     rIBASE, offThread_curHandlerTable(rSELF)
24571     bnez   a3, 1f
24572     jr     rBIX            # nothing to do - jump to real handler
24573 1:
24574     EXPORT_PC()
24575     move   a0, rPC         # arg0
24576     move   a1, rFP         # arg1
24577     move   a2, rSELF       # arg2
24578     JAL(dvmCheckBefore)
24579     jr     rBIX
24580
24581 /* ------------------------------ */
24582     .balign 128
24583 .L_ALT_OP_UNUSED_29FF: /* 0x129 */
24584 /* File: mips/alt_stub.S */
24585 /*
24586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24587  * any interesting requests and then jump to the real instruction
24588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24591  * bail to the real handler if breakFlags==0.
24592  */
24593     lbu    a3, offThread_breakFlags(rSELF)
24594     la     rBIX, dvmAsmInstructionStart + (297 * 128)
24595     lw     rIBASE, offThread_curHandlerTable(rSELF)
24596     bnez   a3, 1f
24597     jr     rBIX            # nothing to do - jump to real handler
24598 1:
24599     EXPORT_PC()
24600     move   a0, rPC         # arg0
24601     move   a1, rFP         # arg1
24602     move   a2, rSELF       # arg2
24603     JAL(dvmCheckBefore)
24604     jr     rBIX
24605
24606 /* ------------------------------ */
24607     .balign 128
24608 .L_ALT_OP_UNUSED_2AFF: /* 0x12a */
24609 /* File: mips/alt_stub.S */
24610 /*
24611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24612  * any interesting requests and then jump to the real instruction
24613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24616  * bail to the real handler if breakFlags==0.
24617  */
24618     lbu    a3, offThread_breakFlags(rSELF)
24619     la     rBIX, dvmAsmInstructionStart + (298 * 128)
24620     lw     rIBASE, offThread_curHandlerTable(rSELF)
24621     bnez   a3, 1f
24622     jr     rBIX            # nothing to do - jump to real handler
24623 1:
24624     EXPORT_PC()
24625     move   a0, rPC         # arg0
24626     move   a1, rFP         # arg1
24627     move   a2, rSELF       # arg2
24628     JAL(dvmCheckBefore)
24629     jr     rBIX
24630
24631 /* ------------------------------ */
24632     .balign 128
24633 .L_ALT_OP_UNUSED_2BFF: /* 0x12b */
24634 /* File: mips/alt_stub.S */
24635 /*
24636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24637  * any interesting requests and then jump to the real instruction
24638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24641  * bail to the real handler if breakFlags==0.
24642  */
24643     lbu    a3, offThread_breakFlags(rSELF)
24644     la     rBIX, dvmAsmInstructionStart + (299 * 128)
24645     lw     rIBASE, offThread_curHandlerTable(rSELF)
24646     bnez   a3, 1f
24647     jr     rBIX            # nothing to do - jump to real handler
24648 1:
24649     EXPORT_PC()
24650     move   a0, rPC         # arg0
24651     move   a1, rFP         # arg1
24652     move   a2, rSELF       # arg2
24653     JAL(dvmCheckBefore)
24654     jr     rBIX
24655
24656 /* ------------------------------ */
24657     .balign 128
24658 .L_ALT_OP_UNUSED_2CFF: /* 0x12c */
24659 /* File: mips/alt_stub.S */
24660 /*
24661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24662  * any interesting requests and then jump to the real instruction
24663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24666  * bail to the real handler if breakFlags==0.
24667  */
24668     lbu    a3, offThread_breakFlags(rSELF)
24669     la     rBIX, dvmAsmInstructionStart + (300 * 128)
24670     lw     rIBASE, offThread_curHandlerTable(rSELF)
24671     bnez   a3, 1f
24672     jr     rBIX            # nothing to do - jump to real handler
24673 1:
24674     EXPORT_PC()
24675     move   a0, rPC         # arg0
24676     move   a1, rFP         # arg1
24677     move   a2, rSELF       # arg2
24678     JAL(dvmCheckBefore)
24679     jr     rBIX
24680
24681 /* ------------------------------ */
24682     .balign 128
24683 .L_ALT_OP_UNUSED_2DFF: /* 0x12d */
24684 /* File: mips/alt_stub.S */
24685 /*
24686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24687  * any interesting requests and then jump to the real instruction
24688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24691  * bail to the real handler if breakFlags==0.
24692  */
24693     lbu    a3, offThread_breakFlags(rSELF)
24694     la     rBIX, dvmAsmInstructionStart + (301 * 128)
24695     lw     rIBASE, offThread_curHandlerTable(rSELF)
24696     bnez   a3, 1f
24697     jr     rBIX            # nothing to do - jump to real handler
24698 1:
24699     EXPORT_PC()
24700     move   a0, rPC         # arg0
24701     move   a1, rFP         # arg1
24702     move   a2, rSELF       # arg2
24703     JAL(dvmCheckBefore)
24704     jr     rBIX
24705
24706 /* ------------------------------ */
24707     .balign 128
24708 .L_ALT_OP_UNUSED_2EFF: /* 0x12e */
24709 /* File: mips/alt_stub.S */
24710 /*
24711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24712  * any interesting requests and then jump to the real instruction
24713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24716  * bail to the real handler if breakFlags==0.
24717  */
24718     lbu    a3, offThread_breakFlags(rSELF)
24719     la     rBIX, dvmAsmInstructionStart + (302 * 128)
24720     lw     rIBASE, offThread_curHandlerTable(rSELF)
24721     bnez   a3, 1f
24722     jr     rBIX            # nothing to do - jump to real handler
24723 1:
24724     EXPORT_PC()
24725     move   a0, rPC         # arg0
24726     move   a1, rFP         # arg1
24727     move   a2, rSELF       # arg2
24728     JAL(dvmCheckBefore)
24729     jr     rBIX
24730
24731 /* ------------------------------ */
24732     .balign 128
24733 .L_ALT_OP_UNUSED_2FFF: /* 0x12f */
24734 /* File: mips/alt_stub.S */
24735 /*
24736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24737  * any interesting requests and then jump to the real instruction
24738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24741  * bail to the real handler if breakFlags==0.
24742  */
24743     lbu    a3, offThread_breakFlags(rSELF)
24744     la     rBIX, dvmAsmInstructionStart + (303 * 128)
24745     lw     rIBASE, offThread_curHandlerTable(rSELF)
24746     bnez   a3, 1f
24747     jr     rBIX            # nothing to do - jump to real handler
24748 1:
24749     EXPORT_PC()
24750     move   a0, rPC         # arg0
24751     move   a1, rFP         # arg1
24752     move   a2, rSELF       # arg2
24753     JAL(dvmCheckBefore)
24754     jr     rBIX
24755
24756 /* ------------------------------ */
24757     .balign 128
24758 .L_ALT_OP_UNUSED_30FF: /* 0x130 */
24759 /* File: mips/alt_stub.S */
24760 /*
24761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24762  * any interesting requests and then jump to the real instruction
24763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24766  * bail to the real handler if breakFlags==0.
24767  */
24768     lbu    a3, offThread_breakFlags(rSELF)
24769     la     rBIX, dvmAsmInstructionStart + (304 * 128)
24770     lw     rIBASE, offThread_curHandlerTable(rSELF)
24771     bnez   a3, 1f
24772     jr     rBIX            # nothing to do - jump to real handler
24773 1:
24774     EXPORT_PC()
24775     move   a0, rPC         # arg0
24776     move   a1, rFP         # arg1
24777     move   a2, rSELF       # arg2
24778     JAL(dvmCheckBefore)
24779     jr     rBIX
24780
24781 /* ------------------------------ */
24782     .balign 128
24783 .L_ALT_OP_UNUSED_31FF: /* 0x131 */
24784 /* File: mips/alt_stub.S */
24785 /*
24786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24787  * any interesting requests and then jump to the real instruction
24788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24791  * bail to the real handler if breakFlags==0.
24792  */
24793     lbu    a3, offThread_breakFlags(rSELF)
24794     la     rBIX, dvmAsmInstructionStart + (305 * 128)
24795     lw     rIBASE, offThread_curHandlerTable(rSELF)
24796     bnez   a3, 1f
24797     jr     rBIX            # nothing to do - jump to real handler
24798 1:
24799     EXPORT_PC()
24800     move   a0, rPC         # arg0
24801     move   a1, rFP         # arg1
24802     move   a2, rSELF       # arg2
24803     JAL(dvmCheckBefore)
24804     jr     rBIX
24805
24806 /* ------------------------------ */
24807     .balign 128
24808 .L_ALT_OP_UNUSED_32FF: /* 0x132 */
24809 /* File: mips/alt_stub.S */
24810 /*
24811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24812  * any interesting requests and then jump to the real instruction
24813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24816  * bail to the real handler if breakFlags==0.
24817  */
24818     lbu    a3, offThread_breakFlags(rSELF)
24819     la     rBIX, dvmAsmInstructionStart + (306 * 128)
24820     lw     rIBASE, offThread_curHandlerTable(rSELF)
24821     bnez   a3, 1f
24822     jr     rBIX            # nothing to do - jump to real handler
24823 1:
24824     EXPORT_PC()
24825     move   a0, rPC         # arg0
24826     move   a1, rFP         # arg1
24827     move   a2, rSELF       # arg2
24828     JAL(dvmCheckBefore)
24829     jr     rBIX
24830
24831 /* ------------------------------ */
24832     .balign 128
24833 .L_ALT_OP_UNUSED_33FF: /* 0x133 */
24834 /* File: mips/alt_stub.S */
24835 /*
24836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24837  * any interesting requests and then jump to the real instruction
24838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24841  * bail to the real handler if breakFlags==0.
24842  */
24843     lbu    a3, offThread_breakFlags(rSELF)
24844     la     rBIX, dvmAsmInstructionStart + (307 * 128)
24845     lw     rIBASE, offThread_curHandlerTable(rSELF)
24846     bnez   a3, 1f
24847     jr     rBIX            # nothing to do - jump to real handler
24848 1:
24849     EXPORT_PC()
24850     move   a0, rPC         # arg0
24851     move   a1, rFP         # arg1
24852     move   a2, rSELF       # arg2
24853     JAL(dvmCheckBefore)
24854     jr     rBIX
24855
24856 /* ------------------------------ */
24857     .balign 128
24858 .L_ALT_OP_UNUSED_34FF: /* 0x134 */
24859 /* File: mips/alt_stub.S */
24860 /*
24861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24862  * any interesting requests and then jump to the real instruction
24863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24866  * bail to the real handler if breakFlags==0.
24867  */
24868     lbu    a3, offThread_breakFlags(rSELF)
24869     la     rBIX, dvmAsmInstructionStart + (308 * 128)
24870     lw     rIBASE, offThread_curHandlerTable(rSELF)
24871     bnez   a3, 1f
24872     jr     rBIX            # nothing to do - jump to real handler
24873 1:
24874     EXPORT_PC()
24875     move   a0, rPC         # arg0
24876     move   a1, rFP         # arg1
24877     move   a2, rSELF       # arg2
24878     JAL(dvmCheckBefore)
24879     jr     rBIX
24880
24881 /* ------------------------------ */
24882     .balign 128
24883 .L_ALT_OP_UNUSED_35FF: /* 0x135 */
24884 /* File: mips/alt_stub.S */
24885 /*
24886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24887  * any interesting requests and then jump to the real instruction
24888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24891  * bail to the real handler if breakFlags==0.
24892  */
24893     lbu    a3, offThread_breakFlags(rSELF)
24894     la     rBIX, dvmAsmInstructionStart + (309 * 128)
24895     lw     rIBASE, offThread_curHandlerTable(rSELF)
24896     bnez   a3, 1f
24897     jr     rBIX            # nothing to do - jump to real handler
24898 1:
24899     EXPORT_PC()
24900     move   a0, rPC         # arg0
24901     move   a1, rFP         # arg1
24902     move   a2, rSELF       # arg2
24903     JAL(dvmCheckBefore)
24904     jr     rBIX
24905
24906 /* ------------------------------ */
24907     .balign 128
24908 .L_ALT_OP_UNUSED_36FF: /* 0x136 */
24909 /* File: mips/alt_stub.S */
24910 /*
24911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24912  * any interesting requests and then jump to the real instruction
24913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24916  * bail to the real handler if breakFlags==0.
24917  */
24918     lbu    a3, offThread_breakFlags(rSELF)
24919     la     rBIX, dvmAsmInstructionStart + (310 * 128)
24920     lw     rIBASE, offThread_curHandlerTable(rSELF)
24921     bnez   a3, 1f
24922     jr     rBIX            # nothing to do - jump to real handler
24923 1:
24924     EXPORT_PC()
24925     move   a0, rPC         # arg0
24926     move   a1, rFP         # arg1
24927     move   a2, rSELF       # arg2
24928     JAL(dvmCheckBefore)
24929     jr     rBIX
24930
24931 /* ------------------------------ */
24932     .balign 128
24933 .L_ALT_OP_UNUSED_37FF: /* 0x137 */
24934 /* File: mips/alt_stub.S */
24935 /*
24936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24937  * any interesting requests and then jump to the real instruction
24938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24941  * bail to the real handler if breakFlags==0.
24942  */
24943     lbu    a3, offThread_breakFlags(rSELF)
24944     la     rBIX, dvmAsmInstructionStart + (311 * 128)
24945     lw     rIBASE, offThread_curHandlerTable(rSELF)
24946     bnez   a3, 1f
24947     jr     rBIX            # nothing to do - jump to real handler
24948 1:
24949     EXPORT_PC()
24950     move   a0, rPC         # arg0
24951     move   a1, rFP         # arg1
24952     move   a2, rSELF       # arg2
24953     JAL(dvmCheckBefore)
24954     jr     rBIX
24955
24956 /* ------------------------------ */
24957     .balign 128
24958 .L_ALT_OP_UNUSED_38FF: /* 0x138 */
24959 /* File: mips/alt_stub.S */
24960 /*
24961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24962  * any interesting requests and then jump to the real instruction
24963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24966  * bail to the real handler if breakFlags==0.
24967  */
24968     lbu    a3, offThread_breakFlags(rSELF)
24969     la     rBIX, dvmAsmInstructionStart + (312 * 128)
24970     lw     rIBASE, offThread_curHandlerTable(rSELF)
24971     bnez   a3, 1f
24972     jr     rBIX            # nothing to do - jump to real handler
24973 1:
24974     EXPORT_PC()
24975     move   a0, rPC         # arg0
24976     move   a1, rFP         # arg1
24977     move   a2, rSELF       # arg2
24978     JAL(dvmCheckBefore)
24979     jr     rBIX
24980
24981 /* ------------------------------ */
24982     .balign 128
24983 .L_ALT_OP_UNUSED_39FF: /* 0x139 */
24984 /* File: mips/alt_stub.S */
24985 /*
24986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
24987  * any interesting requests and then jump to the real instruction
24988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
24989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
24990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
24991  * bail to the real handler if breakFlags==0.
24992  */
24993     lbu    a3, offThread_breakFlags(rSELF)
24994     la     rBIX, dvmAsmInstructionStart + (313 * 128)
24995     lw     rIBASE, offThread_curHandlerTable(rSELF)
24996     bnez   a3, 1f
24997     jr     rBIX            # nothing to do - jump to real handler
24998 1:
24999     EXPORT_PC()
25000     move   a0, rPC         # arg0
25001     move   a1, rFP         # arg1
25002     move   a2, rSELF       # arg2
25003     JAL(dvmCheckBefore)
25004     jr     rBIX
25005
25006 /* ------------------------------ */
25007     .balign 128
25008 .L_ALT_OP_UNUSED_3AFF: /* 0x13a */
25009 /* File: mips/alt_stub.S */
25010 /*
25011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25012  * any interesting requests and then jump to the real instruction
25013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25016  * bail to the real handler if breakFlags==0.
25017  */
25018     lbu    a3, offThread_breakFlags(rSELF)
25019     la     rBIX, dvmAsmInstructionStart + (314 * 128)
25020     lw     rIBASE, offThread_curHandlerTable(rSELF)
25021     bnez   a3, 1f
25022     jr     rBIX            # nothing to do - jump to real handler
25023 1:
25024     EXPORT_PC()
25025     move   a0, rPC         # arg0
25026     move   a1, rFP         # arg1
25027     move   a2, rSELF       # arg2
25028     JAL(dvmCheckBefore)
25029     jr     rBIX
25030
25031 /* ------------------------------ */
25032     .balign 128
25033 .L_ALT_OP_UNUSED_3BFF: /* 0x13b */
25034 /* File: mips/alt_stub.S */
25035 /*
25036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25037  * any interesting requests and then jump to the real instruction
25038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25041  * bail to the real handler if breakFlags==0.
25042  */
25043     lbu    a3, offThread_breakFlags(rSELF)
25044     la     rBIX, dvmAsmInstructionStart + (315 * 128)
25045     lw     rIBASE, offThread_curHandlerTable(rSELF)
25046     bnez   a3, 1f
25047     jr     rBIX            # nothing to do - jump to real handler
25048 1:
25049     EXPORT_PC()
25050     move   a0, rPC         # arg0
25051     move   a1, rFP         # arg1
25052     move   a2, rSELF       # arg2
25053     JAL(dvmCheckBefore)
25054     jr     rBIX
25055
25056 /* ------------------------------ */
25057     .balign 128
25058 .L_ALT_OP_UNUSED_3CFF: /* 0x13c */
25059 /* File: mips/alt_stub.S */
25060 /*
25061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25062  * any interesting requests and then jump to the real instruction
25063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25066  * bail to the real handler if breakFlags==0.
25067  */
25068     lbu    a3, offThread_breakFlags(rSELF)
25069     la     rBIX, dvmAsmInstructionStart + (316 * 128)
25070     lw     rIBASE, offThread_curHandlerTable(rSELF)
25071     bnez   a3, 1f
25072     jr     rBIX            # nothing to do - jump to real handler
25073 1:
25074     EXPORT_PC()
25075     move   a0, rPC         # arg0
25076     move   a1, rFP         # arg1
25077     move   a2, rSELF       # arg2
25078     JAL(dvmCheckBefore)
25079     jr     rBIX
25080
25081 /* ------------------------------ */
25082     .balign 128
25083 .L_ALT_OP_UNUSED_3DFF: /* 0x13d */
25084 /* File: mips/alt_stub.S */
25085 /*
25086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25087  * any interesting requests and then jump to the real instruction
25088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25091  * bail to the real handler if breakFlags==0.
25092  */
25093     lbu    a3, offThread_breakFlags(rSELF)
25094     la     rBIX, dvmAsmInstructionStart + (317 * 128)
25095     lw     rIBASE, offThread_curHandlerTable(rSELF)
25096     bnez   a3, 1f
25097     jr     rBIX            # nothing to do - jump to real handler
25098 1:
25099     EXPORT_PC()
25100     move   a0, rPC         # arg0
25101     move   a1, rFP         # arg1
25102     move   a2, rSELF       # arg2
25103     JAL(dvmCheckBefore)
25104     jr     rBIX
25105
25106 /* ------------------------------ */
25107     .balign 128
25108 .L_ALT_OP_UNUSED_3EFF: /* 0x13e */
25109 /* File: mips/alt_stub.S */
25110 /*
25111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25112  * any interesting requests and then jump to the real instruction
25113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25116  * bail to the real handler if breakFlags==0.
25117  */
25118     lbu    a3, offThread_breakFlags(rSELF)
25119     la     rBIX, dvmAsmInstructionStart + (318 * 128)
25120     lw     rIBASE, offThread_curHandlerTable(rSELF)
25121     bnez   a3, 1f
25122     jr     rBIX            # nothing to do - jump to real handler
25123 1:
25124     EXPORT_PC()
25125     move   a0, rPC         # arg0
25126     move   a1, rFP         # arg1
25127     move   a2, rSELF       # arg2
25128     JAL(dvmCheckBefore)
25129     jr     rBIX
25130
25131 /* ------------------------------ */
25132     .balign 128
25133 .L_ALT_OP_UNUSED_3FFF: /* 0x13f */
25134 /* File: mips/alt_stub.S */
25135 /*
25136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25137  * any interesting requests and then jump to the real instruction
25138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25141  * bail to the real handler if breakFlags==0.
25142  */
25143     lbu    a3, offThread_breakFlags(rSELF)
25144     la     rBIX, dvmAsmInstructionStart + (319 * 128)
25145     lw     rIBASE, offThread_curHandlerTable(rSELF)
25146     bnez   a3, 1f
25147     jr     rBIX            # nothing to do - jump to real handler
25148 1:
25149     EXPORT_PC()
25150     move   a0, rPC         # arg0
25151     move   a1, rFP         # arg1
25152     move   a2, rSELF       # arg2
25153     JAL(dvmCheckBefore)
25154     jr     rBIX
25155
25156 /* ------------------------------ */
25157     .balign 128
25158 .L_ALT_OP_UNUSED_40FF: /* 0x140 */
25159 /* File: mips/alt_stub.S */
25160 /*
25161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25162  * any interesting requests and then jump to the real instruction
25163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25166  * bail to the real handler if breakFlags==0.
25167  */
25168     lbu    a3, offThread_breakFlags(rSELF)
25169     la     rBIX, dvmAsmInstructionStart + (320 * 128)
25170     lw     rIBASE, offThread_curHandlerTable(rSELF)
25171     bnez   a3, 1f
25172     jr     rBIX            # nothing to do - jump to real handler
25173 1:
25174     EXPORT_PC()
25175     move   a0, rPC         # arg0
25176     move   a1, rFP         # arg1
25177     move   a2, rSELF       # arg2
25178     JAL(dvmCheckBefore)
25179     jr     rBIX
25180
25181 /* ------------------------------ */
25182     .balign 128
25183 .L_ALT_OP_UNUSED_41FF: /* 0x141 */
25184 /* File: mips/alt_stub.S */
25185 /*
25186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25187  * any interesting requests and then jump to the real instruction
25188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25191  * bail to the real handler if breakFlags==0.
25192  */
25193     lbu    a3, offThread_breakFlags(rSELF)
25194     la     rBIX, dvmAsmInstructionStart + (321 * 128)
25195     lw     rIBASE, offThread_curHandlerTable(rSELF)
25196     bnez   a3, 1f
25197     jr     rBIX            # nothing to do - jump to real handler
25198 1:
25199     EXPORT_PC()
25200     move   a0, rPC         # arg0
25201     move   a1, rFP         # arg1
25202     move   a2, rSELF       # arg2
25203     JAL(dvmCheckBefore)
25204     jr     rBIX
25205
25206 /* ------------------------------ */
25207     .balign 128
25208 .L_ALT_OP_UNUSED_42FF: /* 0x142 */
25209 /* File: mips/alt_stub.S */
25210 /*
25211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25212  * any interesting requests and then jump to the real instruction
25213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25216  * bail to the real handler if breakFlags==0.
25217  */
25218     lbu    a3, offThread_breakFlags(rSELF)
25219     la     rBIX, dvmAsmInstructionStart + (322 * 128)
25220     lw     rIBASE, offThread_curHandlerTable(rSELF)
25221     bnez   a3, 1f
25222     jr     rBIX            # nothing to do - jump to real handler
25223 1:
25224     EXPORT_PC()
25225     move   a0, rPC         # arg0
25226     move   a1, rFP         # arg1
25227     move   a2, rSELF       # arg2
25228     JAL(dvmCheckBefore)
25229     jr     rBIX
25230
25231 /* ------------------------------ */
25232     .balign 128
25233 .L_ALT_OP_UNUSED_43FF: /* 0x143 */
25234 /* File: mips/alt_stub.S */
25235 /*
25236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25237  * any interesting requests and then jump to the real instruction
25238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25241  * bail to the real handler if breakFlags==0.
25242  */
25243     lbu    a3, offThread_breakFlags(rSELF)
25244     la     rBIX, dvmAsmInstructionStart + (323 * 128)
25245     lw     rIBASE, offThread_curHandlerTable(rSELF)
25246     bnez   a3, 1f
25247     jr     rBIX            # nothing to do - jump to real handler
25248 1:
25249     EXPORT_PC()
25250     move   a0, rPC         # arg0
25251     move   a1, rFP         # arg1
25252     move   a2, rSELF       # arg2
25253     JAL(dvmCheckBefore)
25254     jr     rBIX
25255
25256 /* ------------------------------ */
25257     .balign 128
25258 .L_ALT_OP_UNUSED_44FF: /* 0x144 */
25259 /* File: mips/alt_stub.S */
25260 /*
25261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25262  * any interesting requests and then jump to the real instruction
25263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25266  * bail to the real handler if breakFlags==0.
25267  */
25268     lbu    a3, offThread_breakFlags(rSELF)
25269     la     rBIX, dvmAsmInstructionStart + (324 * 128)
25270     lw     rIBASE, offThread_curHandlerTable(rSELF)
25271     bnez   a3, 1f
25272     jr     rBIX            # nothing to do - jump to real handler
25273 1:
25274     EXPORT_PC()
25275     move   a0, rPC         # arg0
25276     move   a1, rFP         # arg1
25277     move   a2, rSELF       # arg2
25278     JAL(dvmCheckBefore)
25279     jr     rBIX
25280
25281 /* ------------------------------ */
25282     .balign 128
25283 .L_ALT_OP_UNUSED_45FF: /* 0x145 */
25284 /* File: mips/alt_stub.S */
25285 /*
25286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25287  * any interesting requests and then jump to the real instruction
25288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25291  * bail to the real handler if breakFlags==0.
25292  */
25293     lbu    a3, offThread_breakFlags(rSELF)
25294     la     rBIX, dvmAsmInstructionStart + (325 * 128)
25295     lw     rIBASE, offThread_curHandlerTable(rSELF)
25296     bnez   a3, 1f
25297     jr     rBIX            # nothing to do - jump to real handler
25298 1:
25299     EXPORT_PC()
25300     move   a0, rPC         # arg0
25301     move   a1, rFP         # arg1
25302     move   a2, rSELF       # arg2
25303     JAL(dvmCheckBefore)
25304     jr     rBIX
25305
25306 /* ------------------------------ */
25307     .balign 128
25308 .L_ALT_OP_UNUSED_46FF: /* 0x146 */
25309 /* File: mips/alt_stub.S */
25310 /*
25311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25312  * any interesting requests and then jump to the real instruction
25313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25316  * bail to the real handler if breakFlags==0.
25317  */
25318     lbu    a3, offThread_breakFlags(rSELF)
25319     la     rBIX, dvmAsmInstructionStart + (326 * 128)
25320     lw     rIBASE, offThread_curHandlerTable(rSELF)
25321     bnez   a3, 1f
25322     jr     rBIX            # nothing to do - jump to real handler
25323 1:
25324     EXPORT_PC()
25325     move   a0, rPC         # arg0
25326     move   a1, rFP         # arg1
25327     move   a2, rSELF       # arg2
25328     JAL(dvmCheckBefore)
25329     jr     rBIX
25330
25331 /* ------------------------------ */
25332     .balign 128
25333 .L_ALT_OP_UNUSED_47FF: /* 0x147 */
25334 /* File: mips/alt_stub.S */
25335 /*
25336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25337  * any interesting requests and then jump to the real instruction
25338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25341  * bail to the real handler if breakFlags==0.
25342  */
25343     lbu    a3, offThread_breakFlags(rSELF)
25344     la     rBIX, dvmAsmInstructionStart + (327 * 128)
25345     lw     rIBASE, offThread_curHandlerTable(rSELF)
25346     bnez   a3, 1f
25347     jr     rBIX            # nothing to do - jump to real handler
25348 1:
25349     EXPORT_PC()
25350     move   a0, rPC         # arg0
25351     move   a1, rFP         # arg1
25352     move   a2, rSELF       # arg2
25353     JAL(dvmCheckBefore)
25354     jr     rBIX
25355
25356 /* ------------------------------ */
25357     .balign 128
25358 .L_ALT_OP_UNUSED_48FF: /* 0x148 */
25359 /* File: mips/alt_stub.S */
25360 /*
25361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25362  * any interesting requests and then jump to the real instruction
25363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25366  * bail to the real handler if breakFlags==0.
25367  */
25368     lbu    a3, offThread_breakFlags(rSELF)
25369     la     rBIX, dvmAsmInstructionStart + (328 * 128)
25370     lw     rIBASE, offThread_curHandlerTable(rSELF)
25371     bnez   a3, 1f
25372     jr     rBIX            # nothing to do - jump to real handler
25373 1:
25374     EXPORT_PC()
25375     move   a0, rPC         # arg0
25376     move   a1, rFP         # arg1
25377     move   a2, rSELF       # arg2
25378     JAL(dvmCheckBefore)
25379     jr     rBIX
25380
25381 /* ------------------------------ */
25382     .balign 128
25383 .L_ALT_OP_UNUSED_49FF: /* 0x149 */
25384 /* File: mips/alt_stub.S */
25385 /*
25386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25387  * any interesting requests and then jump to the real instruction
25388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25391  * bail to the real handler if breakFlags==0.
25392  */
25393     lbu    a3, offThread_breakFlags(rSELF)
25394     la     rBIX, dvmAsmInstructionStart + (329 * 128)
25395     lw     rIBASE, offThread_curHandlerTable(rSELF)
25396     bnez   a3, 1f
25397     jr     rBIX            # nothing to do - jump to real handler
25398 1:
25399     EXPORT_PC()
25400     move   a0, rPC         # arg0
25401     move   a1, rFP         # arg1
25402     move   a2, rSELF       # arg2
25403     JAL(dvmCheckBefore)
25404     jr     rBIX
25405
25406 /* ------------------------------ */
25407     .balign 128
25408 .L_ALT_OP_UNUSED_4AFF: /* 0x14a */
25409 /* File: mips/alt_stub.S */
25410 /*
25411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25412  * any interesting requests and then jump to the real instruction
25413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25416  * bail to the real handler if breakFlags==0.
25417  */
25418     lbu    a3, offThread_breakFlags(rSELF)
25419     la     rBIX, dvmAsmInstructionStart + (330 * 128)
25420     lw     rIBASE, offThread_curHandlerTable(rSELF)
25421     bnez   a3, 1f
25422     jr     rBIX            # nothing to do - jump to real handler
25423 1:
25424     EXPORT_PC()
25425     move   a0, rPC         # arg0
25426     move   a1, rFP         # arg1
25427     move   a2, rSELF       # arg2
25428     JAL(dvmCheckBefore)
25429     jr     rBIX
25430
25431 /* ------------------------------ */
25432     .balign 128
25433 .L_ALT_OP_UNUSED_4BFF: /* 0x14b */
25434 /* File: mips/alt_stub.S */
25435 /*
25436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25437  * any interesting requests and then jump to the real instruction
25438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25441  * bail to the real handler if breakFlags==0.
25442  */
25443     lbu    a3, offThread_breakFlags(rSELF)
25444     la     rBIX, dvmAsmInstructionStart + (331 * 128)
25445     lw     rIBASE, offThread_curHandlerTable(rSELF)
25446     bnez   a3, 1f
25447     jr     rBIX            # nothing to do - jump to real handler
25448 1:
25449     EXPORT_PC()
25450     move   a0, rPC         # arg0
25451     move   a1, rFP         # arg1
25452     move   a2, rSELF       # arg2
25453     JAL(dvmCheckBefore)
25454     jr     rBIX
25455
25456 /* ------------------------------ */
25457     .balign 128
25458 .L_ALT_OP_UNUSED_4CFF: /* 0x14c */
25459 /* File: mips/alt_stub.S */
25460 /*
25461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25462  * any interesting requests and then jump to the real instruction
25463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25466  * bail to the real handler if breakFlags==0.
25467  */
25468     lbu    a3, offThread_breakFlags(rSELF)
25469     la     rBIX, dvmAsmInstructionStart + (332 * 128)
25470     lw     rIBASE, offThread_curHandlerTable(rSELF)
25471     bnez   a3, 1f
25472     jr     rBIX            # nothing to do - jump to real handler
25473 1:
25474     EXPORT_PC()
25475     move   a0, rPC         # arg0
25476     move   a1, rFP         # arg1
25477     move   a2, rSELF       # arg2
25478     JAL(dvmCheckBefore)
25479     jr     rBIX
25480
25481 /* ------------------------------ */
25482     .balign 128
25483 .L_ALT_OP_UNUSED_4DFF: /* 0x14d */
25484 /* File: mips/alt_stub.S */
25485 /*
25486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25487  * any interesting requests and then jump to the real instruction
25488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25491  * bail to the real handler if breakFlags==0.
25492  */
25493     lbu    a3, offThread_breakFlags(rSELF)
25494     la     rBIX, dvmAsmInstructionStart + (333 * 128)
25495     lw     rIBASE, offThread_curHandlerTable(rSELF)
25496     bnez   a3, 1f
25497     jr     rBIX            # nothing to do - jump to real handler
25498 1:
25499     EXPORT_PC()
25500     move   a0, rPC         # arg0
25501     move   a1, rFP         # arg1
25502     move   a2, rSELF       # arg2
25503     JAL(dvmCheckBefore)
25504     jr     rBIX
25505
25506 /* ------------------------------ */
25507     .balign 128
25508 .L_ALT_OP_UNUSED_4EFF: /* 0x14e */
25509 /* File: mips/alt_stub.S */
25510 /*
25511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25512  * any interesting requests and then jump to the real instruction
25513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25516  * bail to the real handler if breakFlags==0.
25517  */
25518     lbu    a3, offThread_breakFlags(rSELF)
25519     la     rBIX, dvmAsmInstructionStart + (334 * 128)
25520     lw     rIBASE, offThread_curHandlerTable(rSELF)
25521     bnez   a3, 1f
25522     jr     rBIX            # nothing to do - jump to real handler
25523 1:
25524     EXPORT_PC()
25525     move   a0, rPC         # arg0
25526     move   a1, rFP         # arg1
25527     move   a2, rSELF       # arg2
25528     JAL(dvmCheckBefore)
25529     jr     rBIX
25530
25531 /* ------------------------------ */
25532     .balign 128
25533 .L_ALT_OP_UNUSED_4FFF: /* 0x14f */
25534 /* File: mips/alt_stub.S */
25535 /*
25536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25537  * any interesting requests and then jump to the real instruction
25538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25541  * bail to the real handler if breakFlags==0.
25542  */
25543     lbu    a3, offThread_breakFlags(rSELF)
25544     la     rBIX, dvmAsmInstructionStart + (335 * 128)
25545     lw     rIBASE, offThread_curHandlerTable(rSELF)
25546     bnez   a3, 1f
25547     jr     rBIX            # nothing to do - jump to real handler
25548 1:
25549     EXPORT_PC()
25550     move   a0, rPC         # arg0
25551     move   a1, rFP         # arg1
25552     move   a2, rSELF       # arg2
25553     JAL(dvmCheckBefore)
25554     jr     rBIX
25555
25556 /* ------------------------------ */
25557     .balign 128
25558 .L_ALT_OP_UNUSED_50FF: /* 0x150 */
25559 /* File: mips/alt_stub.S */
25560 /*
25561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25562  * any interesting requests and then jump to the real instruction
25563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25566  * bail to the real handler if breakFlags==0.
25567  */
25568     lbu    a3, offThread_breakFlags(rSELF)
25569     la     rBIX, dvmAsmInstructionStart + (336 * 128)
25570     lw     rIBASE, offThread_curHandlerTable(rSELF)
25571     bnez   a3, 1f
25572     jr     rBIX            # nothing to do - jump to real handler
25573 1:
25574     EXPORT_PC()
25575     move   a0, rPC         # arg0
25576     move   a1, rFP         # arg1
25577     move   a2, rSELF       # arg2
25578     JAL(dvmCheckBefore)
25579     jr     rBIX
25580
25581 /* ------------------------------ */
25582     .balign 128
25583 .L_ALT_OP_UNUSED_51FF: /* 0x151 */
25584 /* File: mips/alt_stub.S */
25585 /*
25586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25587  * any interesting requests and then jump to the real instruction
25588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25591  * bail to the real handler if breakFlags==0.
25592  */
25593     lbu    a3, offThread_breakFlags(rSELF)
25594     la     rBIX, dvmAsmInstructionStart + (337 * 128)
25595     lw     rIBASE, offThread_curHandlerTable(rSELF)
25596     bnez   a3, 1f
25597     jr     rBIX            # nothing to do - jump to real handler
25598 1:
25599     EXPORT_PC()
25600     move   a0, rPC         # arg0
25601     move   a1, rFP         # arg1
25602     move   a2, rSELF       # arg2
25603     JAL(dvmCheckBefore)
25604     jr     rBIX
25605
25606 /* ------------------------------ */
25607     .balign 128
25608 .L_ALT_OP_UNUSED_52FF: /* 0x152 */
25609 /* File: mips/alt_stub.S */
25610 /*
25611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25612  * any interesting requests and then jump to the real instruction
25613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25616  * bail to the real handler if breakFlags==0.
25617  */
25618     lbu    a3, offThread_breakFlags(rSELF)
25619     la     rBIX, dvmAsmInstructionStart + (338 * 128)
25620     lw     rIBASE, offThread_curHandlerTable(rSELF)
25621     bnez   a3, 1f
25622     jr     rBIX            # nothing to do - jump to real handler
25623 1:
25624     EXPORT_PC()
25625     move   a0, rPC         # arg0
25626     move   a1, rFP         # arg1
25627     move   a2, rSELF       # arg2
25628     JAL(dvmCheckBefore)
25629     jr     rBIX
25630
25631 /* ------------------------------ */
25632     .balign 128
25633 .L_ALT_OP_UNUSED_53FF: /* 0x153 */
25634 /* File: mips/alt_stub.S */
25635 /*
25636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25637  * any interesting requests and then jump to the real instruction
25638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25641  * bail to the real handler if breakFlags==0.
25642  */
25643     lbu    a3, offThread_breakFlags(rSELF)
25644     la     rBIX, dvmAsmInstructionStart + (339 * 128)
25645     lw     rIBASE, offThread_curHandlerTable(rSELF)
25646     bnez   a3, 1f
25647     jr     rBIX            # nothing to do - jump to real handler
25648 1:
25649     EXPORT_PC()
25650     move   a0, rPC         # arg0
25651     move   a1, rFP         # arg1
25652     move   a2, rSELF       # arg2
25653     JAL(dvmCheckBefore)
25654     jr     rBIX
25655
25656 /* ------------------------------ */
25657     .balign 128
25658 .L_ALT_OP_UNUSED_54FF: /* 0x154 */
25659 /* File: mips/alt_stub.S */
25660 /*
25661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25662  * any interesting requests and then jump to the real instruction
25663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25666  * bail to the real handler if breakFlags==0.
25667  */
25668     lbu    a3, offThread_breakFlags(rSELF)
25669     la     rBIX, dvmAsmInstructionStart + (340 * 128)
25670     lw     rIBASE, offThread_curHandlerTable(rSELF)
25671     bnez   a3, 1f
25672     jr     rBIX            # nothing to do - jump to real handler
25673 1:
25674     EXPORT_PC()
25675     move   a0, rPC         # arg0
25676     move   a1, rFP         # arg1
25677     move   a2, rSELF       # arg2
25678     JAL(dvmCheckBefore)
25679     jr     rBIX
25680
25681 /* ------------------------------ */
25682     .balign 128
25683 .L_ALT_OP_UNUSED_55FF: /* 0x155 */
25684 /* File: mips/alt_stub.S */
25685 /*
25686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25687  * any interesting requests and then jump to the real instruction
25688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25691  * bail to the real handler if breakFlags==0.
25692  */
25693     lbu    a3, offThread_breakFlags(rSELF)
25694     la     rBIX, dvmAsmInstructionStart + (341 * 128)
25695     lw     rIBASE, offThread_curHandlerTable(rSELF)
25696     bnez   a3, 1f
25697     jr     rBIX            # nothing to do - jump to real handler
25698 1:
25699     EXPORT_PC()
25700     move   a0, rPC         # arg0
25701     move   a1, rFP         # arg1
25702     move   a2, rSELF       # arg2
25703     JAL(dvmCheckBefore)
25704     jr     rBIX
25705
25706 /* ------------------------------ */
25707     .balign 128
25708 .L_ALT_OP_UNUSED_56FF: /* 0x156 */
25709 /* File: mips/alt_stub.S */
25710 /*
25711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25712  * any interesting requests and then jump to the real instruction
25713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25716  * bail to the real handler if breakFlags==0.
25717  */
25718     lbu    a3, offThread_breakFlags(rSELF)
25719     la     rBIX, dvmAsmInstructionStart + (342 * 128)
25720     lw     rIBASE, offThread_curHandlerTable(rSELF)
25721     bnez   a3, 1f
25722     jr     rBIX            # nothing to do - jump to real handler
25723 1:
25724     EXPORT_PC()
25725     move   a0, rPC         # arg0
25726     move   a1, rFP         # arg1
25727     move   a2, rSELF       # arg2
25728     JAL(dvmCheckBefore)
25729     jr     rBIX
25730
25731 /* ------------------------------ */
25732     .balign 128
25733 .L_ALT_OP_UNUSED_57FF: /* 0x157 */
25734 /* File: mips/alt_stub.S */
25735 /*
25736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25737  * any interesting requests and then jump to the real instruction
25738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25741  * bail to the real handler if breakFlags==0.
25742  */
25743     lbu    a3, offThread_breakFlags(rSELF)
25744     la     rBIX, dvmAsmInstructionStart + (343 * 128)
25745     lw     rIBASE, offThread_curHandlerTable(rSELF)
25746     bnez   a3, 1f
25747     jr     rBIX            # nothing to do - jump to real handler
25748 1:
25749     EXPORT_PC()
25750     move   a0, rPC         # arg0
25751     move   a1, rFP         # arg1
25752     move   a2, rSELF       # arg2
25753     JAL(dvmCheckBefore)
25754     jr     rBIX
25755
25756 /* ------------------------------ */
25757     .balign 128
25758 .L_ALT_OP_UNUSED_58FF: /* 0x158 */
25759 /* File: mips/alt_stub.S */
25760 /*
25761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25762  * any interesting requests and then jump to the real instruction
25763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25766  * bail to the real handler if breakFlags==0.
25767  */
25768     lbu    a3, offThread_breakFlags(rSELF)
25769     la     rBIX, dvmAsmInstructionStart + (344 * 128)
25770     lw     rIBASE, offThread_curHandlerTable(rSELF)
25771     bnez   a3, 1f
25772     jr     rBIX            # nothing to do - jump to real handler
25773 1:
25774     EXPORT_PC()
25775     move   a0, rPC         # arg0
25776     move   a1, rFP         # arg1
25777     move   a2, rSELF       # arg2
25778     JAL(dvmCheckBefore)
25779     jr     rBIX
25780
25781 /* ------------------------------ */
25782     .balign 128
25783 .L_ALT_OP_UNUSED_59FF: /* 0x159 */
25784 /* File: mips/alt_stub.S */
25785 /*
25786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25787  * any interesting requests and then jump to the real instruction
25788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25791  * bail to the real handler if breakFlags==0.
25792  */
25793     lbu    a3, offThread_breakFlags(rSELF)
25794     la     rBIX, dvmAsmInstructionStart + (345 * 128)
25795     lw     rIBASE, offThread_curHandlerTable(rSELF)
25796     bnez   a3, 1f
25797     jr     rBIX            # nothing to do - jump to real handler
25798 1:
25799     EXPORT_PC()
25800     move   a0, rPC         # arg0
25801     move   a1, rFP         # arg1
25802     move   a2, rSELF       # arg2
25803     JAL(dvmCheckBefore)
25804     jr     rBIX
25805
25806 /* ------------------------------ */
25807     .balign 128
25808 .L_ALT_OP_UNUSED_5AFF: /* 0x15a */
25809 /* File: mips/alt_stub.S */
25810 /*
25811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25812  * any interesting requests and then jump to the real instruction
25813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25816  * bail to the real handler if breakFlags==0.
25817  */
25818     lbu    a3, offThread_breakFlags(rSELF)
25819     la     rBIX, dvmAsmInstructionStart + (346 * 128)
25820     lw     rIBASE, offThread_curHandlerTable(rSELF)
25821     bnez   a3, 1f
25822     jr     rBIX            # nothing to do - jump to real handler
25823 1:
25824     EXPORT_PC()
25825     move   a0, rPC         # arg0
25826     move   a1, rFP         # arg1
25827     move   a2, rSELF       # arg2
25828     JAL(dvmCheckBefore)
25829     jr     rBIX
25830
25831 /* ------------------------------ */
25832     .balign 128
25833 .L_ALT_OP_UNUSED_5BFF: /* 0x15b */
25834 /* File: mips/alt_stub.S */
25835 /*
25836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25837  * any interesting requests and then jump to the real instruction
25838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25841  * bail to the real handler if breakFlags==0.
25842  */
25843     lbu    a3, offThread_breakFlags(rSELF)
25844     la     rBIX, dvmAsmInstructionStart + (347 * 128)
25845     lw     rIBASE, offThread_curHandlerTable(rSELF)
25846     bnez   a3, 1f
25847     jr     rBIX            # nothing to do - jump to real handler
25848 1:
25849     EXPORT_PC()
25850     move   a0, rPC         # arg0
25851     move   a1, rFP         # arg1
25852     move   a2, rSELF       # arg2
25853     JAL(dvmCheckBefore)
25854     jr     rBIX
25855
25856 /* ------------------------------ */
25857     .balign 128
25858 .L_ALT_OP_UNUSED_5CFF: /* 0x15c */
25859 /* File: mips/alt_stub.S */
25860 /*
25861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25862  * any interesting requests and then jump to the real instruction
25863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25866  * bail to the real handler if breakFlags==0.
25867  */
25868     lbu    a3, offThread_breakFlags(rSELF)
25869     la     rBIX, dvmAsmInstructionStart + (348 * 128)
25870     lw     rIBASE, offThread_curHandlerTable(rSELF)
25871     bnez   a3, 1f
25872     jr     rBIX            # nothing to do - jump to real handler
25873 1:
25874     EXPORT_PC()
25875     move   a0, rPC         # arg0
25876     move   a1, rFP         # arg1
25877     move   a2, rSELF       # arg2
25878     JAL(dvmCheckBefore)
25879     jr     rBIX
25880
25881 /* ------------------------------ */
25882     .balign 128
25883 .L_ALT_OP_UNUSED_5DFF: /* 0x15d */
25884 /* File: mips/alt_stub.S */
25885 /*
25886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25887  * any interesting requests and then jump to the real instruction
25888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25891  * bail to the real handler if breakFlags==0.
25892  */
25893     lbu    a3, offThread_breakFlags(rSELF)
25894     la     rBIX, dvmAsmInstructionStart + (349 * 128)
25895     lw     rIBASE, offThread_curHandlerTable(rSELF)
25896     bnez   a3, 1f
25897     jr     rBIX            # nothing to do - jump to real handler
25898 1:
25899     EXPORT_PC()
25900     move   a0, rPC         # arg0
25901     move   a1, rFP         # arg1
25902     move   a2, rSELF       # arg2
25903     JAL(dvmCheckBefore)
25904     jr     rBIX
25905
25906 /* ------------------------------ */
25907     .balign 128
25908 .L_ALT_OP_UNUSED_5EFF: /* 0x15e */
25909 /* File: mips/alt_stub.S */
25910 /*
25911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25912  * any interesting requests and then jump to the real instruction
25913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25916  * bail to the real handler if breakFlags==0.
25917  */
25918     lbu    a3, offThread_breakFlags(rSELF)
25919     la     rBIX, dvmAsmInstructionStart + (350 * 128)
25920     lw     rIBASE, offThread_curHandlerTable(rSELF)
25921     bnez   a3, 1f
25922     jr     rBIX            # nothing to do - jump to real handler
25923 1:
25924     EXPORT_PC()
25925     move   a0, rPC         # arg0
25926     move   a1, rFP         # arg1
25927     move   a2, rSELF       # arg2
25928     JAL(dvmCheckBefore)
25929     jr     rBIX
25930
25931 /* ------------------------------ */
25932     .balign 128
25933 .L_ALT_OP_UNUSED_5FFF: /* 0x15f */
25934 /* File: mips/alt_stub.S */
25935 /*
25936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25937  * any interesting requests and then jump to the real instruction
25938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25941  * bail to the real handler if breakFlags==0.
25942  */
25943     lbu    a3, offThread_breakFlags(rSELF)
25944     la     rBIX, dvmAsmInstructionStart + (351 * 128)
25945     lw     rIBASE, offThread_curHandlerTable(rSELF)
25946     bnez   a3, 1f
25947     jr     rBIX            # nothing to do - jump to real handler
25948 1:
25949     EXPORT_PC()
25950     move   a0, rPC         # arg0
25951     move   a1, rFP         # arg1
25952     move   a2, rSELF       # arg2
25953     JAL(dvmCheckBefore)
25954     jr     rBIX
25955
25956 /* ------------------------------ */
25957     .balign 128
25958 .L_ALT_OP_UNUSED_60FF: /* 0x160 */
25959 /* File: mips/alt_stub.S */
25960 /*
25961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25962  * any interesting requests and then jump to the real instruction
25963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25966  * bail to the real handler if breakFlags==0.
25967  */
25968     lbu    a3, offThread_breakFlags(rSELF)
25969     la     rBIX, dvmAsmInstructionStart + (352 * 128)
25970     lw     rIBASE, offThread_curHandlerTable(rSELF)
25971     bnez   a3, 1f
25972     jr     rBIX            # nothing to do - jump to real handler
25973 1:
25974     EXPORT_PC()
25975     move   a0, rPC         # arg0
25976     move   a1, rFP         # arg1
25977     move   a2, rSELF       # arg2
25978     JAL(dvmCheckBefore)
25979     jr     rBIX
25980
25981 /* ------------------------------ */
25982     .balign 128
25983 .L_ALT_OP_UNUSED_61FF: /* 0x161 */
25984 /* File: mips/alt_stub.S */
25985 /*
25986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
25987  * any interesting requests and then jump to the real instruction
25988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
25989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
25990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
25991  * bail to the real handler if breakFlags==0.
25992  */
25993     lbu    a3, offThread_breakFlags(rSELF)
25994     la     rBIX, dvmAsmInstructionStart + (353 * 128)
25995     lw     rIBASE, offThread_curHandlerTable(rSELF)
25996     bnez   a3, 1f
25997     jr     rBIX            # nothing to do - jump to real handler
25998 1:
25999     EXPORT_PC()
26000     move   a0, rPC         # arg0
26001     move   a1, rFP         # arg1
26002     move   a2, rSELF       # arg2
26003     JAL(dvmCheckBefore)
26004     jr     rBIX
26005
26006 /* ------------------------------ */
26007     .balign 128
26008 .L_ALT_OP_UNUSED_62FF: /* 0x162 */
26009 /* File: mips/alt_stub.S */
26010 /*
26011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26012  * any interesting requests and then jump to the real instruction
26013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26016  * bail to the real handler if breakFlags==0.
26017  */
26018     lbu    a3, offThread_breakFlags(rSELF)
26019     la     rBIX, dvmAsmInstructionStart + (354 * 128)
26020     lw     rIBASE, offThread_curHandlerTable(rSELF)
26021     bnez   a3, 1f
26022     jr     rBIX            # nothing to do - jump to real handler
26023 1:
26024     EXPORT_PC()
26025     move   a0, rPC         # arg0
26026     move   a1, rFP         # arg1
26027     move   a2, rSELF       # arg2
26028     JAL(dvmCheckBefore)
26029     jr     rBIX
26030
26031 /* ------------------------------ */
26032     .balign 128
26033 .L_ALT_OP_UNUSED_63FF: /* 0x163 */
26034 /* File: mips/alt_stub.S */
26035 /*
26036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26037  * any interesting requests and then jump to the real instruction
26038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26041  * bail to the real handler if breakFlags==0.
26042  */
26043     lbu    a3, offThread_breakFlags(rSELF)
26044     la     rBIX, dvmAsmInstructionStart + (355 * 128)
26045     lw     rIBASE, offThread_curHandlerTable(rSELF)
26046     bnez   a3, 1f
26047     jr     rBIX            # nothing to do - jump to real handler
26048 1:
26049     EXPORT_PC()
26050     move   a0, rPC         # arg0
26051     move   a1, rFP         # arg1
26052     move   a2, rSELF       # arg2
26053     JAL(dvmCheckBefore)
26054     jr     rBIX
26055
26056 /* ------------------------------ */
26057     .balign 128
26058 .L_ALT_OP_UNUSED_64FF: /* 0x164 */
26059 /* File: mips/alt_stub.S */
26060 /*
26061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26062  * any interesting requests and then jump to the real instruction
26063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26066  * bail to the real handler if breakFlags==0.
26067  */
26068     lbu    a3, offThread_breakFlags(rSELF)
26069     la     rBIX, dvmAsmInstructionStart + (356 * 128)
26070     lw     rIBASE, offThread_curHandlerTable(rSELF)
26071     bnez   a3, 1f
26072     jr     rBIX            # nothing to do - jump to real handler
26073 1:
26074     EXPORT_PC()
26075     move   a0, rPC         # arg0
26076     move   a1, rFP         # arg1
26077     move   a2, rSELF       # arg2
26078     JAL(dvmCheckBefore)
26079     jr     rBIX
26080
26081 /* ------------------------------ */
26082     .balign 128
26083 .L_ALT_OP_UNUSED_65FF: /* 0x165 */
26084 /* File: mips/alt_stub.S */
26085 /*
26086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26087  * any interesting requests and then jump to the real instruction
26088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26091  * bail to the real handler if breakFlags==0.
26092  */
26093     lbu    a3, offThread_breakFlags(rSELF)
26094     la     rBIX, dvmAsmInstructionStart + (357 * 128)
26095     lw     rIBASE, offThread_curHandlerTable(rSELF)
26096     bnez   a3, 1f
26097     jr     rBIX            # nothing to do - jump to real handler
26098 1:
26099     EXPORT_PC()
26100     move   a0, rPC         # arg0
26101     move   a1, rFP         # arg1
26102     move   a2, rSELF       # arg2
26103     JAL(dvmCheckBefore)
26104     jr     rBIX
26105
26106 /* ------------------------------ */
26107     .balign 128
26108 .L_ALT_OP_UNUSED_66FF: /* 0x166 */
26109 /* File: mips/alt_stub.S */
26110 /*
26111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26112  * any interesting requests and then jump to the real instruction
26113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26116  * bail to the real handler if breakFlags==0.
26117  */
26118     lbu    a3, offThread_breakFlags(rSELF)
26119     la     rBIX, dvmAsmInstructionStart + (358 * 128)
26120     lw     rIBASE, offThread_curHandlerTable(rSELF)
26121     bnez   a3, 1f
26122     jr     rBIX            # nothing to do - jump to real handler
26123 1:
26124     EXPORT_PC()
26125     move   a0, rPC         # arg0
26126     move   a1, rFP         # arg1
26127     move   a2, rSELF       # arg2
26128     JAL(dvmCheckBefore)
26129     jr     rBIX
26130
26131 /* ------------------------------ */
26132     .balign 128
26133 .L_ALT_OP_UNUSED_67FF: /* 0x167 */
26134 /* File: mips/alt_stub.S */
26135 /*
26136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26137  * any interesting requests and then jump to the real instruction
26138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26141  * bail to the real handler if breakFlags==0.
26142  */
26143     lbu    a3, offThread_breakFlags(rSELF)
26144     la     rBIX, dvmAsmInstructionStart + (359 * 128)
26145     lw     rIBASE, offThread_curHandlerTable(rSELF)
26146     bnez   a3, 1f
26147     jr     rBIX            # nothing to do - jump to real handler
26148 1:
26149     EXPORT_PC()
26150     move   a0, rPC         # arg0
26151     move   a1, rFP         # arg1
26152     move   a2, rSELF       # arg2
26153     JAL(dvmCheckBefore)
26154     jr     rBIX
26155
26156 /* ------------------------------ */
26157     .balign 128
26158 .L_ALT_OP_UNUSED_68FF: /* 0x168 */
26159 /* File: mips/alt_stub.S */
26160 /*
26161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26162  * any interesting requests and then jump to the real instruction
26163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26166  * bail to the real handler if breakFlags==0.
26167  */
26168     lbu    a3, offThread_breakFlags(rSELF)
26169     la     rBIX, dvmAsmInstructionStart + (360 * 128)
26170     lw     rIBASE, offThread_curHandlerTable(rSELF)
26171     bnez   a3, 1f
26172     jr     rBIX            # nothing to do - jump to real handler
26173 1:
26174     EXPORT_PC()
26175     move   a0, rPC         # arg0
26176     move   a1, rFP         # arg1
26177     move   a2, rSELF       # arg2
26178     JAL(dvmCheckBefore)
26179     jr     rBIX
26180
26181 /* ------------------------------ */
26182     .balign 128
26183 .L_ALT_OP_UNUSED_69FF: /* 0x169 */
26184 /* File: mips/alt_stub.S */
26185 /*
26186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26187  * any interesting requests and then jump to the real instruction
26188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26191  * bail to the real handler if breakFlags==0.
26192  */
26193     lbu    a3, offThread_breakFlags(rSELF)
26194     la     rBIX, dvmAsmInstructionStart + (361 * 128)
26195     lw     rIBASE, offThread_curHandlerTable(rSELF)
26196     bnez   a3, 1f
26197     jr     rBIX            # nothing to do - jump to real handler
26198 1:
26199     EXPORT_PC()
26200     move   a0, rPC         # arg0
26201     move   a1, rFP         # arg1
26202     move   a2, rSELF       # arg2
26203     JAL(dvmCheckBefore)
26204     jr     rBIX
26205
26206 /* ------------------------------ */
26207     .balign 128
26208 .L_ALT_OP_UNUSED_6AFF: /* 0x16a */
26209 /* File: mips/alt_stub.S */
26210 /*
26211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26212  * any interesting requests and then jump to the real instruction
26213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26216  * bail to the real handler if breakFlags==0.
26217  */
26218     lbu    a3, offThread_breakFlags(rSELF)
26219     la     rBIX, dvmAsmInstructionStart + (362 * 128)
26220     lw     rIBASE, offThread_curHandlerTable(rSELF)
26221     bnez   a3, 1f
26222     jr     rBIX            # nothing to do - jump to real handler
26223 1:
26224     EXPORT_PC()
26225     move   a0, rPC         # arg0
26226     move   a1, rFP         # arg1
26227     move   a2, rSELF       # arg2
26228     JAL(dvmCheckBefore)
26229     jr     rBIX
26230
26231 /* ------------------------------ */
26232     .balign 128
26233 .L_ALT_OP_UNUSED_6BFF: /* 0x16b */
26234 /* File: mips/alt_stub.S */
26235 /*
26236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26237  * any interesting requests and then jump to the real instruction
26238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26241  * bail to the real handler if breakFlags==0.
26242  */
26243     lbu    a3, offThread_breakFlags(rSELF)
26244     la     rBIX, dvmAsmInstructionStart + (363 * 128)
26245     lw     rIBASE, offThread_curHandlerTable(rSELF)
26246     bnez   a3, 1f
26247     jr     rBIX            # nothing to do - jump to real handler
26248 1:
26249     EXPORT_PC()
26250     move   a0, rPC         # arg0
26251     move   a1, rFP         # arg1
26252     move   a2, rSELF       # arg2
26253     JAL(dvmCheckBefore)
26254     jr     rBIX
26255
26256 /* ------------------------------ */
26257     .balign 128
26258 .L_ALT_OP_UNUSED_6CFF: /* 0x16c */
26259 /* File: mips/alt_stub.S */
26260 /*
26261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26262  * any interesting requests and then jump to the real instruction
26263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26266  * bail to the real handler if breakFlags==0.
26267  */
26268     lbu    a3, offThread_breakFlags(rSELF)
26269     la     rBIX, dvmAsmInstructionStart + (364 * 128)
26270     lw     rIBASE, offThread_curHandlerTable(rSELF)
26271     bnez   a3, 1f
26272     jr     rBIX            # nothing to do - jump to real handler
26273 1:
26274     EXPORT_PC()
26275     move   a0, rPC         # arg0
26276     move   a1, rFP         # arg1
26277     move   a2, rSELF       # arg2
26278     JAL(dvmCheckBefore)
26279     jr     rBIX
26280
26281 /* ------------------------------ */
26282     .balign 128
26283 .L_ALT_OP_UNUSED_6DFF: /* 0x16d */
26284 /* File: mips/alt_stub.S */
26285 /*
26286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26287  * any interesting requests and then jump to the real instruction
26288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26291  * bail to the real handler if breakFlags==0.
26292  */
26293     lbu    a3, offThread_breakFlags(rSELF)
26294     la     rBIX, dvmAsmInstructionStart + (365 * 128)
26295     lw     rIBASE, offThread_curHandlerTable(rSELF)
26296     bnez   a3, 1f
26297     jr     rBIX            # nothing to do - jump to real handler
26298 1:
26299     EXPORT_PC()
26300     move   a0, rPC         # arg0
26301     move   a1, rFP         # arg1
26302     move   a2, rSELF       # arg2
26303     JAL(dvmCheckBefore)
26304     jr     rBIX
26305
26306 /* ------------------------------ */
26307     .balign 128
26308 .L_ALT_OP_UNUSED_6EFF: /* 0x16e */
26309 /* File: mips/alt_stub.S */
26310 /*
26311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26312  * any interesting requests and then jump to the real instruction
26313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26316  * bail to the real handler if breakFlags==0.
26317  */
26318     lbu    a3, offThread_breakFlags(rSELF)
26319     la     rBIX, dvmAsmInstructionStart + (366 * 128)
26320     lw     rIBASE, offThread_curHandlerTable(rSELF)
26321     bnez   a3, 1f
26322     jr     rBIX            # nothing to do - jump to real handler
26323 1:
26324     EXPORT_PC()
26325     move   a0, rPC         # arg0
26326     move   a1, rFP         # arg1
26327     move   a2, rSELF       # arg2
26328     JAL(dvmCheckBefore)
26329     jr     rBIX
26330
26331 /* ------------------------------ */
26332     .balign 128
26333 .L_ALT_OP_UNUSED_6FFF: /* 0x16f */
26334 /* File: mips/alt_stub.S */
26335 /*
26336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26337  * any interesting requests and then jump to the real instruction
26338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26341  * bail to the real handler if breakFlags==0.
26342  */
26343     lbu    a3, offThread_breakFlags(rSELF)
26344     la     rBIX, dvmAsmInstructionStart + (367 * 128)
26345     lw     rIBASE, offThread_curHandlerTable(rSELF)
26346     bnez   a3, 1f
26347     jr     rBIX            # nothing to do - jump to real handler
26348 1:
26349     EXPORT_PC()
26350     move   a0, rPC         # arg0
26351     move   a1, rFP         # arg1
26352     move   a2, rSELF       # arg2
26353     JAL(dvmCheckBefore)
26354     jr     rBIX
26355
26356 /* ------------------------------ */
26357     .balign 128
26358 .L_ALT_OP_UNUSED_70FF: /* 0x170 */
26359 /* File: mips/alt_stub.S */
26360 /*
26361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26362  * any interesting requests and then jump to the real instruction
26363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26366  * bail to the real handler if breakFlags==0.
26367  */
26368     lbu    a3, offThread_breakFlags(rSELF)
26369     la     rBIX, dvmAsmInstructionStart + (368 * 128)
26370     lw     rIBASE, offThread_curHandlerTable(rSELF)
26371     bnez   a3, 1f
26372     jr     rBIX            # nothing to do - jump to real handler
26373 1:
26374     EXPORT_PC()
26375     move   a0, rPC         # arg0
26376     move   a1, rFP         # arg1
26377     move   a2, rSELF       # arg2
26378     JAL(dvmCheckBefore)
26379     jr     rBIX
26380
26381 /* ------------------------------ */
26382     .balign 128
26383 .L_ALT_OP_UNUSED_71FF: /* 0x171 */
26384 /* File: mips/alt_stub.S */
26385 /*
26386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26387  * any interesting requests and then jump to the real instruction
26388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26391  * bail to the real handler if breakFlags==0.
26392  */
26393     lbu    a3, offThread_breakFlags(rSELF)
26394     la     rBIX, dvmAsmInstructionStart + (369 * 128)
26395     lw     rIBASE, offThread_curHandlerTable(rSELF)
26396     bnez   a3, 1f
26397     jr     rBIX            # nothing to do - jump to real handler
26398 1:
26399     EXPORT_PC()
26400     move   a0, rPC         # arg0
26401     move   a1, rFP         # arg1
26402     move   a2, rSELF       # arg2
26403     JAL(dvmCheckBefore)
26404     jr     rBIX
26405
26406 /* ------------------------------ */
26407     .balign 128
26408 .L_ALT_OP_UNUSED_72FF: /* 0x172 */
26409 /* File: mips/alt_stub.S */
26410 /*
26411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26412  * any interesting requests and then jump to the real instruction
26413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26416  * bail to the real handler if breakFlags==0.
26417  */
26418     lbu    a3, offThread_breakFlags(rSELF)
26419     la     rBIX, dvmAsmInstructionStart + (370 * 128)
26420     lw     rIBASE, offThread_curHandlerTable(rSELF)
26421     bnez   a3, 1f
26422     jr     rBIX            # nothing to do - jump to real handler
26423 1:
26424     EXPORT_PC()
26425     move   a0, rPC         # arg0
26426     move   a1, rFP         # arg1
26427     move   a2, rSELF       # arg2
26428     JAL(dvmCheckBefore)
26429     jr     rBIX
26430
26431 /* ------------------------------ */
26432     .balign 128
26433 .L_ALT_OP_UNUSED_73FF: /* 0x173 */
26434 /* File: mips/alt_stub.S */
26435 /*
26436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26437  * any interesting requests and then jump to the real instruction
26438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26441  * bail to the real handler if breakFlags==0.
26442  */
26443     lbu    a3, offThread_breakFlags(rSELF)
26444     la     rBIX, dvmAsmInstructionStart + (371 * 128)
26445     lw     rIBASE, offThread_curHandlerTable(rSELF)
26446     bnez   a3, 1f
26447     jr     rBIX            # nothing to do - jump to real handler
26448 1:
26449     EXPORT_PC()
26450     move   a0, rPC         # arg0
26451     move   a1, rFP         # arg1
26452     move   a2, rSELF       # arg2
26453     JAL(dvmCheckBefore)
26454     jr     rBIX
26455
26456 /* ------------------------------ */
26457     .balign 128
26458 .L_ALT_OP_UNUSED_74FF: /* 0x174 */
26459 /* File: mips/alt_stub.S */
26460 /*
26461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26462  * any interesting requests and then jump to the real instruction
26463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26466  * bail to the real handler if breakFlags==0.
26467  */
26468     lbu    a3, offThread_breakFlags(rSELF)
26469     la     rBIX, dvmAsmInstructionStart + (372 * 128)
26470     lw     rIBASE, offThread_curHandlerTable(rSELF)
26471     bnez   a3, 1f
26472     jr     rBIX            # nothing to do - jump to real handler
26473 1:
26474     EXPORT_PC()
26475     move   a0, rPC         # arg0
26476     move   a1, rFP         # arg1
26477     move   a2, rSELF       # arg2
26478     JAL(dvmCheckBefore)
26479     jr     rBIX
26480
26481 /* ------------------------------ */
26482     .balign 128
26483 .L_ALT_OP_UNUSED_75FF: /* 0x175 */
26484 /* File: mips/alt_stub.S */
26485 /*
26486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26487  * any interesting requests and then jump to the real instruction
26488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26491  * bail to the real handler if breakFlags==0.
26492  */
26493     lbu    a3, offThread_breakFlags(rSELF)
26494     la     rBIX, dvmAsmInstructionStart + (373 * 128)
26495     lw     rIBASE, offThread_curHandlerTable(rSELF)
26496     bnez   a3, 1f
26497     jr     rBIX            # nothing to do - jump to real handler
26498 1:
26499     EXPORT_PC()
26500     move   a0, rPC         # arg0
26501     move   a1, rFP         # arg1
26502     move   a2, rSELF       # arg2
26503     JAL(dvmCheckBefore)
26504     jr     rBIX
26505
26506 /* ------------------------------ */
26507     .balign 128
26508 .L_ALT_OP_UNUSED_76FF: /* 0x176 */
26509 /* File: mips/alt_stub.S */
26510 /*
26511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26512  * any interesting requests and then jump to the real instruction
26513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26516  * bail to the real handler if breakFlags==0.
26517  */
26518     lbu    a3, offThread_breakFlags(rSELF)
26519     la     rBIX, dvmAsmInstructionStart + (374 * 128)
26520     lw     rIBASE, offThread_curHandlerTable(rSELF)
26521     bnez   a3, 1f
26522     jr     rBIX            # nothing to do - jump to real handler
26523 1:
26524     EXPORT_PC()
26525     move   a0, rPC         # arg0
26526     move   a1, rFP         # arg1
26527     move   a2, rSELF       # arg2
26528     JAL(dvmCheckBefore)
26529     jr     rBIX
26530
26531 /* ------------------------------ */
26532     .balign 128
26533 .L_ALT_OP_UNUSED_77FF: /* 0x177 */
26534 /* File: mips/alt_stub.S */
26535 /*
26536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26537  * any interesting requests and then jump to the real instruction
26538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26541  * bail to the real handler if breakFlags==0.
26542  */
26543     lbu    a3, offThread_breakFlags(rSELF)
26544     la     rBIX, dvmAsmInstructionStart + (375 * 128)
26545     lw     rIBASE, offThread_curHandlerTable(rSELF)
26546     bnez   a3, 1f
26547     jr     rBIX            # nothing to do - jump to real handler
26548 1:
26549     EXPORT_PC()
26550     move   a0, rPC         # arg0
26551     move   a1, rFP         # arg1
26552     move   a2, rSELF       # arg2
26553     JAL(dvmCheckBefore)
26554     jr     rBIX
26555
26556 /* ------------------------------ */
26557     .balign 128
26558 .L_ALT_OP_UNUSED_78FF: /* 0x178 */
26559 /* File: mips/alt_stub.S */
26560 /*
26561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26562  * any interesting requests and then jump to the real instruction
26563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26566  * bail to the real handler if breakFlags==0.
26567  */
26568     lbu    a3, offThread_breakFlags(rSELF)
26569     la     rBIX, dvmAsmInstructionStart + (376 * 128)
26570     lw     rIBASE, offThread_curHandlerTable(rSELF)
26571     bnez   a3, 1f
26572     jr     rBIX            # nothing to do - jump to real handler
26573 1:
26574     EXPORT_PC()
26575     move   a0, rPC         # arg0
26576     move   a1, rFP         # arg1
26577     move   a2, rSELF       # arg2
26578     JAL(dvmCheckBefore)
26579     jr     rBIX
26580
26581 /* ------------------------------ */
26582     .balign 128
26583 .L_ALT_OP_UNUSED_79FF: /* 0x179 */
26584 /* File: mips/alt_stub.S */
26585 /*
26586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26587  * any interesting requests and then jump to the real instruction
26588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26591  * bail to the real handler if breakFlags==0.
26592  */
26593     lbu    a3, offThread_breakFlags(rSELF)
26594     la     rBIX, dvmAsmInstructionStart + (377 * 128)
26595     lw     rIBASE, offThread_curHandlerTable(rSELF)
26596     bnez   a3, 1f
26597     jr     rBIX            # nothing to do - jump to real handler
26598 1:
26599     EXPORT_PC()
26600     move   a0, rPC         # arg0
26601     move   a1, rFP         # arg1
26602     move   a2, rSELF       # arg2
26603     JAL(dvmCheckBefore)
26604     jr     rBIX
26605
26606 /* ------------------------------ */
26607     .balign 128
26608 .L_ALT_OP_UNUSED_7AFF: /* 0x17a */
26609 /* File: mips/alt_stub.S */
26610 /*
26611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26612  * any interesting requests and then jump to the real instruction
26613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26616  * bail to the real handler if breakFlags==0.
26617  */
26618     lbu    a3, offThread_breakFlags(rSELF)
26619     la     rBIX, dvmAsmInstructionStart + (378 * 128)
26620     lw     rIBASE, offThread_curHandlerTable(rSELF)
26621     bnez   a3, 1f
26622     jr     rBIX            # nothing to do - jump to real handler
26623 1:
26624     EXPORT_PC()
26625     move   a0, rPC         # arg0
26626     move   a1, rFP         # arg1
26627     move   a2, rSELF       # arg2
26628     JAL(dvmCheckBefore)
26629     jr     rBIX
26630
26631 /* ------------------------------ */
26632     .balign 128
26633 .L_ALT_OP_UNUSED_7BFF: /* 0x17b */
26634 /* File: mips/alt_stub.S */
26635 /*
26636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26637  * any interesting requests and then jump to the real instruction
26638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26641  * bail to the real handler if breakFlags==0.
26642  */
26643     lbu    a3, offThread_breakFlags(rSELF)
26644     la     rBIX, dvmAsmInstructionStart + (379 * 128)
26645     lw     rIBASE, offThread_curHandlerTable(rSELF)
26646     bnez   a3, 1f
26647     jr     rBIX            # nothing to do - jump to real handler
26648 1:
26649     EXPORT_PC()
26650     move   a0, rPC         # arg0
26651     move   a1, rFP         # arg1
26652     move   a2, rSELF       # arg2
26653     JAL(dvmCheckBefore)
26654     jr     rBIX
26655
26656 /* ------------------------------ */
26657     .balign 128
26658 .L_ALT_OP_UNUSED_7CFF: /* 0x17c */
26659 /* File: mips/alt_stub.S */
26660 /*
26661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26662  * any interesting requests and then jump to the real instruction
26663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26666  * bail to the real handler if breakFlags==0.
26667  */
26668     lbu    a3, offThread_breakFlags(rSELF)
26669     la     rBIX, dvmAsmInstructionStart + (380 * 128)
26670     lw     rIBASE, offThread_curHandlerTable(rSELF)
26671     bnez   a3, 1f
26672     jr     rBIX            # nothing to do - jump to real handler
26673 1:
26674     EXPORT_PC()
26675     move   a0, rPC         # arg0
26676     move   a1, rFP         # arg1
26677     move   a2, rSELF       # arg2
26678     JAL(dvmCheckBefore)
26679     jr     rBIX
26680
26681 /* ------------------------------ */
26682     .balign 128
26683 .L_ALT_OP_UNUSED_7DFF: /* 0x17d */
26684 /* File: mips/alt_stub.S */
26685 /*
26686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26687  * any interesting requests and then jump to the real instruction
26688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26691  * bail to the real handler if breakFlags==0.
26692  */
26693     lbu    a3, offThread_breakFlags(rSELF)
26694     la     rBIX, dvmAsmInstructionStart + (381 * 128)
26695     lw     rIBASE, offThread_curHandlerTable(rSELF)
26696     bnez   a3, 1f
26697     jr     rBIX            # nothing to do - jump to real handler
26698 1:
26699     EXPORT_PC()
26700     move   a0, rPC         # arg0
26701     move   a1, rFP         # arg1
26702     move   a2, rSELF       # arg2
26703     JAL(dvmCheckBefore)
26704     jr     rBIX
26705
26706 /* ------------------------------ */
26707     .balign 128
26708 .L_ALT_OP_UNUSED_7EFF: /* 0x17e */
26709 /* File: mips/alt_stub.S */
26710 /*
26711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26712  * any interesting requests and then jump to the real instruction
26713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26716  * bail to the real handler if breakFlags==0.
26717  */
26718     lbu    a3, offThread_breakFlags(rSELF)
26719     la     rBIX, dvmAsmInstructionStart + (382 * 128)
26720     lw     rIBASE, offThread_curHandlerTable(rSELF)
26721     bnez   a3, 1f
26722     jr     rBIX            # nothing to do - jump to real handler
26723 1:
26724     EXPORT_PC()
26725     move   a0, rPC         # arg0
26726     move   a1, rFP         # arg1
26727     move   a2, rSELF       # arg2
26728     JAL(dvmCheckBefore)
26729     jr     rBIX
26730
26731 /* ------------------------------ */
26732     .balign 128
26733 .L_ALT_OP_UNUSED_7FFF: /* 0x17f */
26734 /* File: mips/alt_stub.S */
26735 /*
26736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26737  * any interesting requests and then jump to the real instruction
26738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26741  * bail to the real handler if breakFlags==0.
26742  */
26743     lbu    a3, offThread_breakFlags(rSELF)
26744     la     rBIX, dvmAsmInstructionStart + (383 * 128)
26745     lw     rIBASE, offThread_curHandlerTable(rSELF)
26746     bnez   a3, 1f
26747     jr     rBIX            # nothing to do - jump to real handler
26748 1:
26749     EXPORT_PC()
26750     move   a0, rPC         # arg0
26751     move   a1, rFP         # arg1
26752     move   a2, rSELF       # arg2
26753     JAL(dvmCheckBefore)
26754     jr     rBIX
26755
26756 /* ------------------------------ */
26757     .balign 128
26758 .L_ALT_OP_UNUSED_80FF: /* 0x180 */
26759 /* File: mips/alt_stub.S */
26760 /*
26761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26762  * any interesting requests and then jump to the real instruction
26763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26766  * bail to the real handler if breakFlags==0.
26767  */
26768     lbu    a3, offThread_breakFlags(rSELF)
26769     la     rBIX, dvmAsmInstructionStart + (384 * 128)
26770     lw     rIBASE, offThread_curHandlerTable(rSELF)
26771     bnez   a3, 1f
26772     jr     rBIX            # nothing to do - jump to real handler
26773 1:
26774     EXPORT_PC()
26775     move   a0, rPC         # arg0
26776     move   a1, rFP         # arg1
26777     move   a2, rSELF       # arg2
26778     JAL(dvmCheckBefore)
26779     jr     rBIX
26780
26781 /* ------------------------------ */
26782     .balign 128
26783 .L_ALT_OP_UNUSED_81FF: /* 0x181 */
26784 /* File: mips/alt_stub.S */
26785 /*
26786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26787  * any interesting requests and then jump to the real instruction
26788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26791  * bail to the real handler if breakFlags==0.
26792  */
26793     lbu    a3, offThread_breakFlags(rSELF)
26794     la     rBIX, dvmAsmInstructionStart + (385 * 128)
26795     lw     rIBASE, offThread_curHandlerTable(rSELF)
26796     bnez   a3, 1f
26797     jr     rBIX            # nothing to do - jump to real handler
26798 1:
26799     EXPORT_PC()
26800     move   a0, rPC         # arg0
26801     move   a1, rFP         # arg1
26802     move   a2, rSELF       # arg2
26803     JAL(dvmCheckBefore)
26804     jr     rBIX
26805
26806 /* ------------------------------ */
26807     .balign 128
26808 .L_ALT_OP_UNUSED_82FF: /* 0x182 */
26809 /* File: mips/alt_stub.S */
26810 /*
26811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26812  * any interesting requests and then jump to the real instruction
26813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26816  * bail to the real handler if breakFlags==0.
26817  */
26818     lbu    a3, offThread_breakFlags(rSELF)
26819     la     rBIX, dvmAsmInstructionStart + (386 * 128)
26820     lw     rIBASE, offThread_curHandlerTable(rSELF)
26821     bnez   a3, 1f
26822     jr     rBIX            # nothing to do - jump to real handler
26823 1:
26824     EXPORT_PC()
26825     move   a0, rPC         # arg0
26826     move   a1, rFP         # arg1
26827     move   a2, rSELF       # arg2
26828     JAL(dvmCheckBefore)
26829     jr     rBIX
26830
26831 /* ------------------------------ */
26832     .balign 128
26833 .L_ALT_OP_UNUSED_83FF: /* 0x183 */
26834 /* File: mips/alt_stub.S */
26835 /*
26836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26837  * any interesting requests and then jump to the real instruction
26838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26841  * bail to the real handler if breakFlags==0.
26842  */
26843     lbu    a3, offThread_breakFlags(rSELF)
26844     la     rBIX, dvmAsmInstructionStart + (387 * 128)
26845     lw     rIBASE, offThread_curHandlerTable(rSELF)
26846     bnez   a3, 1f
26847     jr     rBIX            # nothing to do - jump to real handler
26848 1:
26849     EXPORT_PC()
26850     move   a0, rPC         # arg0
26851     move   a1, rFP         # arg1
26852     move   a2, rSELF       # arg2
26853     JAL(dvmCheckBefore)
26854     jr     rBIX
26855
26856 /* ------------------------------ */
26857     .balign 128
26858 .L_ALT_OP_UNUSED_84FF: /* 0x184 */
26859 /* File: mips/alt_stub.S */
26860 /*
26861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26862  * any interesting requests and then jump to the real instruction
26863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26866  * bail to the real handler if breakFlags==0.
26867  */
26868     lbu    a3, offThread_breakFlags(rSELF)
26869     la     rBIX, dvmAsmInstructionStart + (388 * 128)
26870     lw     rIBASE, offThread_curHandlerTable(rSELF)
26871     bnez   a3, 1f
26872     jr     rBIX            # nothing to do - jump to real handler
26873 1:
26874     EXPORT_PC()
26875     move   a0, rPC         # arg0
26876     move   a1, rFP         # arg1
26877     move   a2, rSELF       # arg2
26878     JAL(dvmCheckBefore)
26879     jr     rBIX
26880
26881 /* ------------------------------ */
26882     .balign 128
26883 .L_ALT_OP_UNUSED_85FF: /* 0x185 */
26884 /* File: mips/alt_stub.S */
26885 /*
26886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26887  * any interesting requests and then jump to the real instruction
26888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26891  * bail to the real handler if breakFlags==0.
26892  */
26893     lbu    a3, offThread_breakFlags(rSELF)
26894     la     rBIX, dvmAsmInstructionStart + (389 * 128)
26895     lw     rIBASE, offThread_curHandlerTable(rSELF)
26896     bnez   a3, 1f
26897     jr     rBIX            # nothing to do - jump to real handler
26898 1:
26899     EXPORT_PC()
26900     move   a0, rPC         # arg0
26901     move   a1, rFP         # arg1
26902     move   a2, rSELF       # arg2
26903     JAL(dvmCheckBefore)
26904     jr     rBIX
26905
26906 /* ------------------------------ */
26907     .balign 128
26908 .L_ALT_OP_UNUSED_86FF: /* 0x186 */
26909 /* File: mips/alt_stub.S */
26910 /*
26911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26912  * any interesting requests and then jump to the real instruction
26913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26916  * bail to the real handler if breakFlags==0.
26917  */
26918     lbu    a3, offThread_breakFlags(rSELF)
26919     la     rBIX, dvmAsmInstructionStart + (390 * 128)
26920     lw     rIBASE, offThread_curHandlerTable(rSELF)
26921     bnez   a3, 1f
26922     jr     rBIX            # nothing to do - jump to real handler
26923 1:
26924     EXPORT_PC()
26925     move   a0, rPC         # arg0
26926     move   a1, rFP         # arg1
26927     move   a2, rSELF       # arg2
26928     JAL(dvmCheckBefore)
26929     jr     rBIX
26930
26931 /* ------------------------------ */
26932     .balign 128
26933 .L_ALT_OP_UNUSED_87FF: /* 0x187 */
26934 /* File: mips/alt_stub.S */
26935 /*
26936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26937  * any interesting requests and then jump to the real instruction
26938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26941  * bail to the real handler if breakFlags==0.
26942  */
26943     lbu    a3, offThread_breakFlags(rSELF)
26944     la     rBIX, dvmAsmInstructionStart + (391 * 128)
26945     lw     rIBASE, offThread_curHandlerTable(rSELF)
26946     bnez   a3, 1f
26947     jr     rBIX            # nothing to do - jump to real handler
26948 1:
26949     EXPORT_PC()
26950     move   a0, rPC         # arg0
26951     move   a1, rFP         # arg1
26952     move   a2, rSELF       # arg2
26953     JAL(dvmCheckBefore)
26954     jr     rBIX
26955
26956 /* ------------------------------ */
26957     .balign 128
26958 .L_ALT_OP_UNUSED_88FF: /* 0x188 */
26959 /* File: mips/alt_stub.S */
26960 /*
26961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26962  * any interesting requests and then jump to the real instruction
26963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26966  * bail to the real handler if breakFlags==0.
26967  */
26968     lbu    a3, offThread_breakFlags(rSELF)
26969     la     rBIX, dvmAsmInstructionStart + (392 * 128)
26970     lw     rIBASE, offThread_curHandlerTable(rSELF)
26971     bnez   a3, 1f
26972     jr     rBIX            # nothing to do - jump to real handler
26973 1:
26974     EXPORT_PC()
26975     move   a0, rPC         # arg0
26976     move   a1, rFP         # arg1
26977     move   a2, rSELF       # arg2
26978     JAL(dvmCheckBefore)
26979     jr     rBIX
26980
26981 /* ------------------------------ */
26982     .balign 128
26983 .L_ALT_OP_UNUSED_89FF: /* 0x189 */
26984 /* File: mips/alt_stub.S */
26985 /*
26986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
26987  * any interesting requests and then jump to the real instruction
26988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
26989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
26990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
26991  * bail to the real handler if breakFlags==0.
26992  */
26993     lbu    a3, offThread_breakFlags(rSELF)
26994     la     rBIX, dvmAsmInstructionStart + (393 * 128)
26995     lw     rIBASE, offThread_curHandlerTable(rSELF)
26996     bnez   a3, 1f
26997     jr     rBIX            # nothing to do - jump to real handler
26998 1:
26999     EXPORT_PC()
27000     move   a0, rPC         # arg0
27001     move   a1, rFP         # arg1
27002     move   a2, rSELF       # arg2
27003     JAL(dvmCheckBefore)
27004     jr     rBIX
27005
27006 /* ------------------------------ */
27007     .balign 128
27008 .L_ALT_OP_UNUSED_8AFF: /* 0x18a */
27009 /* File: mips/alt_stub.S */
27010 /*
27011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27012  * any interesting requests and then jump to the real instruction
27013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27016  * bail to the real handler if breakFlags==0.
27017  */
27018     lbu    a3, offThread_breakFlags(rSELF)
27019     la     rBIX, dvmAsmInstructionStart + (394 * 128)
27020     lw     rIBASE, offThread_curHandlerTable(rSELF)
27021     bnez   a3, 1f
27022     jr     rBIX            # nothing to do - jump to real handler
27023 1:
27024     EXPORT_PC()
27025     move   a0, rPC         # arg0
27026     move   a1, rFP         # arg1
27027     move   a2, rSELF       # arg2
27028     JAL(dvmCheckBefore)
27029     jr     rBIX
27030
27031 /* ------------------------------ */
27032     .balign 128
27033 .L_ALT_OP_UNUSED_8BFF: /* 0x18b */
27034 /* File: mips/alt_stub.S */
27035 /*
27036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27037  * any interesting requests and then jump to the real instruction
27038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27041  * bail to the real handler if breakFlags==0.
27042  */
27043     lbu    a3, offThread_breakFlags(rSELF)
27044     la     rBIX, dvmAsmInstructionStart + (395 * 128)
27045     lw     rIBASE, offThread_curHandlerTable(rSELF)
27046     bnez   a3, 1f
27047     jr     rBIX            # nothing to do - jump to real handler
27048 1:
27049     EXPORT_PC()
27050     move   a0, rPC         # arg0
27051     move   a1, rFP         # arg1
27052     move   a2, rSELF       # arg2
27053     JAL(dvmCheckBefore)
27054     jr     rBIX
27055
27056 /* ------------------------------ */
27057     .balign 128
27058 .L_ALT_OP_UNUSED_8CFF: /* 0x18c */
27059 /* File: mips/alt_stub.S */
27060 /*
27061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27062  * any interesting requests and then jump to the real instruction
27063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27066  * bail to the real handler if breakFlags==0.
27067  */
27068     lbu    a3, offThread_breakFlags(rSELF)
27069     la     rBIX, dvmAsmInstructionStart + (396 * 128)
27070     lw     rIBASE, offThread_curHandlerTable(rSELF)
27071     bnez   a3, 1f
27072     jr     rBIX            # nothing to do - jump to real handler
27073 1:
27074     EXPORT_PC()
27075     move   a0, rPC         # arg0
27076     move   a1, rFP         # arg1
27077     move   a2, rSELF       # arg2
27078     JAL(dvmCheckBefore)
27079     jr     rBIX
27080
27081 /* ------------------------------ */
27082     .balign 128
27083 .L_ALT_OP_UNUSED_8DFF: /* 0x18d */
27084 /* File: mips/alt_stub.S */
27085 /*
27086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27087  * any interesting requests and then jump to the real instruction
27088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27091  * bail to the real handler if breakFlags==0.
27092  */
27093     lbu    a3, offThread_breakFlags(rSELF)
27094     la     rBIX, dvmAsmInstructionStart + (397 * 128)
27095     lw     rIBASE, offThread_curHandlerTable(rSELF)
27096     bnez   a3, 1f
27097     jr     rBIX            # nothing to do - jump to real handler
27098 1:
27099     EXPORT_PC()
27100     move   a0, rPC         # arg0
27101     move   a1, rFP         # arg1
27102     move   a2, rSELF       # arg2
27103     JAL(dvmCheckBefore)
27104     jr     rBIX
27105
27106 /* ------------------------------ */
27107     .balign 128
27108 .L_ALT_OP_UNUSED_8EFF: /* 0x18e */
27109 /* File: mips/alt_stub.S */
27110 /*
27111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27112  * any interesting requests and then jump to the real instruction
27113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27116  * bail to the real handler if breakFlags==0.
27117  */
27118     lbu    a3, offThread_breakFlags(rSELF)
27119     la     rBIX, dvmAsmInstructionStart + (398 * 128)
27120     lw     rIBASE, offThread_curHandlerTable(rSELF)
27121     bnez   a3, 1f
27122     jr     rBIX            # nothing to do - jump to real handler
27123 1:
27124     EXPORT_PC()
27125     move   a0, rPC         # arg0
27126     move   a1, rFP         # arg1
27127     move   a2, rSELF       # arg2
27128     JAL(dvmCheckBefore)
27129     jr     rBIX
27130
27131 /* ------------------------------ */
27132     .balign 128
27133 .L_ALT_OP_UNUSED_8FFF: /* 0x18f */
27134 /* File: mips/alt_stub.S */
27135 /*
27136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27137  * any interesting requests and then jump to the real instruction
27138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27141  * bail to the real handler if breakFlags==0.
27142  */
27143     lbu    a3, offThread_breakFlags(rSELF)
27144     la     rBIX, dvmAsmInstructionStart + (399 * 128)
27145     lw     rIBASE, offThread_curHandlerTable(rSELF)
27146     bnez   a3, 1f
27147     jr     rBIX            # nothing to do - jump to real handler
27148 1:
27149     EXPORT_PC()
27150     move   a0, rPC         # arg0
27151     move   a1, rFP         # arg1
27152     move   a2, rSELF       # arg2
27153     JAL(dvmCheckBefore)
27154     jr     rBIX
27155
27156 /* ------------------------------ */
27157     .balign 128
27158 .L_ALT_OP_UNUSED_90FF: /* 0x190 */
27159 /* File: mips/alt_stub.S */
27160 /*
27161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27162  * any interesting requests and then jump to the real instruction
27163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27166  * bail to the real handler if breakFlags==0.
27167  */
27168     lbu    a3, offThread_breakFlags(rSELF)
27169     la     rBIX, dvmAsmInstructionStart + (400 * 128)
27170     lw     rIBASE, offThread_curHandlerTable(rSELF)
27171     bnez   a3, 1f
27172     jr     rBIX            # nothing to do - jump to real handler
27173 1:
27174     EXPORT_PC()
27175     move   a0, rPC         # arg0
27176     move   a1, rFP         # arg1
27177     move   a2, rSELF       # arg2
27178     JAL(dvmCheckBefore)
27179     jr     rBIX
27180
27181 /* ------------------------------ */
27182     .balign 128
27183 .L_ALT_OP_UNUSED_91FF: /* 0x191 */
27184 /* File: mips/alt_stub.S */
27185 /*
27186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27187  * any interesting requests and then jump to the real instruction
27188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27191  * bail to the real handler if breakFlags==0.
27192  */
27193     lbu    a3, offThread_breakFlags(rSELF)
27194     la     rBIX, dvmAsmInstructionStart + (401 * 128)
27195     lw     rIBASE, offThread_curHandlerTable(rSELF)
27196     bnez   a3, 1f
27197     jr     rBIX            # nothing to do - jump to real handler
27198 1:
27199     EXPORT_PC()
27200     move   a0, rPC         # arg0
27201     move   a1, rFP         # arg1
27202     move   a2, rSELF       # arg2
27203     JAL(dvmCheckBefore)
27204     jr     rBIX
27205
27206 /* ------------------------------ */
27207     .balign 128
27208 .L_ALT_OP_UNUSED_92FF: /* 0x192 */
27209 /* File: mips/alt_stub.S */
27210 /*
27211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27212  * any interesting requests and then jump to the real instruction
27213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27216  * bail to the real handler if breakFlags==0.
27217  */
27218     lbu    a3, offThread_breakFlags(rSELF)
27219     la     rBIX, dvmAsmInstructionStart + (402 * 128)
27220     lw     rIBASE, offThread_curHandlerTable(rSELF)
27221     bnez   a3, 1f
27222     jr     rBIX            # nothing to do - jump to real handler
27223 1:
27224     EXPORT_PC()
27225     move   a0, rPC         # arg0
27226     move   a1, rFP         # arg1
27227     move   a2, rSELF       # arg2
27228     JAL(dvmCheckBefore)
27229     jr     rBIX
27230
27231 /* ------------------------------ */
27232     .balign 128
27233 .L_ALT_OP_UNUSED_93FF: /* 0x193 */
27234 /* File: mips/alt_stub.S */
27235 /*
27236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27237  * any interesting requests and then jump to the real instruction
27238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27241  * bail to the real handler if breakFlags==0.
27242  */
27243     lbu    a3, offThread_breakFlags(rSELF)
27244     la     rBIX, dvmAsmInstructionStart + (403 * 128)
27245     lw     rIBASE, offThread_curHandlerTable(rSELF)
27246     bnez   a3, 1f
27247     jr     rBIX            # nothing to do - jump to real handler
27248 1:
27249     EXPORT_PC()
27250     move   a0, rPC         # arg0
27251     move   a1, rFP         # arg1
27252     move   a2, rSELF       # arg2
27253     JAL(dvmCheckBefore)
27254     jr     rBIX
27255
27256 /* ------------------------------ */
27257     .balign 128
27258 .L_ALT_OP_UNUSED_94FF: /* 0x194 */
27259 /* File: mips/alt_stub.S */
27260 /*
27261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27262  * any interesting requests and then jump to the real instruction
27263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27266  * bail to the real handler if breakFlags==0.
27267  */
27268     lbu    a3, offThread_breakFlags(rSELF)
27269     la     rBIX, dvmAsmInstructionStart + (404 * 128)
27270     lw     rIBASE, offThread_curHandlerTable(rSELF)
27271     bnez   a3, 1f
27272     jr     rBIX            # nothing to do - jump to real handler
27273 1:
27274     EXPORT_PC()
27275     move   a0, rPC         # arg0
27276     move   a1, rFP         # arg1
27277     move   a2, rSELF       # arg2
27278     JAL(dvmCheckBefore)
27279     jr     rBIX
27280
27281 /* ------------------------------ */
27282     .balign 128
27283 .L_ALT_OP_UNUSED_95FF: /* 0x195 */
27284 /* File: mips/alt_stub.S */
27285 /*
27286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27287  * any interesting requests and then jump to the real instruction
27288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27291  * bail to the real handler if breakFlags==0.
27292  */
27293     lbu    a3, offThread_breakFlags(rSELF)
27294     la     rBIX, dvmAsmInstructionStart + (405 * 128)
27295     lw     rIBASE, offThread_curHandlerTable(rSELF)
27296     bnez   a3, 1f
27297     jr     rBIX            # nothing to do - jump to real handler
27298 1:
27299     EXPORT_PC()
27300     move   a0, rPC         # arg0
27301     move   a1, rFP         # arg1
27302     move   a2, rSELF       # arg2
27303     JAL(dvmCheckBefore)
27304     jr     rBIX
27305
27306 /* ------------------------------ */
27307     .balign 128
27308 .L_ALT_OP_UNUSED_96FF: /* 0x196 */
27309 /* File: mips/alt_stub.S */
27310 /*
27311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27312  * any interesting requests and then jump to the real instruction
27313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27316  * bail to the real handler if breakFlags==0.
27317  */
27318     lbu    a3, offThread_breakFlags(rSELF)
27319     la     rBIX, dvmAsmInstructionStart + (406 * 128)
27320     lw     rIBASE, offThread_curHandlerTable(rSELF)
27321     bnez   a3, 1f
27322     jr     rBIX            # nothing to do - jump to real handler
27323 1:
27324     EXPORT_PC()
27325     move   a0, rPC         # arg0
27326     move   a1, rFP         # arg1
27327     move   a2, rSELF       # arg2
27328     JAL(dvmCheckBefore)
27329     jr     rBIX
27330
27331 /* ------------------------------ */
27332     .balign 128
27333 .L_ALT_OP_UNUSED_97FF: /* 0x197 */
27334 /* File: mips/alt_stub.S */
27335 /*
27336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27337  * any interesting requests and then jump to the real instruction
27338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27341  * bail to the real handler if breakFlags==0.
27342  */
27343     lbu    a3, offThread_breakFlags(rSELF)
27344     la     rBIX, dvmAsmInstructionStart + (407 * 128)
27345     lw     rIBASE, offThread_curHandlerTable(rSELF)
27346     bnez   a3, 1f
27347     jr     rBIX            # nothing to do - jump to real handler
27348 1:
27349     EXPORT_PC()
27350     move   a0, rPC         # arg0
27351     move   a1, rFP         # arg1
27352     move   a2, rSELF       # arg2
27353     JAL(dvmCheckBefore)
27354     jr     rBIX
27355
27356 /* ------------------------------ */
27357     .balign 128
27358 .L_ALT_OP_UNUSED_98FF: /* 0x198 */
27359 /* File: mips/alt_stub.S */
27360 /*
27361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27362  * any interesting requests and then jump to the real instruction
27363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27366  * bail to the real handler if breakFlags==0.
27367  */
27368     lbu    a3, offThread_breakFlags(rSELF)
27369     la     rBIX, dvmAsmInstructionStart + (408 * 128)
27370     lw     rIBASE, offThread_curHandlerTable(rSELF)
27371     bnez   a3, 1f
27372     jr     rBIX            # nothing to do - jump to real handler
27373 1:
27374     EXPORT_PC()
27375     move   a0, rPC         # arg0
27376     move   a1, rFP         # arg1
27377     move   a2, rSELF       # arg2
27378     JAL(dvmCheckBefore)
27379     jr     rBIX
27380
27381 /* ------------------------------ */
27382     .balign 128
27383 .L_ALT_OP_UNUSED_99FF: /* 0x199 */
27384 /* File: mips/alt_stub.S */
27385 /*
27386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27387  * any interesting requests and then jump to the real instruction
27388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27391  * bail to the real handler if breakFlags==0.
27392  */
27393     lbu    a3, offThread_breakFlags(rSELF)
27394     la     rBIX, dvmAsmInstructionStart + (409 * 128)
27395     lw     rIBASE, offThread_curHandlerTable(rSELF)
27396     bnez   a3, 1f
27397     jr     rBIX            # nothing to do - jump to real handler
27398 1:
27399     EXPORT_PC()
27400     move   a0, rPC         # arg0
27401     move   a1, rFP         # arg1
27402     move   a2, rSELF       # arg2
27403     JAL(dvmCheckBefore)
27404     jr     rBIX
27405
27406 /* ------------------------------ */
27407     .balign 128
27408 .L_ALT_OP_UNUSED_9AFF: /* 0x19a */
27409 /* File: mips/alt_stub.S */
27410 /*
27411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27412  * any interesting requests and then jump to the real instruction
27413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27416  * bail to the real handler if breakFlags==0.
27417  */
27418     lbu    a3, offThread_breakFlags(rSELF)
27419     la     rBIX, dvmAsmInstructionStart + (410 * 128)
27420     lw     rIBASE, offThread_curHandlerTable(rSELF)
27421     bnez   a3, 1f
27422     jr     rBIX            # nothing to do - jump to real handler
27423 1:
27424     EXPORT_PC()
27425     move   a0, rPC         # arg0
27426     move   a1, rFP         # arg1
27427     move   a2, rSELF       # arg2
27428     JAL(dvmCheckBefore)
27429     jr     rBIX
27430
27431 /* ------------------------------ */
27432     .balign 128
27433 .L_ALT_OP_UNUSED_9BFF: /* 0x19b */
27434 /* File: mips/alt_stub.S */
27435 /*
27436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27437  * any interesting requests and then jump to the real instruction
27438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27441  * bail to the real handler if breakFlags==0.
27442  */
27443     lbu    a3, offThread_breakFlags(rSELF)
27444     la     rBIX, dvmAsmInstructionStart + (411 * 128)
27445     lw     rIBASE, offThread_curHandlerTable(rSELF)
27446     bnez   a3, 1f
27447     jr     rBIX            # nothing to do - jump to real handler
27448 1:
27449     EXPORT_PC()
27450     move   a0, rPC         # arg0
27451     move   a1, rFP         # arg1
27452     move   a2, rSELF       # arg2
27453     JAL(dvmCheckBefore)
27454     jr     rBIX
27455
27456 /* ------------------------------ */
27457     .balign 128
27458 .L_ALT_OP_UNUSED_9CFF: /* 0x19c */
27459 /* File: mips/alt_stub.S */
27460 /*
27461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27462  * any interesting requests and then jump to the real instruction
27463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27466  * bail to the real handler if breakFlags==0.
27467  */
27468     lbu    a3, offThread_breakFlags(rSELF)
27469     la     rBIX, dvmAsmInstructionStart + (412 * 128)
27470     lw     rIBASE, offThread_curHandlerTable(rSELF)
27471     bnez   a3, 1f
27472     jr     rBIX            # nothing to do - jump to real handler
27473 1:
27474     EXPORT_PC()
27475     move   a0, rPC         # arg0
27476     move   a1, rFP         # arg1
27477     move   a2, rSELF       # arg2
27478     JAL(dvmCheckBefore)
27479     jr     rBIX
27480
27481 /* ------------------------------ */
27482     .balign 128
27483 .L_ALT_OP_UNUSED_9DFF: /* 0x19d */
27484 /* File: mips/alt_stub.S */
27485 /*
27486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27487  * any interesting requests and then jump to the real instruction
27488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27491  * bail to the real handler if breakFlags==0.
27492  */
27493     lbu    a3, offThread_breakFlags(rSELF)
27494     la     rBIX, dvmAsmInstructionStart + (413 * 128)
27495     lw     rIBASE, offThread_curHandlerTable(rSELF)
27496     bnez   a3, 1f
27497     jr     rBIX            # nothing to do - jump to real handler
27498 1:
27499     EXPORT_PC()
27500     move   a0, rPC         # arg0
27501     move   a1, rFP         # arg1
27502     move   a2, rSELF       # arg2
27503     JAL(dvmCheckBefore)
27504     jr     rBIX
27505
27506 /* ------------------------------ */
27507     .balign 128
27508 .L_ALT_OP_UNUSED_9EFF: /* 0x19e */
27509 /* File: mips/alt_stub.S */
27510 /*
27511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27512  * any interesting requests and then jump to the real instruction
27513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27516  * bail to the real handler if breakFlags==0.
27517  */
27518     lbu    a3, offThread_breakFlags(rSELF)
27519     la     rBIX, dvmAsmInstructionStart + (414 * 128)
27520     lw     rIBASE, offThread_curHandlerTable(rSELF)
27521     bnez   a3, 1f
27522     jr     rBIX            # nothing to do - jump to real handler
27523 1:
27524     EXPORT_PC()
27525     move   a0, rPC         # arg0
27526     move   a1, rFP         # arg1
27527     move   a2, rSELF       # arg2
27528     JAL(dvmCheckBefore)
27529     jr     rBIX
27530
27531 /* ------------------------------ */
27532     .balign 128
27533 .L_ALT_OP_UNUSED_9FFF: /* 0x19f */
27534 /* File: mips/alt_stub.S */
27535 /*
27536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27537  * any interesting requests and then jump to the real instruction
27538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27541  * bail to the real handler if breakFlags==0.
27542  */
27543     lbu    a3, offThread_breakFlags(rSELF)
27544     la     rBIX, dvmAsmInstructionStart + (415 * 128)
27545     lw     rIBASE, offThread_curHandlerTable(rSELF)
27546     bnez   a3, 1f
27547     jr     rBIX            # nothing to do - jump to real handler
27548 1:
27549     EXPORT_PC()
27550     move   a0, rPC         # arg0
27551     move   a1, rFP         # arg1
27552     move   a2, rSELF       # arg2
27553     JAL(dvmCheckBefore)
27554     jr     rBIX
27555
27556 /* ------------------------------ */
27557     .balign 128
27558 .L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */
27559 /* File: mips/alt_stub.S */
27560 /*
27561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27562  * any interesting requests and then jump to the real instruction
27563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27566  * bail to the real handler if breakFlags==0.
27567  */
27568     lbu    a3, offThread_breakFlags(rSELF)
27569     la     rBIX, dvmAsmInstructionStart + (416 * 128)
27570     lw     rIBASE, offThread_curHandlerTable(rSELF)
27571     bnez   a3, 1f
27572     jr     rBIX            # nothing to do - jump to real handler
27573 1:
27574     EXPORT_PC()
27575     move   a0, rPC         # arg0
27576     move   a1, rFP         # arg1
27577     move   a2, rSELF       # arg2
27578     JAL(dvmCheckBefore)
27579     jr     rBIX
27580
27581 /* ------------------------------ */
27582     .balign 128
27583 .L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */
27584 /* File: mips/alt_stub.S */
27585 /*
27586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27587  * any interesting requests and then jump to the real instruction
27588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27591  * bail to the real handler if breakFlags==0.
27592  */
27593     lbu    a3, offThread_breakFlags(rSELF)
27594     la     rBIX, dvmAsmInstructionStart + (417 * 128)
27595     lw     rIBASE, offThread_curHandlerTable(rSELF)
27596     bnez   a3, 1f
27597     jr     rBIX            # nothing to do - jump to real handler
27598 1:
27599     EXPORT_PC()
27600     move   a0, rPC         # arg0
27601     move   a1, rFP         # arg1
27602     move   a2, rSELF       # arg2
27603     JAL(dvmCheckBefore)
27604     jr     rBIX
27605
27606 /* ------------------------------ */
27607     .balign 128
27608 .L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */
27609 /* File: mips/alt_stub.S */
27610 /*
27611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27612  * any interesting requests and then jump to the real instruction
27613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27616  * bail to the real handler if breakFlags==0.
27617  */
27618     lbu    a3, offThread_breakFlags(rSELF)
27619     la     rBIX, dvmAsmInstructionStart + (418 * 128)
27620     lw     rIBASE, offThread_curHandlerTable(rSELF)
27621     bnez   a3, 1f
27622     jr     rBIX            # nothing to do - jump to real handler
27623 1:
27624     EXPORT_PC()
27625     move   a0, rPC         # arg0
27626     move   a1, rFP         # arg1
27627     move   a2, rSELF       # arg2
27628     JAL(dvmCheckBefore)
27629     jr     rBIX
27630
27631 /* ------------------------------ */
27632     .balign 128
27633 .L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */
27634 /* File: mips/alt_stub.S */
27635 /*
27636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27637  * any interesting requests and then jump to the real instruction
27638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27641  * bail to the real handler if breakFlags==0.
27642  */
27643     lbu    a3, offThread_breakFlags(rSELF)
27644     la     rBIX, dvmAsmInstructionStart + (419 * 128)
27645     lw     rIBASE, offThread_curHandlerTable(rSELF)
27646     bnez   a3, 1f
27647     jr     rBIX            # nothing to do - jump to real handler
27648 1:
27649     EXPORT_PC()
27650     move   a0, rPC         # arg0
27651     move   a1, rFP         # arg1
27652     move   a2, rSELF       # arg2
27653     JAL(dvmCheckBefore)
27654     jr     rBIX
27655
27656 /* ------------------------------ */
27657     .balign 128
27658 .L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */
27659 /* File: mips/alt_stub.S */
27660 /*
27661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27662  * any interesting requests and then jump to the real instruction
27663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27666  * bail to the real handler if breakFlags==0.
27667  */
27668     lbu    a3, offThread_breakFlags(rSELF)
27669     la     rBIX, dvmAsmInstructionStart + (420 * 128)
27670     lw     rIBASE, offThread_curHandlerTable(rSELF)
27671     bnez   a3, 1f
27672     jr     rBIX            # nothing to do - jump to real handler
27673 1:
27674     EXPORT_PC()
27675     move   a0, rPC         # arg0
27676     move   a1, rFP         # arg1
27677     move   a2, rSELF       # arg2
27678     JAL(dvmCheckBefore)
27679     jr     rBIX
27680
27681 /* ------------------------------ */
27682     .balign 128
27683 .L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */
27684 /* File: mips/alt_stub.S */
27685 /*
27686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27687  * any interesting requests and then jump to the real instruction
27688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27691  * bail to the real handler if breakFlags==0.
27692  */
27693     lbu    a3, offThread_breakFlags(rSELF)
27694     la     rBIX, dvmAsmInstructionStart + (421 * 128)
27695     lw     rIBASE, offThread_curHandlerTable(rSELF)
27696     bnez   a3, 1f
27697     jr     rBIX            # nothing to do - jump to real handler
27698 1:
27699     EXPORT_PC()
27700     move   a0, rPC         # arg0
27701     move   a1, rFP         # arg1
27702     move   a2, rSELF       # arg2
27703     JAL(dvmCheckBefore)
27704     jr     rBIX
27705
27706 /* ------------------------------ */
27707     .balign 128
27708 .L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */
27709 /* File: mips/alt_stub.S */
27710 /*
27711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27712  * any interesting requests and then jump to the real instruction
27713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27716  * bail to the real handler if breakFlags==0.
27717  */
27718     lbu    a3, offThread_breakFlags(rSELF)
27719     la     rBIX, dvmAsmInstructionStart + (422 * 128)
27720     lw     rIBASE, offThread_curHandlerTable(rSELF)
27721     bnez   a3, 1f
27722     jr     rBIX            # nothing to do - jump to real handler
27723 1:
27724     EXPORT_PC()
27725     move   a0, rPC         # arg0
27726     move   a1, rFP         # arg1
27727     move   a2, rSELF       # arg2
27728     JAL(dvmCheckBefore)
27729     jr     rBIX
27730
27731 /* ------------------------------ */
27732     .balign 128
27733 .L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */
27734 /* File: mips/alt_stub.S */
27735 /*
27736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27737  * any interesting requests and then jump to the real instruction
27738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27741  * bail to the real handler if breakFlags==0.
27742  */
27743     lbu    a3, offThread_breakFlags(rSELF)
27744     la     rBIX, dvmAsmInstructionStart + (423 * 128)
27745     lw     rIBASE, offThread_curHandlerTable(rSELF)
27746     bnez   a3, 1f
27747     jr     rBIX            # nothing to do - jump to real handler
27748 1:
27749     EXPORT_PC()
27750     move   a0, rPC         # arg0
27751     move   a1, rFP         # arg1
27752     move   a2, rSELF       # arg2
27753     JAL(dvmCheckBefore)
27754     jr     rBIX
27755
27756 /* ------------------------------ */
27757     .balign 128
27758 .L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */
27759 /* File: mips/alt_stub.S */
27760 /*
27761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27762  * any interesting requests and then jump to the real instruction
27763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27766  * bail to the real handler if breakFlags==0.
27767  */
27768     lbu    a3, offThread_breakFlags(rSELF)
27769     la     rBIX, dvmAsmInstructionStart + (424 * 128)
27770     lw     rIBASE, offThread_curHandlerTable(rSELF)
27771     bnez   a3, 1f
27772     jr     rBIX            # nothing to do - jump to real handler
27773 1:
27774     EXPORT_PC()
27775     move   a0, rPC         # arg0
27776     move   a1, rFP         # arg1
27777     move   a2, rSELF       # arg2
27778     JAL(dvmCheckBefore)
27779     jr     rBIX
27780
27781 /* ------------------------------ */
27782     .balign 128
27783 .L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */
27784 /* File: mips/alt_stub.S */
27785 /*
27786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27787  * any interesting requests and then jump to the real instruction
27788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27791  * bail to the real handler if breakFlags==0.
27792  */
27793     lbu    a3, offThread_breakFlags(rSELF)
27794     la     rBIX, dvmAsmInstructionStart + (425 * 128)
27795     lw     rIBASE, offThread_curHandlerTable(rSELF)
27796     bnez   a3, 1f
27797     jr     rBIX            # nothing to do - jump to real handler
27798 1:
27799     EXPORT_PC()
27800     move   a0, rPC         # arg0
27801     move   a1, rFP         # arg1
27802     move   a2, rSELF       # arg2
27803     JAL(dvmCheckBefore)
27804     jr     rBIX
27805
27806 /* ------------------------------ */
27807     .balign 128
27808 .L_ALT_OP_UNUSED_AAFF: /* 0x1aa */
27809 /* File: mips/alt_stub.S */
27810 /*
27811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27812  * any interesting requests and then jump to the real instruction
27813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27816  * bail to the real handler if breakFlags==0.
27817  */
27818     lbu    a3, offThread_breakFlags(rSELF)
27819     la     rBIX, dvmAsmInstructionStart + (426 * 128)
27820     lw     rIBASE, offThread_curHandlerTable(rSELF)
27821     bnez   a3, 1f
27822     jr     rBIX            # nothing to do - jump to real handler
27823 1:
27824     EXPORT_PC()
27825     move   a0, rPC         # arg0
27826     move   a1, rFP         # arg1
27827     move   a2, rSELF       # arg2
27828     JAL(dvmCheckBefore)
27829     jr     rBIX
27830
27831 /* ------------------------------ */
27832     .balign 128
27833 .L_ALT_OP_UNUSED_ABFF: /* 0x1ab */
27834 /* File: mips/alt_stub.S */
27835 /*
27836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27837  * any interesting requests and then jump to the real instruction
27838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27841  * bail to the real handler if breakFlags==0.
27842  */
27843     lbu    a3, offThread_breakFlags(rSELF)
27844     la     rBIX, dvmAsmInstructionStart + (427 * 128)
27845     lw     rIBASE, offThread_curHandlerTable(rSELF)
27846     bnez   a3, 1f
27847     jr     rBIX            # nothing to do - jump to real handler
27848 1:
27849     EXPORT_PC()
27850     move   a0, rPC         # arg0
27851     move   a1, rFP         # arg1
27852     move   a2, rSELF       # arg2
27853     JAL(dvmCheckBefore)
27854     jr     rBIX
27855
27856 /* ------------------------------ */
27857     .balign 128
27858 .L_ALT_OP_UNUSED_ACFF: /* 0x1ac */
27859 /* File: mips/alt_stub.S */
27860 /*
27861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27862  * any interesting requests and then jump to the real instruction
27863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27866  * bail to the real handler if breakFlags==0.
27867  */
27868     lbu    a3, offThread_breakFlags(rSELF)
27869     la     rBIX, dvmAsmInstructionStart + (428 * 128)
27870     lw     rIBASE, offThread_curHandlerTable(rSELF)
27871     bnez   a3, 1f
27872     jr     rBIX            # nothing to do - jump to real handler
27873 1:
27874     EXPORT_PC()
27875     move   a0, rPC         # arg0
27876     move   a1, rFP         # arg1
27877     move   a2, rSELF       # arg2
27878     JAL(dvmCheckBefore)
27879     jr     rBIX
27880
27881 /* ------------------------------ */
27882     .balign 128
27883 .L_ALT_OP_UNUSED_ADFF: /* 0x1ad */
27884 /* File: mips/alt_stub.S */
27885 /*
27886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27887  * any interesting requests and then jump to the real instruction
27888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27891  * bail to the real handler if breakFlags==0.
27892  */
27893     lbu    a3, offThread_breakFlags(rSELF)
27894     la     rBIX, dvmAsmInstructionStart + (429 * 128)
27895     lw     rIBASE, offThread_curHandlerTable(rSELF)
27896     bnez   a3, 1f
27897     jr     rBIX            # nothing to do - jump to real handler
27898 1:
27899     EXPORT_PC()
27900     move   a0, rPC         # arg0
27901     move   a1, rFP         # arg1
27902     move   a2, rSELF       # arg2
27903     JAL(dvmCheckBefore)
27904     jr     rBIX
27905
27906 /* ------------------------------ */
27907     .balign 128
27908 .L_ALT_OP_UNUSED_AEFF: /* 0x1ae */
27909 /* File: mips/alt_stub.S */
27910 /*
27911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27912  * any interesting requests and then jump to the real instruction
27913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27916  * bail to the real handler if breakFlags==0.
27917  */
27918     lbu    a3, offThread_breakFlags(rSELF)
27919     la     rBIX, dvmAsmInstructionStart + (430 * 128)
27920     lw     rIBASE, offThread_curHandlerTable(rSELF)
27921     bnez   a3, 1f
27922     jr     rBIX            # nothing to do - jump to real handler
27923 1:
27924     EXPORT_PC()
27925     move   a0, rPC         # arg0
27926     move   a1, rFP         # arg1
27927     move   a2, rSELF       # arg2
27928     JAL(dvmCheckBefore)
27929     jr     rBIX
27930
27931 /* ------------------------------ */
27932     .balign 128
27933 .L_ALT_OP_UNUSED_AFFF: /* 0x1af */
27934 /* File: mips/alt_stub.S */
27935 /*
27936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27937  * any interesting requests and then jump to the real instruction
27938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27941  * bail to the real handler if breakFlags==0.
27942  */
27943     lbu    a3, offThread_breakFlags(rSELF)
27944     la     rBIX, dvmAsmInstructionStart + (431 * 128)
27945     lw     rIBASE, offThread_curHandlerTable(rSELF)
27946     bnez   a3, 1f
27947     jr     rBIX            # nothing to do - jump to real handler
27948 1:
27949     EXPORT_PC()
27950     move   a0, rPC         # arg0
27951     move   a1, rFP         # arg1
27952     move   a2, rSELF       # arg2
27953     JAL(dvmCheckBefore)
27954     jr     rBIX
27955
27956 /* ------------------------------ */
27957     .balign 128
27958 .L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */
27959 /* File: mips/alt_stub.S */
27960 /*
27961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27962  * any interesting requests and then jump to the real instruction
27963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27966  * bail to the real handler if breakFlags==0.
27967  */
27968     lbu    a3, offThread_breakFlags(rSELF)
27969     la     rBIX, dvmAsmInstructionStart + (432 * 128)
27970     lw     rIBASE, offThread_curHandlerTable(rSELF)
27971     bnez   a3, 1f
27972     jr     rBIX            # nothing to do - jump to real handler
27973 1:
27974     EXPORT_PC()
27975     move   a0, rPC         # arg0
27976     move   a1, rFP         # arg1
27977     move   a2, rSELF       # arg2
27978     JAL(dvmCheckBefore)
27979     jr     rBIX
27980
27981 /* ------------------------------ */
27982     .balign 128
27983 .L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */
27984 /* File: mips/alt_stub.S */
27985 /*
27986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
27987  * any interesting requests and then jump to the real instruction
27988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
27989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
27990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
27991  * bail to the real handler if breakFlags==0.
27992  */
27993     lbu    a3, offThread_breakFlags(rSELF)
27994     la     rBIX, dvmAsmInstructionStart + (433 * 128)
27995     lw     rIBASE, offThread_curHandlerTable(rSELF)
27996     bnez   a3, 1f
27997     jr     rBIX            # nothing to do - jump to real handler
27998 1:
27999     EXPORT_PC()
28000     move   a0, rPC         # arg0
28001     move   a1, rFP         # arg1
28002     move   a2, rSELF       # arg2
28003     JAL(dvmCheckBefore)
28004     jr     rBIX
28005
28006 /* ------------------------------ */
28007     .balign 128
28008 .L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */
28009 /* File: mips/alt_stub.S */
28010 /*
28011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28012  * any interesting requests and then jump to the real instruction
28013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28016  * bail to the real handler if breakFlags==0.
28017  */
28018     lbu    a3, offThread_breakFlags(rSELF)
28019     la     rBIX, dvmAsmInstructionStart + (434 * 128)
28020     lw     rIBASE, offThread_curHandlerTable(rSELF)
28021     bnez   a3, 1f
28022     jr     rBIX            # nothing to do - jump to real handler
28023 1:
28024     EXPORT_PC()
28025     move   a0, rPC         # arg0
28026     move   a1, rFP         # arg1
28027     move   a2, rSELF       # arg2
28028     JAL(dvmCheckBefore)
28029     jr     rBIX
28030
28031 /* ------------------------------ */
28032     .balign 128
28033 .L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */
28034 /* File: mips/alt_stub.S */
28035 /*
28036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28037  * any interesting requests and then jump to the real instruction
28038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28041  * bail to the real handler if breakFlags==0.
28042  */
28043     lbu    a3, offThread_breakFlags(rSELF)
28044     la     rBIX, dvmAsmInstructionStart + (435 * 128)
28045     lw     rIBASE, offThread_curHandlerTable(rSELF)
28046     bnez   a3, 1f
28047     jr     rBIX            # nothing to do - jump to real handler
28048 1:
28049     EXPORT_PC()
28050     move   a0, rPC         # arg0
28051     move   a1, rFP         # arg1
28052     move   a2, rSELF       # arg2
28053     JAL(dvmCheckBefore)
28054     jr     rBIX
28055
28056 /* ------------------------------ */
28057     .balign 128
28058 .L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */
28059 /* File: mips/alt_stub.S */
28060 /*
28061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28062  * any interesting requests and then jump to the real instruction
28063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28066  * bail to the real handler if breakFlags==0.
28067  */
28068     lbu    a3, offThread_breakFlags(rSELF)
28069     la     rBIX, dvmAsmInstructionStart + (436 * 128)
28070     lw     rIBASE, offThread_curHandlerTable(rSELF)
28071     bnez   a3, 1f
28072     jr     rBIX            # nothing to do - jump to real handler
28073 1:
28074     EXPORT_PC()
28075     move   a0, rPC         # arg0
28076     move   a1, rFP         # arg1
28077     move   a2, rSELF       # arg2
28078     JAL(dvmCheckBefore)
28079     jr     rBIX
28080
28081 /* ------------------------------ */
28082     .balign 128
28083 .L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */
28084 /* File: mips/alt_stub.S */
28085 /*
28086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28087  * any interesting requests and then jump to the real instruction
28088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28091  * bail to the real handler if breakFlags==0.
28092  */
28093     lbu    a3, offThread_breakFlags(rSELF)
28094     la     rBIX, dvmAsmInstructionStart + (437 * 128)
28095     lw     rIBASE, offThread_curHandlerTable(rSELF)
28096     bnez   a3, 1f
28097     jr     rBIX            # nothing to do - jump to real handler
28098 1:
28099     EXPORT_PC()
28100     move   a0, rPC         # arg0
28101     move   a1, rFP         # arg1
28102     move   a2, rSELF       # arg2
28103     JAL(dvmCheckBefore)
28104     jr     rBIX
28105
28106 /* ------------------------------ */
28107     .balign 128
28108 .L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */
28109 /* File: mips/alt_stub.S */
28110 /*
28111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28112  * any interesting requests and then jump to the real instruction
28113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28116  * bail to the real handler if breakFlags==0.
28117  */
28118     lbu    a3, offThread_breakFlags(rSELF)
28119     la     rBIX, dvmAsmInstructionStart + (438 * 128)
28120     lw     rIBASE, offThread_curHandlerTable(rSELF)
28121     bnez   a3, 1f
28122     jr     rBIX            # nothing to do - jump to real handler
28123 1:
28124     EXPORT_PC()
28125     move   a0, rPC         # arg0
28126     move   a1, rFP         # arg1
28127     move   a2, rSELF       # arg2
28128     JAL(dvmCheckBefore)
28129     jr     rBIX
28130
28131 /* ------------------------------ */
28132     .balign 128
28133 .L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */
28134 /* File: mips/alt_stub.S */
28135 /*
28136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28137  * any interesting requests and then jump to the real instruction
28138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28141  * bail to the real handler if breakFlags==0.
28142  */
28143     lbu    a3, offThread_breakFlags(rSELF)
28144     la     rBIX, dvmAsmInstructionStart + (439 * 128)
28145     lw     rIBASE, offThread_curHandlerTable(rSELF)
28146     bnez   a3, 1f
28147     jr     rBIX            # nothing to do - jump to real handler
28148 1:
28149     EXPORT_PC()
28150     move   a0, rPC         # arg0
28151     move   a1, rFP         # arg1
28152     move   a2, rSELF       # arg2
28153     JAL(dvmCheckBefore)
28154     jr     rBIX
28155
28156 /* ------------------------------ */
28157     .balign 128
28158 .L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */
28159 /* File: mips/alt_stub.S */
28160 /*
28161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28162  * any interesting requests and then jump to the real instruction
28163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28166  * bail to the real handler if breakFlags==0.
28167  */
28168     lbu    a3, offThread_breakFlags(rSELF)
28169     la     rBIX, dvmAsmInstructionStart + (440 * 128)
28170     lw     rIBASE, offThread_curHandlerTable(rSELF)
28171     bnez   a3, 1f
28172     jr     rBIX            # nothing to do - jump to real handler
28173 1:
28174     EXPORT_PC()
28175     move   a0, rPC         # arg0
28176     move   a1, rFP         # arg1
28177     move   a2, rSELF       # arg2
28178     JAL(dvmCheckBefore)
28179     jr     rBIX
28180
28181 /* ------------------------------ */
28182     .balign 128
28183 .L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */
28184 /* File: mips/alt_stub.S */
28185 /*
28186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28187  * any interesting requests and then jump to the real instruction
28188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28191  * bail to the real handler if breakFlags==0.
28192  */
28193     lbu    a3, offThread_breakFlags(rSELF)
28194     la     rBIX, dvmAsmInstructionStart + (441 * 128)
28195     lw     rIBASE, offThread_curHandlerTable(rSELF)
28196     bnez   a3, 1f
28197     jr     rBIX            # nothing to do - jump to real handler
28198 1:
28199     EXPORT_PC()
28200     move   a0, rPC         # arg0
28201     move   a1, rFP         # arg1
28202     move   a2, rSELF       # arg2
28203     JAL(dvmCheckBefore)
28204     jr     rBIX
28205
28206 /* ------------------------------ */
28207     .balign 128
28208 .L_ALT_OP_UNUSED_BAFF: /* 0x1ba */
28209 /* File: mips/alt_stub.S */
28210 /*
28211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28212  * any interesting requests and then jump to the real instruction
28213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28216  * bail to the real handler if breakFlags==0.
28217  */
28218     lbu    a3, offThread_breakFlags(rSELF)
28219     la     rBIX, dvmAsmInstructionStart + (442 * 128)
28220     lw     rIBASE, offThread_curHandlerTable(rSELF)
28221     bnez   a3, 1f
28222     jr     rBIX            # nothing to do - jump to real handler
28223 1:
28224     EXPORT_PC()
28225     move   a0, rPC         # arg0
28226     move   a1, rFP         # arg1
28227     move   a2, rSELF       # arg2
28228     JAL(dvmCheckBefore)
28229     jr     rBIX
28230
28231 /* ------------------------------ */
28232     .balign 128
28233 .L_ALT_OP_UNUSED_BBFF: /* 0x1bb */
28234 /* File: mips/alt_stub.S */
28235 /*
28236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28237  * any interesting requests and then jump to the real instruction
28238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28241  * bail to the real handler if breakFlags==0.
28242  */
28243     lbu    a3, offThread_breakFlags(rSELF)
28244     la     rBIX, dvmAsmInstructionStart + (443 * 128)
28245     lw     rIBASE, offThread_curHandlerTable(rSELF)
28246     bnez   a3, 1f
28247     jr     rBIX            # nothing to do - jump to real handler
28248 1:
28249     EXPORT_PC()
28250     move   a0, rPC         # arg0
28251     move   a1, rFP         # arg1
28252     move   a2, rSELF       # arg2
28253     JAL(dvmCheckBefore)
28254     jr     rBIX
28255
28256 /* ------------------------------ */
28257     .balign 128
28258 .L_ALT_OP_UNUSED_BCFF: /* 0x1bc */
28259 /* File: mips/alt_stub.S */
28260 /*
28261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28262  * any interesting requests and then jump to the real instruction
28263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28266  * bail to the real handler if breakFlags==0.
28267  */
28268     lbu    a3, offThread_breakFlags(rSELF)
28269     la     rBIX, dvmAsmInstructionStart + (444 * 128)
28270     lw     rIBASE, offThread_curHandlerTable(rSELF)
28271     bnez   a3, 1f
28272     jr     rBIX            # nothing to do - jump to real handler
28273 1:
28274     EXPORT_PC()
28275     move   a0, rPC         # arg0
28276     move   a1, rFP         # arg1
28277     move   a2, rSELF       # arg2
28278     JAL(dvmCheckBefore)
28279     jr     rBIX
28280
28281 /* ------------------------------ */
28282     .balign 128
28283 .L_ALT_OP_UNUSED_BDFF: /* 0x1bd */
28284 /* File: mips/alt_stub.S */
28285 /*
28286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28287  * any interesting requests and then jump to the real instruction
28288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28291  * bail to the real handler if breakFlags==0.
28292  */
28293     lbu    a3, offThread_breakFlags(rSELF)
28294     la     rBIX, dvmAsmInstructionStart + (445 * 128)
28295     lw     rIBASE, offThread_curHandlerTable(rSELF)
28296     bnez   a3, 1f
28297     jr     rBIX            # nothing to do - jump to real handler
28298 1:
28299     EXPORT_PC()
28300     move   a0, rPC         # arg0
28301     move   a1, rFP         # arg1
28302     move   a2, rSELF       # arg2
28303     JAL(dvmCheckBefore)
28304     jr     rBIX
28305
28306 /* ------------------------------ */
28307     .balign 128
28308 .L_ALT_OP_UNUSED_BEFF: /* 0x1be */
28309 /* File: mips/alt_stub.S */
28310 /*
28311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28312  * any interesting requests and then jump to the real instruction
28313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28316  * bail to the real handler if breakFlags==0.
28317  */
28318     lbu    a3, offThread_breakFlags(rSELF)
28319     la     rBIX, dvmAsmInstructionStart + (446 * 128)
28320     lw     rIBASE, offThread_curHandlerTable(rSELF)
28321     bnez   a3, 1f
28322     jr     rBIX            # nothing to do - jump to real handler
28323 1:
28324     EXPORT_PC()
28325     move   a0, rPC         # arg0
28326     move   a1, rFP         # arg1
28327     move   a2, rSELF       # arg2
28328     JAL(dvmCheckBefore)
28329     jr     rBIX
28330
28331 /* ------------------------------ */
28332     .balign 128
28333 .L_ALT_OP_UNUSED_BFFF: /* 0x1bf */
28334 /* File: mips/alt_stub.S */
28335 /*
28336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28337  * any interesting requests and then jump to the real instruction
28338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28341  * bail to the real handler if breakFlags==0.
28342  */
28343     lbu    a3, offThread_breakFlags(rSELF)
28344     la     rBIX, dvmAsmInstructionStart + (447 * 128)
28345     lw     rIBASE, offThread_curHandlerTable(rSELF)
28346     bnez   a3, 1f
28347     jr     rBIX            # nothing to do - jump to real handler
28348 1:
28349     EXPORT_PC()
28350     move   a0, rPC         # arg0
28351     move   a1, rFP         # arg1
28352     move   a2, rSELF       # arg2
28353     JAL(dvmCheckBefore)
28354     jr     rBIX
28355
28356 /* ------------------------------ */
28357     .balign 128
28358 .L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */
28359 /* File: mips/alt_stub.S */
28360 /*
28361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28362  * any interesting requests and then jump to the real instruction
28363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28366  * bail to the real handler if breakFlags==0.
28367  */
28368     lbu    a3, offThread_breakFlags(rSELF)
28369     la     rBIX, dvmAsmInstructionStart + (448 * 128)
28370     lw     rIBASE, offThread_curHandlerTable(rSELF)
28371     bnez   a3, 1f
28372     jr     rBIX            # nothing to do - jump to real handler
28373 1:
28374     EXPORT_PC()
28375     move   a0, rPC         # arg0
28376     move   a1, rFP         # arg1
28377     move   a2, rSELF       # arg2
28378     JAL(dvmCheckBefore)
28379     jr     rBIX
28380
28381 /* ------------------------------ */
28382     .balign 128
28383 .L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */
28384 /* File: mips/alt_stub.S */
28385 /*
28386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28387  * any interesting requests and then jump to the real instruction
28388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28391  * bail to the real handler if breakFlags==0.
28392  */
28393     lbu    a3, offThread_breakFlags(rSELF)
28394     la     rBIX, dvmAsmInstructionStart + (449 * 128)
28395     lw     rIBASE, offThread_curHandlerTable(rSELF)
28396     bnez   a3, 1f
28397     jr     rBIX            # nothing to do - jump to real handler
28398 1:
28399     EXPORT_PC()
28400     move   a0, rPC         # arg0
28401     move   a1, rFP         # arg1
28402     move   a2, rSELF       # arg2
28403     JAL(dvmCheckBefore)
28404     jr     rBIX
28405
28406 /* ------------------------------ */
28407     .balign 128
28408 .L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */
28409 /* File: mips/alt_stub.S */
28410 /*
28411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28412  * any interesting requests and then jump to the real instruction
28413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28416  * bail to the real handler if breakFlags==0.
28417  */
28418     lbu    a3, offThread_breakFlags(rSELF)
28419     la     rBIX, dvmAsmInstructionStart + (450 * 128)
28420     lw     rIBASE, offThread_curHandlerTable(rSELF)
28421     bnez   a3, 1f
28422     jr     rBIX            # nothing to do - jump to real handler
28423 1:
28424     EXPORT_PC()
28425     move   a0, rPC         # arg0
28426     move   a1, rFP         # arg1
28427     move   a2, rSELF       # arg2
28428     JAL(dvmCheckBefore)
28429     jr     rBIX
28430
28431 /* ------------------------------ */
28432     .balign 128
28433 .L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */
28434 /* File: mips/alt_stub.S */
28435 /*
28436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28437  * any interesting requests and then jump to the real instruction
28438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28441  * bail to the real handler if breakFlags==0.
28442  */
28443     lbu    a3, offThread_breakFlags(rSELF)
28444     la     rBIX, dvmAsmInstructionStart + (451 * 128)
28445     lw     rIBASE, offThread_curHandlerTable(rSELF)
28446     bnez   a3, 1f
28447     jr     rBIX            # nothing to do - jump to real handler
28448 1:
28449     EXPORT_PC()
28450     move   a0, rPC         # arg0
28451     move   a1, rFP         # arg1
28452     move   a2, rSELF       # arg2
28453     JAL(dvmCheckBefore)
28454     jr     rBIX
28455
28456 /* ------------------------------ */
28457     .balign 128
28458 .L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */
28459 /* File: mips/alt_stub.S */
28460 /*
28461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28462  * any interesting requests and then jump to the real instruction
28463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28466  * bail to the real handler if breakFlags==0.
28467  */
28468     lbu    a3, offThread_breakFlags(rSELF)
28469     la     rBIX, dvmAsmInstructionStart + (452 * 128)
28470     lw     rIBASE, offThread_curHandlerTable(rSELF)
28471     bnez   a3, 1f
28472     jr     rBIX            # nothing to do - jump to real handler
28473 1:
28474     EXPORT_PC()
28475     move   a0, rPC         # arg0
28476     move   a1, rFP         # arg1
28477     move   a2, rSELF       # arg2
28478     JAL(dvmCheckBefore)
28479     jr     rBIX
28480
28481 /* ------------------------------ */
28482     .balign 128
28483 .L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */
28484 /* File: mips/alt_stub.S */
28485 /*
28486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28487  * any interesting requests and then jump to the real instruction
28488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28491  * bail to the real handler if breakFlags==0.
28492  */
28493     lbu    a3, offThread_breakFlags(rSELF)
28494     la     rBIX, dvmAsmInstructionStart + (453 * 128)
28495     lw     rIBASE, offThread_curHandlerTable(rSELF)
28496     bnez   a3, 1f
28497     jr     rBIX            # nothing to do - jump to real handler
28498 1:
28499     EXPORT_PC()
28500     move   a0, rPC         # arg0
28501     move   a1, rFP         # arg1
28502     move   a2, rSELF       # arg2
28503     JAL(dvmCheckBefore)
28504     jr     rBIX
28505
28506 /* ------------------------------ */
28507     .balign 128
28508 .L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */
28509 /* File: mips/alt_stub.S */
28510 /*
28511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28512  * any interesting requests and then jump to the real instruction
28513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28516  * bail to the real handler if breakFlags==0.
28517  */
28518     lbu    a3, offThread_breakFlags(rSELF)
28519     la     rBIX, dvmAsmInstructionStart + (454 * 128)
28520     lw     rIBASE, offThread_curHandlerTable(rSELF)
28521     bnez   a3, 1f
28522     jr     rBIX            # nothing to do - jump to real handler
28523 1:
28524     EXPORT_PC()
28525     move   a0, rPC         # arg0
28526     move   a1, rFP         # arg1
28527     move   a2, rSELF       # arg2
28528     JAL(dvmCheckBefore)
28529     jr     rBIX
28530
28531 /* ------------------------------ */
28532     .balign 128
28533 .L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */
28534 /* File: mips/alt_stub.S */
28535 /*
28536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28537  * any interesting requests and then jump to the real instruction
28538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28541  * bail to the real handler if breakFlags==0.
28542  */
28543     lbu    a3, offThread_breakFlags(rSELF)
28544     la     rBIX, dvmAsmInstructionStart + (455 * 128)
28545     lw     rIBASE, offThread_curHandlerTable(rSELF)
28546     bnez   a3, 1f
28547     jr     rBIX            # nothing to do - jump to real handler
28548 1:
28549     EXPORT_PC()
28550     move   a0, rPC         # arg0
28551     move   a1, rFP         # arg1
28552     move   a2, rSELF       # arg2
28553     JAL(dvmCheckBefore)
28554     jr     rBIX
28555
28556 /* ------------------------------ */
28557     .balign 128
28558 .L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */
28559 /* File: mips/alt_stub.S */
28560 /*
28561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28562  * any interesting requests and then jump to the real instruction
28563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28566  * bail to the real handler if breakFlags==0.
28567  */
28568     lbu    a3, offThread_breakFlags(rSELF)
28569     la     rBIX, dvmAsmInstructionStart + (456 * 128)
28570     lw     rIBASE, offThread_curHandlerTable(rSELF)
28571     bnez   a3, 1f
28572     jr     rBIX            # nothing to do - jump to real handler
28573 1:
28574     EXPORT_PC()
28575     move   a0, rPC         # arg0
28576     move   a1, rFP         # arg1
28577     move   a2, rSELF       # arg2
28578     JAL(dvmCheckBefore)
28579     jr     rBIX
28580
28581 /* ------------------------------ */
28582     .balign 128
28583 .L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */
28584 /* File: mips/alt_stub.S */
28585 /*
28586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28587  * any interesting requests and then jump to the real instruction
28588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28591  * bail to the real handler if breakFlags==0.
28592  */
28593     lbu    a3, offThread_breakFlags(rSELF)
28594     la     rBIX, dvmAsmInstructionStart + (457 * 128)
28595     lw     rIBASE, offThread_curHandlerTable(rSELF)
28596     bnez   a3, 1f
28597     jr     rBIX            # nothing to do - jump to real handler
28598 1:
28599     EXPORT_PC()
28600     move   a0, rPC         # arg0
28601     move   a1, rFP         # arg1
28602     move   a2, rSELF       # arg2
28603     JAL(dvmCheckBefore)
28604     jr     rBIX
28605
28606 /* ------------------------------ */
28607     .balign 128
28608 .L_ALT_OP_UNUSED_CAFF: /* 0x1ca */
28609 /* File: mips/alt_stub.S */
28610 /*
28611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28612  * any interesting requests and then jump to the real instruction
28613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28616  * bail to the real handler if breakFlags==0.
28617  */
28618     lbu    a3, offThread_breakFlags(rSELF)
28619     la     rBIX, dvmAsmInstructionStart + (458 * 128)
28620     lw     rIBASE, offThread_curHandlerTable(rSELF)
28621     bnez   a3, 1f
28622     jr     rBIX            # nothing to do - jump to real handler
28623 1:
28624     EXPORT_PC()
28625     move   a0, rPC         # arg0
28626     move   a1, rFP         # arg1
28627     move   a2, rSELF       # arg2
28628     JAL(dvmCheckBefore)
28629     jr     rBIX
28630
28631 /* ------------------------------ */
28632     .balign 128
28633 .L_ALT_OP_UNUSED_CBFF: /* 0x1cb */
28634 /* File: mips/alt_stub.S */
28635 /*
28636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28637  * any interesting requests and then jump to the real instruction
28638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28641  * bail to the real handler if breakFlags==0.
28642  */
28643     lbu    a3, offThread_breakFlags(rSELF)
28644     la     rBIX, dvmAsmInstructionStart + (459 * 128)
28645     lw     rIBASE, offThread_curHandlerTable(rSELF)
28646     bnez   a3, 1f
28647     jr     rBIX            # nothing to do - jump to real handler
28648 1:
28649     EXPORT_PC()
28650     move   a0, rPC         # arg0
28651     move   a1, rFP         # arg1
28652     move   a2, rSELF       # arg2
28653     JAL(dvmCheckBefore)
28654     jr     rBIX
28655
28656 /* ------------------------------ */
28657     .balign 128
28658 .L_ALT_OP_UNUSED_CCFF: /* 0x1cc */
28659 /* File: mips/alt_stub.S */
28660 /*
28661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28662  * any interesting requests and then jump to the real instruction
28663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28666  * bail to the real handler if breakFlags==0.
28667  */
28668     lbu    a3, offThread_breakFlags(rSELF)
28669     la     rBIX, dvmAsmInstructionStart + (460 * 128)
28670     lw     rIBASE, offThread_curHandlerTable(rSELF)
28671     bnez   a3, 1f
28672     jr     rBIX            # nothing to do - jump to real handler
28673 1:
28674     EXPORT_PC()
28675     move   a0, rPC         # arg0
28676     move   a1, rFP         # arg1
28677     move   a2, rSELF       # arg2
28678     JAL(dvmCheckBefore)
28679     jr     rBIX
28680
28681 /* ------------------------------ */
28682     .balign 128
28683 .L_ALT_OP_UNUSED_CDFF: /* 0x1cd */
28684 /* File: mips/alt_stub.S */
28685 /*
28686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28687  * any interesting requests and then jump to the real instruction
28688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28691  * bail to the real handler if breakFlags==0.
28692  */
28693     lbu    a3, offThread_breakFlags(rSELF)
28694     la     rBIX, dvmAsmInstructionStart + (461 * 128)
28695     lw     rIBASE, offThread_curHandlerTable(rSELF)
28696     bnez   a3, 1f
28697     jr     rBIX            # nothing to do - jump to real handler
28698 1:
28699     EXPORT_PC()
28700     move   a0, rPC         # arg0
28701     move   a1, rFP         # arg1
28702     move   a2, rSELF       # arg2
28703     JAL(dvmCheckBefore)
28704     jr     rBIX
28705
28706 /* ------------------------------ */
28707     .balign 128
28708 .L_ALT_OP_UNUSED_CEFF: /* 0x1ce */
28709 /* File: mips/alt_stub.S */
28710 /*
28711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28712  * any interesting requests and then jump to the real instruction
28713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28716  * bail to the real handler if breakFlags==0.
28717  */
28718     lbu    a3, offThread_breakFlags(rSELF)
28719     la     rBIX, dvmAsmInstructionStart + (462 * 128)
28720     lw     rIBASE, offThread_curHandlerTable(rSELF)
28721     bnez   a3, 1f
28722     jr     rBIX            # nothing to do - jump to real handler
28723 1:
28724     EXPORT_PC()
28725     move   a0, rPC         # arg0
28726     move   a1, rFP         # arg1
28727     move   a2, rSELF       # arg2
28728     JAL(dvmCheckBefore)
28729     jr     rBIX
28730
28731 /* ------------------------------ */
28732     .balign 128
28733 .L_ALT_OP_UNUSED_CFFF: /* 0x1cf */
28734 /* File: mips/alt_stub.S */
28735 /*
28736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28737  * any interesting requests and then jump to the real instruction
28738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28741  * bail to the real handler if breakFlags==0.
28742  */
28743     lbu    a3, offThread_breakFlags(rSELF)
28744     la     rBIX, dvmAsmInstructionStart + (463 * 128)
28745     lw     rIBASE, offThread_curHandlerTable(rSELF)
28746     bnez   a3, 1f
28747     jr     rBIX            # nothing to do - jump to real handler
28748 1:
28749     EXPORT_PC()
28750     move   a0, rPC         # arg0
28751     move   a1, rFP         # arg1
28752     move   a2, rSELF       # arg2
28753     JAL(dvmCheckBefore)
28754     jr     rBIX
28755
28756 /* ------------------------------ */
28757     .balign 128
28758 .L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */
28759 /* File: mips/alt_stub.S */
28760 /*
28761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28762  * any interesting requests and then jump to the real instruction
28763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28766  * bail to the real handler if breakFlags==0.
28767  */
28768     lbu    a3, offThread_breakFlags(rSELF)
28769     la     rBIX, dvmAsmInstructionStart + (464 * 128)
28770     lw     rIBASE, offThread_curHandlerTable(rSELF)
28771     bnez   a3, 1f
28772     jr     rBIX            # nothing to do - jump to real handler
28773 1:
28774     EXPORT_PC()
28775     move   a0, rPC         # arg0
28776     move   a1, rFP         # arg1
28777     move   a2, rSELF       # arg2
28778     JAL(dvmCheckBefore)
28779     jr     rBIX
28780
28781 /* ------------------------------ */
28782     .balign 128
28783 .L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */
28784 /* File: mips/alt_stub.S */
28785 /*
28786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28787  * any interesting requests and then jump to the real instruction
28788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28791  * bail to the real handler if breakFlags==0.
28792  */
28793     lbu    a3, offThread_breakFlags(rSELF)
28794     la     rBIX, dvmAsmInstructionStart + (465 * 128)
28795     lw     rIBASE, offThread_curHandlerTable(rSELF)
28796     bnez   a3, 1f
28797     jr     rBIX            # nothing to do - jump to real handler
28798 1:
28799     EXPORT_PC()
28800     move   a0, rPC         # arg0
28801     move   a1, rFP         # arg1
28802     move   a2, rSELF       # arg2
28803     JAL(dvmCheckBefore)
28804     jr     rBIX
28805
28806 /* ------------------------------ */
28807     .balign 128
28808 .L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */
28809 /* File: mips/alt_stub.S */
28810 /*
28811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28812  * any interesting requests and then jump to the real instruction
28813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28816  * bail to the real handler if breakFlags==0.
28817  */
28818     lbu    a3, offThread_breakFlags(rSELF)
28819     la     rBIX, dvmAsmInstructionStart + (466 * 128)
28820     lw     rIBASE, offThread_curHandlerTable(rSELF)
28821     bnez   a3, 1f
28822     jr     rBIX            # nothing to do - jump to real handler
28823 1:
28824     EXPORT_PC()
28825     move   a0, rPC         # arg0
28826     move   a1, rFP         # arg1
28827     move   a2, rSELF       # arg2
28828     JAL(dvmCheckBefore)
28829     jr     rBIX
28830
28831 /* ------------------------------ */
28832     .balign 128
28833 .L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */
28834 /* File: mips/alt_stub.S */
28835 /*
28836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28837  * any interesting requests and then jump to the real instruction
28838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28841  * bail to the real handler if breakFlags==0.
28842  */
28843     lbu    a3, offThread_breakFlags(rSELF)
28844     la     rBIX, dvmAsmInstructionStart + (467 * 128)
28845     lw     rIBASE, offThread_curHandlerTable(rSELF)
28846     bnez   a3, 1f
28847     jr     rBIX            # nothing to do - jump to real handler
28848 1:
28849     EXPORT_PC()
28850     move   a0, rPC         # arg0
28851     move   a1, rFP         # arg1
28852     move   a2, rSELF       # arg2
28853     JAL(dvmCheckBefore)
28854     jr     rBIX
28855
28856 /* ------------------------------ */
28857     .balign 128
28858 .L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */
28859 /* File: mips/alt_stub.S */
28860 /*
28861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28862  * any interesting requests and then jump to the real instruction
28863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28866  * bail to the real handler if breakFlags==0.
28867  */
28868     lbu    a3, offThread_breakFlags(rSELF)
28869     la     rBIX, dvmAsmInstructionStart + (468 * 128)
28870     lw     rIBASE, offThread_curHandlerTable(rSELF)
28871     bnez   a3, 1f
28872     jr     rBIX            # nothing to do - jump to real handler
28873 1:
28874     EXPORT_PC()
28875     move   a0, rPC         # arg0
28876     move   a1, rFP         # arg1
28877     move   a2, rSELF       # arg2
28878     JAL(dvmCheckBefore)
28879     jr     rBIX
28880
28881 /* ------------------------------ */
28882     .balign 128
28883 .L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */
28884 /* File: mips/alt_stub.S */
28885 /*
28886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28887  * any interesting requests and then jump to the real instruction
28888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28891  * bail to the real handler if breakFlags==0.
28892  */
28893     lbu    a3, offThread_breakFlags(rSELF)
28894     la     rBIX, dvmAsmInstructionStart + (469 * 128)
28895     lw     rIBASE, offThread_curHandlerTable(rSELF)
28896     bnez   a3, 1f
28897     jr     rBIX            # nothing to do - jump to real handler
28898 1:
28899     EXPORT_PC()
28900     move   a0, rPC         # arg0
28901     move   a1, rFP         # arg1
28902     move   a2, rSELF       # arg2
28903     JAL(dvmCheckBefore)
28904     jr     rBIX
28905
28906 /* ------------------------------ */
28907     .balign 128
28908 .L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */
28909 /* File: mips/alt_stub.S */
28910 /*
28911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28912  * any interesting requests and then jump to the real instruction
28913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28916  * bail to the real handler if breakFlags==0.
28917  */
28918     lbu    a3, offThread_breakFlags(rSELF)
28919     la     rBIX, dvmAsmInstructionStart + (470 * 128)
28920     lw     rIBASE, offThread_curHandlerTable(rSELF)
28921     bnez   a3, 1f
28922     jr     rBIX            # nothing to do - jump to real handler
28923 1:
28924     EXPORT_PC()
28925     move   a0, rPC         # arg0
28926     move   a1, rFP         # arg1
28927     move   a2, rSELF       # arg2
28928     JAL(dvmCheckBefore)
28929     jr     rBIX
28930
28931 /* ------------------------------ */
28932     .balign 128
28933 .L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */
28934 /* File: mips/alt_stub.S */
28935 /*
28936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28937  * any interesting requests and then jump to the real instruction
28938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28941  * bail to the real handler if breakFlags==0.
28942  */
28943     lbu    a3, offThread_breakFlags(rSELF)
28944     la     rBIX, dvmAsmInstructionStart + (471 * 128)
28945     lw     rIBASE, offThread_curHandlerTable(rSELF)
28946     bnez   a3, 1f
28947     jr     rBIX            # nothing to do - jump to real handler
28948 1:
28949     EXPORT_PC()
28950     move   a0, rPC         # arg0
28951     move   a1, rFP         # arg1
28952     move   a2, rSELF       # arg2
28953     JAL(dvmCheckBefore)
28954     jr     rBIX
28955
28956 /* ------------------------------ */
28957     .balign 128
28958 .L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */
28959 /* File: mips/alt_stub.S */
28960 /*
28961  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28962  * any interesting requests and then jump to the real instruction
28963  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28964  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28965  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28966  * bail to the real handler if breakFlags==0.
28967  */
28968     lbu    a3, offThread_breakFlags(rSELF)
28969     la     rBIX, dvmAsmInstructionStart + (472 * 128)
28970     lw     rIBASE, offThread_curHandlerTable(rSELF)
28971     bnez   a3, 1f
28972     jr     rBIX            # nothing to do - jump to real handler
28973 1:
28974     EXPORT_PC()
28975     move   a0, rPC         # arg0
28976     move   a1, rFP         # arg1
28977     move   a2, rSELF       # arg2
28978     JAL(dvmCheckBefore)
28979     jr     rBIX
28980
28981 /* ------------------------------ */
28982     .balign 128
28983 .L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */
28984 /* File: mips/alt_stub.S */
28985 /*
28986  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
28987  * any interesting requests and then jump to the real instruction
28988  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
28989  * rIBASE updates won't be seen until a refresh, and we can tell we have a
28990  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
28991  * bail to the real handler if breakFlags==0.
28992  */
28993     lbu    a3, offThread_breakFlags(rSELF)
28994     la     rBIX, dvmAsmInstructionStart + (473 * 128)
28995     lw     rIBASE, offThread_curHandlerTable(rSELF)
28996     bnez   a3, 1f
28997     jr     rBIX            # nothing to do - jump to real handler
28998 1:
28999     EXPORT_PC()
29000     move   a0, rPC         # arg0
29001     move   a1, rFP         # arg1
29002     move   a2, rSELF       # arg2
29003     JAL(dvmCheckBefore)
29004     jr     rBIX
29005
29006 /* ------------------------------ */
29007     .balign 128
29008 .L_ALT_OP_UNUSED_DAFF: /* 0x1da */
29009 /* File: mips/alt_stub.S */
29010 /*
29011  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29012  * any interesting requests and then jump to the real instruction
29013  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29014  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29015  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29016  * bail to the real handler if breakFlags==0.
29017  */
29018     lbu    a3, offThread_breakFlags(rSELF)
29019     la     rBIX, dvmAsmInstructionStart + (474 * 128)
29020     lw     rIBASE, offThread_curHandlerTable(rSELF)
29021     bnez   a3, 1f
29022     jr     rBIX            # nothing to do - jump to real handler
29023 1:
29024     EXPORT_PC()
29025     move   a0, rPC         # arg0
29026     move   a1, rFP         # arg1
29027     move   a2, rSELF       # arg2
29028     JAL(dvmCheckBefore)
29029     jr     rBIX
29030
29031 /* ------------------------------ */
29032     .balign 128
29033 .L_ALT_OP_UNUSED_DBFF: /* 0x1db */
29034 /* File: mips/alt_stub.S */
29035 /*
29036  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29037  * any interesting requests and then jump to the real instruction
29038  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29039  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29040  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29041  * bail to the real handler if breakFlags==0.
29042  */
29043     lbu    a3, offThread_breakFlags(rSELF)
29044     la     rBIX, dvmAsmInstructionStart + (475 * 128)
29045     lw     rIBASE, offThread_curHandlerTable(rSELF)
29046     bnez   a3, 1f
29047     jr     rBIX            # nothing to do - jump to real handler
29048 1:
29049     EXPORT_PC()
29050     move   a0, rPC         # arg0
29051     move   a1, rFP         # arg1
29052     move   a2, rSELF       # arg2
29053     JAL(dvmCheckBefore)
29054     jr     rBIX
29055
29056 /* ------------------------------ */
29057     .balign 128
29058 .L_ALT_OP_UNUSED_DCFF: /* 0x1dc */
29059 /* File: mips/alt_stub.S */
29060 /*
29061  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29062  * any interesting requests and then jump to the real instruction
29063  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29064  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29065  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29066  * bail to the real handler if breakFlags==0.
29067  */
29068     lbu    a3, offThread_breakFlags(rSELF)
29069     la     rBIX, dvmAsmInstructionStart + (476 * 128)
29070     lw     rIBASE, offThread_curHandlerTable(rSELF)
29071     bnez   a3, 1f
29072     jr     rBIX            # nothing to do - jump to real handler
29073 1:
29074     EXPORT_PC()
29075     move   a0, rPC         # arg0
29076     move   a1, rFP         # arg1
29077     move   a2, rSELF       # arg2
29078     JAL(dvmCheckBefore)
29079     jr     rBIX
29080
29081 /* ------------------------------ */
29082     .balign 128
29083 .L_ALT_OP_UNUSED_DDFF: /* 0x1dd */
29084 /* File: mips/alt_stub.S */
29085 /*
29086  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29087  * any interesting requests and then jump to the real instruction
29088  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29089  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29090  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29091  * bail to the real handler if breakFlags==0.
29092  */
29093     lbu    a3, offThread_breakFlags(rSELF)
29094     la     rBIX, dvmAsmInstructionStart + (477 * 128)
29095     lw     rIBASE, offThread_curHandlerTable(rSELF)
29096     bnez   a3, 1f
29097     jr     rBIX            # nothing to do - jump to real handler
29098 1:
29099     EXPORT_PC()
29100     move   a0, rPC         # arg0
29101     move   a1, rFP         # arg1
29102     move   a2, rSELF       # arg2
29103     JAL(dvmCheckBefore)
29104     jr     rBIX
29105
29106 /* ------------------------------ */
29107     .balign 128
29108 .L_ALT_OP_UNUSED_DEFF: /* 0x1de */
29109 /* File: mips/alt_stub.S */
29110 /*
29111  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29112  * any interesting requests and then jump to the real instruction
29113  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29114  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29115  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29116  * bail to the real handler if breakFlags==0.
29117  */
29118     lbu    a3, offThread_breakFlags(rSELF)
29119     la     rBIX, dvmAsmInstructionStart + (478 * 128)
29120     lw     rIBASE, offThread_curHandlerTable(rSELF)
29121     bnez   a3, 1f
29122     jr     rBIX            # nothing to do - jump to real handler
29123 1:
29124     EXPORT_PC()
29125     move   a0, rPC         # arg0
29126     move   a1, rFP         # arg1
29127     move   a2, rSELF       # arg2
29128     JAL(dvmCheckBefore)
29129     jr     rBIX
29130
29131 /* ------------------------------ */
29132     .balign 128
29133 .L_ALT_OP_UNUSED_DFFF: /* 0x1df */
29134 /* File: mips/alt_stub.S */
29135 /*
29136  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29137  * any interesting requests and then jump to the real instruction
29138  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29139  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29140  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29141  * bail to the real handler if breakFlags==0.
29142  */
29143     lbu    a3, offThread_breakFlags(rSELF)
29144     la     rBIX, dvmAsmInstructionStart + (479 * 128)
29145     lw     rIBASE, offThread_curHandlerTable(rSELF)
29146     bnez   a3, 1f
29147     jr     rBIX            # nothing to do - jump to real handler
29148 1:
29149     EXPORT_PC()
29150     move   a0, rPC         # arg0
29151     move   a1, rFP         # arg1
29152     move   a2, rSELF       # arg2
29153     JAL(dvmCheckBefore)
29154     jr     rBIX
29155
29156 /* ------------------------------ */
29157     .balign 128
29158 .L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */
29159 /* File: mips/alt_stub.S */
29160 /*
29161  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29162  * any interesting requests and then jump to the real instruction
29163  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29164  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29165  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29166  * bail to the real handler if breakFlags==0.
29167  */
29168     lbu    a3, offThread_breakFlags(rSELF)
29169     la     rBIX, dvmAsmInstructionStart + (480 * 128)
29170     lw     rIBASE, offThread_curHandlerTable(rSELF)
29171     bnez   a3, 1f
29172     jr     rBIX            # nothing to do - jump to real handler
29173 1:
29174     EXPORT_PC()
29175     move   a0, rPC         # arg0
29176     move   a1, rFP         # arg1
29177     move   a2, rSELF       # arg2
29178     JAL(dvmCheckBefore)
29179     jr     rBIX
29180
29181 /* ------------------------------ */
29182     .balign 128
29183 .L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */
29184 /* File: mips/alt_stub.S */
29185 /*
29186  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29187  * any interesting requests and then jump to the real instruction
29188  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29189  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29190  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29191  * bail to the real handler if breakFlags==0.
29192  */
29193     lbu    a3, offThread_breakFlags(rSELF)
29194     la     rBIX, dvmAsmInstructionStart + (481 * 128)
29195     lw     rIBASE, offThread_curHandlerTable(rSELF)
29196     bnez   a3, 1f
29197     jr     rBIX            # nothing to do - jump to real handler
29198 1:
29199     EXPORT_PC()
29200     move   a0, rPC         # arg0
29201     move   a1, rFP         # arg1
29202     move   a2, rSELF       # arg2
29203     JAL(dvmCheckBefore)
29204     jr     rBIX
29205
29206 /* ------------------------------ */
29207     .balign 128
29208 .L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */
29209 /* File: mips/alt_stub.S */
29210 /*
29211  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29212  * any interesting requests and then jump to the real instruction
29213  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29214  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29215  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29216  * bail to the real handler if breakFlags==0.
29217  */
29218     lbu    a3, offThread_breakFlags(rSELF)
29219     la     rBIX, dvmAsmInstructionStart + (482 * 128)
29220     lw     rIBASE, offThread_curHandlerTable(rSELF)
29221     bnez   a3, 1f
29222     jr     rBIX            # nothing to do - jump to real handler
29223 1:
29224     EXPORT_PC()
29225     move   a0, rPC         # arg0
29226     move   a1, rFP         # arg1
29227     move   a2, rSELF       # arg2
29228     JAL(dvmCheckBefore)
29229     jr     rBIX
29230
29231 /* ------------------------------ */
29232     .balign 128
29233 .L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */
29234 /* File: mips/alt_stub.S */
29235 /*
29236  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29237  * any interesting requests and then jump to the real instruction
29238  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29239  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29240  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29241  * bail to the real handler if breakFlags==0.
29242  */
29243     lbu    a3, offThread_breakFlags(rSELF)
29244     la     rBIX, dvmAsmInstructionStart + (483 * 128)
29245     lw     rIBASE, offThread_curHandlerTable(rSELF)
29246     bnez   a3, 1f
29247     jr     rBIX            # nothing to do - jump to real handler
29248 1:
29249     EXPORT_PC()
29250     move   a0, rPC         # arg0
29251     move   a1, rFP         # arg1
29252     move   a2, rSELF       # arg2
29253     JAL(dvmCheckBefore)
29254     jr     rBIX
29255
29256 /* ------------------------------ */
29257     .balign 128
29258 .L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */
29259 /* File: mips/alt_stub.S */
29260 /*
29261  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29262  * any interesting requests and then jump to the real instruction
29263  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29264  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29265  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29266  * bail to the real handler if breakFlags==0.
29267  */
29268     lbu    a3, offThread_breakFlags(rSELF)
29269     la     rBIX, dvmAsmInstructionStart + (484 * 128)
29270     lw     rIBASE, offThread_curHandlerTable(rSELF)
29271     bnez   a3, 1f
29272     jr     rBIX            # nothing to do - jump to real handler
29273 1:
29274     EXPORT_PC()
29275     move   a0, rPC         # arg0
29276     move   a1, rFP         # arg1
29277     move   a2, rSELF       # arg2
29278     JAL(dvmCheckBefore)
29279     jr     rBIX
29280
29281 /* ------------------------------ */
29282     .balign 128
29283 .L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */
29284 /* File: mips/alt_stub.S */
29285 /*
29286  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29287  * any interesting requests and then jump to the real instruction
29288  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29289  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29290  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29291  * bail to the real handler if breakFlags==0.
29292  */
29293     lbu    a3, offThread_breakFlags(rSELF)
29294     la     rBIX, dvmAsmInstructionStart + (485 * 128)
29295     lw     rIBASE, offThread_curHandlerTable(rSELF)
29296     bnez   a3, 1f
29297     jr     rBIX            # nothing to do - jump to real handler
29298 1:
29299     EXPORT_PC()
29300     move   a0, rPC         # arg0
29301     move   a1, rFP         # arg1
29302     move   a2, rSELF       # arg2
29303     JAL(dvmCheckBefore)
29304     jr     rBIX
29305
29306 /* ------------------------------ */
29307     .balign 128
29308 .L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */
29309 /* File: mips/alt_stub.S */
29310 /*
29311  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29312  * any interesting requests and then jump to the real instruction
29313  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29314  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29315  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29316  * bail to the real handler if breakFlags==0.
29317  */
29318     lbu    a3, offThread_breakFlags(rSELF)
29319     la     rBIX, dvmAsmInstructionStart + (486 * 128)
29320     lw     rIBASE, offThread_curHandlerTable(rSELF)
29321     bnez   a3, 1f
29322     jr     rBIX            # nothing to do - jump to real handler
29323 1:
29324     EXPORT_PC()
29325     move   a0, rPC         # arg0
29326     move   a1, rFP         # arg1
29327     move   a2, rSELF       # arg2
29328     JAL(dvmCheckBefore)
29329     jr     rBIX
29330
29331 /* ------------------------------ */
29332     .balign 128
29333 .L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */
29334 /* File: mips/alt_stub.S */
29335 /*
29336  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29337  * any interesting requests and then jump to the real instruction
29338  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29339  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29340  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29341  * bail to the real handler if breakFlags==0.
29342  */
29343     lbu    a3, offThread_breakFlags(rSELF)
29344     la     rBIX, dvmAsmInstructionStart + (487 * 128)
29345     lw     rIBASE, offThread_curHandlerTable(rSELF)
29346     bnez   a3, 1f
29347     jr     rBIX            # nothing to do - jump to real handler
29348 1:
29349     EXPORT_PC()
29350     move   a0, rPC         # arg0
29351     move   a1, rFP         # arg1
29352     move   a2, rSELF       # arg2
29353     JAL(dvmCheckBefore)
29354     jr     rBIX
29355
29356 /* ------------------------------ */
29357     .balign 128
29358 .L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */
29359 /* File: mips/alt_stub.S */
29360 /*
29361  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29362  * any interesting requests and then jump to the real instruction
29363  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29364  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29365  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29366  * bail to the real handler if breakFlags==0.
29367  */
29368     lbu    a3, offThread_breakFlags(rSELF)
29369     la     rBIX, dvmAsmInstructionStart + (488 * 128)
29370     lw     rIBASE, offThread_curHandlerTable(rSELF)
29371     bnez   a3, 1f
29372     jr     rBIX            # nothing to do - jump to real handler
29373 1:
29374     EXPORT_PC()
29375     move   a0, rPC         # arg0
29376     move   a1, rFP         # arg1
29377     move   a2, rSELF       # arg2
29378     JAL(dvmCheckBefore)
29379     jr     rBIX
29380
29381 /* ------------------------------ */
29382     .balign 128
29383 .L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */
29384 /* File: mips/alt_stub.S */
29385 /*
29386  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29387  * any interesting requests and then jump to the real instruction
29388  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29389  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29390  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29391  * bail to the real handler if breakFlags==0.
29392  */
29393     lbu    a3, offThread_breakFlags(rSELF)
29394     la     rBIX, dvmAsmInstructionStart + (489 * 128)
29395     lw     rIBASE, offThread_curHandlerTable(rSELF)
29396     bnez   a3, 1f
29397     jr     rBIX            # nothing to do - jump to real handler
29398 1:
29399     EXPORT_PC()
29400     move   a0, rPC         # arg0
29401     move   a1, rFP         # arg1
29402     move   a2, rSELF       # arg2
29403     JAL(dvmCheckBefore)
29404     jr     rBIX
29405
29406 /* ------------------------------ */
29407     .balign 128
29408 .L_ALT_OP_UNUSED_EAFF: /* 0x1ea */
29409 /* File: mips/alt_stub.S */
29410 /*
29411  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29412  * any interesting requests and then jump to the real instruction
29413  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29414  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29415  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29416  * bail to the real handler if breakFlags==0.
29417  */
29418     lbu    a3, offThread_breakFlags(rSELF)
29419     la     rBIX, dvmAsmInstructionStart + (490 * 128)
29420     lw     rIBASE, offThread_curHandlerTable(rSELF)
29421     bnez   a3, 1f
29422     jr     rBIX            # nothing to do - jump to real handler
29423 1:
29424     EXPORT_PC()
29425     move   a0, rPC         # arg0
29426     move   a1, rFP         # arg1
29427     move   a2, rSELF       # arg2
29428     JAL(dvmCheckBefore)
29429     jr     rBIX
29430
29431 /* ------------------------------ */
29432     .balign 128
29433 .L_ALT_OP_UNUSED_EBFF: /* 0x1eb */
29434 /* File: mips/alt_stub.S */
29435 /*
29436  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29437  * any interesting requests and then jump to the real instruction
29438  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29439  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29440  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29441  * bail to the real handler if breakFlags==0.
29442  */
29443     lbu    a3, offThread_breakFlags(rSELF)
29444     la     rBIX, dvmAsmInstructionStart + (491 * 128)
29445     lw     rIBASE, offThread_curHandlerTable(rSELF)
29446     bnez   a3, 1f
29447     jr     rBIX            # nothing to do - jump to real handler
29448 1:
29449     EXPORT_PC()
29450     move   a0, rPC         # arg0
29451     move   a1, rFP         # arg1
29452     move   a2, rSELF       # arg2
29453     JAL(dvmCheckBefore)
29454     jr     rBIX
29455
29456 /* ------------------------------ */
29457     .balign 128
29458 .L_ALT_OP_UNUSED_ECFF: /* 0x1ec */
29459 /* File: mips/alt_stub.S */
29460 /*
29461  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29462  * any interesting requests and then jump to the real instruction
29463  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29464  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29465  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29466  * bail to the real handler if breakFlags==0.
29467  */
29468     lbu    a3, offThread_breakFlags(rSELF)
29469     la     rBIX, dvmAsmInstructionStart + (492 * 128)
29470     lw     rIBASE, offThread_curHandlerTable(rSELF)
29471     bnez   a3, 1f
29472     jr     rBIX            # nothing to do - jump to real handler
29473 1:
29474     EXPORT_PC()
29475     move   a0, rPC         # arg0
29476     move   a1, rFP         # arg1
29477     move   a2, rSELF       # arg2
29478     JAL(dvmCheckBefore)
29479     jr     rBIX
29480
29481 /* ------------------------------ */
29482     .balign 128
29483 .L_ALT_OP_UNUSED_EDFF: /* 0x1ed */
29484 /* File: mips/alt_stub.S */
29485 /*
29486  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29487  * any interesting requests and then jump to the real instruction
29488  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29489  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29490  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29491  * bail to the real handler if breakFlags==0.
29492  */
29493     lbu    a3, offThread_breakFlags(rSELF)
29494     la     rBIX, dvmAsmInstructionStart + (493 * 128)
29495     lw     rIBASE, offThread_curHandlerTable(rSELF)
29496     bnez   a3, 1f
29497     jr     rBIX            # nothing to do - jump to real handler
29498 1:
29499     EXPORT_PC()
29500     move   a0, rPC         # arg0
29501     move   a1, rFP         # arg1
29502     move   a2, rSELF       # arg2
29503     JAL(dvmCheckBefore)
29504     jr     rBIX
29505
29506 /* ------------------------------ */
29507     .balign 128
29508 .L_ALT_OP_UNUSED_EEFF: /* 0x1ee */
29509 /* File: mips/alt_stub.S */
29510 /*
29511  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29512  * any interesting requests and then jump to the real instruction
29513  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29514  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29515  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29516  * bail to the real handler if breakFlags==0.
29517  */
29518     lbu    a3, offThread_breakFlags(rSELF)
29519     la     rBIX, dvmAsmInstructionStart + (494 * 128)
29520     lw     rIBASE, offThread_curHandlerTable(rSELF)
29521     bnez   a3, 1f
29522     jr     rBIX            # nothing to do - jump to real handler
29523 1:
29524     EXPORT_PC()
29525     move   a0, rPC         # arg0
29526     move   a1, rFP         # arg1
29527     move   a2, rSELF       # arg2
29528     JAL(dvmCheckBefore)
29529     jr     rBIX
29530
29531 /* ------------------------------ */
29532     .balign 128
29533 .L_ALT_OP_UNUSED_EFFF: /* 0x1ef */
29534 /* File: mips/alt_stub.S */
29535 /*
29536  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29537  * any interesting requests and then jump to the real instruction
29538  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29539  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29540  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29541  * bail to the real handler if breakFlags==0.
29542  */
29543     lbu    a3, offThread_breakFlags(rSELF)
29544     la     rBIX, dvmAsmInstructionStart + (495 * 128)
29545     lw     rIBASE, offThread_curHandlerTable(rSELF)
29546     bnez   a3, 1f
29547     jr     rBIX            # nothing to do - jump to real handler
29548 1:
29549     EXPORT_PC()
29550     move   a0, rPC         # arg0
29551     move   a1, rFP         # arg1
29552     move   a2, rSELF       # arg2
29553     JAL(dvmCheckBefore)
29554     jr     rBIX
29555
29556 /* ------------------------------ */
29557     .balign 128
29558 .L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */
29559 /* File: mips/alt_stub.S */
29560 /*
29561  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29562  * any interesting requests and then jump to the real instruction
29563  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29564  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29565  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29566  * bail to the real handler if breakFlags==0.
29567  */
29568     lbu    a3, offThread_breakFlags(rSELF)
29569     la     rBIX, dvmAsmInstructionStart + (496 * 128)
29570     lw     rIBASE, offThread_curHandlerTable(rSELF)
29571     bnez   a3, 1f
29572     jr     rBIX            # nothing to do - jump to real handler
29573 1:
29574     EXPORT_PC()
29575     move   a0, rPC         # arg0
29576     move   a1, rFP         # arg1
29577     move   a2, rSELF       # arg2
29578     JAL(dvmCheckBefore)
29579     jr     rBIX
29580
29581 /* ------------------------------ */
29582     .balign 128
29583 .L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */
29584 /* File: mips/alt_stub.S */
29585 /*
29586  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29587  * any interesting requests and then jump to the real instruction
29588  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29589  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29590  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29591  * bail to the real handler if breakFlags==0.
29592  */
29593     lbu    a3, offThread_breakFlags(rSELF)
29594     la     rBIX, dvmAsmInstructionStart + (497 * 128)
29595     lw     rIBASE, offThread_curHandlerTable(rSELF)
29596     bnez   a3, 1f
29597     jr     rBIX            # nothing to do - jump to real handler
29598 1:
29599     EXPORT_PC()
29600     move   a0, rPC         # arg0
29601     move   a1, rFP         # arg1
29602     move   a2, rSELF       # arg2
29603     JAL(dvmCheckBefore)
29604     jr     rBIX
29605
29606 /* ------------------------------ */
29607     .balign 128
29608 .L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */
29609 /* File: mips/alt_stub.S */
29610 /*
29611  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29612  * any interesting requests and then jump to the real instruction
29613  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29614  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29615  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29616  * bail to the real handler if breakFlags==0.
29617  */
29618     lbu    a3, offThread_breakFlags(rSELF)
29619     la     rBIX, dvmAsmInstructionStart + (498 * 128)
29620     lw     rIBASE, offThread_curHandlerTable(rSELF)
29621     bnez   a3, 1f
29622     jr     rBIX            # nothing to do - jump to real handler
29623 1:
29624     EXPORT_PC()
29625     move   a0, rPC         # arg0
29626     move   a1, rFP         # arg1
29627     move   a2, rSELF       # arg2
29628     JAL(dvmCheckBefore)
29629     jr     rBIX
29630
29631 /* ------------------------------ */
29632     .balign 128
29633 .L_ALT_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */
29634 /* File: mips/alt_stub.S */
29635 /*
29636  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29637  * any interesting requests and then jump to the real instruction
29638  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29639  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29640  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29641  * bail to the real handler if breakFlags==0.
29642  */
29643     lbu    a3, offThread_breakFlags(rSELF)
29644     la     rBIX, dvmAsmInstructionStart + (499 * 128)
29645     lw     rIBASE, offThread_curHandlerTable(rSELF)
29646     bnez   a3, 1f
29647     jr     rBIX            # nothing to do - jump to real handler
29648 1:
29649     EXPORT_PC()
29650     move   a0, rPC         # arg0
29651     move   a1, rFP         # arg1
29652     move   a2, rSELF       # arg2
29653     JAL(dvmCheckBefore)
29654     jr     rBIX
29655
29656 /* ------------------------------ */
29657     .balign 128
29658 .L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */
29659 /* File: mips/alt_stub.S */
29660 /*
29661  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29662  * any interesting requests and then jump to the real instruction
29663  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29664  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29665  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29666  * bail to the real handler if breakFlags==0.
29667  */
29668     lbu    a3, offThread_breakFlags(rSELF)
29669     la     rBIX, dvmAsmInstructionStart + (500 * 128)
29670     lw     rIBASE, offThread_curHandlerTable(rSELF)
29671     bnez   a3, 1f
29672     jr     rBIX            # nothing to do - jump to real handler
29673 1:
29674     EXPORT_PC()
29675     move   a0, rPC         # arg0
29676     move   a1, rFP         # arg1
29677     move   a2, rSELF       # arg2
29678     JAL(dvmCheckBefore)
29679     jr     rBIX
29680
29681 /* ------------------------------ */
29682     .balign 128
29683 .L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */
29684 /* File: mips/alt_stub.S */
29685 /*
29686  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29687  * any interesting requests and then jump to the real instruction
29688  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29689  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29690  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29691  * bail to the real handler if breakFlags==0.
29692  */
29693     lbu    a3, offThread_breakFlags(rSELF)
29694     la     rBIX, dvmAsmInstructionStart + (501 * 128)
29695     lw     rIBASE, offThread_curHandlerTable(rSELF)
29696     bnez   a3, 1f
29697     jr     rBIX            # nothing to do - jump to real handler
29698 1:
29699     EXPORT_PC()
29700     move   a0, rPC         # arg0
29701     move   a1, rFP         # arg1
29702     move   a2, rSELF       # arg2
29703     JAL(dvmCheckBefore)
29704     jr     rBIX
29705
29706 /* ------------------------------ */
29707     .balign 128
29708 .L_ALT_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */
29709 /* File: mips/alt_stub.S */
29710 /*
29711  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29712  * any interesting requests and then jump to the real instruction
29713  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29714  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29715  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29716  * bail to the real handler if breakFlags==0.
29717  */
29718     lbu    a3, offThread_breakFlags(rSELF)
29719     la     rBIX, dvmAsmInstructionStart + (502 * 128)
29720     lw     rIBASE, offThread_curHandlerTable(rSELF)
29721     bnez   a3, 1f
29722     jr     rBIX            # nothing to do - jump to real handler
29723 1:
29724     EXPORT_PC()
29725     move   a0, rPC         # arg0
29726     move   a1, rFP         # arg1
29727     move   a2, rSELF       # arg2
29728     JAL(dvmCheckBefore)
29729     jr     rBIX
29730
29731 /* ------------------------------ */
29732     .balign 128
29733 .L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */
29734 /* File: mips/alt_stub.S */
29735 /*
29736  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29737  * any interesting requests and then jump to the real instruction
29738  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29739  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29740  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29741  * bail to the real handler if breakFlags==0.
29742  */
29743     lbu    a3, offThread_breakFlags(rSELF)
29744     la     rBIX, dvmAsmInstructionStart + (503 * 128)
29745     lw     rIBASE, offThread_curHandlerTable(rSELF)
29746     bnez   a3, 1f
29747     jr     rBIX            # nothing to do - jump to real handler
29748 1:
29749     EXPORT_PC()
29750     move   a0, rPC         # arg0
29751     move   a1, rFP         # arg1
29752     move   a2, rSELF       # arg2
29753     JAL(dvmCheckBefore)
29754     jr     rBIX
29755
29756 /* ------------------------------ */
29757     .balign 128
29758 .L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */
29759 /* File: mips/alt_stub.S */
29760 /*
29761  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29762  * any interesting requests and then jump to the real instruction
29763  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29764  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29765  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29766  * bail to the real handler if breakFlags==0.
29767  */
29768     lbu    a3, offThread_breakFlags(rSELF)
29769     la     rBIX, dvmAsmInstructionStart + (504 * 128)
29770     lw     rIBASE, offThread_curHandlerTable(rSELF)
29771     bnez   a3, 1f
29772     jr     rBIX            # nothing to do - jump to real handler
29773 1:
29774     EXPORT_PC()
29775     move   a0, rPC         # arg0
29776     move   a1, rFP         # arg1
29777     move   a2, rSELF       # arg2
29778     JAL(dvmCheckBefore)
29779     jr     rBIX
29780
29781 /* ------------------------------ */
29782     .balign 128
29783 .L_ALT_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */
29784 /* File: mips/alt_stub.S */
29785 /*
29786  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29787  * any interesting requests and then jump to the real instruction
29788  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29789  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29790  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29791  * bail to the real handler if breakFlags==0.
29792  */
29793     lbu    a3, offThread_breakFlags(rSELF)
29794     la     rBIX, dvmAsmInstructionStart + (505 * 128)
29795     lw     rIBASE, offThread_curHandlerTable(rSELF)
29796     bnez   a3, 1f
29797     jr     rBIX            # nothing to do - jump to real handler
29798 1:
29799     EXPORT_PC()
29800     move   a0, rPC         # arg0
29801     move   a1, rFP         # arg1
29802     move   a2, rSELF       # arg2
29803     JAL(dvmCheckBefore)
29804     jr     rBIX
29805
29806 /* ------------------------------ */
29807     .balign 128
29808 .L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */
29809 /* File: mips/alt_stub.S */
29810 /*
29811  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29812  * any interesting requests and then jump to the real instruction
29813  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29814  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29815  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29816  * bail to the real handler if breakFlags==0.
29817  */
29818     lbu    a3, offThread_breakFlags(rSELF)
29819     la     rBIX, dvmAsmInstructionStart + (506 * 128)
29820     lw     rIBASE, offThread_curHandlerTable(rSELF)
29821     bnez   a3, 1f
29822     jr     rBIX            # nothing to do - jump to real handler
29823 1:
29824     EXPORT_PC()
29825     move   a0, rPC         # arg0
29826     move   a1, rFP         # arg1
29827     move   a2, rSELF       # arg2
29828     JAL(dvmCheckBefore)
29829     jr     rBIX
29830
29831 /* ------------------------------ */
29832     .balign 128
29833 .L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */
29834 /* File: mips/alt_stub.S */
29835 /*
29836  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29837  * any interesting requests and then jump to the real instruction
29838  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29839  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29840  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29841  * bail to the real handler if breakFlags==0.
29842  */
29843     lbu    a3, offThread_breakFlags(rSELF)
29844     la     rBIX, dvmAsmInstructionStart + (507 * 128)
29845     lw     rIBASE, offThread_curHandlerTable(rSELF)
29846     bnez   a3, 1f
29847     jr     rBIX            # nothing to do - jump to real handler
29848 1:
29849     EXPORT_PC()
29850     move   a0, rPC         # arg0
29851     move   a1, rFP         # arg1
29852     move   a2, rSELF       # arg2
29853     JAL(dvmCheckBefore)
29854     jr     rBIX
29855
29856 /* ------------------------------ */
29857     .balign 128
29858 .L_ALT_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */
29859 /* File: mips/alt_stub.S */
29860 /*
29861  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29862  * any interesting requests and then jump to the real instruction
29863  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29864  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29865  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29866  * bail to the real handler if breakFlags==0.
29867  */
29868     lbu    a3, offThread_breakFlags(rSELF)
29869     la     rBIX, dvmAsmInstructionStart + (508 * 128)
29870     lw     rIBASE, offThread_curHandlerTable(rSELF)
29871     bnez   a3, 1f
29872     jr     rBIX            # nothing to do - jump to real handler
29873 1:
29874     EXPORT_PC()
29875     move   a0, rPC         # arg0
29876     move   a1, rFP         # arg1
29877     move   a2, rSELF       # arg2
29878     JAL(dvmCheckBefore)
29879     jr     rBIX
29880
29881 /* ------------------------------ */
29882     .balign 128
29883 .L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */
29884 /* File: mips/alt_stub.S */
29885 /*
29886  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29887  * any interesting requests and then jump to the real instruction
29888  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29889  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29890  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29891  * bail to the real handler if breakFlags==0.
29892  */
29893     lbu    a3, offThread_breakFlags(rSELF)
29894     la     rBIX, dvmAsmInstructionStart + (509 * 128)
29895     lw     rIBASE, offThread_curHandlerTable(rSELF)
29896     bnez   a3, 1f
29897     jr     rBIX            # nothing to do - jump to real handler
29898 1:
29899     EXPORT_PC()
29900     move   a0, rPC         # arg0
29901     move   a1, rFP         # arg1
29902     move   a2, rSELF       # arg2
29903     JAL(dvmCheckBefore)
29904     jr     rBIX
29905
29906 /* ------------------------------ */
29907     .balign 128
29908 .L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */
29909 /* File: mips/alt_stub.S */
29910 /*
29911  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29912  * any interesting requests and then jump to the real instruction
29913  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29914  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29915  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29916  * bail to the real handler if breakFlags==0.
29917  */
29918     lbu    a3, offThread_breakFlags(rSELF)
29919     la     rBIX, dvmAsmInstructionStart + (510 * 128)
29920     lw     rIBASE, offThread_curHandlerTable(rSELF)
29921     bnez   a3, 1f
29922     jr     rBIX            # nothing to do - jump to real handler
29923 1:
29924     EXPORT_PC()
29925     move   a0, rPC         # arg0
29926     move   a1, rFP         # arg1
29927     move   a2, rSELF       # arg2
29928     JAL(dvmCheckBefore)
29929     jr     rBIX
29930
29931 /* ------------------------------ */
29932     .balign 128
29933 .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */
29934 /* File: mips/alt_stub.S */
29935 /*
29936  * Inter-instruction transfer stub.  Call out to dvmCheckBefore to handle
29937  * any interesting requests and then jump to the real instruction
29938  * handler.    Note that the call to dvmCheckBefore is done as a tail call.
29939  * rIBASE updates won't be seen until a refresh, and we can tell we have a
29940  * stale rIBASE if breakFlags==0.  Always refresh rIBASE here, and then
29941  * bail to the real handler if breakFlags==0.
29942  */
29943     lbu    a3, offThread_breakFlags(rSELF)
29944     la     rBIX, dvmAsmInstructionStart + (511 * 128)
29945     lw     rIBASE, offThread_curHandlerTable(rSELF)
29946     bnez   a3, 1f
29947     jr     rBIX            # nothing to do - jump to real handler
29948 1:
29949     EXPORT_PC()
29950     move   a0, rPC         # arg0
29951     move   a1, rFP         # arg1
29952     move   a2, rSELF       # arg2
29953     JAL(dvmCheckBefore)
29954     jr     rBIX
29955
29956     .balign 128
29957     .size   dvmAsmAltInstructionStart, .-dvmAsmAltInstructionStart
29958     .global dvmAsmAltInstructionEnd
29959 dvmAsmAltInstructionEnd: